@use-the-fork/spindle 0.0.2 → 0.2.0

package/build/SubagentDrivenDevelopment/Commands/ReviewCommand.js

@@ -5,16 +5,19 @@ import { ReviewService } from "../Services/ReviewService.js";
 export class ReviewCommand extends Command {
     static register(root, createApp) {
         reviewSchema(root).action(async (action, options) => {
+            if (options.scope !== undefined && options.scope !== "delivery") {
+                throw new Error("--scope must be 'delivery'.");
+            }
+            if (Boolean(options.ticket) === (options.scope === "delivery")) {
+                throw new Error("review needs exactly one of --ticket or --scope delivery.");
+            }
             if (action === "require") {
                 if (options.type && options.agent && options.type !== options.agent) {
                     throw new Error("--type and --agent must identify the same review agent.");
                 }
                 const reviewType = options.type ?? options.agent;
-                if (options.scope !== "delivery") {
-                    throw new Error("Feature review requirements need --scope delivery.");
-                }
                 if (!options.spec || !reviewType || !options.details || !options.author) {
-                    throw new Error("review require needs --spec, --scope delivery, --type, --details, and --author.");
+                    throw new Error("review require needs --spec, --type, --details, and --author.");
                 }
                 if (options.inventory)
                     throw new Error("--inventory is not valid with 'review require'.");
@@ -33,11 +36,8 @@ export class ReviewCommand extends Command {
             if (options.type || options.agent || options.details) {
                 throw new Error("--type, --agent, and --details are only valid with 'review require'.");
             }
-            if (!options.spec ||
-                options.scope !== "delivery" ||
-                !options.inventory ||
-                !options.author) {
-                throw new Error("Feature review requires --spec, --scope delivery, --inventory, and --author.");
+            if (!options.spec || !options.inventory || !options.author) {
+                throw new Error("review requires --spec, --inventory, and --author.");
             }
             const command = await (await createApp()).make(ReviewCommand);
             console.log(JSON.stringify(await command.run({

package/build/SubagentDrivenDevelopment/Commands/StartCommand.js

@@ -0,0 +1,23 @@
+import { Command } from "../../Commands/Command.js";
+import { CommandOptions } from "../../Commands/CommandOptions.js";
+import { group } from "./groups.js";
+import { FeatureWorktreeService } from "../Services/FeatureWorktreeService.js";
+export class StartCommand extends Command {
+    static register(root, createApp) {
+        group(root)
+            .command("start")
+            .description("Commit feature records and create a feature branch and worktree.")
+            .requiredOption("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
+            .requiredOption("--workspace <directory>", "Existing absolute external directory for the new worktree", CommandOptions.once("--workspace"))
+            .requiredOption("--confirm-records", "Confirm feature records were inspected for sensitive content")
+            .allowExcessArguments(false)
+            .action(async (options) => {
+            const command = await (await createApp()).make(StartCommand);
+            console.log(JSON.stringify(await command.run(options), null, 2));
+        });
+    }
+    async run(options) {
+        this.assertApplicationBooted();
+        return (await this.app.make(FeatureWorktreeService)).start(options);
+    }
+}

package/build/SubagentDrivenDevelopment/Commands/StatusCommand.js

@@ -1,6 +1,7 @@
 import { Command } from "../../Commands/Command.js";
 import { CommandOptions } from "../../Commands/CommandOptions.js";
 import { group } from "./groups.js";
+import { FeatureFinalizationService } from "../Services/FeatureFinalizationService.js";
 import { FeatureInspectionService } from "../Services/FeatureInspectionService.js";
 export class StatusCommand extends Command {
     static register(root, createApp) {
@@ -16,6 +17,10 @@ export class StatusCommand extends Command {
     }
     async run(options) {
         this.assertApplicationBooted();
+        const finalization = await this.app.make(FeatureFinalizationService);
+        const recorded = finalization.recordedFeature(options.spec);
+        if (recorded)
+            return finalization.status(recorded.feature);
         return (await this.app.make(FeatureInspectionService)).status(options);
     }
 }

package/build/SubagentDrivenDevelopment/Commands/groups.js

@@ -23,10 +23,11 @@ export function reviewSchema(root) {
         return existing;
     return program
         .command("review")
-        .description("Require a specialist or freeze the feature inventory for review.")
+        .description("Require a specialist or freeze a ticket or feature inventory for review.")
         .argument("[action]", "Use 'require' to pin a justified specialist reviewer")
         .option("--spec <path>", "Feature spec path", CommandOptions.once("--spec"))
-        .option("--scope <scope>", "Workflow scope: delivery")
+        .option("--ticket <id>", "Ticket ID", CommandOptions.once("--ticket"))
+        .option("--scope <scope>", "Workflow scope: delivery", CommandOptions.once("--scope"))
         .option("--inventory <json>", "Controller-confirmed Git-derived inventory as a JSON string array", CommandOptions.once("--inventory"))
         .option("--author <author>", "Controller author", CommandOptions.once("--author"))
         .option("--type <name>", "Review-eligible Blueprint agent key to require", CommandOptions.once("--type"))

package/build/SubagentDrivenDevelopment/Evidence/GitEvidence.js

@@ -70,9 +70,9 @@ export class GitEvidence extends Service {
         }
         return paths;
     }
-    worktreeContentDigest(paths) {
+    worktreeContentDigest(paths, workspace) {
         const records = paths.map((path) => {
-            const location = join(this.app.workspaceRoot, path);
+            const location = join(workspace ?? this.app.workspaceRoot, path);
             const entry = lstatIfPresent(location);
             if (!entry)
                 return [path, "deleted", ""];
@@ -132,15 +132,17 @@ export class GitEvidence extends Service {
         });
         return createHash("sha256").update(JSON.stringify(records)).digest("hex");
     }
-    cleanGitBaseline(feature) {
+    cleanDispatchBaseline(feature, allowPendingRecords = false) {
         const root = realpathSync(this.app.workspaceRoot);
+        if (allowPendingRecords)
+            return this.pendingDispatchBaseline(feature, root);
         const changes = this.gitChangeSummary(feature);
         if (changes) {
             const deliveryRecords = this.deliveryRecordPaths(feature);
             if (deliveryRecords.length > 0) {
-                throw new Error(`Cannot claim while uncommitted delivery records remain; the caller must commit them first:\n${deliveryRecords.join("\n")}`);
+                throw new Error(`Cannot dispatch while uncommitted delivery records remain; inspect and confirm them before committing:\n${deliveryRecords.join("\n")}`);
             }
-            throw new Error(`Cannot claim from a dirty checkout; commit or otherwise resolve staged, unstaged, and untracked changes first:\n${changes}`);
+            throw new Error(`Cannot dispatch from a dirty checkout; inspect and resolve staged, unstaged, and unrelated changes first:\n${changes}`);
         }
         const revision = this.git.run(["rev-parse", "--verify", "HEAD"], {
             cwd: root,
@@ -154,10 +156,90 @@ export class GitEvidence extends Service {
         }
         return revision.stdout.trim();
     }
-    contentIdentity(feature, ticket, baseSha = this.headSha(), checks, coveredPaths) {
-        const root = realpathSync(this.app.workspaceRoot);
-        const headSha = this.headSha();
-        const changedPaths = this.changedPaths(baseSha);
+    pendingDispatchBaseline(feature, root) {
+        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 ticket dispatch.`);
+        }
+        const ledger = this.ledgerRepository.readLedger(feature);
+        const pending = ledger.tickets
+            .map((ticket) => ticket.integration ?? ticket.integrationHistory?.at(-1))
+            .filter((integration) => integration?.postMerge?.status === "pending");
+        const head = this.headSha(root);
+        if (!pending.length || pending.some((integration) => integration?.mergeSha !== head)) {
+            throw new Error("Pending post-merge validation does not match the exact feature HEAD.");
+        }
+        const gitPath = (name) => resolve(root, this.gitBuffer(["rev-parse", "--git-path", name], root).toString("utf8").trim());
+        for (const operation of [
+            "MERGE_HEAD",
+            "CHERRY_PICK_HEAD",
+            "REVERT_HEAD",
+            "REBASE_HEAD",
+            "rebase-merge",
+            "rebase-apply",
+            "sequencer",
+        ]) {
+            if (lstatIfPresent(gitPath(operation))) {
+                throw new Error(`Existing Git operation ${operation} was preserved; inspect it before dispatch.`);
+            }
+        }
+        const common = realpathSync(this.gitBuffer(["rev-parse", "--path-format=absolute", "--git-common-dir"], root)
+            .toString("utf8")
+            .trim());
+        if (lstatIfPresent(join(common, "spindle-record-commit", `${feature.feature}.json`))) {
+            throw new Error("Pending workflow-record commit journal must be resolved before dispatch.");
+        }
+        const status = this.gitBuffer([
+            "status",
+            "--porcelain=v1",
+            "-z",
+            "--untracked-files=all",
+            "--ignore-submodules=none",
+            "--",
+            ".",
+        ], root)
+            .toString("utf8")
+            .split("\0")
+            .filter(Boolean);
+        const allowed = this.workflowDeliveryRecordPaths(feature, ledger);
+        const lock = `.scratch/${feature.feature}/.sdd-tickets.lock`;
+        for (const entry of status) {
+            const state = entry.slice(0, 2);
+            const path = entry.slice(3);
+            if (state[0] !== " " && state !== "??") {
+                throw new Error(`Staged data was preserved; inspect it before dispatch: ${path}.`);
+            }
+            if (path === lock)
+                continue;
+            if (!allowed.has(path)) {
+                throw new Error(`Unrelated or non-canonical changes were preserved: ${path}.`);
+            }
+            const file = lstatIfPresent(join(root, path));
+            if (!file?.isFile() || file.isSymbolicLink()) {
+                throw new Error(`Canonical workflow record is missing or unsafe: ${path}.`);
+            }
+        }
+        if (this.headSha(root) !== head)
+            throw new Error("Feature HEAD changed during ticket dispatch.");
+        return head;
+    }
+    contentIdentity(feature, ticket, baseSha, checks, coveredPaths, workspace) {
+        const progress = this.ledgerRepository
+            .readLedger(feature)
+            .tickets.find((item) => item.id === ticket.id);
+        const root = workspace ??
+            (progress ? this.ticketWorkspace(progress) : undefined) ??
+            realpathSync(this.app.workspaceRoot);
+        const headSha = this.headSha(root);
+        const changedPaths = this.changedPaths(baseSha ?? headSha, root);
         const paths = new Set(coveredPaths ?? changedPaths);
         if (coveredPaths) {
             for (const path of paths) {
@@ -183,7 +265,7 @@ export class GitEvidence extends Service {
         for (const path of [...paths].sort()) {
             field("record", "path");
             field("path", path);
-            field("index-stage", this.gitBuffer(["ls-files", "--stage", "-z", "--", `:(literal)${path}`]));
+            field("index-stage", this.gitBuffer(["ls-files", "--stage", "-z", "--", `:(literal)${path}`], root));
             const indexed = this.git.run(["show", `:${path}`], {
                 cwd: root,
                 encoding: "buffer",
@@ -227,8 +309,16 @@ export class GitEvidence extends Service {
             .update(JSON.stringify(requirementParts))
             .digest("hex");
         const snapshot = createHash("sha256")
-            .update(JSON.stringify([codeSnapshot, requirementsSnapshot]))
+            .update(JSON.stringify(progress?.worktree && root === progress.worktree.workspace
+            ? [codeSnapshot, requirementsSnapshot, headSha]
+            : [codeSnapshot, requirementsSnapshot]))
             .digest("hex");
+        if (this.headSha(root) !== headSha) {
+            throw new Error("Git HEAD changed while computing content evidence.");
+        }
+        if (progress?.worktree && root === progress.worktree.workspace) {
+            this.ticketWorkspace(progress);
+        }
         return { snapshot, codeSnapshot, requirementsSnapshot, headSha };
     }
     deliveryIdentity(feature, ledger, tickets) {
@@ -239,7 +329,7 @@ export class GitEvidence extends Service {
         if (!delivery.baseSha) {
             throw new Error("Aggregate evidence requires the first ticket's recorded Git baseline.");
         }
-        const codeIdentity = this.contentIdentity(feature, tickets[0], delivery.baseSha);
+        const codeIdentity = this.contentIdentity(feature, tickets[0], delivery.baseSha, undefined, undefined, realpathSync(this.app.workspaceRoot));
         const requirementsSnapshot = createHash("sha256")
             .update(JSON.stringify([
             readFileSync(feature.spec, "utf8"),
@@ -266,25 +356,25 @@ export class GitEvidence extends Service {
             headSha: codeIdentity.headSha,
         };
     }
-    changedPaths(baseSha) {
+    changedPaths(baseSha, workspace) {
         const paths = new Set();
         for (const args of [
-            ["diff", "--name-only", "-z", baseSha, "--", "."],
-            ["diff", "--cached", "--name-only", "-z", baseSha, "--", "."],
+            ["diff", "--name-only", "--no-renames", "-z", baseSha, "--", "."],
+            ["diff", "--cached", "--name-only", "--no-renames", "-z", baseSha, "--", "."],
             ["ls-files", "--others", "--exclude-standard", "-z"],
         ]) {
-            const output = this.gitBuffer(args).toString("utf8");
+            const output = this.gitBuffer(args, workspace).toString("utf8");
             for (const path of output.split("\0")) {
                 if (path && path !== ".scratch" && !path.startsWith(".scratch/"))
                     paths.add(path);
             }
         }
-        this.assertStableSubmodules(baseSha, paths);
+        this.assertStableSubmodules(baseSha, paths, workspace);
         return [...paths].sort();
     }
-    assertStableSubmodules(baseSha, changedPaths) {
+    assertStableSubmodules(baseSha, changedPaths, workspace) {
         const gitlinks = new Map();
-        for (const record of this.gitBuffer(["ls-files", "--stage", "-z"])
+        for (const record of this.gitBuffer(["ls-files", "--stage", "-z"], workspace)
             .toString("utf8")
             .split("\0")) {
             const [metadata, path] = record.split("\t", 2);
@@ -295,7 +385,7 @@ export class GitEvidence extends Service {
                 gitlinks.set(path, sha);
         }
         const knownPaths = new Set(gitlinks.keys());
-        for (const record of this.gitBuffer(["ls-tree", "-r", "-z", baseSha])
+        for (const record of this.gitBuffer(["ls-tree", "-r", "-z", baseSha], workspace)
             .toString("utf8")
             .split("\0")) {
             const [metadata, path] = record.split("\t", 2);
@@ -307,7 +397,7 @@ export class GitEvidence extends Service {
             }
         }
         for (const path of knownPaths) {
-            const entry = lstatIfPresent(join(this.app.workspaceRoot, path));
+            const entry = lstatIfPresent(join(workspace ?? this.app.workspaceRoot, path));
             if (!entry) {
                 throw new Error(`Cannot compute code identity for submodule '${path}'; its worktree is missing or uninitialized.`);
             }
@@ -321,21 +411,14 @@ export class GitEvidence extends Service {
                 continue;
             let revision;
             try {
-                revision = this.gitBuffer(["-C", path, "rev-parse", "--verify", "HEAD"])
+                revision = this.gitBuffer(["-C", path, "rev-parse", "--verify", "HEAD"], workspace)
                     .toString("utf8")
                     .trim();
             }
             catch {
                 throw new Error(`Cannot compute code identity for submodule '${path}'; its worktree is missing or uninitialized.`);
             }
-            const status = this.gitBuffer([
-                "-C",
-                path,
-                "status",
-                "--porcelain",
-                "--untracked-files=all",
-                "--ignore-submodules=none",
-            ]).toString("utf8");
+            const status = this.gitBuffer(["-C", path, "status", "--porcelain", "--untracked-files=all", "--ignore-submodules=none"], workspace).toString("utf8");
             if (revision !== gitlinks.get(path) || status.length > 0) {
                 throw new Error(`Cannot compute code identity for changed submodule '${path}'; submodule changes are unsupported.`);
             }
@@ -364,9 +447,75 @@ export class GitEvidence extends Service {
         }
         return JSON.stringify([...sections.entries()].sort(([left], [right]) => left.localeCompare(right)));
     }
-    headSha() {
+    ticketWorkspace(progress) {
+        if (!progress.worktree)
+            return undefined;
+        const recorded = progress.worktree;
+        const entry = lstatIfPresent(recorded.workspace);
+        if (!entry?.isDirectory() ||
+            entry.isSymbolicLink() ||
+            realpathSync(recorded.workspace) !== recorded.workspace) {
+            throw new Error(`Ticket ${progress.id} worktree is missing or unsafe: ${recorded.workspace}.`);
+        }
+        const canonical = realpathSync(this.app.workspaceRoot);
+        const common = this.gitBuffer(["rev-parse", "--path-format=absolute", "--git-common-dir"])
+            .toString("utf8")
+            .trim();
+        const ticketCommon = this.gitBuffer(["rev-parse", "--path-format=absolute", "--git-common-dir"], recorded.workspace)
+            .toString("utf8")
+            .trim();
+        const branch = this.gitBuffer(["symbolic-ref", "--quiet", "--short", "HEAD"], recorded.workspace)
+            .toString("utf8")
+            .trim();
+        const top = this.gitBuffer(["rev-parse", "--show-toplevel"], recorded.workspace)
+            .toString("utf8")
+            .trim();
+        const registrations = this.gitBuffer(["worktree", "list", "--porcelain", "-z"])
+            .toString("utf8")
+            .split("\0");
+        if (isPathInside(canonical, recorded.workspace) ||
+            realpathSync(common) !== realpathSync(ticketCommon) ||
+            realpathSync(top) !== recorded.workspace ||
+            !registrations.includes(`worktree ${recorded.workspace}`) ||
+            branch !== recorded.branch) {
+            throw new Error(`Ticket ${progress.id} worktree no longer matches its recorded repository and branch.`);
+        }
+        const ancestor = this.git.run(["merge-base", "--is-ancestor", recorded.baseSha, "HEAD"], {
+            cwd: recorded.workspace,
+            encoding: "utf8",
+        });
+        if (ancestor.error)
+            throw ancestor.error;
+        if (ancestor.status !== 0)
+            throw new Error(`Ticket ${progress.id} no longer descends from its recorded baseline.`);
+        return recorded.workspace;
+    }
+    assertTicketCodeCommitted(progress) {
+        const workspace = this.ticketWorkspace(progress);
+        if (!workspace)
+            return;
+        const scratchDiff = this.gitBuffer(["diff", "--name-only", "--no-renames", "-z", progress.baseSha, "HEAD", "--", ".scratch"], workspace);
+        const scratchStatus = this.gitBuffer(["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", ".scratch"], workspace);
+        if (scratchDiff.length || scratchStatus.length) {
+            throw new Error("Ticket worktree must not modify .scratch; use canonical feature records.");
+        }
+        const changed = new Set();
+        for (const args of [
+            ["diff", "--name-only", "--no-renames", "-z", "HEAD", "--", "."],
+            ["diff", "--cached", "--name-only", "--no-renames", "-z", "HEAD", "--", "."],
+            ["ls-files", "--others", "--exclude-standard", "-z"],
+        ]) {
+            for (const path of this.gitBuffer(args, workspace).toString("utf8").split("\0")) {
+                if (path && path !== ".scratch" && !path.startsWith(".scratch/"))
+                    changed.add(path);
+            }
+        }
+        if (changed.size > 0)
+            throw new Error(`Commit ticket code before review: ${[...changed].sort().join(", ")}.`);
+    }
+    headSha(workspace) {
         const revision = this.git.run(["rev-parse", "--verify", "HEAD"], {
-            cwd: realpathSync(this.app.workspaceRoot),
+            cwd: workspace ?? realpathSync(this.app.workspaceRoot),
             encoding: "utf8",
             env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
         });
@@ -377,9 +526,9 @@ export class GitEvidence extends Service {
         }
         return revision.stdout.trim();
     }
-    gitBuffer(args) {
+    gitBuffer(args, workspace) {
         const result = this.git.run(args, {
-            cwd: realpathSync(this.app.workspaceRoot),
+            cwd: workspace ?? realpathSync(this.app.workspaceRoot),
             encoding: "buffer",
             env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
         });
@@ -411,7 +560,7 @@ export class GitEvidence extends Service {
         if (status.error)
             throw status.error;
         if (status.status !== 0) {
-            throw new Error(`git status failed while checking claim readiness: ${status.stderr.trim()}`);
+            throw new Error(`git status failed while checking dispatch readiness: ${status.stderr.trim()}`);
         }
         return status.stdout.trim();
     }
@@ -427,10 +576,12 @@ export class GitEvidence extends Service {
             return false;
         }
         try {
+            const workspace = this.ticketWorkspace(progress);
             return (progress.integration.contentDigest === accepted.contentDigest &&
                 JSON.stringify(progress.integration.files) === JSON.stringify(accepted.files) &&
-                JSON.stringify(this.changedPaths(progress.baseSha)) === JSON.stringify(accepted.files) &&
-                this.worktreeContentDigest(accepted.files) === accepted.contentDigest);
+                JSON.stringify(this.changedPaths(progress.baseSha, workspace)) ===
+                    JSON.stringify(accepted.files) &&
+                this.worktreeContentDigest(accepted.files, workspace) === accepted.contentDigest);
         }
         catch {
             return false;

package/build/SubagentDrivenDevelopment/Models/Workflow.js

@@ -5,11 +5,9 @@ export const TICKET_CATEGORIES = ["bug", "enhancement"];
 export const TRACKER_STATUSES = ["open", "in-progress", "closed"];
 export const EXECUTION_STATES = [
     "unstarted",
-    "claimed",
     "implementing",
     "reviewing",
     "changes-requested",
-    "accepted",
     "integrated",
     "complete",
     "blocked",

package/build/SubagentDrivenDevelopment/Persistence/AssignmentSchema.js

@@ -13,6 +13,10 @@ export function isImplementationAssignment(value) {
         !value.controller.trim() ||
         typeof value.report !== "string" ||
         !isAbsolute(value.report) ||
+        (Object.hasOwn(value, "workspace") &&
+            (typeof value.workspace !== "string" || !isAbsolute(value.workspace))) ||
+        (Object.hasOwn(value, "branch") &&
+            (typeof value.branch !== "string" || !value.branch.trim())) ||
         typeof value.requestedAt !== "string" ||
         !Number.isFinite(Date.parse(value.requestedAt)) ||
         !["pending", "submitted", "unavailable"].includes(String(value.status)) ||

package/build/SubagentDrivenDevelopment/Persistence/CheckSchema.js

@@ -12,7 +12,7 @@ export function isCheckRequirement(value) {
         return false;
     }
     const removed = Object.hasOwn(value, "removedAt");
-    return (!removed ||
+    return ((!removed && !Object.hasOwn(value, "removedBy") && !Object.hasOwn(value, "removalDetails")) ||
         (typeof value.removedAt === "string" &&
             Number.isFinite(Date.parse(value.removedAt)) &&
             typeof value.removedBy === "string" &&
@@ -24,7 +24,7 @@ export function isCheckRecord(value) {
     if (isRecord(value) &&
         typeof value.command === "string" &&
         !!value.command.trim() &&
-        ["passed", "failed", "unavailable"].includes(String(value.result)) &&
+        (value.result === "passed" || value.result === "failed" || value.result === "unavailable") &&
         typeof value.author === "string" &&
         !!value.author.trim() &&
         typeof value.snapshot === "string" &&
@@ -37,6 +37,8 @@ export function isCheckRecord(value) {
         /^[0-9a-f]{40,64}$/i.test(value.headSha) &&
         typeof value.recordedAt === "string" &&
         Number.isFinite(Date.parse(value.recordedAt)) &&
+        (!Object.hasOwn(value, "details") ||
+            (typeof value.details === "string" && !!value.details.trim())) &&
         (value.result === "passed" || (typeof value.details === "string" && !!value.details.trim()))) {
         const hasScope = Object.hasOwn(value, "coveredPaths") || Object.hasOwn(value, "coverageSnapshot");
         return (!hasScope ||
@@ -49,17 +51,6 @@ export function isCheckRecord(value) {
     }
     return false;
 }
-export function isCheckGateInvalidation(value) {
-    return (isRecord(value) &&
-        typeof value.at === "string" &&
-        Number.isFinite(Date.parse(value.at)) &&
-        typeof value.author === "string" &&
-        !!value.author.trim() &&
-        typeof value.command === "string" &&
-        !!value.command.trim() &&
-        ["accepted", "integrated"].includes(String(value.from)) &&
-        value.to === "reviewing");
-}
 export function isSafeCoveragePath(value) {
     return (typeof value === "string" &&
         !!value &&

package/build/SubagentDrivenDevelopment/Persistence/LedgerRepository.js

@@ -1,15 +1,47 @@
 import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 import { blueprintCatalog } from "../../BlueprintManagement/Catalog/BlueprintCatalog.js";
 import { Service } from "../../Foundation/Service.js";
 import { FEATURE_DIRECTORY, EXECUTION_STATES, TICKET_CATEGORIES, TRACKER_STATUSES, } from "../Models/Workflow.js";
 import { isImplementationAssignment, isCorrectionAttempt, isCorrectionAdjudication, hasMatchingCorrectionAttempt, } from "./AssignmentSchema.js";
-import { isCheckRequirement, isCheckRecord, isCheckGateInvalidation, } from "./CheckSchema.js";
+import { isCheckRequirement, isCheckRecord, } from "./CheckSchema.js";
 import { isReviewFinding, isRequirementsDecision, } from "./FindingSchema.js";
 import { isDeliveryProgress, isAcceptedEvidence, isIntegrationRecord, } from "./ProgressSchema.js";
 import { isReviewAssignment, isSpecialistReviewRequirement, } from "./ReviewSchema.js";
 import { Records } from "../../Support/Records.js";
 const isRecord = Records.isRecord;
+function matchingCorrectionChecks(current, previous) {
+    const expected = previous.postMerge?.checks;
+    const checks = current.postMerge?.checks;
+    return (!!expected &&
+        !!checks &&
+        JSON.stringify(expected.required.map((item) => item.command)) ===
+            JSON.stringify(checks.required.map((item) => item.command)));
+}
+function matchingCorrectionHistory(history) {
+    const first = history[0];
+    return !!first && history.every((integration) => matchingCorrectionChecks(integration, first));
+}
+function validBaselineHistory(value, baseSha) {
+    if (!Array.isArray(value) ||
+        value.length === 0 ||
+        !value.every((change) => isRecord(change) &&
+            typeof change.from === "string" &&
+            /^[0-9a-f]{40,64}$/i.test(change.from) &&
+            typeof change.to === "string" &&
+            /^[0-9a-f]{40,64}$/i.test(change.to) &&
+            change.from !== change.to &&
+            typeof change.ticketHead === "string" &&
+            /^[0-9a-f]{40,64}$/i.test(change.ticketHead) &&
+            typeof change.at === "string" &&
+            Number.isFinite(Date.parse(change.at)) &&
+            typeof change.author === "string" &&
+            !!change.author.trim() &&
+            Object.keys(change).every((key) => ["from", "to", "ticketHead", "at", "author"].includes(key))))
+        return false;
+    return (value.every((change, index) => index === 0 || value[index - 1].to === change.from) &&
+        value.at(-1).to === baseSha);
+}
 export class LedgerRepository extends Service {
     constructor(app) {
         super(app);
@@ -81,6 +113,16 @@ export class LedgerRepository extends Service {
                         !!ticket.owner.trim() &&
                         typeof ticket.baseSha === "string" &&
                         /^[0-9a-f]{40,64}$/i.test(ticket.baseSha))) &&
+                (!Object.hasOwn(ticket, "baselineHistory") ||
+                    validBaselineHistory(ticket.baselineHistory, ticket.baseSha)) &&
+                (!Object.hasOwn(ticket, "worktree") ||
+                    (isRecord(ticket.worktree) &&
+                        typeof ticket.worktree.workspace === "string" &&
+                        isAbsolute(ticket.worktree.workspace) &&
+                        ticket.worktree.branch === `tickets/${feature}/${ticket.id}` &&
+                        typeof ticket.worktree.baseSha === "string" &&
+                        ticket.worktree.baseSha === ticket.baseSha &&
+                        /^[0-9a-f]{40,64}$/i.test(ticket.worktree.baseSha))) &&
                 (!Object.hasOwn(ticket, "acceptedEvidence") ||
                     isAcceptedEvidence(ticket.acceptedEvidence)) &&
                 (!Object.hasOwn(ticket, "integration") ||
@@ -90,6 +132,23 @@ export class LedgerRepository extends Service {
                         JSON.stringify(ticket.integration.files) ===
                             JSON.stringify(ticket.acceptedEvidence.files) &&
                         ticket.integration.contentDigest === ticket.acceptedEvidence.contentDigest)) &&
+                (!Object.hasOwn(ticket, "integrationHistory") ||
+                    (Array.isArray(ticket.integrationHistory) &&
+                        ticket.integrationHistory.length > 0 &&
+                        ticket.integrationHistory.every(isIntegrationRecord) &&
+                        ticket.integrationHistory.every((integration) => {
+                            const postMerge = integration.postMerge;
+                            const records = postMerge?.checks?.records ?? [];
+                            return (postMerge?.status === "pending" &&
+                                records.some((record, index) => record.result === "failed" &&
+                                    !records.slice(index + 1).some((later) => later.command === record.command)));
+                        }) &&
+                        new Set(ticket.integrationHistory.map((integration) => integration.mergeSha)).size ===
+                            ticket.integrationHistory.length &&
+                        (!isIntegrationRecord(ticket.integration) ||
+                            (!new Set(ticket.integrationHistory.map((integration) => integration.mergeSha)).has(ticket.integration.mergeSha) &&
+                                matchingCorrectionChecks(ticket.integration, ticket.integrationHistory[ticket.integrationHistory.length - 1]))) &&
+                        matchingCorrectionHistory(ticket.integrationHistory))) &&
                 (!Object.hasOwn(ticket, "reviewRequirements") ||
                     (Array.isArray(ticket.reviewRequirements) &&
                         ticket.reviewRequirements.every(isSpecialistReviewRequirement) &&
@@ -101,11 +160,13 @@ export class LedgerRepository extends Service {
                         ticket.checks.required.every(isCheckRequirement) &&
                         Array.isArray(ticket.checks.records) &&
                         ticket.checks.records.every(isCheckRecord) &&
-                        (!Object.hasOwn(ticket.checks, "invalidations") ||
-                            (Array.isArray(ticket.checks.invalidations) &&
-                                ticket.checks.invalidations.every(isCheckGateInvalidation))))) &&
+                        !Object.hasOwn(ticket.checks, "invalidations"))) &&
                 (!Object.hasOwn(ticket, "assignment") ||
                     (isImplementationAssignment(ticket.assignment) &&
+                        (!ticket.worktree ||
+                            (isRecord(ticket.worktree) &&
+                                ticket.assignment.workspace === ticket.worktree.workspace &&
+                                ticket.assignment.branch === ticket.worktree.branch)) &&
                         ticket.assignment.report ===
                             join(this.app.workspaceRoot, ".scratch", feature, "reports", ticket.assignment.action === "implement"
                                 ? `${ticket.id}-implementation.md`