@use-the-fork/spindle 0.0.0-stage → 0.0.2

package/build/SubagentDrivenDevelopment/Services/ChecksService.js

@@ -0,0 +1,319 @@
+import { Service } from "../../Foundation/Service.js";
+import { isSafeCoveragePath } from "../Persistence/CheckSchema.js";
+import { validateAuthor, validateTicketId, } from "../Policies/InputValidation.js";
+export class ChecksService extends Service {
+    gitEvidence;
+    ticketRepository;
+    ledgerRepository;
+    workspaceTransaction;
+    workflowPolicy;
+    featureInspectionService;
+    constructor(app, gitEvidence, ticketRepository, ledgerRepository, workspaceTransaction, workflowPolicy, featureInspectionService) {
+        super(app);
+        this.gitEvidence = gitEvidence;
+        this.ticketRepository = ticketRepository;
+        this.ledgerRepository = ledgerRepository;
+        this.workspaceTransaction = workspaceTransaction;
+        this.workflowPolicy = workflowPolicy;
+        this.featureInspectionService = featureInspectionService;
+    }
+    checksRequire(options) {
+        if (options.scope === "delivery") {
+            if (options.ticket)
+                throw new Error("--ticket and --scope delivery are mutually exclusive.");
+            return this.deliveryChecksRequire(options);
+        }
+        if (options.scope !== undefined)
+            throw new Error("--scope must be 'delivery'.");
+        if (!options.ticket)
+            throw new Error("checks require needs --ticket or --scope delivery.");
+        validateTicketId(options.ticket);
+        validateAuthor(options.author);
+        const command = options.command.trim();
+        if (!command)
+            throw new Error("Check command must not be empty.");
+        if (options.remove && !options.details?.trim()) {
+            throw new Error("Removing a required check requires non-empty --details rationale.");
+        }
+        if (!options.remove && options.details !== undefined) {
+            throw new Error("--details is only valid when removing a required check.");
+        }
+        const feature = this.featureInspectionService.resolveFeature(options.spec);
+        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) {
+                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 active = checks.required.find((requirement) => requirement.command === command && !requirement.removedAt);
+            if (options.remove) {
+                if (!active)
+                    throw new Error(`Required check is not declared: ${command}.`);
+                active.removedAt = new Date().toISOString();
+                active.removedBy = options.author.trim();
+                active.removalDetails = options.details.trim();
+            }
+            else {
+                if (active) {
+                    return {
+                        ticket: options.ticket,
+                        checks,
+                        idempotent: true,
+                        ...this.gitEvidence.contentIdentity(feature, this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket), progress.baseSha, checks),
+                    };
+                }
+                checks.required.push({
+                    command,
+                    addedAt: new Date().toISOString(),
+                    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,
+            };
+        });
+    }
+    checksRecord(options) {
+        if (options.scope === "delivery") {
+            if (options.ticket)
+                throw new Error("--ticket and --scope delivery are mutually exclusive.");
+            return this.deliveryChecksRecord(options);
+        }
+        if (options.scope !== undefined)
+            throw new Error("--scope must be 'delivery'.");
+        if (!options.ticket)
+            throw new Error("checks record needs --ticket or --scope delivery.");
+        validateTicketId(options.ticket);
+        validateAuthor(options.author);
+        const command = options.command.trim();
+        if (!command)
+            throw new Error("Check command must not be empty.");
+        if (!/^[0-9a-f]{64}$/i.test(options.snapshot)) {
+            throw new Error("Snapshot must be a 64-character hexadecimal content identity.");
+        }
+        if (!["passed", "failed", "unavailable"].includes(options.result)) {
+            throw new Error(`Invalid check result: ${options.result}.`);
+        }
+        if (options.result !== "passed" && !options.details?.trim()) {
+            throw new Error("--details is required for failed or unavailable checks.");
+        }
+        const feature = this.featureInspectionService.resolveFeature(options.spec);
+        return this.workspaceTransaction.run(feature.workspace, () => {
+            const ledger = this.ledgerRepository.readLedger(feature);
+            const progress = this.workflowPolicy.requireProgress(ledger, options.ticket);
+            const checks = progress.checks;
+            if (!checks)
+                throw new Error("No required checks are declared for this ticket.");
+            const requirement = checks.required.find((item) => item.command === command && !item.removedAt);
+            if (!requirement)
+                throw new Error(`Check command is not currently required: ${command}.`);
+            const coveredPaths = options.paths === undefined
+                ? undefined
+                : [...new Set(options.paths.map((path) => path.trim()))].sort();
+            if (coveredPaths &&
+                (coveredPaths.length === 0 || coveredPaths.some((path) => !isSafeCoveragePath(path)))) {
+                throw new Error("--paths must contain unique safe checkout-relative file paths.");
+            }
+            const ticket = this.ticketRepository.requireTicket(this.ticketRepository.readTickets(feature.workspace), options.ticket);
+            const identity = this.gitEvidence.contentIdentity(feature, ticket, progress.baseSha, checks);
+            if (identity.snapshot !== options.snapshot) {
+                throw new Error(`Snapshot is stale; current content identity is ${identity.snapshot}. No check result was recorded.`);
+            }
+            const latestForCommand = [...checks.records]
+                .reverse()
+                .find((record) => record.command === command);
+            const repeat = latestForCommand &&
+                latestForCommand.result === options.result &&
+                latestForCommand.author === options.author.trim() &&
+                latestForCommand.snapshot === options.snapshot &&
+                latestForCommand.details === options.details?.trim() &&
+                JSON.stringify(latestForCommand.coveredPaths) === JSON.stringify(coveredPaths)
+                ? latestForCommand
+                : undefined;
+            if (repeat)
+                return { ticket: options.ticket, record: repeat, idempotent: true, ...identity };
+            const record = {
+                command,
+                result: options.result,
+                author: options.author.trim(),
+                snapshot: identity.snapshot,
+                codeSnapshot: identity.codeSnapshot,
+                requirementsSnapshot: identity.requirementsSnapshot,
+                headSha: identity.headSha,
+                recordedAt: new Date().toISOString(),
+                ...(coveredPaths
+                    ? {
+                        coveredPaths,
+                        coverageSnapshot: this.gitEvidence.contentIdentity(feature, ticket, progress.baseSha, checks, coveredPaths).codeSnapshot,
+                    }
+                    : {}),
+                ...(options.details?.trim() ? { details: options.details.trim() } : {}),
+            };
+            checks.records.push(record);
+            let correctionCheckHistory;
+            if (progress.assignment?.action === "correct") {
+                const attempt = progress.correctionAttempts?.find((candidate) => candidate.number === progress.assignment?.attempt);
+                if (attempt) {
+                    const recorded = (attempt.checks ??= []);
+                    correctionCheckHistory = recorded;
+                    if (!recorded.some((candidate) => candidate.recordedAt === record.recordedAt)) {
+                        recorded.push(record);
+                    }
+                }
+            }
+            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) {
+                checks.records.pop();
+                correctionCheckHistory?.pop();
+                throw new Error("Content changed while recording the check; retry with a fresh snapshot.");
+            }
+            this.workspaceTransaction.writeLedger(feature, ledger);
+            return { ticket: options.ticket, record, ...identity };
+        });
+    }
+    deliveryChecksRequire(options) {
+        validateAuthor(options.author);
+        const command = options.command.trim();
+        if (!command)
+            throw new Error("Check command must not be empty.");
+        if (options.remove && !options.details?.trim()) {
+            throw new Error("Removing a required check requires non-empty --details rationale.");
+        }
+        if (!options.remove && options.details !== undefined) {
+            throw new Error("--details is only valid when removing a required check.");
+        }
+        const feature = this.featureInspectionService.resolveFeature(options.spec);
+        return this.workspaceTransaction.run(feature.workspace, () => {
+            const ledger = this.ledgerRepository.readLedger(feature);
+            const delivery = ledger.delivery;
+            this.workflowPolicy.assertDeliveryOpen(delivery);
+            if (delivery.owner && delivery.owner !== options.author.trim()) {
+                throw new Error("Only the recorded delivery controller may change required checks.");
+            }
+            if (delivery.execution === "reviewing" && (delivery.reviewAssignments?.length ?? 0) > 0) {
+                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 active = checks.required.find((requirement) => requirement.command === command && !requirement.removedAt);
+            if (options.remove) {
+                if (!active)
+                    throw new Error(`Required delivery check is not declared: ${command}.`);
+                active.removedAt = new Date().toISOString();
+                active.removedBy = options.author.trim();
+                active.removalDetails = options.details.trim();
+            }
+            else {
+                if (active) {
+                    const identity = this.gitEvidence.deliveryIdentity(feature, ledger, this.ticketRepository.readTickets(feature.workspace));
+                    return { scope: "delivery", checks, idempotent: true, ...identity };
+                }
+                checks.required.push({
+                    command,
+                    addedAt: new Date().toISOString(),
+                    addedBy: options.author.trim(),
+                });
+            }
+            const identity = this.gitEvidence.deliveryIdentity(feature, ledger, this.ticketRepository.readTickets(feature.workspace));
+            delivery.history.push({
+                at: new Date().toISOString(),
+                author: options.author.trim(),
+                action: `${options.remove ? "delivery-check-removed" : "delivery-check-required"}:${command}`,
+            });
+            this.workspaceTransaction.writeLedger(feature, ledger);
+            return { scope: "delivery", checks, ...identity };
+        });
+    }
+    deliveryChecksRecord(options) {
+        validateAuthor(options.author);
+        const command = options.command.trim();
+        if (!command)
+            throw new Error("Check command must not be empty.");
+        if (!/^[0-9a-f]{64}$/i.test(options.snapshot)) {
+            throw new Error("Snapshot must be a 64-character hexadecimal content identity.");
+        }
+        if (!["passed", "failed", "unavailable"].includes(options.result)) {
+            throw new Error(`Invalid check result: ${options.result}.`);
+        }
+        if (options.result !== "passed" && !options.details?.trim()) {
+            throw new Error("--details is required for failed or unavailable checks.");
+        }
+        const feature = this.featureInspectionService.resolveFeature(options.spec);
+        return this.workspaceTransaction.run(feature.workspace, () => {
+            const ledger = this.ledgerRepository.readLedger(feature);
+            const delivery = ledger.delivery;
+            this.workflowPolicy.assertDeliveryOpen(delivery);
+            if (!delivery.checks)
+                throw new Error("No required checks are declared for delivery.");
+            if (delivery.owner !== options.author.trim()) {
+                throw new Error("Only the recorded delivery controller may record final checks.");
+            }
+            const requirement = delivery.checks.required.find((item) => item.command === command && !item.removedAt);
+            if (!requirement)
+                throw new Error(`Check command is not currently required for delivery: ${command}.`);
+            const identity = this.gitEvidence.deliveryIdentity(feature, ledger, this.ticketRepository.readTickets(feature.workspace));
+            if (identity.snapshot !== options.snapshot) {
+                throw new Error(`Snapshot is stale; current delivery identity is ${identity.snapshot}. No check result was recorded.`);
+            }
+            const prior = [...delivery.checks.records]
+                .reverse()
+                .find((record) => record.command === command);
+            if (prior &&
+                prior.result === options.result &&
+                prior.author === options.author.trim() &&
+                prior.snapshot === identity.snapshot &&
+                prior.details === options.details?.trim()) {
+                return { scope: "delivery", record: prior, idempotent: true, ...identity };
+            }
+            const record = {
+                command,
+                result: options.result,
+                author: options.author.trim(),
+                snapshot: identity.snapshot,
+                codeSnapshot: identity.codeSnapshot,
+                requirementsSnapshot: identity.requirementsSnapshot,
+                headSha: identity.headSha,
+                recordedAt: new Date().toISOString(),
+                ...(options.details?.trim() ? { details: options.details.trim() } : {}),
+            };
+            delivery.checks.records.push(record);
+            if (record.result !== "passed")
+                delivery.execution = "changes-requested";
+            delivery.history.push({
+                at: record.recordedAt,
+                author: record.author,
+                action: `delivery-check-recorded:${command}:${record.result}`,
+            });
+            const confirmed = this.gitEvidence.deliveryIdentity(feature, ledger, this.ticketRepository.readTickets(feature.workspace));
+            if (confirmed.snapshot !== identity.snapshot) {
+                delivery.checks.records.pop();
+                delivery.history.pop();
+                throw new Error("Content changed while recording the delivery check; retry with a fresh snapshot.");
+            }
+            this.workspaceTransaction.writeLedger(feature, ledger);
+            return { scope: "delivery", record, ...identity };
+        });
+    }
+}

package/build/SubagentDrivenDevelopment/Services/CorrectionService.js

@@ -0,0 +1,273 @@
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import matter from "gray-matter";
+import { Service } from "../../Foundation/Service.js";
+import { lstatIfPresent } from "../Persistence/FileSystem.js";
+import { validateAuthor, validateTicketId, } from "../Policies/InputValidation.js";
+export class CorrectionService extends Service {
+    gitEvidence;
+    reportEvidence;
+    ticketRepository;
+    ledgerRepository;
+    workspaceTransaction;
+    workflowPolicy;
+    deliveryCorrectionService;
+    featureInspectionService;
+    constructor(app, gitEvidence, reportEvidence, ticketRepository, ledgerRepository, workspaceTransaction, workflowPolicy, deliveryCorrectionService, featureInspectionService) {
+        super(app);
+        this.gitEvidence = gitEvidence;
+        this.reportEvidence = reportEvidence;
+        this.ticketRepository = ticketRepository;
+        this.ledgerRepository = ledgerRepository;
+        this.workspaceTransaction = workspaceTransaction;
+        this.workflowPolicy = workflowPolicy;
+        this.deliveryCorrectionService = deliveryCorrectionService;
+        this.featureInspectionService = featureInspectionService;
+    }
+    correct(options) {
+        if (options.scope === "delivery") {
+            if (options.ticket)
+                throw new Error("--ticket and --scope delivery are mutually exclusive.");
+            return this.deliveryCorrectionService.deliveryCorrect(options);
+        }
+        if (options.scope !== undefined)
+            throw new Error("--scope must be 'delivery'.");
+        if (!options.ticket)
+            throw new Error("correct requires --ticket or --scope delivery.");
+        validateTicketId(options.ticket);
+        validateAuthor(options.author);
+        const findingIds = [...new Set((options.findings ?? []).map((finding) => finding.trim()))];
+        if (findingIds.some((finding) => !/^F-\d{4,}$/.test(finding))) {
+            throw new Error("--findings must contain canonical finding IDs.");
+        }
+        const objective = options.details.trim();
+        if (!objective)
+            throw new Error("--details must not be empty.");
+        if (options.decision !== undefined && !["continue", "pause"].includes(options.decision)) {
+            throw new Error("--decision must be 'continue' or 'pause'.");
+        }
+        if (options.decision !== "pause" && findingIds.length === 0 && !options.checkFailure?.trim()) {
+            throw new Error("correct requires actionable --findings or a non-mechanical --check-failure.");
+        }
+        if (options.decision === "pause") {
+            if (![
+                "no-progress",
+                "repeated-failure",
+                "recurring-blocker",
+                "requirements-disagreement",
+                "worker-blocked",
+            ].includes(options.reason ?? "")) {
+                throw new Error("--reason is required for a pause and must identify the adjudication category.");
+            }
+            if (options.assessment || options.assessmentResult)
+                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.");
+        }
+        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.owner !== options.author.trim()) {
+                throw new Error("Only the recorded ticket controller may dispatch a correction.");
+            }
+            const attempts = (progress.correctionAttempts ??= []);
+            if (options.decision === "pause") {
+                if (progress.execution === "implementing" && progress.assignment?.status !== "submitted") {
+                    throw new Error("A pending implementation assignment must be resumed, not paused.");
+                }
+                const identity = this.gitEvidence.contentIdentity(feature, ticket, progress.baseSha, progress.checks);
+                const hasCurrentFailure = (progress.checks?.records ?? []).some((record) => record.snapshot === identity.snapshot &&
+                    record.codeSnapshot === identity.codeSnapshot &&
+                    record.requirementsSnapshot === identity.requirementsSnapshot &&
+                    record.result === "failed");
+                if (attempts.length === 0 &&
+                    progress.execution !== "changes-requested" &&
+                    !hasCurrentFailure) {
+                    throw new Error("Adjudication pause requires a recorded failed correction, check, or review.");
+                }
+                const adjudication = {
+                    status: "pending",
+                    reason: options.reason,
+                    details: objective,
+                    recordedAt: new Date().toISOString(),
+                    recordedBy: options.author.trim(),
+                };
+                if (progress.adjudication?.status === "pending" &&
+                    progress.adjudication.reason === adjudication.reason &&
+                    progress.adjudication.details === adjudication.details &&
+                    progress.adjudication.recordedBy === adjudication.recordedBy) {
+                    return {
+                        ticket: options.ticket,
+                        execution: progress.execution,
+                        adjudication: progress.adjudication,
+                        paused: true,
+                        idempotent: true,
+                        ...identity,
+                    };
+                }
+                progress.adjudication = adjudication;
+                const afterTicket = matter.stringify(this.ticketRepository.appendAudit(ticket.body, options.author, `Corrective work paused for adjudication (${adjudication.reason}): ${adjudication.details}.`), this.ticketRepository.metadata(ticket));
+                this.workspaceTransaction.writeWorkflowState(feature, ticket, afterTicket, ledger);
+                return {
+                    ticket: options.ticket,
+                    execution: progress.execution,
+                    adjudication,
+                    paused: true,
+                    ...identity,
+                };
+            }
+            if (progress.execution === "implementing" &&
+                progress.assignment?.action === "correct" &&
+                progress.assignment.status !== "submitted" &&
+                progress.assignment.findingIds?.join(",") === findingIds.join(",") &&
+                progress.assignment.checkFailure === options.checkFailure?.trim() &&
+                progress.assignment.objective === objective) {
+                const current = attempts.find((attempt) => attempt.number === progress.assignment?.attempt);
+                if (!current)
+                    throw new Error("Corrective assignment has no persisted attempt record.");
+                const identity = this.gitEvidence.contentIdentity(feature, ticket, progress.baseSha, progress.checks);
+                return {
+                    ticket: options.ticket,
+                    execution: "implementing",
+                    attempt: current,
+                    assignment: progress.assignment,
+                    idempotent: true,
+                    ...identity,
+                };
+            }
+            const pendingAdjudication = progress.adjudication?.status === "pending";
+            if (pendingAdjudication && options.decision !== "continue") {
+                throw new Error(`Ticket ${options.ticket} is paused for adjudication (${progress.adjudication?.reason}); resolve it before another correction.`);
+            }
+            const checkDriven = !!options.checkFailure?.trim();
+            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)) {
+                throw new Error(`Ticket ${options.ticket} must have a submitted implementation before correction.`);
+            }
+            if (!progress.baseSha)
+                throw new Error("Correction requires the ticket's recorded Git baseline.");
+            if (progress.assignment?.action === "correct" && progress.assignment.status !== "submitted") {
+                throw new Error("The current correction assignment must be resumed, not replaced.");
+            }
+            if (attempts.length > 0 || pendingAdjudication) {
+                if (options.decision !== "continue" || !options.assessment?.trim()) {
+                    throw new Error("A subsequent correction requires --decision continue and an explicit --assessment.");
+                }
+                const previous = attempts.at(-1);
+                if (previous.progressAssessment?.decision !== "continue" ||
+                    previous.progressAssessment.result !== "productive" ||
+                    previous.progressAssessment.recordedBy !== options.author.trim() ||
+                    previous.progressAssessment.details !== options.assessment.trim()) {
+                    previous.progressAssessment = {
+                        decision: "continue",
+                        result: "productive",
+                        details: options.assessment.trim(),
+                        recordedAt: new Date().toISOString(),
+                        recordedBy: options.author.trim(),
+                    };
+                }
+            }
+            else if (options.decision || options.assessment) {
+                throw new Error("The first correction does not accept a continuation assessment.");
+            }
+            const identity = this.gitEvidence.contentIdentity(feature, ticket, progress.baseSha, progress.checks);
+            const findings = progress.findings ?? [];
+            for (const id of findingIds) {
+                const finding = findings.find((candidate) => candidate.id === id);
+                if (!finding || finding.status !== "confirmed") {
+                    throw new Error(`Finding ${id} is not an actionable unresolved finding.`);
+                }
+            }
+            const checkFailure = options.checkFailure?.trim();
+            if (checkFailure) {
+                const record = progress.checks?.records
+                    .filter((candidate) => candidate.command === checkFailure &&
+                    candidate.snapshot === identity.snapshot &&
+                    candidate.codeSnapshot === identity.codeSnapshot &&
+                    candidate.requirementsSnapshot === identity.requirementsSnapshot)
+                    .at(-1);
+                if (!record || record.result !== "failed") {
+                    throw new Error(`Check failure '${checkFailure}' must be an explicitly recorded failed check for the current snapshot.`);
+                }
+            }
+            const number = attempts.length + 1;
+            const assignment = {
+                id: randomUUID(),
+                role: "implementation",
+                action: "correct",
+                controller: options.author.trim(),
+                attempt: number,
+                findingIds,
+                ...(checkFailure ? { checkFailure } : {}),
+                objective,
+                report: join(feature.workspace, "reports", `${options.ticket}-round-${number}-fix.md`),
+                requestedAt: new Date().toISOString(),
+                status: "pending",
+                handoffs: [],
+            };
+            this.reportEvidence.assertReportPath(feature, assignment.report, false);
+            if (lstatIfPresent(assignment.report)) {
+                throw new Error(`Assigned report already exists and was preserved: ${assignment.report}.`);
+            }
+            const attempt = {
+                number,
+                findingIds,
+                ...(checkFailure ? { checkFailure } : {}),
+                objective,
+                startedAt: assignment.requestedAt,
+                startedBy: options.author.trim(),
+                assignmentId: assignment.id,
+                assignment,
+                ...(progress.assignment ? { priorAssignment: progress.assignment } : {}),
+                ...(checkFailure
+                    ? {
+                        checks: (progress.checks?.records ?? []).filter((record) => record.snapshot === identity.snapshot &&
+                            record.codeSnapshot === identity.codeSnapshot &&
+                            record.requirementsSnapshot === identity.requirementsSnapshot),
+                    }
+                    : {}),
+            };
+            if (attempts.length > 0 || pendingAdjudication) {
+                attempt.progressAssessment = {
+                    decision: "continue",
+                    result: "productive",
+                    details: options.assessment.trim(),
+                    recordedAt: new Date().toISOString(),
+                    recordedBy: options.author.trim(),
+                };
+            }
+            attempts.push(attempt);
+            progress.execution = "implementing";
+            progress.assignment = assignment;
+            if (pendingAdjudication && progress.adjudication) {
+                progress.adjudication.status = "resolved";
+                progress.adjudication.resolution = {
+                    details: options.assessment.trim(),
+                    recordedAt: new Date().toISOString(),
+                    recordedBy: options.author.trim(),
+                };
+            }
+            const afterTicket = matter.stringify(this.ticketRepository.appendAudit(ticket.body, options.author, `Corrective attempt ${number} recorded; objective=${objective}; findings=${findingIds.join(",") || "none"}${checkFailure ? `; check-failure=${checkFailure}` : ""}; report=${assignment.report}. No agent was launched.`), this.ticketRepository.metadata(ticket));
+            this.workspaceTransaction.writeWorkflowState(feature, ticket, afterTicket, ledger);
+            return {
+                ticket: options.ticket,
+                execution: "implementing",
+                attempt,
+                assignment,
+                ...identity,
+            };
+        });
+    }
+}