@use-the-fork/spindle 0.1.0 → 0.2.0

package/build/SubagentDrivenDevelopment/SubagentDrivenDevelopmentServiceProvider.js

@@ -2,19 +2,20 @@ import { ServiceProvider } from "../Foundation/ServiceProvider.js";
 import { GitService } from "../Git/Services/GitService.js";
 import { ChecksRecordCommand } from "./Commands/ChecksRecordCommand.js";
 import { ChecksRequireCommand } from "./Commands/ChecksRequireCommand.js";
-import { ClaimCommand } from "./Commands/ClaimCommand.js";
 import { CorrectCommand } from "./Commands/CorrectCommand.js";
 import { CreateCommand } from "./Commands/CreateCommand.js";
 import { FindingCreateCommand } from "./Commands/FindingCreateCommand.js";
 import { FindingUpdateCommand } from "./Commands/FindingUpdateCommand.js";
 import { FinishCommand } from "./Commands/FinishCommand.js";
 import { ImplementCommand } from "./Commands/ImplementCommand.js";
+import { IntegrateCommand } from "./Commands/IntegrateCommand.js";
 import { NextCommand } from "./Commands/NextCommand.js";
 import { ReadyCommand } from "./Commands/ReadyCommand.js";
 import { RequirementsDecideCommand } from "./Commands/RequirementsDecideCommand.js";
 import { ResumeCommand } from "./Commands/ResumeCommand.js";
 import { ReviewCommand } from "./Commands/ReviewCommand.js";
 import { ReviewRequireCommand } from "./Commands/ReviewRequireCommand.js";
+import { StartCommand } from "./Commands/StartCommand.js";
 import { StatusCommand } from "./Commands/StatusCommand.js";
 import { SubmitCommand } from "./Commands/SubmitCommand.js";
 import { TicketCommentCommand } from "./Commands/TicketCommentCommand.js";
@@ -43,23 +44,27 @@ import { DeliveryFindingService } from "./Services/DeliveryFindingService.js";
 import { DeliveryService } from "./Services/DeliveryService.js";
 import { DeliverySubmissionService } from "./Services/DeliverySubmissionService.js";
 import { FeatureCreationService } from "./Services/FeatureCreationService.js";
+import { FeatureFinalizationService } from "./Services/FeatureFinalizationService.js";
 import { FeatureInspectionService } from "./Services/FeatureInspectionService.js";
+import { FeatureWorktreeService } from "./Services/FeatureWorktreeService.js";
 import { FindingService } from "./Services/FindingService.js";
-import { IntegrationService } from "./Services/IntegrationService.js";
 import { ReadinessService } from "./Services/ReadinessService.js";
 import { RequirementsService } from "./Services/RequirementsService.js";
 import { ReviewService } from "./Services/ReviewService.js";
 import { SubmissionService } from "./Services/SubmissionService.js";
+import { TicketIntegrationService } from "./Services/TicketIntegrationService.js";
 import { TicketService } from "./Services/TicketService.js";
+import { TicketWorktreeService } from "./Services/TicketWorktreeService.js";
+import { WorkflowRecordsCommitter } from "./Services/WorkflowRecordsCommitter.js";
 export class SubagentDrivenDevelopmentServiceProvider extends ServiceProvider {
     static commands() {
         return [
             CreateCommand,
+            StartCommand,
             TicketCreateCommand,
             TicketUpdateCommand,
             TicketCommentCommand,
             ReadyCommand,
-            ClaimCommand,
             ChecksRequireCommand,
             ChecksRecordCommand,
             ImplementCommand,
@@ -70,6 +75,7 @@ export class SubagentDrivenDevelopmentServiceProvider extends ServiceProvider {
             FindingUpdateCommand,
             RequirementsDecideCommand,
             SubmitCommand,
+            IntegrateCommand,
             FinishCommand,
             ResumeCommand,
             NextCommand,
@@ -77,14 +83,17 @@ export class SubagentDrivenDevelopmentServiceProvider extends ServiceProvider {
         ];
     }
     register() {
+        this.app.singleton(FeatureFinalizationService, async (app) => new FeatureFinalizationService(app, await app.make(GitService), await app.make(LedgerRepository)));
+        this.app.singleton(TicketWorktreeService, async (app) => new TicketWorktreeService(app, await app.make(GitService), await app.make(GitEvidence)));
+        this.app.singleton(FeatureWorktreeService, async (app) => new FeatureWorktreeService(app, await app.make(GitService), await app.make(FeatureInspectionService), await app.make(WorkspaceTransaction)));
         this.app.singleton(ReadinessReader, async (app) => new ReadinessReader(app, await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(PathSafety)));
         this.app.singleton(ReadinessPolicy, async (app) => new ReadinessPolicy(app, await app.make(TicketRepository)));
         this.app.singleton(FeatureCreationService, async (app) => new FeatureCreationService(app, await app.make(FeatureWorkspace), await app.make(PathSafety), await app.make(WorkspaceTransaction), await app.make(GitEvidence)));
-        this.app.singleton(FeatureInspectionService, async (app) => new FeatureInspectionService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(FeatureWorkspace), await app.make(TicketRepository), await app.make(AcceptancePolicy), await app.make(AssignmentPolicy), await app.make(CheckPolicy), await app.make(FindingPolicy), await app.make(ReviewPolicy)));
+        this.app.singleton(FeatureInspectionService, async (app) => new FeatureInspectionService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(FeatureWorkspace), await app.make(TicketRepository), await app.make(AssignmentPolicy), await app.make(CheckPolicy), await app.make(FindingPolicy), await app.make(ReviewPolicy)));
         this.app.singleton(TicketService, async (app) => new TicketService(app, await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(PathSafety), await app.make(WorkspaceTransaction), await app.make(FeatureInspectionService)));
         this.app.singleton(ReadinessService, async (app) => new ReadinessService(app, await app.make(FeatureInspectionService), await app.make(ReadinessReader), await app.make(ReadinessPolicy), await app.make(PathSafety)));
-        this.app.singleton(AssignmentService, async (app) => new AssignmentService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(AssignmentPolicy), await app.make(CheckPolicy), await app.make(ReviewPolicy), await app.make(WorkflowPolicy), await app.make(FeatureInspectionService)));
-        this.app.singleton(CorrectionService, async (app) => new CorrectionService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(WorkflowPolicy), await app.make(DeliveryCorrectionService), await app.make(FeatureInspectionService)));
+        this.app.singleton(AssignmentService, async (app) => new AssignmentService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(AssignmentPolicy), await app.make(CheckPolicy), await app.make(ReviewPolicy), await app.make(ReadinessPolicy), await app.make(WorkflowPolicy), await app.make(FeatureInspectionService), await app.make(TicketWorktreeService), await app.make(WorkflowRecordsCommitter)));
+        this.app.singleton(CorrectionService, async (app) => new CorrectionService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(WorkflowPolicy), await app.make(DeliveryCorrectionService), await app.make(FeatureInspectionService), await app.make(ChecksService)));
         this.app.singleton(DeliveryCorrectionService, async (app) => new DeliveryCorrectionService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(FeatureInspectionService)));
         this.app.singleton(ChecksService, async (app) => new ChecksService(app, await app.make(GitEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(WorkflowPolicy), await app.make(FeatureInspectionService)));
         this.app.singleton(ReviewService, async (app) => new ReviewService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(AssignmentPolicy), await app.make(CheckPolicy), await app.make(ReviewPolicy), await app.make(WorkflowPolicy), await app.make(FeatureInspectionService)));
@@ -93,8 +102,9 @@ export class SubagentDrivenDevelopmentServiceProvider extends ServiceProvider {
         this.app.singleton(RequirementsService, async (app) => new RequirementsService(app, await app.make(GitEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(WorkflowPolicy), await app.make(FeatureInspectionService)));
         this.app.singleton(SubmissionService, async (app) => new SubmissionService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(CheckPolicy), await app.make(ReviewPolicy), await app.make(WorkflowPolicy), await app.make(DeliverySubmissionService), await app.make(FeatureInspectionService)));
         this.app.singleton(DeliverySubmissionService, async (app) => new DeliverySubmissionService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(CheckPolicy), await app.make(ReviewPolicy), await app.make(FeatureInspectionService)));
-        this.app.singleton(IntegrationService, async (app) => new IntegrationService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(AcceptancePolicy), await app.make(WorkflowPolicy), await app.make(FeatureInspectionService)));
-        this.app.singleton(DeliveryService, async (app) => new DeliveryService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(CheckPolicy), await app.make(FindingPolicy), await app.make(ReviewPolicy), await app.make(FeatureInspectionService)));
+        this.app.singleton(TicketIntegrationService, async (app) => new TicketIntegrationService(app, await app.make(GitService), await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(AcceptancePolicy), await app.make(WorkflowPolicy), await app.make(FeatureInspectionService), await app.make(WorkflowRecordsCommitter)));
+        this.app.singleton(WorkflowRecordsCommitter, async (app) => new WorkflowRecordsCommitter(app, await app.make(GitService)));
+        this.app.singleton(DeliveryService, async (app) => new DeliveryService(app, await app.make(GitEvidence), await app.make(ReportEvidence), await app.make(TicketRepository), await app.make(LedgerRepository), await app.make(WorkspaceTransaction), await app.make(CheckPolicy), await app.make(FindingPolicy), await app.make(ReviewPolicy), await app.make(FeatureInspectionService), await app.make(FeatureFinalizationService)));
         this.app.singleton(FeatureWorkspace, async (app) => new FeatureWorkspace(app, await app.make(LedgerRepository), await app.make(PathSafety)));
         this.app.singleton(LedgerRepository, async (app) => new LedgerRepository(app));
         this.app.singleton(TicketRepository, async (app) => new TicketRepository(app, await app.make(PathSafety), await app.make(LedgerRepository)));

package/build/TemplateRendering/Computed/Providers/AuthoringFlowchartProvider.js

@@ -4,7 +4,7 @@ export class AuthoringFlowchartProvider extends ComputedVariableProvider {
         return [
             "```mermaid",
             "flowchart TD",
-            '    A["Read and consider only the `int-writing-for-agents` and `asd-ste100` skills"]',
+            '    A["Read and consider only the `int-writing-for-agents` and `ref-asd-ste100` skills"]',
             '    A --> B["Use the `grill` skill on the user request"]',
             '    B --> C{"Shared understanding confirmed?"}',
             '    C -- "No" --> B',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@use-the-fork/spindle",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "",
   "keywords": [],
   "license": "ISC",
@@ -40,7 +40,7 @@
   "devEngines": {
     "packageManager": {
       "name": "pnpm",
-      "version": "12.11.1",
+      "version": ">=12.9.0",
       "onFail": "warn"
     }
   },

package/build/SubagentDrivenDevelopment/Services/IntegrationService.js

@@ -1,258 +0,0 @@
-import matter from "gray-matter";
-import { Service } from "../../Foundation/Service.js";
-import { validateAuthor, validateTicketId, } from "../Policies/InputValidation.js";
-import { requiredTicketReviewers } from "../Policies/RequiredReviewers.js";
-export class IntegrationService extends Service {
-    gitEvidence;
-    reportEvidence;
-    ticketRepository;
-    ledgerRepository;
-    workspaceTransaction;
-    acceptancePolicy;
-    workflowPolicy;
-    featureInspectionService;
-    constructor(app, gitEvidence, reportEvidence, ticketRepository, ledgerRepository, workspaceTransaction, acceptancePolicy, workflowPolicy, featureInspectionService) {
-        super(app);
-        this.gitEvidence = gitEvidence;
-        this.reportEvidence = reportEvidence;
-        this.ticketRepository = ticketRepository;
-        this.ledgerRepository = ledgerRepository;
-        this.workspaceTransaction = workspaceTransaction;
-        this.acceptancePolicy = acceptancePolicy;
-        this.workflowPolicy = workflowPolicy;
-        this.featureInspectionService = featureInspectionService;
-    }
-    accept(options) {
-        validateTicketId(options.ticket);
-        validateAuthor(options.author);
-        const feature = this.featureInspectionService.resolveFeature(options.spec);
-        return this.workspaceTransaction.run(feature.workspace, () => {
-            const ledger = this.ledgerRepository.readLedger(feature);
-            const ticket = this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket);
-            const progress = this.workflowPolicy.requireProgress(ledger, options.ticket);
-            if (progress.execution !== "reviewing" &&
-                progress.execution !== "changes-requested" &&
-                progress.execution !== "accepted") {
-                throw new Error(`Ticket ${options.ticket} must be reviewing before it can be accepted.`);
-            }
-            if (!progress.owner || progress.owner !== options.author.trim()) {
-                throw new Error("Only the current controller may accept this ticket.");
-            }
-            const identity = this.gitEvidence.contentIdentity(feature, ticket, progress.baseSha, progress.checks);
-            const blockers = this.acceptancePolicy.acceptBlockers(feature, ledger, ticket, progress, identity);
-            if (blockers.length > 0) {
-                throw new Error(`Ticket ${options.ticket} cannot be accepted:\n${blockers.join("\n")}`);
-            }
-            const reviews = requiredTicketReviewers(ledger, progress).map(({ agent, details }) => {
-                const assignment = progress.reviewAssignments.find((candidate) => candidate.agent === agent &&
-                    candidate.objective === details &&
-                    candidate.scope === "initial");
-                return {
-                    agent,
-                    assignment: assignment.id,
-                    result: "passed",
-                    ...(assignment.noFindings === true
-                        ? { noFindings: true }
-                        : { findingIds: assignment.findingIds }),
-                };
-            });
-            if (progress.execution === "accepted") {
-                if (!progress.acceptedEvidence) {
-                    throw new Error(`Accepted ticket ${options.ticket} has no frozen integration evidence.`);
-                }
-                return {
-                    ticket: options.ticket,
-                    execution: "accepted",
-                    reviews,
-                    idempotent: true,
-                    ...identity,
-                };
-            }
-            const confirmedTicket = this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket);
-            const confirmedIdentity = this.gitEvidence.contentIdentity(feature, confirmedTicket, progress.baseSha, progress.checks);
-            const confirmedBlockers = this.acceptancePolicy.acceptBlockers(feature, ledger, confirmedTicket, progress, confirmedIdentity);
-            if (confirmedIdentity.snapshot !== identity.snapshot || confirmedBlockers.length > 0) {
-                throw new Error(`Ticket content changed while accepting; revalidate current review and check coverage:\n${confirmedBlockers.join("\n")}`);
-            }
-            const acceptedFiles = this.workflowPolicy.acceptedInventory(progress, options.ticket);
-            if (JSON.stringify(this.gitEvidence.changedPaths(progress.baseSha)) !==
-                JSON.stringify(acceptedFiles)) {
-                throw new Error("Accepted Git inventory changed while accepting the ticket.");
-            }
-            const contentDigest = this.gitEvidence.worktreeContentDigest(acceptedFiles);
-            progress.execution = "accepted";
-            progress.acceptedEvidence = {
-                snapshot: identity.snapshot,
-                codeSnapshot: identity.codeSnapshot,
-                requirementsSnapshot: identity.requirementsSnapshot,
-                files: acceptedFiles,
-                contentDigest,
-            };
-            const afterTicket = matter.stringify(this.ticketRepository.appendAudit(ticket.body, options.author, `Ticket accepted with current passing checks and complete initial review coverage: ${reviews.map((review) => `${review.agent} (${review.assignment})`).join(", ")}.`), this.ticketRepository.metadata(ticket));
-            this.workspaceTransaction.writeWorkflowState(feature, ticket, afterTicket, ledger);
-            return {
-                ticket: options.ticket,
-                execution: "accepted",
-                reviews,
-                ...identity,
-            };
-        });
-    }
-    integrate(options) {
-        validateTicketId(options.ticket);
-        validateAuthor(options.author);
-        if (options.commit && !/^[0-9a-f]{40,64}$/i.test(options.commit)) {
-            throw new Error("--commit must be an existing full Git commit SHA.");
-        }
-        const feature = this.featureInspectionService.resolveFeature(options.spec);
-        return this.workspaceTransaction.run(feature.workspace, () => {
-            const ledger = this.ledgerRepository.readLedger(feature);
-            const ticket = this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket);
-            const progress = this.workflowPolicy.requireProgress(ledger, options.ticket);
-            if (progress.execution !== "accepted" && progress.execution !== "integrated") {
-                throw new Error(`Ticket ${options.ticket} must be accepted before integration.`);
-            }
-            if (!progress.owner || progress.owner !== options.author.trim()) {
-                throw new Error("Only the current controller may integrate this ticket.");
-            }
-            const accepted = progress.acceptedEvidence;
-            if (!accepted) {
-                throw new Error(`Ticket ${options.ticket} has no frozen accepted inventory and evidence.`);
-            }
-            if (!progress.baseSha) {
-                throw new Error(`Ticket ${options.ticket} has no recorded Git baseline for integration.`);
-            }
-            const identity = this.gitEvidence.contentIdentity(feature, ticket, progress.baseSha, progress.checks);
-            if (identity.requirementsSnapshot !== accepted.requirementsSnapshot) {
-                throw new Error("Accepted requirements evidence is stale; re-review is required.");
-            }
-            const inventory = this.gitEvidence.changedPaths(progress.baseSha);
-            if (JSON.stringify(inventory) !== JSON.stringify(accepted.files)) {
-                throw new Error(`Git-derived inventory changed after acceptance; expected ${JSON.stringify(accepted.files)}, found ${JSON.stringify(inventory)}.`);
-            }
-            const currentDigest = this.gitEvidence.worktreeContentDigest(accepted.files);
-            if (currentDigest !== accepted.contentDigest) {
-                throw new Error("Accepted file content changed after acceptance.");
-            }
-            this.gitEvidence.assertSafeIntegrationChanges(feature, accepted.files, ledger);
-            this.reportEvidence.assertAcceptedReportsCurrent(feature, progress);
-            if (!options.commit) {
-                if (progress.execution === "integrated") {
-                    return {
-                        ticket: options.ticket,
-                        execution: "integrated",
-                        acceptedFiles: accepted.files,
-                        deliveryRecords: this.gitEvidence.deliveryRecordPaths(feature),
-                        commitSha: progress.integration?.commitSha,
-                        idempotent: true,
-                        ...identity,
-                    };
-                }
-                const blockers = this.acceptancePolicy.acceptBlockers(feature, ledger, ticket, progress, identity);
-                if (blockers.length > 0) {
-                    throw new Error(`Ticket ${options.ticket} cannot be integrated:\n${blockers.join("\n")}`);
-                }
-                return {
-                    ticket: options.ticket,
-                    execution: "accepted",
-                    acceptedFiles: accepted.files,
-                    deliveryRecords: this.gitEvidence.deliveryRecordPaths(feature),
-                    ...identity,
-                };
-            }
-            const requestedCommit = this.gitEvidence
-                .gitBuffer(["rev-parse", "--verify", `${options.commit}^{commit}`])
-                .toString("utf8")
-                .trim()
-                .toLowerCase();
-            if (requestedCommit !== options.commit.toLowerCase()) {
-                throw new Error(`Commit ${options.commit} did not resolve to the requested commit.`);
-            }
-            if (progress.execution === "integrated") {
-                if (progress.integration?.commitSha !== requestedCommit) {
-                    throw new Error(`Ticket ${options.ticket} is already integrated through ${progress.integration?.commitSha ?? "an unknown commit"}.`);
-                }
-                if (this.gitEvidence.gitIndexContentDigest(accepted.files) !== accepted.contentDigest) {
-                    throw new Error("Staged index content does not match the accepted file content.");
-                }
-                return {
-                    ticket: options.ticket,
-                    execution: "integrated",
-                    acceptedFiles: accepted.files,
-                    deliveryRecords: this.gitEvidence.deliveryRecordPaths(feature),
-                    commitSha: requestedCommit,
-                    idempotent: true,
-                    ...identity,
-                };
-            }
-            const acceptedIdentity = {
-                snapshot: accepted.snapshot,
-                codeSnapshot: accepted.codeSnapshot,
-                requirementsSnapshot: accepted.requirementsSnapshot,
-                headSha: identity.headSha,
-            };
-            const acceptanceBlockers = this.acceptancePolicy.acceptBlockers(feature, ledger, ticket, progress, acceptedIdentity);
-            if (acceptanceBlockers.length > 0) {
-                throw new Error(`Accepted evidence is no longer valid for integration:\n${acceptanceBlockers.join("\n")}`);
-            }
-            const headSha = this.gitEvidence.headSha();
-            if (headSha !== requestedCommit) {
-                throw new Error(`Commit ${requestedCommit} must be the current HEAD (${headSha}) before integration can be confirmed.`);
-            }
-            const ancestry = this.gitEvidence
-                .gitBuffer(["rev-list", "--parents", "-n", "1", requestedCommit])
-                .toString("utf8")
-                .trim()
-                .split(/\s+/);
-            if (ancestry.length !== 2 || ancestry[1] !== progress.baseSha) {
-                throw new Error(`Commit ${requestedCommit} must be a caller-created child of the recorded baseline ${progress.baseSha}.`);
-            }
-            const committedFiles = this.gitEvidence
-                .gitBuffer([
-                "diff",
-                "--name-only",
-                "-z",
-                "--no-renames",
-                progress.baseSha,
-                requestedCommit,
-                "--",
-                ".",
-            ])
-                .toString("utf8")
-                .split("\0")
-                .filter(Boolean)
-                .sort();
-            if (JSON.stringify(committedFiles) !== JSON.stringify(accepted.files)) {
-                throw new Error(`Commit contents do not match the accepted inventory; expected ${JSON.stringify(accepted.files)}, found ${JSON.stringify(committedFiles)}.`);
-            }
-            if (this.gitEvidence.gitTreeContentDigest(requestedCommit, accepted.files) !==
-                accepted.contentDigest) {
-                throw new Error("Caller commit content does not match the accepted file content.");
-            }
-            if (this.gitEvidence.worktreeContentDigest(accepted.files) !== accepted.contentDigest) {
-                throw new Error("Accepted file content changed before integration confirmation.");
-            }
-            if (this.gitEvidence.gitIndexContentDigest(accepted.files) !== accepted.contentDigest) {
-                throw new Error("Staged index content does not match the accepted file content.");
-            }
-            progress.execution = "integrated";
-            progress.integration = {
-                commitSha: requestedCommit,
-                integratedAt: new Date().toISOString(),
-                integratedBy: options.author.trim(),
-                files: accepted.files,
-                contentDigest: accepted.contentDigest,
-            };
-            const afterTicket = matter.stringify(this.ticketRepository.appendAudit(ticket.body, options.author, `Ticket integration confirmed against caller-owned commit ${requestedCommit}; delivery records remain caller-owned.`), this.ticketRepository.metadata(ticket));
-            this.workspaceTransaction.writeWorkflowState(feature, ticket, afterTicket, ledger);
-            return {
-                ticket: options.ticket,
-                execution: "integrated",
-                acceptedFiles: accepted.files,
-                deliveryRecords: this.gitEvidence.deliveryRecordPaths(feature),
-                commitSha: requestedCommit,
-                ...this.gitEvidence.contentIdentity(feature, this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket), progress.baseSha, progress.checks),
-            };
-        });
-    }
-}