@wrongstack/sdd 0.295.1 → 0.296.2

package/dist/index.js

@@ -1836,10 +1836,10 @@ 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 {
     }
@@ -1848,8 +1848,8 @@ var AISpecBuilder = class {
   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 +1863,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 {
     }
   }
@@ -2015,6 +2015,43 @@ var AISpecBuilder = class {
   getTaskGraphId() {
     return this.session.taskGraphId;
   }
+  /** Persist the last agent utterance so resume can rehydrate the UI + Q/A pairing. */
+  setLastAgentText(text) {
+    this.session.lastAgentText = text;
+    this.session.updatedAt = Date.now();
+    this.autoSave();
+  }
+  getLastAgentText() {
+    return this.session.lastAgentText;
+  }
+  /** Record a run kicked off from this interview (board deep-link after restart). */
+  setLastRunId(runId) {
+    this.session.lastRunId = runId;
+    this.session.updatedAt = Date.now();
+    this.autoSave();
+  }
+  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 +2218,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 +2234,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 +2258,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) {
+    this.builder.setLastAgentText(text);
+  }
+  getLastAgentText() {
+    return this.builder.getLastAgentText();
+  }
+  setLastRunId(runId) {
+    this.builder.setLastRunId(runId);
+  }
+  getLastRunId() {
+    return this.builder.getLastRunId();
+  }
+  wasResumed() {
+    return this.resumedFromDisk;
+  }
   phase() {
     return this.builder.getPhase();
   }
@@ -2319,6 +2384,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,
@@ -2443,15 +2511,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 = {}) {
@@ -2486,6 +2551,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 +2841,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 +3321,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 +3378,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)
-    });
-    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
-      }
+      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)
     });
-    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
-      };
+    if (outcome.success) {
+      this.retryMap.delete(task.id);
+      this.persistRetries(task.id, 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]);
-    }
-    return { taskId, success, result };
+    return outcome;
   }
   /**
    * Apply a task failure: retry (→ pending, bump retry count) while attempts
@@ -3647,8 +3746,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 +3835,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 +3888,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 +4339,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 = [];
@@ -4841,13 +5005,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 +5055,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 +5089,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 +5157,7 @@ export {
   decomposeNonAtomicTasks,
   destroySddProject,
   extractVerificationCommand,
+  gatherProjectContext,
   getTemplate,
   hasConflictMarkers,
   isExplanatoryText,