@use-the-fork/spindle 0.0.2 → 0.2.0

package/build/SubagentDrivenDevelopment/Services/DeliveryCorrectionService.js

@@ -44,19 +44,15 @@ export class DeliveryCorrectionService extends Service {
             ].includes(options.reason ?? "")) {
                 throw new Error("--reason is required for a pause and must identify the adjudication category.");
             }
-            if (options.assessment || options.assessmentResult) {
+            if (options.assessment) {
                 throw new Error("--assessment is only valid with --decision continue.");
             }
         }
         else if (options.reason) {
             throw new Error("--reason is only valid with --decision pause.");
         }
-        if (options.decision === "continue" &&
-            (!options.assessment?.trim() || options.assessmentResult !== "productive")) {
-            throw new Error("--assessment and --assessment-result productive are required with --decision continue.");
-        }
-        if (options.assessmentResult && options.decision !== "continue") {
-            throw new Error("--assessment-result is only valid with --decision continue.");
+        if (options.decision === "continue" && !options.assessment?.trim()) {
+            throw new Error("--assessment is required with --decision continue.");
         }
         const feature = this.featureInspectionService.resolveFeature(options.spec);
         return this.workspaceTransaction.run(feature.workspace, () => {

package/build/SubagentDrivenDevelopment/Services/DeliveryService.js

@@ -14,7 +14,8 @@ export class DeliveryService extends Service {
     findingPolicy;
     reviewPolicy;
     featureInspectionService;
-    constructor(app, gitEvidence, reportEvidence, ticketRepository, ledgerRepository, workspaceTransaction, checkPolicy, findingPolicy, reviewPolicy, featureInspectionService) {
+    finalization;
+    constructor(app, gitEvidence, reportEvidence, ticketRepository, ledgerRepository, workspaceTransaction, checkPolicy, findingPolicy, reviewPolicy, featureInspectionService, finalization) {
         super(app);
         this.gitEvidence = gitEvidence;
         this.reportEvidence = reportEvidence;
@@ -25,12 +26,17 @@ export class DeliveryService extends Service {
         this.findingPolicy = findingPolicy;
         this.reviewPolicy = reviewPolicy;
         this.featureInspectionService = featureInspectionService;
+        this.finalization = finalization;
     }
     finish(options) {
         validateAuthor(options.author);
-        const feature = this.featureInspectionService.resolveFeature(options.spec);
+        const feature = this.finalization.recordedFeature(options.spec) ??
+            this.featureInspectionService.resolveFeature(options.spec);
+        return this.finalization.finish(feature, options, (ledger) => this.assertReady(feature, options, ledger));
+    }
+    assertReady(feature, options, approvedLedger) {
         return this.workspaceTransaction.run(feature.workspace, () => {
-            const ledger = this.ledgerRepository.readLedger(feature);
+            const ledger = approvedLedger ?? this.ledgerRepository.readLedger(feature);
             const delivery = ledger.delivery;
             if (ledger.tickets.length === 0) {
                 throw new Error("Cannot finish; the feature must contain at least one ticket.");
@@ -42,9 +48,39 @@ export class DeliveryService extends Service {
             if (missing.length > 0) {
                 throw new Error(`Cannot finish; every feature ticket must be closed: ${missing.join(", ")}.`);
             }
+            const unintegrated = ledger.tickets
+                .filter((progress) => progress.execution !== "integrated" || !progress.integration)
+                .map((progress) => progress.id);
+            if (unintegrated.length > 0) {
+                throw new Error(`Cannot finish; every ticket must be integrated: ${unintegrated.join(", ")}.`);
+            }
+            if (ledger.tickets.some((progress) => !progress.worktree ||
+                progress.integration?.postMerge?.status !== "passed" ||
+                !progress.integration.postMerge.checks ||
+                progress.integration.postMerge.mergeSha !== progress.integration.mergeSha ||
+                progress.integration.postMerge.checks.required.length === 0 ||
+                progress.integration.postMerge.checks.required.some((requirement) => {
+                    const latest = progress
+                        .integration.postMerge.checks.records.filter((record) => record.command === requirement.command)
+                        .at(-1);
+                    return (latest?.result !== "passed" || latest.headSha !== progress.integration.mergeSha);
+                }))) {
+                throw new Error("Cannot finish; every ticket needs recorded worktree ownership and passing exact post-merge validation.");
+            }
             if (tickets.length !== ledger.tickets.length) {
                 throw new Error("Cannot finish; one or more feature ticket documents are missing.");
             }
+            for (const progress of ledger.tickets) {
+                if (!progress.acceptedEvidence || progress.adjudication?.status === "pending") {
+                    throw new Error(`Cannot finish; ticket ${progress.id} has no frozen acceptance evidence or awaits adjudication.`);
+                }
+                const blockers = this.findingPolicy.findingBlockers(progress, {
+                    ...progress.acceptedEvidence,
+                    headSha: progress.integration.commitSha,
+                });
+                if (blockers.length)
+                    throw new Error(`Cannot finish; ticket findings remain blocking:\n${blockers.join("\n")}`);
+            }
             if (delivery.adjudication?.status === "pending") {
                 throw new Error(`Cannot finish; delivery correction is paused for adjudication (${delivery.adjudication.reason}).`);
             }
@@ -101,49 +137,18 @@ export class DeliveryService extends Service {
                     reportSha256: createHash("sha256").update(content).digest("hex"),
                 };
             }
-            if (delivery.finished) {
-                const same = delivery.finished.report === retrospective?.report &&
-                    delivery.finished.reportSha256 === retrospective?.reportSha256;
-                if (!same) {
-                    throw new Error("Full-spec delivery is already finished with different retrospective evidence.");
-                }
-                return {
-                    scope: "delivery",
-                    finished: true,
-                    idempotent: true,
-                    retrospectiveRequired: ledger.retrospectiveRequired,
-                    ...(retrospective ? { retrospective } : {}),
-                    ...identity,
-                };
-            }
             const confirmed = this.gitEvidence.deliveryIdentity(feature, ledger, this.ticketRepository.readTickets(feature.workspace));
             if (confirmed.snapshot !== identity.snapshot ||
                 this.checkPolicy.deliveryCheckBlockers(delivery, confirmed).length > 0) {
                 throw new Error("Aggregate content or check evidence changed while finishing; resume and revalidate delivery.");
             }
-            delivery.execution = "complete";
-            delivery.finished = {
-                at: new Date().toISOString(),
-                author: options.author.trim(),
-                ...retrospective,
-            };
-            delivery.status = "complete";
-            delivery.history.push({
-                at: delivery.finished.at,
-                author: delivery.finished.author,
-                action: "delivery-finished",
-            });
-            this.workspaceTransaction.writeLedger(feature, ledger);
-            return {
-                scope: "delivery",
-                finished: true,
-                retrospectiveRequired: ledger.retrospectiveRequired,
-                ...(retrospective ? { retrospective } : {}),
-                ...identity,
-            };
+            return { ledger, identity, retrospective };
         });
     }
     next(options) {
+        const recorded = this.finalization.recordedFeature(options.spec);
+        if (recorded)
+            return this.finalization.status(recorded.feature);
         const status = this.featureInspectionService.status(options);
         return {
             feature: status.feature,

package/build/SubagentDrivenDevelopment/Services/FeatureCreationService.js

@@ -97,7 +97,7 @@ export class FeatureCreationService extends Service {
                     retrospectiveRequired: options.requireRetrospective ?? false,
                     reviewPolicy: {
                         version: 1,
-                        ticket: ["sdd-reviewer"],
+                        ticket: ["sdd-task-reviewer"],
                         delivery: ["sdd-reviewer"],
                     },
                     tickets: [],