@wrongstack/sdd 0.298.3 → 0.300.0

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { TaskGenerator, extractVerificationCommand, assessGeneratedTaskAtomicity
 export { TaskTracker, DefaultTaskStore, type TaskStore, type TaskTrackerOptions, type TaskTransition, type TaskTrackerChange, type TaskTrackerListener, } from '@wrongstack/core/tasking';
 export { TaskFlow, SpecDrivenDev, type TaskFlowPhase, type TaskFlowOptions, type TaskFlowExecutionContext, type TaskFlowEventMap, type TaskFlowEventName, type SpecDrivenDevOptions, } from './task-flow.js';
 export { SpecStore, type SpecStoreOptions, type SpecIndexEntry } from './spec-store.js';
-export { TaskGraphStore, type TaskGraphStoreOptions, type TaskGraphIndexEntry } from './task-graph-store.js';
+export { TaskGraphStore, type TaskGraphStoreOptions, type TaskGraphIndexEntry, } from './task-graph-store.js';
 export { buildBoardTasks, buildBoardSnapshot, shortIdMap, type SddBoardSnapshot, type SddBoardTask, type SddBoardColumn, type SddBoardStatus, type SddTaskDisplayStatus, type SddDeadlockChain, type SddBoardFeedEntry, } from './board-types.js';
 export { SddBoardStore, type SddBoardStoreOptions, type SddBoardIndexEntry, type SddBoardEvent, } from './sdd-board-store.js';
 export { SddBoardProjector, type SddBoardPersistence, type SddBoardProjectorOptions, } from './sdd-board-projector.js';
@@ -14,9 +14,10 @@ export { cleanupSddWorktrees, cleanupStaleWorktrees, cleanupStaleSddWorktrees, r
 export { AISpecBuilder, type AISpecBuilderOptions, type AISpecPhase, type AISpecSession, type AISpecSessionPersistence, type CollectedAnswer, isAISpecSession, } from './spec-builder.js';
 export { createKanbanSddSessionPersistence } from './kanban-sdd-session.js';
 export { gatherProjectContext } from './project-context.js';
+export { intakeToInterviewKickoff, startInterviewFromIntake, type IntakeInterviewKickoff, } from './intake-kickoff.js';
 export { SPEC_TEMPLATES, getTemplate, listTemplates, templateToMarkdown, } from './spec-templates.js';
 export { renderTaskGraph, renderProgress, renderTaskList, renderSpecAnalysis, } from './task-visualizer.js';
-export { analyzeCriticalPath, type CriticalPathAnalysis, type BottleneckTask } from './critical-path.js';
+export { analyzeCriticalPath, type CriticalPathAnalysis, type BottleneckTask, } from './critical-path.js';
 export { SpecVersioning, type SpecVersion, type SpecDiff } from './spec-versioning.js';
 export { AutoExecutor, createAutoExecutor, type AutoExecutorOptions, type TaskExecutionContext, type TaskExecutionResult, type ExecutionSummary, } from './auto-executor.js';
 export { SddTaskDecomposer, type SddTaskDecomposerOptions, type TaskBatch, } from './sdd-task-decomposer.js';

package/dist/index.js

@@ -2730,7 +2730,17 @@ async function executeSddTask(params) {
         taskId,
         reason: merged.reason
       });
-      await params.applyTaskFailure(taskId, subagentId, merged.reason);
+      if (merged.fatal) {
+        opts.tracker.updateNodeStatus(taskId, "failed", merged.reason);
+        params.emit("sdd.task.failed", {
+          runId: params.runId,
+          taskId,
+          subagentId,
+          error: merged.reason
+        });
+      } else {
+        await params.applyTaskFailure(taskId, subagentId, merged.reason);
+      }
     } else {
       const conflictFiles = merged.conflictFiles ?? [];
       params.emit("sdd.task.conflict", { runId: params.runId, taskId, conflictFiles });
@@ -2976,6 +2986,12 @@ var SddParallelRun = class {
    * snapshot so a post-run rollback can read them off disk.
    */
   mergedCommits = [];
+  /**
+   * Fatal, non-recoverable run error — set together with `stopRequested` when
+   * the run hard-stops (e.g. a known-invalid merge that could not be rolled
+   * back). Surfaced on `run()`'s result so the caller can see WHY it stopped.
+   */
+  fatalError;
   /** Monotonic dispatch counter (unique subagent ids) + dispatch-round counter. */
   dispatchSeq = 0;
   round = 0;
@@ -3112,6 +3128,7 @@ var SddParallelRun = class {
   async cancelTask(taskId) {
     const node = this.opts.tracker.getNode(taskId);
     if (!node) return false;
+    if (node.status === "completed") return false;
     this.cancelledTasks.add(taskId);
     this.opts.tracker.patchMetadata(taskId, { cancelled: true });
     this.opts.tracker.updateNodeStatus(taskId, "failed", "cancelled by user");
@@ -3175,6 +3192,7 @@ var SddParallelRun = class {
    */
   async run() {
     this.stopRequested = false;
+    this.fatalError = void 0;
     this.restoreRetryMap();
     const startTime = Date.now();
     this.round = 0;
@@ -3265,14 +3283,18 @@ var SddParallelRun = class {
         this.opts.onProgress?.(this.buildProgress());
       }
     }
-    if (this.stopRequested) await this.teardown();
+    if (this.stopRequested) {
+      await Promise.allSettled(running.values());
+      await this.teardown();
+    }
     const finalProgress = this.opts.tracker.getProgress();
     this.emit("sdd.run.finished", {
       runId: this.runId,
       deadlocked,
       completed: finalProgress.completed,
       failed: finalProgress.failed,
-      stopped: this.stopRequested
+      stopped: this.stopRequested,
+      ...this.fatalError ? { fatalError: this.fatalError } : {}
     });
     return {
       totalWaves: this.round,
@@ -3281,6 +3303,7 @@ var SddParallelRun = class {
       totalDurationMs: Date.now() - startTime,
       deadlocked,
       stopRequested: this.stopRequested,
+      ...this.fatalError ? { fatalError: this.fatalError } : {},
       finalProgress
     };
   }
@@ -3390,6 +3413,17 @@ var SddParallelRun = class {
       }
     }
   }
+  /**
+   * Hard-stop the run after an unrecoverable error: the base branch is in a
+   * state no retry can fix (e.g. a known-invalid merge that could not be rolled
+   * back), so continuing would contaminate every task forked after this point.
+   * The reason is surfaced on `run()`'s result and the `sdd.run.finished` event.
+   */
+  abortRun(reason) {
+    this.fatalError = reason;
+    this.stopRequested = true;
+    this.coordinator?.stopAll();
+  }
   // -------------------------------------------------------------------
   // Internal
   // -------------------------------------------------------------------
@@ -3592,8 +3626,16 @@ var SddParallelRun = class {
             regressed = `verification error after conflict resolution: ${String(err)}`;
           }
           if (regressed) {
-            await wt.revertBaseTo(handle, baseSha).catch(() => {
-            });
+            const rolledBack = await wt.revertBaseTo(handle, baseSha).catch(() => false);
+            if (!rolledBack) {
+              this.abortRun(
+                `cannot roll back invalid merge of "${task.title}" (${task.id}): ${regressed}`
+              );
+              await wt.release(handle, { keep: true }).catch(() => {
+              });
+              this.forgetWorktree(task.id, { keepBranchLabel: true });
+              return { ok: false, conflictFiles: [], reason: regressed, fatal: true };
+            }
             await wt.release(handle, { keep: false }).catch(() => {
             });
             this.forgetWorktree(task.id, { keepBranchLabel: true });
@@ -4226,6 +4268,32 @@ async function gatherProjectContext(projectRoot) {
   return parts.join("\n");
 }
 
+// src/intake-kickoff.ts
+function deriveTitle(value) {
+  const firstLine = value.split("\n").map((line) => line.trim()).find(Boolean);
+  if (!firstLine) return "New SDD Project";
+  const sentence = firstLine.split(/(?<=[.!?])\s/)[0] ?? firstLine;
+  return sentence.length <= 64 ? sentence : `${sentence.slice(0, 63).trimEnd()}\u2026`;
+}
+function intakeToInterviewKickoff(record) {
+  const contextLines = [];
+  if (record.businessGoal) contextLines.push(`Business goal: ${record.businessGoal}`);
+  if (record.expectedOutcome) contextLines.push(`Expected outcome: ${record.expectedOutcome}`);
+  if (record.scopeNotes) contextLines.push(`Scope notes: ${record.scopeNotes}`);
+  for (const targetUser of record.targetUsers) contextLines.push(`Target user: ${targetUser}`);
+  for (const constraint of record.constraints) contextLines.push(`Constraint: ${constraint}`);
+  for (const context of record.providedContext) contextLines.push(`Context: ${context}`);
+  return {
+    title: deriveTitle(record.title),
+    intent: record.originalRequest,
+    projectContext: contextLines.length > 0 ? contextLines.join("\n") : ""
+  };
+}
+function startInterviewFromIntake(driver, record) {
+  const kickoff = intakeToInterviewKickoff(record);
+  return driver.start(kickoff.title, kickoff.intent);
+}
+
 // src/spec-templates.ts
 var SPEC_TEMPLATES = [
   {
@@ -5530,6 +5598,7 @@ export {
   gatherProjectContext,
   getTemplate,
   hasConflictMarkers,
+  intakeToInterviewKickoff,
   isAISpecSession,
   isExplanatoryText,
   listTemplates,
@@ -5548,6 +5617,7 @@ export {
   rollbackSddRunFromDisk,
   shortIdMap,
   splitGraphNode,
+  startInterviewFromIntake,
   startSddRun,
   templateToMarkdown,
   tokenizeCommand

package/dist/intake-kickoff.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Requirements Intake → SDD interview kickoff.
+ *
+ * Bridges `@wrongstack/requirement-intake` records into the spec-builder
+ * interview. The original request stays the interview's intent verbatim;
+ * collected high-level facts (goal, outcome, constraints, target users) are
+ * folded into the project context the questioning prompt receives. Nothing
+ * here rewrites or summarizes the original request — it only routes it.
+ */
+import type { RequirementIntakeRecord } from '@wrongstack/requirement-intake';
+import type { SddInterviewDriver } from './sdd-interview-driver.js';
+export interface IntakeInterviewKickoff {
+    /** Short interview title (≤ 64 chars, first sentence of the record title). */
+    title: string;
+    /** Interview intent — the exact original request, verbatim. */
+    intent: string;
+    /** Extra project context (goal/outcome/constraints/users) for the prompt. */
+    projectContext: string;
+}
+/**
+ * Map an intake record to interview kickoff values. `intent` is the exact
+ * `originalRequest`; `projectContext` carries the collected high-level fields
+ * so the spec interview does not re-ask for already-provided information.
+ */
+export declare function intakeToInterviewKickoff(record: RequirementIntakeRecord): IntakeInterviewKickoff;
+/**
+ * Start a spec-builder interview from an intake record. Returns the first AI
+ * prompt (a question kickoff), ready to feed the agent loop. The driver should
+ * be constructed with `projectContext: kickoff.projectContext` so the
+ * questioning prompt already knows the collected facts.
+ */
+export declare function startInterviewFromIntake(driver: Pick<SddInterviewDriver, 'start'>, record: RequirementIntakeRecord): string;
+//# sourceMappingURL=intake-kickoff.d.ts.map

package/dist/sdd-parallel-run-types.d.ts

@@ -195,6 +195,12 @@ export interface RunResult {
     totalDurationMs: number;
     deadlocked: boolean;
     stopRequested: boolean;
+    /**
+     * Fatal, non-recoverable run error — set when the run hard-stopped
+     * (`stopRequested: true`) because no retry could fix the base state
+     * (e.g. a known-invalid merge that could not be rolled back).
+     */
+    fatalError?: string | undefined;
     finalProgress: TaskProgress;
 }
 //# sourceMappingURL=sdd-parallel-run-types.d.ts.map

package/dist/sdd-parallel-run.d.ts

@@ -74,6 +74,12 @@ export declare class SddParallelRun {
      * snapshot so a post-run rollback can read them off disk.
      */
     private mergedCommits;
+    /**
+     * Fatal, non-recoverable run error — set together with `stopRequested` when
+     * the run hard-stops (e.g. a known-invalid merge that could not be rolled
+     * back). Surfaced on `run()`'s result so the caller can see WHY it stopped.
+     */
+    private fatalError;
     /** Monotonic dispatch counter (unique subagent ids) + dispatch-round counter. */
     private dispatchSeq;
     private round;
@@ -197,6 +203,13 @@ export declare class SddParallelRun {
     static resetOrphans(tracker: TaskTracker): number;
     /** Clean teardown after a stop: reset interrupted tasks + release worktrees. */
     private teardown;
+    /**
+     * Hard-stop the run after an unrecoverable error: the base branch is in a
+     * state no retry can fix (e.g. a known-invalid merge that could not be rolled
+     * back), so continuing would contaminate every task forked after this point.
+     * The reason is surfaced on `run()`'s result and the `sdd.run.finished` event.
+     */
+    private abortRun;
     private buildCoordinator;
     private defaultFactory;
     /**

package/dist/sdd-task-execution.d.ts

@@ -22,6 +22,7 @@ export declare function executeSddTask(params: {
         ok: boolean;
         conflictFiles?: string[];
         reason?: string;
+        fatal?: boolean;
     }>;
     applyTaskFailure: (taskId: string, subagentId: string, errMsg: string) => Promise<void>;
 }): Promise<TaskOutcome>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wrongstack/sdd",
-  "version": "0.298.3",
+  "version": "0.300.0",
   "license": "MIT",
   "description": "WrongStack Spec-Driven Development engine — standalone package extracted from @wrongstack/core. Task graph generation, tracking, execution, lifecycle management, and AI-driven spec building for SDD workflows.",
   "repository": {
@@ -27,8 +27,9 @@
     "!dist/**/*.map"
   ],
   "dependencies": {
-    "@wrongstack/core": "0.298.3",
-    "@wrongstack/kanban": "0.298.3"
+    "@wrongstack/core": "0.300.0",
+    "@wrongstack/kanban": "0.300.0",
+    "@wrongstack/requirement-intake": "0.300.0"
   },
   "devDependencies": {
     "@types/node": "^26.1.2",