@wrongstack/sdd 0.295.1 → 0.296.3

package/dist/index.js

@@ -1836,20 +1836,21 @@ var AISpecBuilder = class {
   async saveSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp5 = await import("node:fs/promises");
-      const path4 = await import("node:path");
+      const fsp6 = await import("node:fs/promises");
+      const path6 = await import("node:path");
       const { atomicWrite: atomicWrite4 } = await import("@wrongstack/core/utils");
-      await fsp5.mkdir(path4.dirname(this.sessionPath), { recursive: true });
+      await fsp6.mkdir(path6.dirname(this.sessionPath), { recursive: true });
       await atomicWrite4(this.sessionPath, JSON.stringify(this.session, null, 2));
-    } catch {
+    } catch (error) {
+      console.error("[sdd] Failed to persist session", error);
     }
   }
   /** Load session state from disk. Returns true if a session was loaded. */
   async loadSession() {
     if (!this.sessionPath) return false;
     try {
-      const fsp5 = await import("node:fs/promises");
-      const raw = await fsp5.readFile(this.sessionPath, "utf8");
+      const fsp6 = await import("node:fs/promises");
+      const raw = await fsp6.readFile(this.sessionPath, "utf8");
       const loaded = JSON.parse(raw);
       if (loaded?.id && loaded?.phase && loaded?.title) {
         this.session = loaded;
@@ -1863,8 +1864,8 @@ var AISpecBuilder = class {
   async deleteSession() {
     if (!this.sessionPath) return;
     try {
-      const fsp5 = await import("node:fs/promises");
-      await fsp5.unlink(this.sessionPath);
+      const fsp6 = await import("node:fs/promises");
+      await fsp6.unlink(this.sessionPath);
     } catch {
     }
   }
@@ -2003,11 +2004,15 @@ var AISpecBuilder = class {
     this.autoSave();
   }
   /**
-   * Set the task graph ID for this session.
+   * Set the task graph ID for this session. Awaits the save so a caller that
+   * immediately follows with `await saveSession()` cannot end up with the
+   * awaited write committing first and the fire-and-forget rename reverting
+   * the persisted `taskGraphId` to its pre-set value. Same race window that
+   * broke `setLastAgentText`/`setLastRunId` on the resume test.
    */
-  setTaskGraphId(graphId) {
+  async setTaskGraphId(graphId) {
     this.session.taskGraphId = graphId;
-    this.autoSave();
+    await this.saveSession();
   }
   /**
    * Get the task graph ID for this session.
@@ -2015,6 +2020,50 @@ var AISpecBuilder = class {
   getTaskGraphId() {
     return this.session.taskGraphId;
   }
+  /**
+   * Persist the last agent utterance so resume can rehydrate the UI + Q/A
+   * pairing. Awaits the save so the next mutation in the call chain (e.g.
+   * `setLastRunId`) cannot fire a concurrent save that overwrites this one
+   * with a stale snapshot — the fire-and-forget `autoSave()` pattern leaves
+   * a race window where an earlier queued save may commit its rename after
+   * a later one, silently reverting the persisted state.
+   */
+  async setLastAgentText(text) {
+    this.session.lastAgentText = text;
+    this.session.updatedAt = Date.now();
+    await this.saveSession();
+  }
+  getLastAgentText() {
+    return this.session.lastAgentText;
+  }
+  /** Record a run kicked off from this interview (board deep-link after restart). See {@link setLastAgentText} for the awaited-save rationale. */
+  async setLastRunId(runId) {
+    this.session.lastRunId = runId;
+    this.session.updatedAt = Date.now();
+    await this.saveSession();
+  }
+  getLastRunId() {
+    return this.session.lastRunId;
+  }
+  /**
+   * Hard-reset in-memory session fields while keeping the same session id /
+   * store binding. Used when the operator abandons a resumed interview and
+   * starts a brand-new goal (the next save overwrites the session file).
+   */
+  resetForNewInterview() {
+    this.session.phase = "questioning";
+    this.session.title = "";
+    this.session.userIntent = "";
+    this.session.answers = [];
+    this.session.questionCount = 0;
+    this.session.spec = void 0;
+    this.session.implementation = void 0;
+    this.session.taskGraphId = void 0;
+    this.session.lastAgentText = void 0;
+    this.session.lastRunId = void 0;
+    this.session.approved = false;
+    this.session.updatedAt = Date.now();
+  }
   // ── Spec Persistence ──────────────────────────────────────────────────────
   /**
    * Save the current spec to the store.
@@ -2181,6 +2230,8 @@ var SddInterviewDriver = class {
   maxQuestions;
   tracker = null;
   graph = null;
+  /** Set when {@link loadExisting} successfully rehydrated a session from disk. */
+  resumedFromDisk = false;
   constructor(opts) {
     this.o = opts;
     this.minQuestions = opts.minQuestions ?? 2;
@@ -2195,9 +2246,11 @@ var SddInterviewDriver = class {
   }
   /** Begin a fresh interview. Returns the first AI prompt (a question kickoff). */
   start(title, intent) {
+    this.builder.resetForNewInterview();
     this.builder.startSession(title, intent);
     this.tracker = null;
     this.graph = null;
+    this.resumedFromDisk = false;
     return this.builder.getAIPrompt();
   }
   /**
@@ -2217,8 +2270,32 @@ var SddInterviewDriver = class {
         this.tracker = tracker;
       }
     }
+    this.resumedFromDisk = true;
     return true;
   }
+  /** Drop the on-disk session (if any) and clear in-memory interview state. */
+  async discard() {
+    await this.builder.deleteSession();
+    this.builder.resetForNewInterview();
+    this.tracker = null;
+    this.graph = null;
+    this.resumedFromDisk = false;
+  }
+  setLastAgentText(text) {
+    return this.builder.setLastAgentText(text);
+  }
+  getLastAgentText() {
+    return this.builder.getLastAgentText();
+  }
+  setLastRunId(runId) {
+    return this.builder.setLastRunId(runId);
+  }
+  getLastRunId() {
+    return this.builder.getLastRunId();
+  }
+  wasResumed() {
+    return this.resumedFromDisk;
+  }
   phase() {
     return this.builder.getPhase();
   }
@@ -2303,7 +2380,7 @@ var SddInterviewDriver = class {
     this.tracker = tracker;
     this.graph = graph;
     await this.persistGraph(graph);
-    this.builder.setTaskGraphId(graph.id);
+    await this.builder.setTaskGraphId(graph.id);
     await this.builder.saveSession();
     return graph;
   }
@@ -2319,6 +2396,9 @@ var SddInterviewDriver = class {
       minQuestions: this.minQuestions,
       maxQuestions: this.maxQuestions,
       answers: s.answers.map((a) => ({ question: a.question, answer: a.answer })),
+      lastAgentText: s.lastAgentText,
+      lastRunId: s.lastRunId,
+      resumed: this.resumedFromDisk || void 0,
       spec: spec ? {
         id: spec.id,
         title: spec.title,
@@ -2413,7 +2493,7 @@ var SddInterviewDriver = class {
       }
     }
     await this.persistGraph(graph);
-    this.builder.setTaskGraphId(graph.id);
+    await this.builder.setTaskGraphId(graph.id);
     await this.builder.saveSession();
     return graph.id;
   }
@@ -2443,15 +2523,12 @@ function isExplanatoryText(text) {
 import { TOKENS } from "@wrongstack/core/kernel";
 
 // src/sdd-parallel-run.ts
-import { expectDefined as expectDefined3 } from "@wrongstack/core/utils";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import {
-  assignNickname,
   DefaultMultiAgentCoordinator,
   makeAgentSubagentRunner,
   withDisabledToolFiltering
 } from "@wrongstack/core/coordination";
-import { ERROR_CODES as ERROR_CODES3, SddError as SddError3 } from "@wrongstack/core/types";
 
 // src/graph-split.ts
 function splitGraphNode(tracker, taskId, subtasks, options = {}) {
@@ -2463,8 +2540,7 @@ function splitGraphNode(tracker, taskId, subtasks, options = {}) {
   const dependents = tracker.getDependents(taskId);
   const leafIds = subtasks.map((s) => {
     const criterion = s.successCriterion?.trim();
-    const verificationCommand = criterion ? extractVerificationCommand([criterion]) : void 0;
-    const description = criterion && !verificationCommand ? `${s.description}
+    const description = criterion ? `${s.description}
 
 **Acceptance Criteria:**
 - ${criterion}` : s.description;
@@ -2474,8 +2550,7 @@ function splitGraphNode(tracker, taskId, subtasks, options = {}) {
       type: s.type ?? node.type,
       priority: s.priority ?? node.priority,
       status: "pending",
-      parentId: taskId,
-      ...verificationCommand ? { metadata: { verificationCommand } } : {}
+      parentId: taskId
     }).id;
   });
   for (const leaf of leafIds) {
@@ -2486,6 +2561,180 @@ function splitGraphNode(tracker, taskId, subtasks, options = {}) {
   return leafIds;
 }
 
+// src/sdd-task-execution.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { expectDefined as expectDefined3 } from "@wrongstack/core/utils";
+import { assignNickname } from "@wrongstack/core/coordination";
+import { ERROR_CODES as ERROR_CODES3, SddError as SddError3 } from "@wrongstack/core/types";
+async function executeSddTask(params) {
+  const { task, opts } = params;
+  const taskId = task.id;
+  let agentName = task.assignee;
+  if (!agentName) {
+    const nick = assignNickname("executor", params.usedNicknames);
+    params.usedNicknames.add(nick.key);
+    agentName = nick.display.replace(/\s*\([^)]*\)\s*$/, "");
+    opts.tracker.updateNode(taskId, { assignee: agentName });
+  }
+  opts.tracker.updateNodeStatus(taskId, "in_progress");
+  await params.allocateWorktrees([task]);
+  if (!params.coordinator)
+    throw new SddError3({
+      message: "SDD parallel runner requires a coordinator",
+      code: ERROR_CODES3.SDD_INVALID_STATE
+    });
+  const coordinator = params.coordinator;
+  const subagentId = params.nextSubagentId();
+  const correlationId = randomUUID2();
+  const meta = task.metadata ?? {};
+  const model = (typeof meta.model === "string" ? meta.model : void 0) ?? opts.defaultModel;
+  const provider = (typeof meta.provider === "string" ? meta.provider : void 0) ?? opts.defaultProvider;
+  const fallbackModels = Array.isArray(meta.fallbackModels) ? meta.fallbackModels : opts.fallbackModels;
+  const spawnResult = await coordinator.spawn({
+    id: subagentId,
+    name: agentName,
+    role: "executor",
+    idleTimeoutMs: params.idleTimeoutMs,
+    ...params.timeoutMs ? { timeoutMs: params.timeoutMs } : {},
+    cwd: params.taskCwds.get(taskId),
+    disabledTools: ["delegate"],
+    ...model ? { model } : {},
+    ...provider ? { provider } : {},
+    ...fallbackModels?.length ? { fallbackModels } : {}
+  });
+  if (!spawnResult.subagentId) {
+    throw new SddError3({
+      message: "One or more subagent spawns failed",
+      code: ERROR_CODES3.SDD_INVALID_STATE
+    });
+  }
+  params.taskSubagents.set(taskId, subagentId);
+  params.emit("sdd.task.started", {
+    runId: params.runId,
+    taskId,
+    subagentId,
+    agentName,
+    worktreeBranch: params.taskBranches.get(taskId)
+  });
+  await coordinator.assign({
+    id: correlationId,
+    description: buildTaskDirective(opts.graph.title, task),
+    subagentId,
+    ...params.timeoutMs ? { timeoutMs: params.timeoutMs } : {},
+    context: {
+      telemetryTaskId: taskId,
+      telemetryRunId: params.runId,
+      telemetryBoardId: opts.graph.id
+    }
+  });
+  let result;
+  try {
+    const got = await coordinator.awaitTasks([correlationId]);
+    result = expectDefined3(got[0]);
+  } catch (err) {
+    result = {
+      subagentId,
+      taskId: correlationId,
+      status: "failed",
+      error: { kind: "unknown", message: String(err), retryable: false },
+      iterations: 0,
+      toolCalls: 0,
+      durationMs: 0
+    };
+  }
+  params.taskSubagents.delete(taskId);
+  if (params.cancelledTasks.has(taskId)) {
+    await params.resolveWorktrees([task]);
+    return { taskId, success: false, result };
+  }
+  const verificationFailReason = await verifyTaskResult(params, result);
+  let success = false;
+  if (result.status === "success" && !verificationFailReason) {
+    const merged = await params.integrateWorktree(task, result);
+    if (merged.ok) {
+      success = true;
+      opts.tracker.updateNodeStatus(taskId, "completed");
+      params.emit("sdd.task.completed", {
+        runId: params.runId,
+        taskId,
+        subagentId,
+        durationMs: result.durationMs
+      });
+    } else if (merged.reason) {
+      params.emit("sdd.task.verification_failed", {
+        runId: params.runId,
+        taskId,
+        reason: merged.reason
+      });
+      await params.applyTaskFailure(taskId, subagentId, merged.reason);
+    } else {
+      const conflictFiles = merged.conflictFiles ?? [];
+      params.emit("sdd.task.conflict", { runId: params.runId, taskId, conflictFiles });
+      const reason = `merge conflict${conflictFiles.length ? `: ${conflictFiles.join(", ")}` : ""}`;
+      await params.applyTaskFailure(taskId, subagentId, reason);
+    }
+  } else {
+    const errMsg = verificationFailReason ?? (result.error?.kind ? `${result.error.kind}: ${result.error.message}` : result.error?.message ?? "unknown error");
+    await params.applyTaskFailure(taskId, subagentId, errMsg);
+    await params.resolveWorktrees([task]);
+  }
+  return { taskId, success, result };
+}
+function buildTaskDirective(graphTitle, task) {
+  const directivePreamble = [
+    "\u2550\u2550\u2550 SDD PARALLEL EXECUTION \u2550\u2550\u2550",
+    "",
+    `Graph: ${graphTitle}`,
+    "",
+    "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
+    "\u2022 Execute the assigned SDD task end-to-end using multiple tool calls.",
+    "\u2022 Mark the task [done] in the tracker when complete.",
+    "\u2022 Do not ask before routine in-project tool use; if a permission gate appears, wait for that flow.",
+    "\u2022 Keep output concise \u2014 summarize changes, do not transcribe files."
+  ].join("\n");
+  return [
+    directivePreamble,
+    "",
+    `\u2500\u2500 TASK \u2500\u2500`,
+    `[${task.priority.toUpperCase()}] ${task.title}`,
+    "",
+    task.description
+  ].join("\n");
+}
+async function verifyTaskResult(params, result) {
+  const { task, opts, taskCwds } = params;
+  if (result.status !== "success" || !opts.verifyTask) return void 0;
+  const taskId = task.id;
+  const cwd = taskCwds.get(taskId) ?? opts.projectRoot;
+  let verificationFailReason;
+  try {
+    const verdict = await opts.verifyTask({ task, result, cwd });
+    if (!verdict.ok) {
+      verificationFailReason = `verification failed: ${verdict.reason ?? "acceptance criteria not met"}`;
+    }
+  } catch (err) {
+    verificationFailReason = `verification error: ${String(err)}`;
+  }
+  const hadVerifiable = typeof task.metadata?.["verificationCommand"] === "string" || task.description.includes("**Acceptance Criteria:**");
+  if (verificationFailReason) {
+    opts.tracker.patchMetadata(taskId, {
+      verificationState: "failed",
+      verificationDetail: verificationFailReason
+    });
+    params.emit("sdd.task.verification_failed", {
+      runId: params.runId,
+      taskId,
+      reason: verificationFailReason
+    });
+  } else if (hadVerifiable) {
+    opts.tracker.patchMetadata(taskId, {
+      verificationState: "passed",
+      verificationDetail: void 0
+    });
+  }
+  return verificationFailReason;
+}
+
 // src/sdd-task-decomposer.ts
 var SddTaskDecomposer = class {
   constructor(tracker, _graph, opts = {}) {
@@ -2602,7 +2851,7 @@ var SddParallelRun = class {
     this.maxRetries = Math.max(0, opts.maxRetries ?? 3);
     this.maxSupervisorEscalations = Math.max(0, opts.maxSupervisorEscalations ?? 2);
     this.maxFailedSweeps = Math.max(0, opts.maxFailedRetrySweeps ?? 2);
-    this.runId = opts.runId ?? `sdd-${randomUUID2().slice(0, 8)}`;
+    this.runId = opts.runId ?? `sdd-${randomUUID3().slice(0, 8)}`;
     this.events = opts.events;
     this.sessionIdSource = opts.sessionId;
     this.maxTotalWaves = opts.maxTotalWaves ?? opts.graph.nodes.size * (this.maxRetries + 2) + 10;
@@ -3082,7 +3331,7 @@ var SddParallelRun = class {
   // -------------------------------------------------------------------
   buildCoordinator() {
     const config = {
-      coordinatorId: `sdd-parallel-${randomUUID2().slice(0, 8)}`,
+      coordinatorId: `sdd-parallel-${randomUUID3().slice(0, 8)}`,
       maxConcurrent: this.slots,
       doneCondition: { type: "all_tasks_done" },
       // Default budget guard for every spawned worker: idle reaper (resets on
@@ -3139,170 +3388,30 @@ var SddParallelRun = class {
    * missing coordinator or failed spawn so callers can enforce all-or-nothing.
    */
   async executeOne(task) {
-    const taskId = task.id;
-    let agentName = task.assignee;
-    if (!agentName) {
-      const nick = assignNickname("executor", this.usedNicknames);
-      this.usedNicknames.add(nick.key);
-      agentName = nick.display.replace(/\s*\([^)]*\)\s*$/, "");
-      this.opts.tracker.updateNode(taskId, { assignee: agentName });
-    }
-    this.opts.tracker.updateNodeStatus(taskId, "in_progress");
-    await this.allocateWorktrees([task]);
-    if (!this.coordinator)
-      throw new SddError3({
-        message: "SDD parallel runner requires a coordinator",
-        code: ERROR_CODES3.SDD_INVALID_STATE
-      });
-    const coordinator = this.coordinator;
-    const subagentId = `sdd-d${this.dispatchSeq++}`;
-    const correlationId = randomUUID2();
-    const meta = task.metadata ?? {};
-    const model = (typeof meta.model === "string" ? meta.model : void 0) ?? this.opts.defaultModel;
-    const provider = (typeof meta.provider === "string" ? meta.provider : void 0) ?? this.opts.defaultProvider;
-    const fallbackModels = Array.isArray(meta.fallbackModels) ? meta.fallbackModels : this.opts.fallbackModels;
-    const spawnResult = await coordinator.spawn({
-      id: subagentId,
-      name: agentName,
-      role: "executor",
-      // Idle reaper is always on; the hard wall-clock cap only when opted in.
+    const outcome = await executeSddTask({
+      task,
+      opts: this.opts,
+      coordinator: this.coordinator,
+      usedNicknames: this.usedNicknames,
       idleTimeoutMs: this.idleTimeoutMs,
-      ...this.timeoutMs ? { timeoutMs: this.timeoutMs } : {},
-      cwd: this.taskCwds.get(taskId),
-      disabledTools: ["delegate"],
-      ...model ? { model } : {},
-      ...provider ? { provider } : {},
-      ...fallbackModels?.length ? { fallbackModels } : {}
-    });
-    if (!spawnResult.subagentId) {
-      throw new SddError3({
-        message: "One or more subagent spawns failed",
-        code: ERROR_CODES3.SDD_INVALID_STATE
-      });
-    }
-    this.taskSubagents.set(taskId, subagentId);
-    this.emit("sdd.task.started", {
+      timeoutMs: this.timeoutMs,
       runId: this.runId,
-      taskId,
-      subagentId,
-      agentName,
-      worktreeBranch: this.taskBranches.get(taskId)
+      nextSubagentId: () => `sdd-d${this.dispatchSeq++}`,
+      emit: (event, payload) => this.emit(event, payload),
+      taskCwds: this.taskCwds,
+      taskBranches: this.taskBranches,
+      taskSubagents: this.taskSubagents,
+      cancelledTasks: this.cancelledTasks,
+      allocateWorktrees: (tasks) => this.allocateWorktrees(tasks),
+      resolveWorktrees: (tasks) => this.resolveWorktrees(tasks),
+      integrateWorktree: (taskNode, result) => this.integrateWorktree(taskNode, result),
+      applyTaskFailure: (taskId, subagentId, errMsg) => this.applyTaskFailure(taskId, subagentId, errMsg)
     });
-    const directivePreamble = [
-      "\u2550\u2550\u2550 SDD PARALLEL EXECUTION \u2550\u2550\u2550",
-      "",
-      `Graph: ${this.opts.graph.title}`,
-      "",
-      "\u2500\u2500 EXECUTION PROTOCOL \u2500\u2500",
-      "\u2022 Execute the assigned SDD task end-to-end using multiple tool calls.",
-      "\u2022 Mark the task [done] in the tracker when complete.",
-      "\u2022 Do not ask before routine in-project tool use; if a permission gate appears, wait for that flow.",
-      "\u2022 Keep output concise \u2014 summarize changes, do not transcribe files."
-    ].join("\n");
-    await coordinator.assign({
-      id: correlationId,
-      description: [
-        directivePreamble,
-        "",
-        `\u2500\u2500 TASK \u2500\u2500`,
-        `[${task.priority.toUpperCase()}] ${task.title}`,
-        "",
-        task.description
-      ].join("\n"),
-      subagentId,
-      ...this.timeoutMs ? { timeoutMs: this.timeoutMs } : {},
-      context: {
-        telemetryTaskId: taskId,
-        telemetryRunId: this.runId,
-        telemetryBoardId: this.opts.graph.id
-      }
-    });
-    let result;
-    try {
-      const got = await coordinator.awaitTasks([correlationId]);
-      result = expectDefined3(got[0]);
-    } catch (err) {
-      result = {
-        subagentId,
-        taskId: correlationId,
-        status: "failed",
-        error: { kind: "unknown", message: String(err), retryable: false },
-        iterations: 0,
-        toolCalls: 0,
-        durationMs: 0
-      };
-    }
-    this.taskSubagents.delete(taskId);
-    if (this.cancelledTasks.has(taskId)) {
-      await this.resolveWorktrees([task]);
-      return { taskId, success: false, result };
-    }
-    let verificationFailReason;
-    if (result.status === "success" && this.opts.verifyTask) {
-      const cwd = this.taskCwds.get(taskId) ?? this.opts.projectRoot;
-      try {
-        const verdict = await this.opts.verifyTask({ task, result, cwd });
-        if (!verdict.ok) {
-          verificationFailReason = `verification failed: ${verdict.reason ?? "acceptance criteria not met"}`;
-        }
-      } catch (err) {
-        verificationFailReason = `verification error: ${String(err)}`;
-      }
-      const hadVerifiable = typeof task.metadata?.["verificationCommand"] === "string" || task.description.includes("**Acceptance Criteria:**");
-      if (verificationFailReason) {
-        this.opts.tracker.patchMetadata(taskId, {
-          verificationState: "failed",
-          verificationDetail: verificationFailReason
-        });
-        this.emit("sdd.task.verification_failed", {
-          runId: this.runId,
-          taskId,
-          reason: verificationFailReason
-        });
-      } else if (hadVerifiable) {
-        this.opts.tracker.patchMetadata(taskId, {
-          verificationState: "passed",
-          verificationDetail: void 0
-        });
-      }
-    }
-    let success = false;
-    if (result.status === "success" && !verificationFailReason) {
-      const merged = await this.integrateWorktree(task, result);
-      if (merged.ok) {
-        success = true;
-        this.opts.tracker.updateNodeStatus(taskId, "completed");
-        this.retryMap.delete(taskId);
-        this.persistRetries(taskId, 0);
-        this.emit("sdd.task.completed", {
-          runId: this.runId,
-          taskId,
-          subagentId,
-          durationMs: result.durationMs
-        });
-      } else if (merged.reason) {
-        this.emit("sdd.task.verification_failed", {
-          runId: this.runId,
-          taskId,
-          reason: merged.reason
-        });
-        await this.applyTaskFailure(taskId, subagentId, merged.reason);
-      } else {
-        const conflictFiles = merged.conflictFiles ?? [];
-        this.emit("sdd.task.conflict", {
-          runId: this.runId,
-          taskId,
-          conflictFiles
-        });
-        const reason = `merge conflict${conflictFiles.length ? `: ${conflictFiles.join(", ")}` : ""}`;
-        await this.applyTaskFailure(taskId, subagentId, reason);
-      }
-    } else {
-      const errMsg = verificationFailReason ?? (result.error?.kind ? `${result.error.kind}: ${result.error.message}` : result.error?.message ?? "unknown error");
-      await this.applyTaskFailure(taskId, subagentId, errMsg);
-      await this.resolveWorktrees([task]);
+    if (outcome.success) {
+      this.retryMap.delete(task.id);
+      this.persistRetries(task.id, 0);
     }
-    return { taskId, success, result };
+    return outcome;
   }
   /**
    * Apply a task failure: retry (→ pending, bump retry count) while attempts
@@ -3647,8 +3756,10 @@ function startSddRun(opts) {
 
 // src/sdd-lifecycle.ts
 import * as fsp4 from "node:fs/promises";
+import * as path4 from "node:path";
 import { toErrorMessage as toErrorMessage2 } from "@wrongstack/core/utils";
 import { WorktreeManager } from "@wrongstack/core/worktree";
+import { listBoards, removeBoard } from "@wrongstack/kanban";
 async function cleanupSddWorktrees(projectRoot) {
   const wt = new WorktreeManager({ projectRoot });
   return wt.cleanupAllManaged();
@@ -3734,9 +3845,22 @@ async function destroySddProject(opts) {
     }
   };
   await rmFile(opts.paths.projectSddSession, "session");
+  await rmFile(
+    path4.join(path4.dirname(opts.paths.projectSddSession), "sdd-wizard-session.json"),
+    "wizard-session"
+  );
   await rmDir(opts.paths.projectSpecs, "specs");
   await rmDir(opts.paths.projectTaskGraphs, "task-graphs");
   await rmDir(opts.paths.projectSddBoards, "boards");
+  try {
+    const mirrors = (await listBoards(opts.projectRoot)).filter((b) => b.tags?.includes("sdd"));
+    let mirrorsRemoved = 0;
+    for (const b of mirrors) {
+      if (await removeBoard(opts.projectRoot, b.id)) mirrorsRemoved++;
+    }
+    if (mirrorsRemoved > 0) deleted.push(`kanban-mirrors(${mirrorsRemoved})`);
+  } catch {
+  }
   return { worktreesRemoved: removed, deleted, reverted, revertOk, revertReason };
 }
 async function applySddLifecycle(op, opts) {
@@ -3774,6 +3898,56 @@ async function applySddLifecycle(op, opts) {
   }
 }
 
+// src/project-context.ts
+import * as fsp5 from "node:fs/promises";
+import * as path5 from "node:path";
+async function gatherProjectContext(projectRoot) {
+  const parts = [];
+  const root = projectRoot.trim() || process.cwd();
+  try {
+    const pkgPath = path5.join(root, "package.json");
+    const pkgRaw = await fsp5.readFile(pkgPath, "utf8");
+    const pkg = JSON.parse(pkgRaw);
+    parts.push(`Project: ${String(pkg.name ?? "unknown")}`);
+    parts.push(`Description: ${String(pkg.description ?? "none")}`);
+    if (pkg.dependencies && typeof pkg.dependencies === "object") {
+      const deps = Object.keys(pkg.dependencies);
+      parts.push(`Dependencies: ${deps.slice(0, 20).join(", ")}${deps.length > 20 ? "..." : ""}`);
+    }
+    if (pkg.devDependencies && typeof pkg.devDependencies === "object") {
+      const devDeps = Object.keys(pkg.devDependencies);
+      parts.push(
+        `Dev Dependencies: ${devDeps.slice(0, 15).join(", ")}${devDeps.length > 15 ? "..." : ""}`
+      );
+    }
+  } catch {
+  }
+  try {
+    await fsp5.access(path5.join(root, "tsconfig.json"));
+    parts.push("Language: TypeScript");
+  } catch {
+  }
+  try {
+    const srcDir = path5.join(root, "src");
+    const entries = await fsp5.readdir(srcDir, { withFileTypes: true });
+    const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    if (dirs.length > 0) parts.push(`Source structure: src/${dirs.join(", src/")}`);
+  } catch {
+  }
+  try {
+    const packagesDir = path5.join(root, "packages");
+    const entries = await fsp5.readdir(packagesDir, { withFileTypes: true });
+    const pkgs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    if (pkgs.length > 0) {
+      parts.push(
+        `Packages: ${pkgs.slice(0, 25).join(", ")}${pkgs.length > 25 ? "..." : ""}`
+      );
+    }
+  } catch {
+  }
+  return parts.join("\n");
+}
+
 // src/spec-templates.ts
 var SPEC_TEMPLATES = [
   {
@@ -4175,15 +4349,15 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
       maxId = id;
     }
   }
-  const path4 = [];
+  const path6 = [];
   let current = maxId;
   const visited = /* @__PURE__ */ new Set();
   while (current && !visited.has(current)) {
     visited.add(current);
-    path4.unshift(current);
+    path6.unshift(current);
     current = prev.get(current) ?? null;
   }
-  return path4;
+  return path6;
 }
 function computeParallelGroups(graph, blockedByMap) {
   const groups = [];
@@ -4604,8 +4778,70 @@ Supervisor rescues already used: ${attempts}`,
 
 // src/verify-task.ts
 import { spawn } from "node:child_process";
-function verificationShell(platform) {
-  return platform === "win32" ? ["cmd", "/d", "/c"] : ["sh", "-c"];
+function tokenizeCommand(command) {
+  const trimmed = command.trim();
+  if (!trimmed) return void 0;
+  const argv = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let hasToken = false;
+  for (let i = 0; i < trimmed.length; i++) {
+    const ch = trimmed[i];
+    if (inSingle) {
+      if (ch === "'") {
+        inSingle = false;
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (inDouble) {
+      if (ch === '"') {
+        inDouble = false;
+      } else if (ch === "\\" && i + 1 < trimmed.length) {
+        const next = trimmed[i + 1];
+        if (next === '"' || next === "\\" || next === "$" || next === "`") {
+          current += next;
+          i++;
+        } else {
+          current += ch;
+        }
+      } else {
+        current += ch;
+      }
+      continue;
+    }
+    if (ch === "'") {
+      inSingle = true;
+      hasToken = true;
+      continue;
+    }
+    if (ch === '"') {
+      inDouble = true;
+      hasToken = true;
+      continue;
+    }
+    if (ch === "\\" && i + 1 < trimmed.length) {
+      current += trimmed[i + 1];
+      i++;
+      hasToken = true;
+      continue;
+    }
+    if (ch === " " || ch === "	") {
+      if (hasToken) {
+        argv.push(current);
+        current = "";
+        hasToken = false;
+      }
+      continue;
+    }
+    current += ch;
+    hasToken = true;
+  }
+  if (inSingle || inDouble) return void 0;
+  if (hasToken) argv.push(current);
+  return argv.length > 0 ? argv : void 0;
 }
 function makeCompositeVerifier(parts) {
   return async function verifyTask(info) {
@@ -4656,11 +4892,15 @@ function makeCommandVerifier(options = {}) {
   const metadataKey = options.metadataKey ?? "verificationCommand";
   const timeoutMs = options.timeoutMs ?? 18e4;
   return async function verifyTask(info) {
-    const cmd = info.task.metadata?.[metadataKey];
-    if (typeof cmd !== "string" || !cmd.trim()) return { ok: true };
+    const rawCommand = info.task.metadata?.[metadataKey];
+    if (typeof rawCommand !== "string" || !rawCommand.trim()) return { ok: true };
+    const argv = tokenizeCommand(rawCommand);
+    if (!argv || argv.length === 0) {
+      return { ok: false, reason: `verification command is malformed: ${rawCommand}` };
+    }
+    const [executable, ...args] = argv;
     return await new Promise((resolve) => {
-      const [shell, ...shellArgs] = verificationShell(process.platform);
-      const child = spawn(shell, [...shellArgs, cmd], {
+      const child = spawn(executable, args, {
         cwd: info.cwd,
         shell: false,
         windowsHide: true,
@@ -4670,13 +4910,13 @@ function makeCommandVerifier(options = {}) {
       const timer = setTimeout(() => {
         timedOut = true;
         child.kill();
-        resolve({ ok: false, reason: `verification timed out: ${cmd}` });
+        resolve({ ok: false, reason: `verification timed out: ${rawCommand}` });
       }, timeoutMs);
       child.on("exit", (code) => {
         clearTimeout(timer);
         if (timedOut) return;
         resolve(
-          code === 0 ? { ok: true } : { ok: false, reason: `verification failed (exit ${code}): ${cmd}` }
+          code === 0 ? { ok: true } : { ok: false, reason: `verification failed (exit ${code}): ${rawCommand}` }
         );
       });
       child.on("error", (err) => {
@@ -4841,13 +5081,13 @@ async function decomposeNonAtomicTasks(opts) {
 }
 
 // src/conflict-resolver.ts
-import { readFile as readFile4, writeFile } from "node:fs/promises";
-import { isAbsolute, join as join4 } from "node:path";
+import { readFile as readFile5, writeFile } from "node:fs/promises";
+import { isAbsolute, join as join6 } from "node:path";
 import { readBundledInstructionText as readBundledInstructionText2, renderInstructionTemplate as renderInstructionTemplate2 } from "@wrongstack/core/utils";
 var defaultFileIO = {
-  read: (path4) => readFile4(path4, "utf8"),
-  write: async (path4, content) => {
-    await writeFile(path4, content, "utf8");
+  read: (path6) => readFile5(path6, "utf8"),
+  write: async (path6, content) => {
+    await writeFile(path6, content, "utf8");
   }
 };
 var START = "<<<<<<<";
@@ -4891,7 +5131,7 @@ function makePreferSideConflictResolver(side, io = defaultFileIO) {
   return async function conflictResolver(info) {
     if (info.conflictFiles.length === 0) return false;
     for (const rel of info.conflictFiles) {
-      const abs = isAbsolute(rel) ? rel : join4(info.cwd, rel);
+      const abs = isAbsolute(rel) ? rel : join6(info.cwd, rel);
       let content;
       try {
         content = await io.read(abs);
@@ -4925,7 +5165,7 @@ function makeLlmConflictResolver(opts) {
   return async function conflictResolver(info) {
     if (info.conflictFiles.length === 0) return false;
     for (const rel of info.conflictFiles) {
-      const abs = isAbsolute(rel) ? rel : join4(info.cwd, rel);
+      const abs = isAbsolute(rel) ? rel : join6(info.cwd, rel);
       let content;
       try {
         content = await io.read(abs);
@@ -4993,6 +5233,7 @@ export {
   decomposeNonAtomicTasks,
   destroySddProject,
   extractVerificationCommand,
+  gatherProjectContext,
   getTemplate,
   hasConflictMarkers,
   isExplanatoryText,
@@ -5013,6 +5254,7 @@ export {
   shortIdMap,
   splitGraphNode,
   startSddRun,
-  templateToMarkdown
+  templateToMarkdown,
+  tokenizeCommand
 };
 //# sourceMappingURL=index.js.map