@wrongstack/core 0.7.4 → 0.7.6

package/dist/{multi-agent-coordinator-D8PLzfz6.d.ts → multi-agent-coordinator-3Ypfg-hr.d.ts}

@@ -1,177 +1,6 @@
-import { c as Agent, f as AgentInput } from './index-BUHs7xJ9.js';
-import { E as EventBus } from './events-D4pGukpI.js';
-import { m as SubagentConfig, u as TaskSpec, s as SubagentRunner, k as MultiAgentCoordinator, M as MultiAgentConfig, S as SpawnResult, B as BridgeMessage, A as AgentBridge, j as CoordinatorStatus, t as TaskResult } from './multi-agent-7OK4pEKW.js';
+import { m as SubagentConfig, k as MultiAgentCoordinator, M as MultiAgentConfig, s as SubagentRunner, S as SpawnResult, u as TaskSpec, B as BridgeMessage, A as AgentBridge, j as CoordinatorStatus, t as TaskResult } from './multi-agent-7OK4pEKW.js';
 import { EventEmitter } from 'node:events';
 
-/**
- * Single fleet-wide event with subagent attribution. Whatever a child
- * agent emits on its own EventBus gets re-published here, prefixed with
- * `subagentId` so a single subscriber can multiplex across the fleet.
- *
- * The director uses `FleetBus.filter('tool.executed', …)` to see every
- * tool call across the fleet; the TUI uses
- * `FleetBus.subscribe(id, handler)` to render a per-subagent panel.
- */
-interface FleetEvent {
-    subagentId: string;
-    taskId?: string;
-    ts: number;
-    type: string;
-    payload: unknown;
-}
-type FleetHandler = (event: FleetEvent) => void;
-/**
- * Fan-in for per-subagent EventBuses. Each subagent's bus is plugged in
- * via `attach()`; the FleetBus re-emits every event with subagent
- * attribution. Detachment is automatic via the returned disposer — call
- * it when a subagent terminates so we don't leak listeners.
- *
- * The bus exposes two subscription modes: by `subagentId` (everything
- * from one child) and by `type` (one event-type across the fleet). They
- * compose — if you need a per-subagent + per-type slice, subscribe by
- * type and filter on `event.subagentId` in your handler.
- */
-declare class FleetBus {
-    private readonly byId;
-    private readonly byType;
-    private readonly any;
-    /**
-     * Hook a subagent's EventBus into the fleet. EventBus is strongly
-     * typed and doesn't expose an `onAny` hook, so we subscribe to the
-     * canonical set of event types a subagent emits during a run. New
-     * event types added to the kernel must be added here too — but the
-     * cost is a tiny single line per type, and the explicit list keeps
-     * the wire format clear.
-     *
-     * Returns a disposer that detaches every subscription; call on
-     * subagent teardown so the listeners don't outlive the run.
-     */
-    attach(subagentId: string, bus: EventBus, taskId?: string): () => void;
-    /** Subscribe to every event from one subagent. */
-    subscribe(subagentId: string, handler: FleetHandler): () => void;
-    /** Subscribe to one event type across all subagents. */
-    filter(type: string, handler: FleetHandler): () => void;
-    /** Subscribe to literally everything. The fleet roll-up uses this. */
-    onAny(handler: FleetHandler): () => void;
-    emit(event: FleetEvent): void;
-}
-/**
- * Roll-up of token usage + cost across an entire director run. The
- * director's `fleet_status` tool returns this so the model can reason
- * about budget in its next turn ("the researcher already burned $0.40,
- * lean on summaries for the next task").
- */
-interface FleetUsage {
-    total: {
-        input: number;
-        output: number;
-        cacheRead: number;
-        cacheWrite: number;
-        cost: number;
-    };
-    perSubagent: Record<string, SubagentUsageSnapshot>;
-}
-interface SubagentUsageSnapshot {
-    subagentId: string;
-    provider?: string;
-    model?: string;
-    input: number;
-    output: number;
-    cacheRead: number;
-    cacheWrite: number;
-    cost: number;
-    toolCalls: number;
-    iterations: number;
-    startedAt: number;
-    lastEventAt: number;
-}
-/**
- * Aggregates provider.response + tool.executed events from the FleetBus
- * into a live `FleetUsage` snapshot. Costs are computed by the caller
- * via a `priceLookup(subagentId)` so we don't bake provider-pricing
- * coupling into core; the CLI/tests supply a function that resolves
- * each subagent's per-token rates from the models registry.
- */
-declare class FleetUsageAggregator {
-    private readonly bus;
-    private readonly priceLookup?;
-    private readonly metaLookup?;
-    private readonly perSubagent;
-    private readonly total;
-    constructor(bus: FleetBus, priceLookup?: ((subagentId: string) => {
-        input?: number;
-        output?: number;
-        cacheRead?: number;
-        cacheWrite?: number;
-    } | undefined) | undefined, metaLookup?: ((subagentId: string) => {
-        provider?: string;
-        model?: string;
-    } | undefined) | undefined);
-    /** Live snapshot — safe to call from a tool's execute() body. */
-    snapshot(): FleetUsage;
-    private ensure;
-    private onProviderResponse;
-    private onToolExecuted;
-    private onIterationStarted;
-}
-
-/**
- * Caller-supplied factory that builds an isolated `Agent` for a subagent.
- * The factory MUST construct a fresh `Context` per call — sharing context
- * between subagents defeats isolation. Each Agent should also use either
- * its own `EventBus` or a forwarded view, so per-subagent metrics can be
- * attributed correctly.
- */
-type AgentFactory = (config: SubagentConfig) => Promise<AgentFactoryResult>;
-interface AgentFactoryResult {
-    agent: Agent;
-    /** Event bus the factory wired to this agent — required for budget hookup. */
-    events: EventBus;
-    /**
-     * Optional cleanup hook invoked in the runner's `finally` block once
-     * the task ends (success, failure, abort — same exit path). Factories
-     * that own resources scoped to a single task (per-subagent JSONL
-     * writers, transient providers, throwaway containers) implement this
-     * to close them deterministically instead of relying on GC. Errors
-     * thrown here are swallowed so a flaky cleanup can't mask the task's
-     * real result.
-     */
-    dispose?: () => Promise<void> | void;
-}
-interface AgentRunnerOptions {
-    factory: AgentFactory;
-    /**
-     * Format a TaskSpec into the user input the agent will receive. Defaults
-     * to `task.description ?? ''`. Override when subagents expect structured
-     * input (e.g. JSON contracts, role-prefixed prompts).
-     */
-    formatTaskInput?: (task: TaskSpec, config: SubagentConfig) => AgentInput;
-    /**
-     * When set, the runner attaches the subagent's EventBus to this FleetBus
-     * on task start and detaches it when the task finishes. This is the
-     * injection seam that lets the TUI fleet panel observe subagent activity
-     * live — without it, FleetBus stays empty.
-     */
-    fleetBus?: FleetBus;
-}
-/**
- * Builds a `SubagentRunner` that drives a real `Agent` per task while honoring
- * the coordinator's budget and abort signal. This is the production adapter —
- * the coordinator's `runner` option in CLI/TUI assemblies points here.
- *
- * Lifecycle per task:
- *   1. factory(config) → fresh Agent + EventBus.
- *   2. Subscribe to events to feed the budget (tool calls, token usage).
- *   3. Call agent.run(input, { signal }) — the coordinator's signal cancels.
- *   4. Map RunResult.status onto a `SubagentRunOutcome` or throw on failure.
- *   5. Unsubscribe and let the factory's resources be GC'd.
- *
- * The budget is checked synchronously from event handlers — a runaway agent
- * that crosses its tool-call limit triggers `BudgetExceededError`, which the
- * coordinator surfaces as `status: 'failed'` on the task result.
- */
-declare function makeAgentSubagentRunner(opts: AgentRunnerOptions): SubagentRunner;
-
 /**
  * Catalog types for the WrongStack agent fleet.
  *
@@ -445,4 +274,4 @@ declare class DefaultMultiAgentCoordinator extends EventEmitter implements Multi
     private isDone;
 }
 
-export { type AgentBudgetTier as A, DEFAULT_DISPATCH_ROLE as D, FleetBus as F, HEAVY_BUDGET as H, LIGHT_BUDGET as L, MEDIUM_BUDGET as M, type SubagentUsageSnapshot as S, TOOLS as T, type AgentCapability as a, type AgentDefinition as b, type AgentFactory as c, type AgentFactoryResult as d, type AgentPhase as e, type AgentRunnerOptions as f, DefaultMultiAgentCoordinator as g, type DispatchCandidate as h, type DispatchClassifier as i, type DispatchMethod as j, type DispatchOptions as k, type DispatchResult as l, type FleetEvent as m, type FleetHandler as n, type FleetUsage as o, FleetUsageAggregator as p, type MultiAgentCoordinatorOptions as q, dispatchAgent as r, makeAgentSubagentRunner as s, makeLLMClassifier as t, scoreAgents as u };
+export { type AgentBudgetTier as A, DEFAULT_DISPATCH_ROLE as D, HEAVY_BUDGET as H, LIGHT_BUDGET as L, MEDIUM_BUDGET as M, TOOLS as T, type AgentCapability as a, type AgentDefinition as b, type AgentPhase as c, DefaultMultiAgentCoordinator as d, type DispatchCandidate as e, type DispatchClassifier as f, type DispatchMethod as g, type DispatchOptions as h, type DispatchResult as i, type MultiAgentCoordinatorOptions as j, dispatchAgent as k, makeLLMClassifier as m, scoreAgents as s };

package/dist/{null-fleet-bus-Bkk3gafb.d.ts → null-fleet-bus-JdTSYJv9.d.ts}

@@ -1,8 +1,9 @@
-import { e as AgentPhase, b as AgentDefinition, F as FleetBus, o as FleetUsage, p as FleetUsageAggregator } from './multi-agent-coordinator-D8PLzfz6.js';
+import { c as AgentPhase, b as AgentDefinition } from './multi-agent-coordinator-3Ypfg-hr.js';
 import { m as SubagentConfig, t as TaskResult, j as CoordinatorStatus, u as TaskSpec, M as MultiAgentConfig, s as SubagentRunner } from './multi-agent-7OK4pEKW.js';
 import { B as SessionWriter, Q as Tool, y as SessionStore } from './context-z2x5gv_V.js';
 import { a as DirectorStateSnapshot } from './director-state-BmYi3DGA.js';
 import { I as InMemoryAgentBridge } from './agent-bridge-hXRN-GO_.js';
+import { F as FleetBus, e as FleetUsage, f as FleetUsageAggregator } from './agent-subagent-runner-BOBYkW_r.js';
 import { E as EventBus } from './events-D4pGukpI.js';
 
 /**

package/dist/permission-policy-D5Gj1o2K.d.ts

@@ -0,0 +1,111 @@
+import { Q as Tool, d as Context } from './context-z2x5gv_V.js';
+import { I as InputReader } from './input-reader-E-ffP2ee.js';
+import { a as PermissionPolicy, P as PermissionDecision } from './secret-scrubber-nI8qjaqW.js';
+
+interface PermissionPolicyOptions {
+    trustFile: string;
+    yolo?: boolean;
+    /**
+     * When true, YOLO mode allows even `destructive` tools without confirm.
+     * Corresponds to the `--force-all-yolo` CLI flag.
+     */
+    forceAllYolo?: boolean;
+    promptDelegate?: (tool: Tool, input: unknown, suggestedPattern: string) => Promise<'yes' | 'no' | 'always' | 'deny'>;
+    inputReader?: InputReader;
+}
+declare class DefaultPermissionPolicy implements PermissionPolicy {
+    private policy;
+    private loaded;
+    private readonly trustFile;
+    private yolo;
+    private forceAllYolo;
+    /**
+     * Session-scoped "soft deny" map. When the user presses 'n' (block once),
+     * the tool+pattern is added here. If the LLM retries in the same session,
+     * we return deny directly without asking again.
+     *
+     * Cleared on reload() since reload = fresh trust file snapshot.
+     */
+    private sessionDenied;
+    /**
+     * Session-scoped "soft trust" map. When the user presses 'a' (allow once),
+     * the tool+pattern is added here. If the LLM retries in the same session,
+     * we return auto directly without asking again.
+     *
+     * Cleared on reload().
+     */
+    private sessionAllowed;
+    /**
+     * Interactive prompt delegate. When set, `evaluate()` calls it to get a
+     * user decision synchronously (CLI REPL path). When cleared (TUI / WebUI),
+     * `evaluate()` returns `confirm` so the caller can emit
+     * `tool.confirm_needed` for the UI layer to handle.
+     *
+     * Mutable so the host can switch from CLI-prompt to event-driven
+     * confirmation at runtime (e.g. when `--goal` forces TUI mode after
+     * the agent was already constructed).
+     */
+    private promptDelegate?;
+    /** Pre-compiled wildcard patterns — rebuilt on reload for O(1) lookup. */
+    private wildcardEntries;
+    constructor(opts: PermissionPolicyOptions);
+    /**
+     * Replace (or clear) the interactive prompt delegate at runtime.
+     * Used by the CLI to switch from inline prompts (REPL) to event-driven
+     * confirmation (TUI) when the run mode is determined after the policy
+     * was constructed (e.g. `--goal` auto-flipping to TUI).
+     */
+    setPromptDelegate(delegate: PermissionPolicyOptions['promptDelegate']): void;
+    /** Toggle YOLO (auto-approve) mode at runtime. */
+    setYolo(enabled: boolean): void;
+    /** Check whether YOLO mode is currently active. */
+    getYolo(): boolean;
+    /** Toggle force-all-YOLO at runtime. */
+    setForceAllYolo(enabled: boolean): void;
+    /** Check whether force-all-YOLO is active. */
+    getForceAllYolo(): boolean;
+    reload(): Promise<void>;
+    evaluate(tool: Tool, input: unknown, ctx: Context): Promise<PermissionDecision>;
+    trust(rule: {
+        tool: string;
+        pattern: string;
+    }): Promise<void>;
+    /** Persist a deny rule — this tool+pattern pair is permanently blocked. */
+    deny(rule: {
+        tool: string;
+        pattern: string;
+    }): Promise<void>;
+    /** Block this tool+pattern for the rest of this session (no trust file). */
+    denyOnce(rule: {
+        tool: string;
+        pattern: string;
+    }): void;
+    /** Auto-approve this tool+pattern for the rest of this session (no trust file). */
+    allowOnce(rule: {
+        tool: string;
+        pattern: string;
+    }): void;
+    private subjectFor;
+    private findNamespaceEntry;
+}
+/**
+ * Auto-approving PermissionPolicy used for subagents. Subagents run
+ * non-interactively under a director — they cannot answer permission
+ * prompts, so a non-YOLO policy on the leader would silently hang the
+ * delegated run on the first sensitive tool call. The user already
+ * authorized the delegation when they invoked the leader; subagents
+ * inherit that authorization automatically.
+ *
+ * Tool defaults of `permission: 'deny'` are still honored (this is a
+ * subagent capability override, not a deny-bypass).
+ */
+declare class AutoApprovePermissionPolicy implements PermissionPolicy {
+    evaluate(tool: Tool): Promise<PermissionDecision>;
+    trust(): Promise<void>;
+    deny(): Promise<void>;
+    denyOnce(): void;
+    allowOnce(): void;
+    reload(): Promise<void>;
+}
+
+export { AutoApprovePermissionPolicy as A, DefaultPermissionPolicy as D, type PermissionPolicyOptions as P };

package/dist/{plan-templates-DWbEIJvV.d.ts → plan-templates-C-IOLJ8Q.d.ts}

@@ -2,7 +2,7 @@ import { E as EventBus } from './events-D4pGukpI.js';
 import { y as SessionStore, x as SessionMetadata, B as SessionWriter, r as ResumedSession, S as SessionData, z as SessionSummary, c as ContentBlock, w as SessionEvent, N as TodoItem, f as ConversationState } from './context-z2x5gv_V.js';
 import { e as AttachmentStore, A as AddAttachmentInput, d as AttachmentRef, a as Attachment } from './session-reader-DsadjyF9.js';
 import { b as MemoryStore, a as MemoryScope } from './memory-CEXuo7sz.js';
-import { a as WstackPaths } from './wstack-paths-BGu2INTm.js';
+import { a as WstackPaths } from './wstack-paths-gCrJ631C.js';
 import { c as ConfigStore, a as Config, b as ConfigLoader } from './config-Bi4Q0fnz.js';
 import { S as SecretVault } from './secret-vault-DoISxaKO.js';
 

package/dist/sdd/index.d.ts

@@ -1,7 +1,15 @@
 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-D4pGukpI.js';
-import { D as DoneCondition } from '../multi-agent-7OK4pEKW.js';
+import { D as DoneCondition, t as TaskResult } from '../multi-agent-7OK4pEKW.js';
+import { c as Agent } from '../index-BUHs7xJ9.js';
+import { A as AgentFactory } from '../agent-subagent-runner-BOBYkW_r.js';
 import '../context-z2x5gv_V.js';
+import '../logger-DDd5C--Z.js';
+import '../system-prompt-CWA6ml-d.js';
+import '../observability-BhnVLBLS.js';
+import '../secret-scrubber-nI8qjaqW.js';
+import '../config-Bi4Q0fnz.js';
+import '../models-registry-BcYJDKLm.js';
 
 declare class SpecParser {
     parse(content: string): Specification;
@@ -624,4 +632,167 @@ declare function createAutoExecutor(opts: {
     maxRetries?: number;
 }): AutoExecutor;
 
-export { AISpecBuilder, type AISpecBuilderOptions, type AISpecPhase, type AISpecSession, AutoExecutor, type AutoExecutorOptions, type BottleneckTask, type CollectedAnswer, type CriticalPathAnalysis, DefaultTaskStore, type ExecutionSummary, type GeneratedTask, SPEC_TEMPLATES, type SpecDiff, SpecDrivenDev, type SpecDrivenDevOptions, type SpecIndexEntry, SpecParser, SpecStore, type SpecStoreOptions, type SpecVersion, SpecVersioning, type TaskExecutionContext, type TaskExecutionResult, TaskFlow, type TaskFlowEventMap, type TaskFlowEventName, type TaskFlowExecutionContext, type TaskFlowOptions, type TaskFlowPhase, TaskGenerator, type TaskGeneratorOptions, type TaskGraphIndexEntry, TaskGraphStore, type TaskGraphStoreOptions, type TaskStore, TaskTracker, type TaskTrackerOptions, type TaskTransition, analyzeCriticalPath, createAutoExecutor, getTemplate, listTemplates, renderProgress, renderSpecAnalysis, renderTaskGraph, renderTaskList, templateToMarkdown };
+/**
+ * SddTaskDecomposer
+ *
+ * Converts a TaskGraph (from SDD's TaskGenerator) into a dependency-aware
+ * sequence of batches for ParallelEternalEngine.
+ *
+ * Key behaviour:
+ * - Each `nextBatch()` call returns up to `parallelSlots` ready tasks
+ *   (all blockers completed, sorted by priority).
+ * - Tasks that are blocked by an in-progress task are NOT included
+ *   in the batch — they wait for the blocker to complete.
+ * - When `isDone()` returns true the whole graph is either completed
+ *   or deadlocked (all remaining tasks are blocked by failed tasks).
+ *
+ * Usage:
+ * ```
+ * const decomposer = new SddTaskDecomposer(tracker, graph, { parallelSlots: 4 });
+ * while (!decomposer.isDone()) {
+ *   const batch = decomposer.nextBatch();
+ *   if (batch.length === 0) break; // deadlock
+ *   await fanOut(batch);
+ *   decomposer.acknowledgeBatch(batch.map(t => t.id));
+ * }
+ * ```
+ */
+
+interface SddTaskDecomposerOptions {
+    /** Max tasks per batch. Default: 4. Range 1–16. */
+    parallelSlots?: number;
+}
+interface TaskBatch {
+    /** Tasks ready to execute in this wave. */
+    tasks: TaskNode[];
+    /** 0-based wave number since the decomposer was constructed. */
+    wave: number;
+    /** True when every node in the graph is either completed or failed. */
+    allDone: boolean;
+    /** True when no batch was produced because remaining tasks are all blocked by failed nodes. */
+    deadlocked: boolean;
+}
+declare class SddTaskDecomposer {
+    private readonly tracker;
+    private readonly graph;
+    private readonly slots;
+    private wave;
+    constructor(tracker: TaskTracker, graph: TaskGraph, opts?: SddTaskDecomposerOptions);
+    /**
+     * Return the next batch of runnable tasks.
+     * Returns `allDone: true` when every node is completed.
+     * Returns `deadlocked: true` when no batch can be produced because
+     * all remaining tasks are blocked by failed nodes.
+     */
+    nextBatch(): TaskBatch;
+    /**
+     * Advance the wave counter after a batch completes.
+     * Call this once per `nextBatch()` result that was fan-out.
+     */
+    acknowledgeBatch(_completedTaskIds: string[]): void;
+    /**
+     * True when every node in the graph is completed.
+     * Use this to exit the fan-out loop after `isDone() || deadlocked`.
+     */
+    isDone(): boolean;
+    /**
+     * Total waves produced so far.
+     */
+    getWaveCount(): number;
+    /**
+     * Return pending nodes whose blockers are all completed.
+     * Sorted by priority (critical first), then by creation time.
+     */
+    private pendingReadyNodes;
+    /** True when at least one non-completed, non-failed task is blocked. */
+    private hasAnyBlockedTasks;
+}
+
+/**
+ * SddParallelRun
+ *
+ * Drives a TaskGraph through ParallelEternalEngine's infrastructure
+ * (DefaultMultiAgentCoordinator + AgentSubagentRunner) but powered by
+ * SddTaskDecomposer — producing dependency-aware waves instead of
+ * goal-driven iterations.
+ *
+ * One-shot: completes when all tasks are done OR a deadlock is detected.
+ * Does NOT loop — each run() call is a discrete execution.
+ *
+ * Usage:
+ * ```
+ * const run = new SddParallelRun({ tracker, graph, agent, projectRoot });
+ * await run.run({ onWave });
+ * // or with progress callback:
+ * await run.run({ onProgress: (p) => console.log(renderProgress(p)) });
+ * ```
+ */
+
+interface SddParallelRunOptions {
+    /** Pre-constructed TaskTracker (must already hold the graph's initial state). */
+    tracker: TaskTracker;
+    /** The TaskGraph produced by TaskGenerator from an approved spec. */
+    graph: TaskGraph;
+    /** The main agent — used as the subagent factory. */
+    agent: Agent;
+    /** Project root (used for coordinator id). */
+    projectRoot: string;
+    /** Override default parallel slots (1–16). Default: 4. */
+    parallelSlots?: number;
+    /** Per-task timeout in ms. Default: 300_000 (5 min). */
+    taskTimeoutMs?: number;
+    /** Override the default agent factory. */
+    subagentFactory?: AgentFactory;
+    /** Called after each wave completes. */
+    onWave?: (wave: WaveResult) => void;
+    /** Called with progress stats every ~2s during execution. */
+    onProgress?: (progress: SddProgress) => void;
+}
+interface SddProgress {
+    wave: number;
+    total: number;
+    completed: number;
+    inProgress: number;
+    failed: number;
+    blocked: number;
+    pending: number;
+    percent: number;
+    deadlocked: boolean;
+}
+interface WaveResult {
+    wave: number;
+    batch: TaskBatch;
+    results: TaskResult[];
+    successCount: number;
+    failCount: number;
+    durationMs: number;
+    stopRequested: boolean;
+}
+interface RunResult {
+    totalWaves: number;
+    totalCompleted: number;
+    totalFailed: number;
+    totalDurationMs: number;
+    deadlocked: boolean;
+    stopRequested: boolean;
+    finalProgress: TaskProgress;
+}
+declare class SddParallelRun {
+    private readonly opts;
+    private readonly slots;
+    private readonly timeoutMs;
+    private decomposer;
+    private coordinator;
+    private stopRequested;
+    constructor(opts: SddParallelRunOptions);
+    /** Trigger stop — causes run() to abort after the current wave. */
+    stop(): void;
+    /** Execute all waves until completion or deadlock. Returns final summary. */
+    run(): Promise<RunResult>;
+    private buildCoordinator;
+    private defaultFactory;
+    executeWave(batch: TaskBatch): Promise<WaveResult>;
+    private buildProgress;
+}
+
+export { AISpecBuilder, type AISpecBuilderOptions, type AISpecPhase, type AISpecSession, AutoExecutor, type AutoExecutorOptions, type BottleneckTask, type CollectedAnswer, type CriticalPathAnalysis, DefaultTaskStore, type ExecutionSummary, type GeneratedTask, type RunResult, SPEC_TEMPLATES, SddParallelRun, type SddParallelRunOptions, type SddProgress, SddTaskDecomposer, type SddTaskDecomposerOptions, type SpecDiff, SpecDrivenDev, type SpecDrivenDevOptions, type SpecIndexEntry, SpecParser, SpecStore, type SpecStoreOptions, type SpecVersion, SpecVersioning, type TaskBatch, type TaskExecutionContext, type TaskExecutionResult, TaskFlow, type TaskFlowEventMap, type TaskFlowEventName, type TaskFlowExecutionContext, type TaskFlowOptions, type TaskFlowPhase, TaskGenerator, type TaskGeneratorOptions, type TaskGraphIndexEntry, TaskGraphStore, type TaskGraphStoreOptions, type TaskStore, TaskTracker, type TaskTrackerOptions, type TaskTransition, type WaveResult, analyzeCriticalPath, createAutoExecutor, getTemplate, listTemplates, renderProgress, renderSpecAnalysis, renderTaskGraph, renderTaskList, templateToMarkdown };