@use-the-fork/spindle 0.1.0 → 0.2.0

package/build/SubagentDrivenDevelopment/Services/ChecksService.js

@@ -1,6 +1,11 @@
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, readFileSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
 import { Service } from "../../Foundation/Service.js";
 import { isSafeCoveragePath } from "../Persistence/CheckSchema.js";
 import { validateAuthor, validateTicketId, } from "../Policies/InputValidation.js";
+import { ReadinessPolicy } from "../Policies/ReadinessPolicy.js";
+import { Records } from "../../Support/Records.js";
 export class ChecksService extends Service {
     gitEvidence;
     ticketRepository;
@@ -18,10 +23,19 @@ export class ChecksService extends Service {
         this.featureInspectionService = featureInspectionService;
     }
     checksRequire(options) {
+        if (options.rebaseBaseline && options.scope !== undefined)
+            throw new Error("--rebase-baseline requires ticket review scope.");
+        if (options.rebaseBaseline && (options.remove || options.details !== undefined))
+            throw new Error("--rebase-baseline cannot change check requirements.");
+        if (options.scope === "post-merge")
+            return this.postMergeRequire(options);
+        if (typeof options.command !== "string")
+            throw new Error("Exactly one command is required.");
+        const single = { ...options, command: options.command };
         if (options.scope === "delivery") {
             if (options.ticket)
                 throw new Error("--ticket and --scope delivery are mutually exclusive.");
-            return this.deliveryChecksRequire(options);
+            return this.deliveryChecksRequire(single);
         }
         if (options.scope !== undefined)
             throw new Error("--scope must be 'delivery'.");
@@ -42,10 +56,17 @@ export class ChecksService extends Service {
         return this.workspaceTransaction.run(feature.workspace, () => {
             const ledger = this.ledgerRepository.readLedger(feature);
             const progress = this.workflowPolicy.requireProgress(ledger, options.ticket);
-            if (progress.execution === "reviewing" && (progress.reviewAssignments?.length ?? 0) > 0) {
+            if (progress.execution === "integrated")
+                throw new Error("Integrated tickets use --scope post-merge for validation.");
+            const rebased = options.rebaseBaseline
+                ? this.adoptRebasedTicket(feature, ledger, progress, options.author, command)
+                : false;
+            if (!rebased &&
+                progress.execution === "reviewing" &&
+                (progress.reviewAssignments?.length ?? 0) > 0) {
                 throw new Error("The review snapshot is frozen; required checks cannot change while review assignments are active.");
             }
-            const checks = (progress.checks ??= { required: [], records: [], invalidations: [] });
+            const checks = (progress.checks ??= { required: [], records: [] });
             const active = checks.required.find((requirement) => requirement.command === command && !requirement.removedAt);
             if (options.remove) {
                 if (!active)
@@ -56,11 +77,14 @@ export class ChecksService extends Service {
             }
             else {
                 if (active) {
+                    const identity = this.gitEvidence.contentIdentity(feature, this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket), progress.baseSha, checks, undefined, rebased ? progress.worktree?.workspace : undefined);
+                    if (rebased)
+                        this.workspaceTransaction.writeLedger(feature, ledger);
                     return {
                         ticket: options.ticket,
                         checks,
                         idempotent: true,
-                        ...this.gitEvidence.contentIdentity(feature, this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket), progress.baseSha, checks),
+                        ...identity,
                     };
                 }
                 checks.required.push({
@@ -69,37 +93,364 @@ export class ChecksService extends Service {
                     addedBy: options.author.trim(),
                 });
             }
-            let invalidatedDecision;
-            if (progress.execution === "accepted" || progress.execution === "integrated") {
-                const from = progress.execution;
-                progress.execution = "reviewing";
-                const invalidation = {
-                    at: new Date().toISOString(),
-                    author: options.author.trim(),
-                    command,
-                    from,
-                    to: "reviewing",
-                };
-                (checks.invalidations ??= []).push(invalidation);
-                invalidatedDecision = { from, to: "reviewing" };
-            }
             const currentTicket = this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket);
             const identity = this.gitEvidence.contentIdentity(feature, currentTicket, progress.baseSha, checks);
             this.workspaceTransaction.writeLedger(feature, ledger);
             return {
                 ticket: options.ticket,
                 checks,
-                ...(invalidatedDecision ? { invalidatedDecision } : {}),
                 ...identity,
             };
         });
     }
+    adoptRebasedTicket(feature, ledger, progress, author, command) {
+        if (progress.owner !== author.trim())
+            throw new Error("Only the ticket controller may adopt a rebased baseline.");
+        if (progress.execution !== "reviewing" ||
+            progress.assignment?.status !== "submitted" ||
+            !progress.worktree)
+            throw new Error("Rebasing requires a submitted ticket in review with an isolated worktree.");
+        if (!progress.checks?.required.some((item) => item.command === command && !item.removedAt))
+            throw new Error("--rebase-baseline requires an existing required command.");
+        for (const variable of [
+            "GIT_DIR",
+            "GIT_WORK_TREE",
+            "GIT_COMMON_DIR",
+            "GIT_INDEX_FILE",
+            "GIT_OBJECT_DIRECTORY",
+            "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+            "GIT_NAMESPACE",
+        ]) {
+            if (process.env[variable])
+                throw new Error(`Unset ${variable} before adopting a rebased ticket.`);
+        }
+        const root = realpathSync(this.app.workspaceRoot);
+        const git = (args, cwd = root) => this.gitEvidence.gitBuffer(args, cwd).toString("utf8").trim();
+        if (git(["symbolic-ref", "--quiet", "--short", "HEAD"]) !== `features/${feature.feature}` ||
+            realpathSync(feature.workspace) !== realpathSync(join(root, ".scratch", feature.feature)))
+            throw new Error("The canonical feature worktree and branch are required.");
+        const workspace = this.gitEvidence.ticketWorkspace(progress);
+        if (!workspace)
+            throw new Error("Ticket worktree is missing.");
+        for (const cwd of [root, workspace]) {
+            for (const operation of [
+                "MERGE_HEAD",
+                "CHERRY_PICK_HEAD",
+                "REVERT_HEAD",
+                "rebase-merge",
+                "rebase-apply",
+                "sequencer",
+            ]) {
+                if (existsSync(resolve(cwd, git(["rev-parse", "--git-path", operation], cwd))))
+                    throw new Error(`Resolve Git operation ${operation} before adopting the baseline.`);
+            }
+        }
+        const status = git(["status", "--porcelain=v1", "--untracked-files=all", "--ignore-submodules=none"], workspace);
+        if (status)
+            throw new Error("Ticket worktree must be clean; user changes were preserved.");
+        const allowed = this.gitEvidence.workflowDeliveryRecordPaths(feature, ledger);
+        const lock = `.scratch/${feature.feature}/.sdd-tickets.lock`;
+        const dirty = this.gitEvidence
+            .allGitChangePaths()
+            .filter((path) => path !== lock && !allowed.has(path));
+        if (dirty.length)
+            throw new Error(`Feature code must be clean: ${dirty.join(", ")}.`);
+        const base = this.gitEvidence.headSha(root);
+        const head = this.gitEvidence.headSha(workspace);
+        if (head === base)
+            throw new Error("Ticket must contain a distinct reviewed code commit.");
+        git(["merge-base", "--is-ancestor", base, head], workspace);
+        if (!progress.baseSha)
+            throw new Error("Ticket baseline is missing.");
+        git(["merge-base", "--is-ancestor", progress.baseSha, base], root);
+        this.assertPrerequisiteBaseline(ledger, progress, base);
+        if (git(["diff", "--name-only", base, head, "--", ".scratch"], workspace))
+            throw new Error("Rebased ticket commits must not change canonical workflow records.");
+        if (progress.baseSha === base)
+            return false;
+        const attempt = progress.assignment.action === "correct"
+            ? progress.correctionAttempts?.find((item) => item.number === progress.assignment?.attempt)
+            : undefined;
+        if (progress.assignment.action === "correct" && !attempt)
+            throw new Error("Correction attempt is missing.");
+        const previous = attempt
+            ? (attempt.reviewAssignments ?? [])
+            : (progress.reviewAssignments ?? []);
+        if (previous.some((item) => item.status !== "submitted"))
+            throw new Error("Pending reviews must finish before rebasing; assignments were preserved.");
+        if (previous.length) {
+            (progress.reviewHistory ??= []).push(...previous);
+            if (attempt)
+                delete attempt.reviewAssignments;
+            else
+                delete progress.reviewAssignments;
+        }
+        (progress.baselineHistory ??= []).push({
+            from: progress.baseSha,
+            to: base,
+            ticketHead: head,
+            at: new Date().toISOString(),
+            author: author.trim(),
+        });
+        progress.baseSha = base;
+        progress.worktree.baseSha = base;
+        if (this.gitEvidence.headSha(root) !== base || this.gitEvidence.headSha(workspace) !== head)
+            throw new Error("A Git HEAD changed while adopting the baseline; retry.");
+        return true;
+    }
+    assertPrerequisiteBaseline(ledger, progress, baseline) {
+        for (const id of progress.blockedBy) {
+            const dependency = this.workflowPolicy.requireProgress(ledger, id);
+            const mergeSha = dependency.integration?.mergeSha;
+            if (dependency.status !== "closed" ||
+                dependency.blocker ||
+                dependency.execution !== "integrated" ||
+                dependency.integration?.postMerge?.status !== "passed" ||
+                !mergeSha) {
+                throw new Error(`Ticket ${id} is not closed and post-merge validated.`);
+            }
+            try {
+                this.gitEvidence.gitBuffer(["merge-base", "--is-ancestor", mergeSha, baseline]);
+            }
+            catch {
+                throw new Error(`Ticket baseline does not include validated prerequisite ${id}.`);
+            }
+        }
+    }
     checksRecord(options) {
+        if (options.scope === "post-merge")
+            return this.postMergeRecord(options);
         if (options.scope === "delivery") {
             if (options.ticket)
                 throw new Error("--ticket and --scope delivery are mutually exclusive.");
             return this.deliveryChecksRecord(options);
         }
+        return this.ticketChecksRecord(options);
+    }
+    postMergeRequire(options) {
+        validateTicketId(options.ticket);
+        validateAuthor(options.author);
+        if (options.remove || options.details !== undefined)
+            throw new Error("Post-merge checks must be declared as a complete list, without --remove or --details.");
+        const commands = (Array.isArray(options.command) ? options.command : [options.command]).map((command) => command.trim());
+        if (!commands.length ||
+            commands.some((command) => !command) ||
+            new Set(commands).size !== commands.length)
+            throw new Error("Declare a non-empty list of unique post-merge commands.");
+        const feature = this.featureInspectionService.resolveFeature(options.spec);
+        return this.workspaceTransaction.run(feature.workspace, () => {
+            const ledger = this.ledgerRepository.readLedger(feature);
+            const { progress, postMerge } = this.postMergeProgress(ledger, options.ticket, options.author);
+            const previous = progress.integrationHistory?.at(-1)?.postMerge?.checks;
+            if (previous &&
+                JSON.stringify(previous.required.map((item) => item.command)) !== JSON.stringify(commands))
+                throw new Error("Post-merge correction must retain the entire prior required check list.");
+            const prior = postMerge.checks;
+            const same = prior &&
+                JSON.stringify(prior.required.map((item) => item.command)) === JSON.stringify(commands);
+            if (prior?.records.length && !same)
+                throw new Error("Post-merge check list is frozen after the first result.");
+            const checks = same && prior
+                ? prior
+                : {
+                    required: commands.map((command) => ({
+                        command,
+                        addedAt: new Date().toISOString(),
+                        addedBy: options.author.trim(),
+                    })),
+                    records: [],
+                };
+            if (!same)
+                postMerge.checks = checks;
+            const identity = this.postMergeIdentity(feature, ledger, progress, checks);
+            if (!same)
+                this.workspaceTransaction.writeLedger(feature, ledger);
+            const closure = same && checks.records.length
+                ? this.closePostMergeIfReady(feature, ledger, progress, checks, identity, options.author)
+                : {};
+            return {
+                ticket: options.ticket,
+                scope: "post-merge",
+                checks,
+                ...(same ? { idempotent: true } : {}),
+                ...closure,
+                ...identity,
+            };
+        });
+    }
+    postMergeRecord(options) {
+        validateTicketId(options.ticket);
+        validateAuthor(options.author);
+        if (options.paths !== undefined)
+            throw new Error("--paths is not supported for post-merge checks.");
+        const command = options.command.trim();
+        const result = options.result;
+        if (result !== "passed" && result !== "failed" && result !== "unavailable")
+            throw new Error(`Invalid check result: ${result}.`);
+        if (result !== "passed" && !options.details?.trim())
+            throw new Error("--details is required for failed or unavailable checks.");
+        if (!/^[0-9a-f]{64}$/i.test(options.snapshot))
+            throw new Error("Snapshot must be a 64-character hexadecimal content identity.");
+        const feature = this.featureInspectionService.resolveFeature(options.spec);
+        return this.workspaceTransaction.run(feature.workspace, () => {
+            const ledger = this.ledgerRepository.readLedger(feature);
+            const { progress, postMerge } = this.postMergeProgress(ledger, options.ticket, options.author);
+            const checks = postMerge.checks;
+            if (!checks?.required.length)
+                throw new Error("Declare the entire non-empty post-merge check list first.");
+            if (!checks.required.some((item) => item.command === command))
+                throw new Error(`Check command is not required: ${command}.`);
+            const identity = this.postMergeIdentity(feature, ledger, progress, checks);
+            if (identity.snapshot !== options.snapshot)
+                throw new Error(`Snapshot is stale; current post-merge identity is ${identity.snapshot}.`);
+            const record = {
+                command,
+                result,
+                author: options.author.trim(),
+                ...identity,
+                recordedAt: new Date().toISOString(),
+                ...(options.details?.trim() ? { details: options.details.trim() } : {}),
+            };
+            checks.records.push(record);
+            const confirmed = this.postMergeIdentity(feature, ledger, progress, checks);
+            if (confirmed.snapshot !== identity.snapshot || confirmed.headSha !== identity.headSha)
+                throw new Error("Feature changed while recording the check; retry with a fresh snapshot.");
+            const closure = this.closePostMergeIfReady(feature, ledger, progress, checks, identity, options.author);
+            if (!closure.closed)
+                this.workspaceTransaction.writeLedger(feature, ledger);
+            return { ticket: options.ticket, scope: "post-merge", record, ...closure, ...identity };
+        });
+    }
+    closePostMergeIfReady(feature, ledger, progress, checks, identity, author) {
+        const latest = checks.required.map((item) => [...checks.records].reverse().find((candidate) => candidate.command === item.command));
+        if (!latest.length || latest.some((record) => record?.result !== "passed"))
+            return {};
+        if (latest.some((record) => record?.snapshot !== identity.snapshot || record.headSha !== identity.headSha)) {
+            return {
+                closed: false,
+                closureBlocked: ["Post-merge check evidence is stale for the current requirements."],
+                retry: "Run and record each stale check against the current snapshot before retrying closure.",
+            };
+        }
+        const tickets = this.ticketRepository.readTickets(feature.workspace);
+        this.ticketRepository.validateDependencyGraph(tickets);
+        const ticket = this.ticketRepository.requireTicket(tickets, progress.id);
+        const unmet = ReadinessPolicy.unmetDependencies(ticket, tickets, ledger);
+        const closureBlocked = [
+            ...(ticket.blocker ? [`Ticket blocker: ${ticket.blocker}`] : []),
+            ...(unmet.length ? [`Unmet or unvalidated dependencies: ${unmet.join(", ")}`] : []),
+        ];
+        if (closureBlocked.length) {
+            return {
+                closed: false,
+                closureBlocked,
+                retry: "Resolve the blockers, then repeat checks require with the same complete post-merge command list to retry closure.",
+            };
+        }
+        const postMerge = progress.integration?.postMerge;
+        if (!postMerge || postMerge.status !== "pending")
+            throw new Error("Post-merge integration is no longer pending.");
+        postMerge.status = "passed";
+        progress.status = "closed";
+        const body = this.ticketRepository.appendAudit(ticket.body, author, `Post-merge checks passed at ${identity.headSha}; ticket closed.`);
+        this.workspaceTransaction.writeWorkflowState(feature, ticket, this.ticketRepository.serializeTicket(ticket, body), ledger);
+        return { closed: true };
+    }
+    postMergeProgress(ledger, ticket, author) {
+        const progress = this.workflowPolicy.requireProgress(ledger, ticket);
+        const integration = progress.integration;
+        const postMerge = integration?.postMerge;
+        if (progress.owner !== author.trim())
+            throw new Error("Only the ticket controller may manage post-merge checks.");
+        if (progress.execution !== "integrated" ||
+            progress.status === "closed" ||
+            !integration?.mergeSha ||
+            postMerge?.status !== "pending" ||
+            postMerge.mergeSha !== integration.mergeSha)
+            throw new Error("Ticket must have a pending post-merge integration.");
+        return { progress, postMerge };
+    }
+    postMergeIdentity(feature, ledger, progress, checks, allowWorkflowDescendants = false) {
+        for (const variable of [
+            "GIT_DIR",
+            "GIT_WORK_TREE",
+            "GIT_COMMON_DIR",
+            "GIT_INDEX_FILE",
+            "GIT_OBJECT_DIRECTORY",
+            "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+            "GIT_NAMESPACE",
+        ]) {
+            if (process.env[variable])
+                throw new Error(`Unset ${variable} before post-merge validation.`);
+        }
+        const root = realpathSync(this.app.workspaceRoot);
+        const git = (args) => this.gitEvidence.gitBuffer(args, root).toString("utf8").trim();
+        const common = realpathSync(git(["rev-parse", "--path-format=absolute", "--git-common-dir"]));
+        const statePath = join(common, "spindle-feature-start", `${feature.feature}.json`);
+        const entry = lstatSync(statePath);
+        if (!entry.isFile() || entry.isSymbolicLink())
+            throw new Error("Canonical feature startup state is unsafe.");
+        const state = JSON.parse(readFileSync(statePath, "utf8"));
+        if (!Records.isRecord(state) ||
+            state.version !== 1 ||
+            state.phase !== "created" ||
+            state.feature !== feature.feature ||
+            state.featureWorkspace !== root ||
+            state.featureBranch !== `features/${feature.feature}` ||
+            git(["symbolic-ref", "--quiet", "--short", "HEAD"]) !== state.featureBranch)
+            throw new Error("Post-merge checks require the canonical feature worktree and branch.");
+        const currentHead = git(["rev-parse", "--verify", "HEAD"]);
+        const mergeSha = progress.integration?.mergeSha;
+        if (!mergeSha)
+            throw new Error("The recorded merge commit is missing.");
+        const allowed = this.gitEvidence.workflowDeliveryRecordPaths(feature, ledger);
+        if (currentHead !== mergeSha) {
+            if (!allowWorkflowDescendants)
+                throw new Error("Feature HEAD is not the exact recorded merge commit.");
+            git(["merge-base", "--is-ancestor", mergeSha, currentHead]);
+            const changed = this.gitEvidence
+                .gitBuffer(["diff", "--name-only", "-z", "--no-renames", mergeSha, currentHead, "--", "."], root)
+                .toString("utf8")
+                .split("\0")
+                .filter(Boolean);
+            if (changed.some((path) => !allowed.has(path)))
+                throw new Error("Feature code changed after the recorded merge; post-merge failure is stale.");
+        }
+        const headSha = mergeSha;
+        for (const operation of [
+            "MERGE_HEAD",
+            "CHERRY_PICK_HEAD",
+            "REVERT_HEAD",
+            "rebase-merge",
+            "rebase-apply",
+            "sequencer",
+        ]) {
+            if (existsSync(resolve(root, git(["rev-parse", "--git-path", operation]))))
+                throw new Error(`Post-merge checks cannot run during Git operation ${operation}.`);
+        }
+        const lock = `.scratch/${feature.feature}/.sdd-tickets.lock`;
+        const dirty = this.gitEvidence
+            .allGitChangePaths()
+            .filter((path) => path !== lock && !allowed.has(path));
+        if (dirty.length)
+            throw new Error(`Post-merge checks require clean code: ${dirty.join(", ")}`);
+        const ticket = this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), progress.id);
+        const hash = (value) => createHash("sha256").update(JSON.stringify(value)).digest("hex");
+        const codeSnapshot = hash(["post-merge-code-v1", headSha]);
+        const requirementsSnapshot = hash([
+            "post-merge-requirements-v1",
+            readFileSync(feature.spec, "utf8"),
+            this.gitEvidence.ticketRequirements(ticket.raw),
+            checks.required.map((item) => item.command),
+        ]);
+        return {
+            headSha,
+            codeSnapshot,
+            requirementsSnapshot,
+            snapshot: hash(["post-merge-v1", codeSnapshot, requirementsSnapshot]),
+        };
+    }
+    ticketChecksRecord(options) {
         if (options.scope !== undefined)
             throw new Error("--scope must be 'delivery'.");
         if (!options.ticket)
@@ -122,6 +473,8 @@ export class ChecksService extends Service {
         return this.workspaceTransaction.run(feature.workspace, () => {
             const ledger = this.ledgerRepository.readLedger(feature);
             const progress = this.workflowPolicy.requireProgress(ledger, options.ticket);
+            if (progress.integration?.postMerge)
+                throw new Error("Integrated tickets use --scope post-merge for validation.");
             const checks = progress.checks;
             if (!checks)
                 throw new Error("No required checks are declared for this ticket.");
@@ -147,6 +500,7 @@ export class ChecksService extends Service {
                 latestForCommand.result === options.result &&
                 latestForCommand.author === options.author.trim() &&
                 latestForCommand.snapshot === options.snapshot &&
+                (!progress.worktree || latestForCommand.headSha === identity.headSha) &&
                 latestForCommand.details === options.details?.trim() &&
                 JSON.stringify(latestForCommand.coveredPaths) === JSON.stringify(coveredPaths)
                 ? latestForCommand
@@ -184,7 +538,8 @@ export class ChecksService extends Service {
             }
             const confirmedTicket = this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket);
             const confirmedIdentity = this.gitEvidence.contentIdentity(feature, confirmedTicket, progress.baseSha, checks);
-            if (confirmedIdentity.snapshot !== identity.snapshot) {
+            if (confirmedIdentity.snapshot !== identity.snapshot ||
+                (progress.worktree && confirmedIdentity.headSha !== identity.headSha)) {
                 checks.records.pop();
                 correctionCheckHistory?.pop();
                 throw new Error("Content changed while recording the check; retry with a fresh snapshot.");
@@ -216,7 +571,7 @@ export class ChecksService extends Service {
                 throw new Error("Aggregate review is frozen; required delivery checks cannot change.");
             }
             delivery.owner = options.author.trim();
-            const checks = (delivery.checks ??= { required: [], records: [], invalidations: [] });
+            const checks = (delivery.checks ??= { required: [], records: [] });
             const active = checks.required.find((requirement) => requirement.command === command && !requirement.removedAt);
             if (options.remove) {
                 if (!active)

package/build/SubagentDrivenDevelopment/Services/CorrectionService.js

@@ -1,5 +1,5 @@
 import { randomUUID } from "node:crypto";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import matter from "gray-matter";
 import { Service } from "../../Foundation/Service.js";
 import { lstatIfPresent } from "../Persistence/FileSystem.js";
@@ -13,7 +13,8 @@ export class CorrectionService extends Service {
     workflowPolicy;
     deliveryCorrectionService;
     featureInspectionService;
-    constructor(app, gitEvidence, reportEvidence, ticketRepository, ledgerRepository, workspaceTransaction, workflowPolicy, deliveryCorrectionService, featureInspectionService) {
+    checksService;
+    constructor(app, gitEvidence, reportEvidence, ticketRepository, ledgerRepository, workspaceTransaction, workflowPolicy, deliveryCorrectionService, featureInspectionService, checksService) {
         super(app);
         this.gitEvidence = gitEvidence;
         this.reportEvidence = reportEvidence;
@@ -23,6 +24,7 @@ export class CorrectionService extends Service {
         this.workflowPolicy = workflowPolicy;
         this.deliveryCorrectionService = deliveryCorrectionService;
         this.featureInspectionService = featureInspectionService;
+        this.checksService = checksService;
     }
     correct(options) {
         if (options.scope === "delivery") {
@@ -59,18 +61,14 @@ export class CorrectionService extends Service {
             ].includes(options.reason ?? "")) {
                 throw new Error("--reason is required for a pause and must identify the adjudication category.");
             }
-            if (options.assessment || options.assessmentResult)
+            if (options.assessment)
                 throw new Error("--assessment is only valid with --decision continue.");
         }
         else if (options.reason) {
             throw new Error("--reason is only valid with --decision pause.");
         }
-        if (options.decision === "continue" &&
-            (!options.assessment?.trim() || options.assessmentResult !== "productive")) {
-            throw new Error("--assessment and --assessment-result productive are required with --decision continue.");
-        }
-        if (options.assessmentResult && options.decision !== "continue") {
-            throw new Error("--assessment-result is only valid with --decision continue.");
+        if (options.decision === "continue" && !options.assessment?.trim()) {
+            throw new Error("--assessment is required with --decision continue.");
         }
         const feature = this.featureInspectionService.resolveFeature(options.spec);
         return this.workspaceTransaction.run(feature.workspace, () => {
@@ -150,10 +148,72 @@ export class CorrectionService extends Service {
                 throw new Error(`Ticket ${options.ticket} is paused for adjudication (${progress.adjudication?.reason}); resolve it before another correction.`);
             }
             const checkDriven = !!options.checkFailure?.trim();
+            const failedIntegration = progress.execution === "integrated" ? progress.integration : undefined;
+            const postMergeChecks = failedIntegration?.postMerge?.checks;
+            let failedPostMergeRecord;
+            if (failedIntegration && options.checkFailure?.trim()) {
+                if (failedIntegration.postMerge?.status !== "pending" || !postMergeChecks) {
+                    throw new Error("Post-merge correction requires a pending failed validation.");
+                }
+                const latest = [...postMergeChecks.records]
+                    .reverse()
+                    .find((record) => record.command === options.checkFailure?.trim());
+                if (!latest || latest.result !== "failed") {
+                    throw new Error("Post-merge correction requires the latest result for that command to be failed.");
+                }
+                const current = this.checksService.postMergeIdentity(feature, ledger, progress, postMergeChecks, true);
+                if (latest.snapshot !== current.snapshot || latest.headSha !== current.headSha) {
+                    throw new Error("Post-merge failure is stale; record current failure evidence before correction.");
+                }
+                const workspace = this.gitEvidence.ticketWorkspace(progress);
+                const mergeSha = failedIntegration.mergeSha;
+                if (!workspace || !mergeSha || this.gitEvidence.headSha(workspace) !== mergeSha) {
+                    throw new Error("Fast-forward the clean ticket worktree to the failed feature merge before dispatching correction.");
+                }
+                const status = this.gitEvidence
+                    .gitBuffer(["status", "--porcelain=v1", "--untracked-files=all", "--ignore-submodules=none"], workspace)
+                    .toString("utf8");
+                if (status)
+                    throw new Error("Ticket worktree must be clean before post-merge correction; changes were preserved.");
+                for (const operation of [
+                    "MERGE_HEAD",
+                    "CHERRY_PICK_HEAD",
+                    "REVERT_HEAD",
+                    "rebase-merge",
+                    "rebase-apply",
+                    "sequencer",
+                ]) {
+                    const path = this.gitEvidence
+                        .gitBuffer(["rev-parse", "--git-path", operation], workspace)
+                        .toString("utf8")
+                        .trim();
+                    if (lstatIfPresent(resolve(workspace, path)))
+                        throw new Error(`Ticket Git operation ${operation} must be resolved before correction.`);
+                }
+                if (!progress.worktree)
+                    throw new Error("Post-merge correction requires an isolated ticket worktree.");
+                if (!progress.baseSha)
+                    throw new Error("Ticket baseline is missing.");
+                this.gitEvidence.gitBuffer(["merge-base", "--is-ancestor", progress.baseSha, mergeSha]);
+                this.checksService.assertPrerequisiteBaseline(ledger, progress, mergeSha);
+                (progress.baselineHistory ??= []).push({
+                    from: progress.baseSha,
+                    to: mergeSha,
+                    ticketHead: mergeSha,
+                    at: new Date().toISOString(),
+                    author: options.author.trim(),
+                });
+                progress.baseSha = mergeSha;
+                progress.worktree.baseSha = mergeSha;
+                this.gitEvidence.assertTicketCodeCommitted(progress);
+                failedPostMergeRecord = latest;
+            }
             if (!checkDriven && progress.execution !== "changes-requested") {
                 throw new Error(`Ticket ${options.ticket} must have a failed review before correction.`);
             }
-            if (checkDriven && !["reviewing", "changes-requested"].includes(progress.execution)) {
+            if (checkDriven &&
+                !["reviewing", "changes-requested"].includes(progress.execution) &&
+                !failedPostMergeRecord) {
                 throw new Error(`Ticket ${options.ticket} must have a submitted implementation before correction.`);
             }
             if (!progress.baseSha)
@@ -191,7 +251,7 @@ export class CorrectionService extends Service {
                 }
             }
             const checkFailure = options.checkFailure?.trim();
-            if (checkFailure) {
+            if (checkFailure && !failedPostMergeRecord) {
                 const record = progress.checks?.records
                     .filter((candidate) => candidate.command === checkFailure &&
                     candidate.snapshot === identity.snapshot &&
@@ -213,6 +273,9 @@ export class CorrectionService extends Service {
                 ...(checkFailure ? { checkFailure } : {}),
                 objective,
                 report: join(feature.workspace, "reports", `${options.ticket}-round-${number}-fix.md`),
+                ...(progress.worktree
+                    ? { workspace: progress.worktree.workspace, branch: progress.worktree.branch }
+                    : {}),
                 requestedAt: new Date().toISOString(),
                 status: "pending",
                 handoffs: [],
@@ -233,9 +296,11 @@ export class CorrectionService extends Service {
                 ...(progress.assignment ? { priorAssignment: progress.assignment } : {}),
                 ...(checkFailure
                     ? {
-                        checks: (progress.checks?.records ?? []).filter((record) => record.snapshot === identity.snapshot &&
-                            record.codeSnapshot === identity.codeSnapshot &&
-                            record.requirementsSnapshot === identity.requirementsSnapshot),
+                        checks: failedPostMergeRecord
+                            ? [failedPostMergeRecord]
+                            : (progress.checks?.records ?? []).filter((record) => record.snapshot === identity.snapshot &&
+                                record.codeSnapshot === identity.codeSnapshot &&
+                                record.requirementsSnapshot === identity.requirementsSnapshot),
                     }
                     : {}),
             };
@@ -249,6 +314,10 @@ export class CorrectionService extends Service {
                 };
             }
             attempts.push(attempt);
+            if (failedPostMergeRecord && failedIntegration) {
+                (progress.integrationHistory ??= []).push(failedIntegration);
+                delete progress.integration;
+            }
             progress.execution = "implementing";
             progress.assignment = assignment;
             if (pendingAdjudication && progress.adjudication) {