@wrongstack/core 0.77.0 → 0.82.6

package/dist/sdd/index.d.ts

@@ -1,16 +1,16 @@
-import { h as Specification, S as SpecAnalysis, g as SpecValidationResult, l as TaskGraph, m as TaskNode, k as TaskFilter, p as TaskSort, o as TaskProgress, r as TaskType, n as TaskPriority, e as SpecStatus, f as SpecTemplate, b as SpecRequirement } from '../task-graph-D1YQbpxF.js';
-import { E as EventBus } from '../events-CYaoLN5_.js';
-import { D as DoneCondition, A as Agent, c as AgentFactory, X as TaskResult } from '../agent-subagent-runner-D8qW8OSC.js';
-import '../context-y87Jc5ei.js';
-import '../index-Dsda0uCn.js';
-import '../logger-DDd5C--Z.js';
-import '../system-prompt-CA11g6Jo.js';
-import '../config-Dy0CK_o6.js';
-import '../models-registry-BcYJDKLm.js';
-import '../observability-BhnVLBLS.js';
+import { h as Specification, S as SpecAnalysis, g as SpecValidationResult, l as TaskGraph, m as TaskNode, k as TaskFilter, p as TaskSort, o as TaskProgress, r as TaskType, n as TaskPriority, e as SpecStatus, f as SpecTemplate, b as SpecRequirement } from '../task-graph-CikNdRTG.js';
+import { E as EventBus } from '../events-DnRqXaZ3.js';
+import { D as DoneCondition, A as Agent, c as AgentFactory, X as TaskResult } from '../agent-subagent-runner-2Aq0jOSj.js';
+import '../context-ToHAp4-U.js';
+import '../index-N0_c4bHQ.js';
+import '../logger-B72yyPc6.js';
+import '../system-prompt-C0rLCeyn.js';
+import '../config-_DZ7dN-T.js';
+import '../models-registry-Be3osGt5.js';
+import '../observability-CoSNZdhX.js';
 import '../secret-scrubber-3MHDDAtm.js';
-import '../permission-V5BLOrY6.js';
-import '../retry-policy-CG3qvH_e.js';
+import '../permission-14CChMmO.js';
+import '../retry-policy-DSu6O6rD.js';
 
 declare class SpecParser {
     parse(content: string): Specification;
@@ -43,13 +43,13 @@ interface TaskTrackerOptions {
      * fire-and-forget their writes; without this, a failing store silently
      * loses graph mutations. Defaults to a console.warn.
      */
-    onPersistError?: (err: unknown) => void;
+    onPersistError?: (((err: unknown) => void)) | undefined;
 }
 interface TaskTransition {
     from: TaskNode['status'];
     to: TaskNode['status'];
     timestamp: number;
-    reason?: string;
+    reason?: string | undefined;
 }
 declare class TaskTracker {
     private readonly opts;
@@ -90,13 +90,13 @@ interface TaskGeneratorOptions {
     taskTracker: TaskTracker;
 }
 interface GeneratedTask {
-    specRequirementId?: string;
+    specRequirementId?: string | undefined;
     title: string;
     description: string;
     type: TaskType;
     priority: TaskPriority;
-    estimateHours?: number;
-    tags?: string[];
+    estimateHours?: number | undefined;
+    tags?: string[] | undefined;
 }
 declare class TaskGenerator {
     private readonly opts;
@@ -138,7 +138,7 @@ interface TaskFlowEventMap {
     };
     'task.completed': {
         taskId: string;
-        result?: unknown;
+        result?: unknown | undefined;
     };
     'task.failed': {
         taskId: string;
@@ -167,13 +167,13 @@ type TaskFlowEventName = keyof TaskFlowEventMap;
 interface TaskFlowOptions {
     tracker: TaskTracker;
     events: EventBus;
-    doneCondition?: DoneCondition;
-    maxConcurrent?: number;
+    doneCondition?: DoneCondition | undefined;
+    maxConcurrent?: number | undefined;
 }
 interface TaskFlowExecutionContext {
     executeTask: (task: TaskNode) => Promise<unknown>;
-    onTaskComplete?: (task: TaskNode, result: unknown) => void;
-    onTaskFail?: (task: TaskNode, error: Error) => void;
+    onTaskComplete?: (task: TaskNode | undefined, result: unknown) => void;
+    onTaskFail?: (task: TaskNode | undefined, error: Error) => void;
 }
 declare class TaskFlow {
     private readonly opts;
@@ -199,7 +199,7 @@ declare class TaskFlow {
 interface SpecDrivenDevOptions {
     workingDirectory: string;
     events: EventBus;
-    doneCondition?: DoneCondition;
+    doneCondition?: DoneCondition | undefined;
 }
 declare class SpecDrivenDev {
     private store;
@@ -298,9 +298,9 @@ interface AISpecSession {
     projectContext: string;
     answers: CollectedAnswer[];
     questionCount: number;
-    spec?: Specification;
-    implementation?: string;
-    taskGraphId?: string;
+    spec?: Specification | undefined;
+    implementation?: string | undefined;
+    taskGraphId?: string | undefined;
     approved: boolean;
     createdAt: number;
     updatedAt: number;
@@ -308,13 +308,13 @@ interface AISpecSession {
 interface AISpecBuilderOptions {
     store: SpecStore;
     /** Minimum questions the AI should ask. Default: 2 */
-    minQuestions?: number;
+    minQuestions?: number | undefined;
     /** Maximum questions before forcing spec generation. Default: 10 */
-    maxQuestions?: number;
+    maxQuestions?: number | undefined;
     /** Project context string (package.json, file structure, etc.) */
-    projectContext?: string;
+    projectContext?: string | undefined;
     /** Path to persist session state. If set, session survives process restarts. */
-    sessionPath?: string;
+    sessionPath?: string | undefined;
 }
 /**
  * AI-driven specification builder. Instead of static questions, this builder
@@ -446,7 +446,7 @@ declare function templateToMarkdown(template: SpecTemplate, title?: string): str
  * Render a task graph as ASCII art for terminal display.
  */
 declare function renderTaskGraph(graph: TaskGraph, opts?: {
-    compact?: boolean;
+    compact?: boolean | undefined;
 }): string;
 /**
  * Render a progress bar.
@@ -505,7 +505,7 @@ interface SpecVersion {
     version: string;
     spec: Specification;
     timestamp: number;
-    changeDescription?: string;
+    changeDescription?: string | undefined;
 }
 interface SpecDiff {
     added: SpecRequirement[];
@@ -552,19 +552,19 @@ interface AutoExecutorOptions {
     tracker: TaskTracker;
     events: EventBus;
     /** Maximum concurrent tasks. Defaults to 1 (sequential). */
-    maxConcurrent?: number;
+    maxConcurrent?: number | undefined;
     /** Maximum retry attempts for failed tasks. */
-    maxRetries?: number;
+    maxRetries?: number | undefined;
     /** Custom task executor function. */
     executeTask: (task: TaskNode, context: TaskExecutionContext) => Promise<TaskExecutionResult>;
     /** Called before each task starts. */
-    onTaskStart?: (task: TaskNode) => void;
+    onTaskStart?: (((task: TaskNode) => void)) | undefined;
     /** Called after each task completes. */
     onTaskComplete?: (task: TaskNode, result: TaskExecutionResult) => void;
     /** Called when a task fails. */
     onTaskFail?: (task: TaskNode, error: Error, retryCount: number) => void;
     /** Called when all tasks are done or no more can execute. */
-    onDone?: (summary: ExecutionSummary) => void;
+    onDone?: (((summary: ExecutionSummary) => void)) | undefined;
 }
 interface TaskExecutionContext {
     /** The spec being implemented. */
@@ -582,10 +582,10 @@ interface TaskExecutionContext {
 }
 interface TaskExecutionResult {
     success: boolean;
-    output?: string;
-    error?: string;
+    output?: string | undefined;
+    error?: string | undefined;
     /** If true, the task will be retried. */
-    retry?: boolean;
+    retry?: boolean | undefined;
 }
 interface ExecutionSummary {
     total: number;
@@ -629,8 +629,8 @@ declare function createAutoExecutor(opts: {
     tracker: TaskTracker;
     events: EventBus;
     executeTask: AutoExecutorOptions['executeTask'];
-    maxConcurrent?: number;
-    maxRetries?: number;
+    maxConcurrent?: number | undefined;
+    maxRetries?: number | undefined;
 }): AutoExecutor;
 
 /**
@@ -661,7 +661,7 @@ declare function createAutoExecutor(opts: {
 
 interface SddTaskDecomposerOptions {
     /** Max tasks per batch. Default: 4. Range 1–16. */
-    parallelSlots?: number;
+    parallelSlots?: number | undefined;
 }
 interface TaskBatch {
     /** Tasks ready to execute in this wave. */
@@ -738,15 +738,15 @@ interface SddParallelRunOptions {
     /** Project root (used for coordinator id). */
     projectRoot: string;
     /** Override default parallel slots (1–16). Default: 4. */
-    parallelSlots?: number;
+    parallelSlots?: number | undefined;
     /** Per-task timeout in ms. Default: 300_000 (5 min). */
-    taskTimeoutMs?: number;
+    taskTimeoutMs?: number | undefined;
     /** Override the default agent factory. */
-    subagentFactory?: AgentFactory;
+    subagentFactory?: AgentFactory | undefined;
     /** Called after each wave completes. */
-    onWave?: (wave: WaveResult) => void;
+    onWave?: ((wave: WaveResult) => void) | undefined;
     /** Called with progress stats every ~2s during execution. */
-    onProgress?: (progress: SddProgress) => void;
+    onProgress?: ((progress: SddProgress) => void) | undefined;
 }
 interface SddProgress {
     wave: number;

package/dist/sdd/index.js

@@ -686,7 +686,7 @@ var TaskTracker = class {
         if (filter.type?.length && !filter.type.includes(n.type)) return false;
         if (filter.assignee?.length && n.assignee && !filter.assignee.includes(n.assignee))
           return false;
-        if (filter.tags?.length && n.tags && !n.tags.some((t) => filter.tags.includes(t)))
+        if (filter.tags?.length && n.tags && !n.tags.some((t) => filter.tags?.includes(t)))
           return false;
         if (filter.specRequirementId && n.specRequirementId !== filter.specRequirementId)
           return false;
@@ -1200,6 +1200,12 @@ var TaskGraphStore = class {
 };
 
 // src/sdd/spec-builder.ts
+function expectDefined(value) {
+  if (value === null || value === void 0) {
+    throw new Error("Expected value to be defined");
+  }
+  return value;
+}
 function buildQuestioningPrompt(session, min, max) {
   const answered = session.answers.length;
   const remaining = Math.max(0, min - answered);
@@ -1245,7 +1251,7 @@ function buildQuestioningPrompt(session, min, max) {
   if (answered > 0) {
     lines.push("", "**Conversation so far:**");
     for (let i = 0; i < answered; i++) {
-      const a = session.answers[i];
+      const a = expectDefined(session.answers[i]);
       lines.push(``, `Q${i + 1}: ${a.question}`, `A${i + 1}: ${a.answer}`);
     }
   }
@@ -1987,6 +1993,12 @@ function truncate(str, maxLen) {
 }
 
 // src/sdd/critical-path.ts
+function expectDefined2(value) {
+  if (value === null || value === void 0) {
+    throw new Error("Expected value to be defined");
+  }
+  return value;
+}
 function analyzeCriticalPath(graph) {
   const nodes = Array.from(graph.nodes.values());
   const topoOrder = topologicalSort(graph);
@@ -1995,9 +2007,9 @@ function analyzeCriticalPath(graph) {
   for (const edge of graph.edges) {
     if (edge.type === "depends_on") {
       if (!blockedByMap.has(edge.from)) blockedByMap.set(edge.from, /* @__PURE__ */ new Set());
-      blockedByMap.get(edge.from).add(edge.to);
+      blockedByMap.get(edge.from)?.add(edge.to);
       if (!blocksMap.has(edge.to)) blocksMap.set(edge.to, /* @__PURE__ */ new Set());
-      blocksMap.get(edge.to).add(edge.from);
+      blocksMap.get(edge.to)?.add(edge.from);
     }
   }
   const readyTasks = [];
@@ -2062,7 +2074,7 @@ function getTransitiveBlocked(_graph, taskId, blocksMap) {
   const visited = /* @__PURE__ */ new Set();
   const queue = [taskId];
   while (queue.length > 0) {
-    const current = queue.shift();
+    const current = expectDefined2(queue.shift());
     const blocked = blocksMap.get(current);
     if (!blocked) continue;
     for (const id of blocked) {
@@ -2087,7 +2099,7 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
   for (const [taskId, blockers] of blockedByMap) {
     for (const blockerId of blockers) {
       if (!blocksMap.has(blockerId)) blocksMap.set(blockerId, /* @__PURE__ */ new Set());
-      blocksMap.get(blockerId).add(taskId);
+      blocksMap.get(blockerId)?.add(taskId);
     }
   }
   const n = allIds.length;
@@ -2108,7 +2120,7 @@ function computeCriticalPath(graph, _topoOrder, blockedByMap) {
     if (!changed) break;
   }
   let maxDist = 0;
-  let maxId = allIds[0];
+  let maxId = expectDefined2(allIds[0]);
   for (const id of allIds) {
     const d = dist.get(id) ?? 0;
     if (d > maxDist) {
@@ -2740,16 +2752,16 @@ var SubagentBudget = class _SubagentBudget {
     }
     if (exceeded.length === 0) return [];
     if (!this._onThreshold) {
-      const first2 = exceeded[0];
+      const first2 = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     if (this._mode === "sync") {
-      const first2 = exceeded[0];
+      const first2 = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     const bus = this._events;
     if (!bus || !bus.hasListenerFor("budget.threshold_reached")) {
-      const first2 = exceeded[0];
+      const first2 = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       throw new BudgetExceededError(first2.kind, first2.limit, first2.used);
     }
     for (const entry of exceeded) {
@@ -2757,8 +2769,9 @@ var SubagentBudget = class _SubagentBudget {
       const decision2 = this._negotiateExtension(entry.kind, exceeded);
       this._pendingNegotiations.set(entry.kind, decision2);
     }
-    const first = exceeded[0];
+    const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
     const decision = this._pendingNegotiations.get(first.kind);
+    if (!decision) throw new Error(`No pending negotiation for ${first.kind}`);
     throw new BudgetThresholdSignal(first.kind, first.limit, first.used, decision);
   }
   /**
@@ -2780,8 +2793,11 @@ var SubagentBudget = class _SubagentBudget {
    * a fresh signal.
    */
   async _negotiateExtension(kind, exceeded) {
+    if (!this._onThreshold) {
+      return "stop";
+    }
     try {
-      const first = exceeded[0];
+      const first = exceeded[0] ?? { kind: "iterations", limit: 0, used: 0 };
       const result = this._onThreshold({
         kind: first.kind,
         used: first.used,
@@ -5920,6 +5936,7 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
   takeNextDispatchableTask() {
     for (let i = 0; i < this.pendingTasks.length; i++) {
       const task = this.pendingTasks[i];
+      if (!task) continue;
       const subagentId = task.subagentId ? this.isIdleSubagent(task.subagentId) ? task.subagentId : null : this.findIdleSubagent();
       if (!subagentId) continue;
       this.pendingTasks.splice(i, 1);
@@ -6111,14 +6128,14 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
         const idleExceeded = idleLimit !== void 0 && budget.idleMs() >= idleLimit;
         if (idleExceeded && !wallExceeded) {
           this.subagents.get(ctx.subagentId)?.abortController.abort();
-          reject(new BudgetExceededError("timeout", idleLimit, budget.idleMs()));
+          reject(new BudgetExceededError("timeout", idleLimit ?? 0, budget.idleMs()));
           return;
         }
         if (!wallExceeded) {
           scheduleNext();
           return;
         }
-        const limit = wallLimit;
+        const limit = wallLimit ?? 0;
         if (!budget.onThreshold) {
           this.subagents.get(ctx.subagentId)?.abortController.abort();
           reject(new BudgetExceededError("timeout", limit, elapsed));
@@ -6277,6 +6294,12 @@ var DefaultMultiAgentCoordinator = class _DefaultMultiAgentCoordinator extends E
 };
 
 // src/sdd/sdd-parallel-run.ts
+function expectDefined3(value) {
+  if (value === null || value === void 0) {
+    throw new Error("Expected value to be defined");
+  }
+  return value;
+}
 var SddParallelRun = class {
   constructor(opts) {
     this.opts = opts;
@@ -6377,8 +6400,10 @@ var SddParallelRun = class {
       "\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");
+    if (!this.coordinator) throw new Error("SDD parallel runner requires a coordinator");
+    const coordinator = this.coordinator;
     const spawns = subagentIds.map(
-      (subagentId) => this.coordinator.spawn({
+      (subagentId) => coordinator.spawn({
         id: subagentId,
         name: subagentId,
         role: "executor",
@@ -6386,12 +6411,12 @@ var SddParallelRun = class {
       })
     );
     const spawnResults = await Promise.all(spawns);
-    if (!spawnResults.every((r) => r.subagentId)) {
+    if (!spawnResults.every((r) => Boolean(r.subagentId))) {
       throw new Error("One or more subagent spawns failed");
     }
     const assignPromises = tasks.map((task, i) => {
       const spec = {
-        id: taskIds[i],
+        id: taskIds[i] ?? task.id,
         description: [
           directivePreamble,
           "",
@@ -6400,15 +6425,15 @@ var SddParallelRun = class {
           "",
           task.description
         ].join("\n"),
-        subagentId: subagentIds[i],
+        subagentId: subagentIds[i] ?? spawnResults[i]?.subagentId ?? task.id,
         timeoutMs: this.timeoutMs
       };
-      return this.coordinator.assign(spec);
+      return this.coordinator?.assign(spec);
     });
     await Promise.all(assignPromises);
     let results;
     try {
-      results = await this.coordinator.awaitTasks(taskIds);
+      results = await coordinator.awaitTasks(taskIds);
     } catch (err) {
       results = taskIds.map((id) => ({
         subagentId: "",
@@ -6423,8 +6448,8 @@ var SddParallelRun = class {
     const successCount = results.filter((r) => r.status === "success").length;
     const failCount = results.length - successCount;
     for (let i = 0; i < results.length; i++) {
-      const result = results[i];
-      const taskId = taskIds[i];
+      const result = expectDefined3(results[i]);
+      const taskId = expectDefined3(taskIds[i]);
       if (result.status === "success") {
         this.opts.tracker.updateNodeStatus(taskId, "completed");
       } else {