feat: import open Discussion Framework agendas into Works
Test / Tests and coverage occurred while executing withChecks step.
Intrepid/AI Engineering/pipeline/head There was a failure building this commit
build / jvm (push) Canceled after 0s
build / native (macos-15, macos-arm64) (push) Canceled after 0s
build / native (ubuntu-24.04, linux-x86_64) (push) Canceled after 0s
build / native (windows-2025, windows-x86_64) (push) Canceled after 0s

Add deterministic preview and fingerprint-bound application for independent
DF sources under an AIE umbrella. Preserve complete agendas and original
evidence with source-scoped identities, validated receipts and safe retries.

Publish prepared Works atomically, require review for changed imports and
retain existing refinement without source edits or model calls.

Advertise protocol contract 2 while continuing to read contract-1 projects. Add JVM,
concurrency, recovery and native coverage; document usage and complete
WRK-0007 with verification evidence.
This commit is contained in:
Nilton Constantino
2026-11-16 14:53:05 +00:00
parent 3d2abb487f
commit 8e75bf7516
74 changed files with 3663 additions and 78 deletions
@@ -52,7 +52,7 @@ class CompatibilityTest {
var report = inspect();
assertThat(report.state()).isEqualTo(CURRENT); assertThat(report.readable()).isTrue();
assertThat(report.migrationRequired()).isFalse();
assertThat(report.currentProtocolVersion()).isEqualTo(1);
assertThat(report.currentProtocolVersion()).isEqualTo(2);
assertThat(report.formats()).contains(FormatVersions.SEQUENCE, FormatVersions.DOCUMENT);
assertThat(ok("project", "compatibility", "--format", "json")).contains("\"cliVersion\"", "\"readableVersions\"", "\"migrationRequired\" : false");
assertThat(ok("status", "--format", "json")).contains("\"compatibility\"", "\"state\" : \"CURRENT\"");
@@ -0,0 +1,269 @@
package net.intrepid.aiengineering;
import net.intrepid.aiengineering.artifact.*;
import net.intrepid.aiengineering.cli.EngineeringCli;
import net.intrepid.aiengineering.discussion.*;
import net.intrepid.aiengineering.filesystem.*;
import net.intrepid.aiengineering.legacyimport.*;
import net.intrepid.aiengineering.project.*;
import net.intrepid.aiengineering.verification.*;
import net.intrepid.aiengineering.work.*;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.nio.file.*;
import java.util.*;
import static net.intrepid.aiengineering.legacyimport.DiscussionImport.*;
import static org.assertj.core.api.Assertions.*;
class DiscussionImportTest {
@TempDir Path temp;
Path root, alpha, beta;
String output;
final DiscussionImportService importer = new DiscussionImportService();
final WorkService works = new WorkService();
void init() throws Exception {
root = Files.createDirectory(temp.resolve("destination")).toRealPath();
new ProjectService().initialize(root, "Import destination");
alpha = copyFixture("alpha", Files.createDirectory(temp.resolve("alpha")));
beta = copyFixture("beta", Files.createDirectory(temp.resolve("beta")));
}
static Path copyFixture(String name, Path target) throws Exception {
Path fixture = Path.of(Objects.requireNonNull(DiscussionImportTest.class.getResource("/discussion-import/" + name)).toURI());
try (var files = Files.walk(fixture)) {
for (var source : files.toList()) {
Path next = target.resolve(fixture.relativize(source).toString());
if (Files.isDirectory(source)) Files.createDirectories(next); else Files.copy(source, next);
}
}
return target.toRealPath();
}
List<Source> sources() { return List.of(new Source("alpha", alpha.toString(), List.of("runtime", "docs")), new Source("beta", beta.toString(), List.of("studio"))); }
List<Source> betaOnly() { return List.of(new Source("beta", beta.toString(), null)); }
static Map<String, String> snapshot(Path path) throws Exception {
var values = new TreeMap<String, String>();
try (var files = Files.walk(path)) {
for (var file : files.filter(Files::isRegularFile).toList()) values.put(path.relativize(file).toString(), Revisions.hash(Files.readAllBytes(file)));
}
return values;
}
int cli(Path cwd, String... args) {
var out = new StringWriter(); var err = new StringWriter();
int code = new EngineeringCli(cwd).execute(new PrintWriter(out), new PrintWriter(err), args);
output = out + err.toString(); return code;
}
Report preview(List<Source> sources) { return importer.preview(root, sources); }
Report apply(List<Source> sources) {
var preview = preview(sources); assertThat(preview.valid()).as(preview.toString()).isTrue();
return importer.apply(root, sources, preview.fingerprint(), "fixture-owner");
}
Path betaAgenda() { return beta.resolve("discussion/workflow/agendas/AGD-0001-studio.md"); }
@Test void previewIsDeterministicReadOnlyAndSelectsAgendaStateAcrossIndependentRoots() throws Exception {
init(); Files.deleteIfExists(root.resolve(".ai-engineering/.local/write.lock"));
var before = snapshot(temp); var report = preview(sources());
assertThat(report.valid()).as(report.toString()).isTrue(); assertThat(report.applied()).isFalse();
assertThat(report.discussions()).extracting(Entry::action).containsExactly(Action.CREATE, Action.SKIP, Action.CREATE);
assertThat(report.discussions().getFirst().agendas()).extracting(AgendaView::selected).containsExactly(true, false, true);
assertThat(report.fingerprint()).isEqualTo(preview(sources().reversed()).fingerprint());
assertThat(snapshot(temp)).isEqualTo(before);
assertThat(Files.exists(root.resolve(".ai-engineering/.local/write.lock"))).isFalse();
}
@Test void applyPreservesRawAgendasEvidenceTargetsAndCreatesOneOpenWorkPerSourceDsc() throws Exception {
init();
Path original = alpha.resolve("discussion/workflow/agendas/AGD-0001-transport.md");
Files.write(original, Files.readString(original).replace("\n", "\r\n").getBytes(StandardCharsets.UTF_8));
var beforeAlpha = snapshot(alpha); var beforeBeta = snapshot(beta);
var report = apply(sources()); assertThat(report.publishedWorks()).hasSize(2);
var imported = works.list(root); assertThat(imported).hasSize(2);
for (var work : imported) {
assertThat(work.status()).isEqualTo(Work.Status.OPEN);
assertThat(work.decisions()).isEmpty(); assertThat(work.plans()).isEmpty(); assertThat(work.surveys()).isEmpty();
assertThat(work.completions()).isEmpty(); assertThat(work.agentRuns()).isEmpty();
assertThat(new VerificationService().work(root, work.id()).valid()).isTrue();
}
var runtime = works.load(root, report.publishedWorks().get("alpha:DSC-0001"));
assertThat(runtime.description()).contains("runtime", "docs", "alpha"); assertThat(runtime.discussions()).hasSize(2);
var notes = new DiscussionService().list(root, runtime.id());
assertThat(notes).allSatisfy(note -> assertThat(note.kind()).isEqualTo(DiscussionEntry.Kind.NOTE));
assertThat(notes.getFirst().text()).isEqualTo(Files.readString(original));
var receipt = importer.receipts(root, runtime.id()).getFirst();
assertThat(receipt.agendas()).hasSize(2); assertThat(receipt.targets()).containsExactly("docs", "runtime");
var evidence = new ArtifactService().list(root, runtime.id()); assertThat(evidence).hasSize(4);
var originalArtifact = evidence.stream().filter(a -> a.id().equals(receipt.agendas().getFirst().artifactId())).findFirst().orElseThrow();
assertThat(Files.readAllBytes(works.folder(root, runtime.id()).resolve(originalArtifact.path()))).isEqualTo(Files.readAllBytes(original));
var dsc = evidence.stream().filter(a -> a.id().equals(receipt.dscArtifactId())).findFirst().orElseThrow();
assertThat(Files.readString(works.folder(root, runtime.id()).resolve(dsc.path()))).contains("custom_context", "original metadata");
assertThat(new VerificationService().context(root, runtime.id()).discussionHistory().getFirst().text()).contains("café, λ", "Qual opção usar?");
assertThat(snapshot(alpha)).isEqualTo(beforeAlpha); assertThat(snapshot(beta)).isEqualTo(beforeBeta);
assertThat(new CompatibilityService().inspect(root).state()).isEqualTo(CompatibilityService.State.CURRENT);
}
@Test void identicalReimportIsNoOpAfterDestinationRefinementAndSourceRelocation() throws Exception {
init(); var initial = apply(betaOnly()); String id = initial.publishedWorks().get("beta:DSC-0001");
new DiscussionService().add(root, id, "Human refinement after migration", DiscussionEntry.Kind.NOTE, "owner", "main", null);
var before = snapshot(root); var report = preview(betaOnly());
assertThat(report.discussions().getFirst().action()).isEqualTo(Action.UNCHANGED);
assertThat(importer.apply(root, betaOnly(), report.fingerprint(), "owner").publishedWorks()).isEmpty();
assertThat(snapshot(root)).isEqualTo(before);
beta = Files.move(beta, temp.resolve("relocated-beta")).toRealPath();
var relocated = preview(betaOnly()); assertThat(relocated.discussions().getFirst().action()).isEqualTo(Action.UNCHANGED);
assertThat(importer.apply(root, betaOnly(), relocated.fingerprint(), "owner").publishedWorks()).isEmpty();
assertThat(snapshot(root)).isEqualTo(before);
}
@Test void changesRequireReviewAndNeverOverwriteOrRemoveImportedContext() throws Exception {
init(); apply(betaOnly()); var before = snapshot(root);
Files.writeString(betaAgenda(), Files.readString(betaAgenda()) + "\nNew source discussion\n");
var report = preview(betaOnly()); assertThat(report.valid()).isFalse();
assertThat(report.discussions().getFirst().action()).isEqualTo(Action.REVIEW);
assertThat(importer.apply(root, betaOnly(), report.fingerprint(), "owner").valid()).isFalse();
assertThat(snapshot(root)).isEqualTo(before);
Path index = beta.resolve("discussion/index.ndjson");
Files.writeString(index, Files.readString(index).replace("\"status\":\"open\"", "\"status\":\"accepted\""));
Files.writeString(betaAgenda(), Files.readString(betaAgenda()).replace("status: open", "status: accepted"));
var closed = preview(betaOnly()); assertThat(closed.valid()).isTrue();
assertThat(closed.discussions().getFirst().action()).isEqualTo(Action.SKIP);
assertThat(importer.apply(root, betaOnly(), closed.fingerprint(), "owner").publishedWorks()).isEmpty();
assertThat(snapshot(root)).isEqualTo(before);
}
@Test void stalePreviewAndInvalidBatchAllocateNoWorks() throws Exception {
init(); var valid = preview(sources());
Files.writeString(betaAgenda(), Files.readString(betaAgenda()) + "\nChanged after preview\n");
var stale = importer.apply(root, sources(), valid.fingerprint(), "owner");
assertThat(stale.valid()).isFalse(); assertThat(stale.errors()).anySatisfy(e -> assertThat(e).contains("Preview changed"));
assertThat(works.list(root)).isEmpty(); assertThat(Files.exists(root.resolve(".ai-engineering/works/.sequence.yaml"))).isFalse();
Files.delete(betaAgenda()); var invalid = preview(sources()); assertThat(invalid.valid()).isFalse();
assertThat(importer.apply(root, sources(), invalid.fingerprint(), "owner").valid()).isFalse();
assertThat(works.list(root)).isEmpty();
}
@Test void selectedIndexMarkdownMismatchTerminalDscAndDuplicatesAreDiagnosed() throws Exception {
init(); String original = Files.readString(betaAgenda());
Files.writeString(betaAgenda(), original.replace("status: open", "status: accepted"));
assertThat(preview(betaOnly()).errors()).anySatisfy(e -> assertThat(e).contains("differs between index and Markdown"));
Files.writeString(betaAgenda(), original);
Path index = beta.resolve("discussion/index.ndjson"); String data = Files.readString(index);
Files.writeString(index, data.replace("\"id\":\"DSC-0001\",\"status\":\"open\"", "\"id\":\"DSC-0001\",\"status\":\"done\""));
assertThat(preview(betaOnly()).errors()).anySatisfy(e -> assertThat(e).contains("terminal DSC"));
Files.writeString(index, data + data.lines().skip(1).findFirst().orElseThrow() + "\n");
assertThat(preview(betaOnly()).errors()).anySatisfy(e -> assertThat(e).contains("Duplicate DSC"));
assertThat(works.list(root)).isEmpty();
}
@Test void unsafePathsSymlinksAndInvalidUtf8AreBlockedWithoutReadingExternalContent() throws Exception {
init(); Path index = beta.resolve("discussion/index.ndjson"); String data = Files.readString(index);
Files.writeString(index, data.replace("AGD-0001-studio.md", "../../../../outside.md"));
assertThat(preview(betaOnly()).errors()).anySatisfy(e -> assertThat(e).contains("Path traversal"));
Files.writeString(index, data);
Path outside = temp.resolve("outside.md"); Files.writeString(outside, "External private fixture");
Files.delete(betaAgenda()); Files.createSymbolicLink(betaAgenda(), outside);
var linked = preview(betaOnly()); assertThat(linked.valid()).isFalse();
assertThat(linked.errors().toString()).contains("Symlink rejected").doesNotContain("External private fixture");
Files.delete(betaAgenda()); Files.write(betaAgenda(), new byte[]{(byte)0xc3, (byte)0x28});
assertThat(preview(betaOnly()).errors()).anySatisfy(e -> assertThat(e).contains("UTF-8"));
assertThat(works.list(root)).isEmpty();
}
@Test void oversizedAgendaAndBrokenReceiptBlockImportAndCompatibilityInspectsReceiptVersions() throws Exception {
init(); byte[] original = Files.readAllBytes(betaAgenda());
Files.write(betaAgenda(), new byte[(int)ArtifactService.MAX_BYTES + 1]);
assertThat(preview(betaOnly()).errors()).anySatisfy(e -> assertThat(e).contains("byte limit"));
Files.write(betaAgenda(), original); var applied = apply(betaOnly());
String work = applied.publishedWorks().get("beta:DSC-0001"); Path folder = works.folder(root, work);
var manifest = new ArtifactService().list(root, work).stream().filter(a -> a.origin().startsWith(RECEIPT_ORIGIN)).findFirst().orElseThrow();
Path payload = folder.resolve(manifest.path()); byte[] future = Files.readString(payload).replace("\"schemaVersion\" : 1", "\"schemaVersion\" : 99").getBytes(StandardCharsets.UTF_8);
Files.write(payload, future);
var metadata = new Artifact(1, manifest.id(), manifest.workId(), manifest.origin(), manifest.purpose(), manifest.path(), Revisions.hash(future), future.length, manifest.author(), manifest.createdAt());
Files.writeString(payload.getParent().resolve("artifact.yaml"), Documents.yaml(metadata));
var before = snapshot(root);
assertThat(preview(betaOnly()).valid()).isFalse();
assertThat(new VerificationService().work(root, work).valid()).isFalse();
assertThat(new CompatibilityService().inspect(root).state()).isEqualTo(CompatibilityService.State.UNSUPPORTED);
assertThat(snapshot(root)).isEqualTo(before);
}
@Test void cliSupportsCallerRelativeRootsDiscussionDirectoryAndExplicitProject() throws Exception {
init(); var before = snapshot(root);
String[] preview = {"--project", root.toString(), "import", "discussion", "--source", "studio=beta/discussion", "--target", "studio=editor", "--format", "json"};
assertThat(cli(temp, preview)).as(output).isZero();
var report = Documents.parseJson(output, Report.class); assertThat(report.valid()).isTrue();
assertThat(snapshot(root)).isEqualTo(before);
var apply = new ArrayList<>(List.of(preview)); apply.addAll(List.of("--apply", "--expect", report.fingerprint(), "--author", "owner"));
assertThat(cli(temp, apply.toArray(String[]::new))).as(output).isZero();
assertThat(Documents.parseJson(output, Report.class).publishedWorks()).hasSize(1);
assertThat(cli(root, "import", "discussion", "--source", "beta=" + beta, "--apply")).isEqualTo(2);
assertThat(cli(root, "import", "discussion", "--source", "beta=" + beta, "--target", "unknown=x")).isEqualTo(2);
assertThat(cli(root, "import", "discussion", "--source", "beta=" + beta, "--source", "beta=" + alpha)).isEqualTo(2);
assertThat(cli(root, "import", "discussion", "--source", "beta=" + beta, "--source", "other=" + beta)).isEqualTo(2);
}
@Test void projectReadPolicyAndChangedTargetsAreRespected() throws Exception {
init(); apply(betaOnly()); var changed = preview(List.of(new Source("beta", beta.toString(), List.of("new-target"))));
assertThat(changed.valid()).isFalse(); assertThat(changed.discussions().getFirst().action()).isEqualTo(Action.REVIEW);
Path restricted = Files.createDirectory(root.resolve("restricted")); copyFixture("beta", restricted);
var config = new ProjectService().load(root);
var updated = new ProjectConfig(1, config.project(), List.of(new ProjectConfig.Repository("restricted", "restricted", "linked-git", null, new ProjectConfig.Access(false, false), List.of())), null);
Files.writeString(root.resolve(".ai-engineering/ai-engineering.yaml"), Documents.yaml(updated));
var denied = preview(List.of(new Source("restricted", restricted.toString(), null)));
assertThat(denied.valid()).isFalse(); assertThat(denied.errors()).anySatisfy(e -> assertThat(e).contains("not readable by project policy"));
assertThat(denied.sources().getFirst().indexSha256()).isNull();
}
@Test void completedArchivedImportsRemainUnchanged() throws Exception {
init(); String id = apply(betaOnly()).publishedWorks().get("beta:DSC-0001");
assertThat(cli(root, "work", "update", id, "--acceptance", "Original agenda remains available")).as(output).isZero();
assertThat(cli(root, "work", "complete", id, "--by", "fixture-owner", "--summary", "Fixture original verified", "--human-approved",
"--criterion", "1=ART-0001", "--no-integration-needed", "Disposable import fixture")).as(output).isZero();
assertThat(cli(root, "work", "archive", id, "--by", "fixture-owner", "--reason", "Fixture retained")).as(output).isZero();
var before = snapshot(root); var report = preview(betaOnly());
assertThat(report.discussions().getFirst().action()).isEqualTo(Action.UNCHANGED);
assertThat(importer.apply(root, betaOnly(), report.fingerprint(), "owner").publishedWorks()).isEmpty();
assertThat(snapshot(root)).isEqualTo(before); assertThat(new VerificationService().project(root).valid()).isTrue();
}
@Test void malformedIndexesDuplicateAgendasAndAggregateByteLimitAreRejected() throws Exception {
init(); Path index = beta.resolve("discussion/index.ndjson"); String original = Files.readString(index);
Files.writeString(index, original + "{broken\n");
assertThat(preview(betaOnly()).valid()).isFalse();
Files.writeString(index, original.replace("\"type\":\"meta\"", "\"type\":\"meta\",\"schemaVersion\":99"));
assertThat(preview(betaOnly()).errors()).anySatisfy(e -> assertThat(e).contains("Unsupported DF schemaVersion"));
String agenda = "{\"id\":\"AGD-0001\",\"file\":\"AGD-0001-studio.md\",\"status\":\"open\"}";
Files.writeString(index, original.replace(agenda, agenda + "," + agenda));
assertThat(preview(betaOnly()).errors()).anySatisfy(e -> assertThat(e).contains("Duplicate AGD"));
var large = new ArrayList<Source>();
byte[] meta = "{\"type\":\"meta\",\"next_id\":{}}\n".getBytes(StandardCharsets.UTF_8);
for (int n = 0; n < 5; n++) {
Path source = Files.createDirectories(temp.resolve("large-" + n).resolve("discussion"));
byte[] bytes = new byte[DiscussionImportService.MAX_INDEX_BYTES]; Arrays.fill(bytes, (byte)' '); System.arraycopy(meta, 0, bytes, 0, meta.length);
Files.write(source.resolve("index.ndjson"), bytes); large.add(new Source("large-" + n, source.getParent().toString(), null));
}
var oversized = preview(large); assertThat(oversized.valid()).isFalse();
assertThat(oversized.errors()).anySatisfy(e -> assertThat(e).contains("32 MiB"));
assertThat(works.list(root)).isEmpty();
}
@Test void discoveryManifestAdvertisesOnlySupportedImportAndLegacyFalseRemainsReadable() throws Exception {
init(); Path manifest = root.resolve(".ai-engineering/protocol.json");
String advertised = Files.readString(manifest);
assertThat(advertised).contains("\"legacyImport\": true", "discussion-import");
assertThat(new VerificationService().project(root).valid()).isTrue();
Files.writeString(manifest, advertised.replace("\"legacyImport\": true", "\"legacyImport\": false").replace("\"protocolVersion\": 2", "\"protocolVersion\": 1"));
assertThat(new VerificationService().project(root).valid()).isTrue();
assertThat(new CompatibilityService().inspect(root).state()).isEqualTo(CompatibilityService.State.LEGACY_COMPATIBLE);
Files.writeString(manifest, advertised.replace("\"protocolVersion\": 2", "\"protocolVersion\": 1"));
assertThat(new VerificationService().project(root).valid()).isFalse();
Files.writeString(manifest, advertised.replace("discussion-import", "unsupported-import"));
assertThat(new CompatibilityService().inspect(root).readable()).isFalse();
assertThat(new VerificationService().project(root).valid()).isFalse();
}
@Test void concurrentJvmApplicationsDoNotDuplicateSourceIdentities() throws Exception {
init(); var preview = preview(sources());
var command = List.of(Path.of(System.getProperty("java.home"), "bin", "java").toString(), "-jar", System.getProperty("cli.jar"),
"--project", root.toString(), "import", "discussion", "--source", "alpha=" + alpha, "--source", "beta=" + beta,
"--target", "alpha=runtime", "--target", "alpha=docs", "--target", "beta=studio", "--apply", "--expect", preview.fingerprint(), "--format", "json");
var first = new ProcessBuilder(command).redirectErrorStream(true).start(); var second = new ProcessBuilder(command).redirectErrorStream(true).start();
var codes = new ArrayList<Integer>();
try {
for (var process : List.of(first, second)) {
assertThat(process.waitFor(45, java.util.concurrent.TimeUnit.SECONDS)).isTrue();
String result = new String(process.getInputStream().readAllBytes(), StandardCharsets.UTF_8);
assertThat(process.exitValue()).as(result).isIn(0, 4); codes.add(process.exitValue());
}
} finally { first.destroyForcibly(); second.destroyForcibly(); }
assertThat(codes).containsExactlyInAnyOrder(0, 4); assertThat(works.list(root)).hasSize(2);
assertThat(preview(sources()).discussions()).filteredOn(e -> e.action() != Action.SKIP).allSatisfy(e -> assertThat(e.action()).isEqualTo(Action.UNCHANGED));
assertThat(new VerificationService().project(root).valid()).isTrue();
}
}
@@ -0,0 +1,46 @@
package net.intrepid.aiengineering.legacyimport;
import net.intrepid.aiengineering.filesystem.*;
import net.intrepid.aiengineering.project.ProjectService;
import net.intrepid.aiengineering.verification.VerificationService;
import net.intrepid.aiengineering.work.WorkService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
import java.nio.file.*;
import java.util.*;
import static net.intrepid.aiengineering.legacyimport.DiscussionImport.*;
import static org.assertj.core.api.Assertions.*;
class DiscussionImportRecoveryTest {
@TempDir Path temp;
@Test void interruptionBetweenPublishedWorksResumesWithoutDuplicationOrRewriting() throws Exception {
Path root = Files.createDirectory(temp.resolve("target")).toRealPath(); new ProjectService().initialize(root, "Target");
var sources = new ArrayList<Source>();
for (String id : List.of("alpha", "beta")) {
Path from = Path.of(Objects.requireNonNull(getClass().getResource("/discussion-import/" + id)).toURI());
Path to = Files.createDirectory(temp.resolve(id));
try (var files = Files.walk(from)) {
for (var file : files.toList()) {
Path target = to.resolve(from.relativize(file).toString());
if (Files.isDirectory(file)) Files.createDirectories(target); else Files.copy(file, target);
}
}
sources.add(new Source(id, to.toRealPath().toString(), null));
}
var faulty = new DiscussionImportService(work -> { throw new ProtocolException(1, "Simulated interruption after directory publication"); });
var preview = faulty.preview(root, sources);
assertThatThrownBy(() -> faulty.apply(root, sources, preview.fingerprint(), "tester"))
.isInstanceOf(ProtocolException.class).hasMessageContaining("published Works: {alpha:DSC-0001=WRK-0001}");
var works = new WorkService(); assertThat(works.list(root)).hasSize(1);
assertThat(new VerificationService().project(root).valid()).isTrue();
Path first = works.folder(root, "WRK-0001"); var snapshot = new TreeMap<String, String>();
try (var files = Files.walk(first)) { for (var p : files.filter(Files::isRegularFile).toList()) snapshot.put(p.toString(), Files.readString(p)); }
var recovered = new DiscussionImportService(); var remaining = recovered.preview(root, sources);
assertThat(remaining.discussions()).extracting(Entry::action).containsExactly(Action.UNCHANGED, Action.SKIP, Action.CREATE);
var applied = recovered.apply(root, sources, remaining.fingerprint(), "tester");
assertThat(applied.publishedWorks()).containsExactlyEntriesOf(Map.of("beta:DSC-0001", "WRK-0002"));
assertThat(works.list(root)).hasSize(2);
for (var entry : snapshot.entrySet()) assertThat(Files.readString(Path.of(entry.getKey()))).isEqualTo(entry.getValue());
assertThat(new VerificationService().project(root).valid()).isTrue();
}
}