@wrongstack/core 0.284.1 → 0.285.0

package/dist/agent-status-tracker.d.ts

@@ -0,0 +1,74 @@
+/**
+ * AgentStatusTracker — subscribes to EventBus events and keeps the
+ * SessionRegistry updated with live agent status.
+ *
+ * Created once per process during boot. Listens for:
+ * - agent.run.started / agent.run.completed → agent status changes
+ * - tool.started / tool.executed → current tool tracking
+ * - brain.ask_human → waiting_user status
+ * - fleet events (subagent spawn/start/done) → agent entries
+ *
+ * @module agent-status-tracker
+ */
+import type { EventBus } from './kernel/events.js';
+import type { AgentEntry, SessionRegistry } from './session-registry.js';
+export interface AgentStatusTrackerOptions {
+    events: EventBus;
+    registry: SessionRegistry;
+    /** Session id whose live agent state is mirrored by this tracker. */
+    sessionId?: string | (() => string | undefined) | undefined;
+    /** Leader agent name shown in the registry. Default: "leader". */
+    leaderName?: string | undefined;
+    /**
+     * Best-effort callback fired after each registry write settles. Used to nudge
+     * local WebUI servers (FleetNotifier) so cross-process status reaches the map
+     * without waiting on their file-watch/poll. Never block or throw.
+     */
+    onUpdate?: (() => void) | undefined;
+}
+export declare class AgentStatusTracker {
+    private readonly events;
+    private readonly registry;
+    private readonly sessionId;
+    private readonly leaderName;
+    private agents;
+    private lastAgents;
+    private leaderStatus;
+    private leaderCurrentTool;
+    private leaderIterations;
+    private leaderToolCalls;
+    private leaderCostUsd;
+    private leaderTokensIn;
+    private leaderTokensOut;
+    private leaderCtxPct;
+    private leaderModel;
+    private leaderPartialText;
+    private leaderStartedAt;
+    private unsubscribers;
+    private readonly onUpdate;
+    private sweepTimer;
+    private partialTimer;
+    constructor(opts: AgentStatusTrackerOptions);
+    /** Current full agent list (leader + subagents) as of the last flush. */
+    getAgents(): AgentEntry[];
+    start(): void;
+    stop(): void;
+    /**
+     * Coalesce streamed-text flushes: at most one registry write per
+     * {@link PARTIAL_FLUSH_THROTTLE_MS} while text streams in, so per-token
+     * deltas never thrash the cross-process registry file.
+     */
+    private schedulePartialFlush;
+    /**
+     * Remove subagents that have been finished (idle/error) for longer than
+     * {@link AGENT_REAP_MS}. Running / streaming / waiting_user agents are kept
+     * regardless of age — only *not-working* agents are reaped.
+     */
+    private sweep;
+    private flush;
+    private currentSessionId;
+    private acceptsSession;
+    private markLeaderStarted;
+    private captureLeaderContext;
+}
+//# sourceMappingURL=agent-status-tracker.d.ts.map

package/dist/agent-status-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-status-tracker.d.ts","sourceRoot":"","sources":["../src/agent-status-tracker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EACV,UAAU,EAEV,eAAe,EAChB,MAAM,uBAAuB,CAAC;AAgB/B,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,QAAQ,CAAC;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,GAAG,CAAC,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC;IAC5D,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS,CAAC;CACrC;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;IAClC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkB;IAC3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkD;IAC5E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IAGpC,OAAO,CAAC,MAAM,CAAiC;IAG/C,OAAO,CAAC,UAAU,CAAoB;IAGtC,OAAO,CAAC,YAAY,CAA2B;IAC/C,OAAO,CAAC,iBAAiB,CAAqB;IAC9C,OAAO,CAAC,gBAAgB,CAAK;IAC7B,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,eAAe,CAAK;IAC5B,OAAO,CAAC,YAAY,CAAqB;IACzC,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,iBAAiB,CAAM;IAC/B,OAAO,CAAC,eAAe,CAAqB;IAE5C,OAAO,CAAC,aAAa,CAAyB;IAC9C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA2B;IACpD,OAAO,CAAC,UAAU,CAA+C;IACjE,OAAO,CAAC,YAAY,CAA8C;IAElE,YAAY,IAAI,EAAE,yBAAyB,EAM1C;IAED,yEAAyE;IACzE,SAAS,IAAI,UAAU,EAAE,CAExB;IAED,KAAK,IAAI,IAAI,CAoTZ;IAED,IAAI,IAAI,IAAI,CAaX;IAED;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAS5B;;;;OAIG;IACH,OAAO,CAAC,KAAK;IAcb,OAAO,CAAC,KAAK;IA6Cb,OAAO,CAAC,gBAAgB;IAIxB,OAAO,CAAC,cAAc;IAQtB,OAAO,CAAC,iBAAiB;IAYzB,OAAO,CAAC,oBAAoB;CA0B7B"}

package/dist/autophase/auto-phase-planner.d.ts

@@ -0,0 +1,79 @@
+/**
+ * AutoPhasePlanner - converts a goal into phases using a real LLM call,
+ * producing a large task list with todos under each phase.
+ *
+ * Similar to SDD's spec-to-task flow, but different: the output is directly
+ * `PhaseTemplate[]`; each phase carries `taskTemplates`, so
+ * `PhaseGraphBuilder` produces a populated `PhaseGraph` and `PhaseOrchestrator`
+ * runs each task through a real agent execution.
+ *
+ * The planner is not tied to a specific LLM: callers provide a `runOnce(prompt)` function
+ * (a subagent run in the CLI, or a deterministic stub in tests).
+ */
+import type { PhaseTemplate } from './types.js';
+export interface AutoPhasePlannerOptions {
+    /**
+     * One-shot LLM call: receives a prompt and returns the model text output.
+     * In the CLI this wraps subagent.run; in tests it can be a deterministic stub.
+     */
+    runOnce: (prompt: string) => Promise<string>;
+    /** Goal or project title. */
+    goal: string;
+    /** Optional project context such as package.json or directory structure. */
+    projectContext?: string | undefined;
+    /** Requested minimum phase count. Defaults to 3. */
+    minPhases?: number | undefined;
+    /** Requested maximum phase count. Defaults to 8. */
+    maxPhases?: number | undefined;
+    /** Target todo count per phase. Defaults to 6. */
+    todosPerPhase?: number | undefined;
+    /**
+     * Maximum total tasks across all phases. When set, plans exceeding
+     * this limit will have `budgetExceeded: true` and `warnings` will
+     * describe the overage. Defaults to 0 (no limit).
+     */
+    maxTotalTasks?: number | undefined;
+}
+export interface AutoPhasePlanResult {
+    /** Phase templates passed to PhaseGraphBuilder. */
+    phases: PhaseTemplate[];
+    /** Raw model output for debugging and logs. */
+    raw: string;
+    /** True when JSON could not be parsed; `phases` is empty in that case. */
+    parseFailed: boolean;
+    /** Validation warnings collected during coercion (e.g. invalid priority defaults). */
+    warnings: string[];
+    /**
+     * Rough cost estimate (in tokens) for executing this plan.
+     * Based on estimated task count × average per-task LLM round-trip.
+     */
+    estimatedCostTokens?: number | undefined;
+    /** True when the plan exceeds `maxTotalTasks` budget. */
+    budgetExceeded?: boolean | undefined;
+}
+/**
+ * AutoPhasePlanner drives the model through `plan()` and produces `PhaseTemplate[]`.
+ */
+export declare class AutoPhasePlanner {
+    private readonly opts;
+    constructor(opts: AutoPhasePlannerOptions);
+    /** Convert the goal into a phase-and-todo plan. */
+    plan(): Promise<AutoPhasePlanResult>;
+    /** Instruction prompt for the plan the model should produce. */
+    buildPrompt(): string;
+    /** Extract JSON from raw output, validate it, and convert it to PhaseTemplate[].
+     *  Returns `{ phases, warnings }` where warnings describe coerced defaults. */
+    parse(raw: string): {
+        phases: PhaseTemplate[];
+        warnings: string[];
+    };
+    private coercePhase;
+    private coerceTask;
+}
+/**
+ * Extract the first JSON array from text. Tries, in order:
+ *  1. The first [ ... ] inside a ```json ... ``` or bare ``` code block
+ *  2. The first balanced [ ... ] block in the text, aware of strings and escapes
+ */
+export declare function extractJSONArray(text: string): string | null;
+//# sourceMappingURL=auto-phase-planner.d.ts.map

package/dist/autophase/auto-phase-planner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-phase-planner.d.ts","sourceRoot":"","sources":["../../src/autophase/auto-phase-planner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAOH,OAAO,KAAK,EAAa,aAAa,EAAE,MAAM,YAAY,CAAC;AAK3D,MAAM,WAAW,uBAAuB;IACtC;;;OAGG;IACH,OAAO,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7C,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,oDAAoD;IACpD,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,kDAAkD;IAClD,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED,MAAM,WAAW,mBAAmB;IAClC,mDAAmD;IACnD,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,+CAA+C;IAC/C,GAAG,EAAE,MAAM,CAAC;IACZ,0EAA0E;IAC1E,WAAW,EAAE,OAAO,CAAC;IACrB,sFAAsF;IACtF,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzC,yDAAyD;IACzD,cAAc,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACtC;AAiBD;;GAEG;AACH,qBAAa,gBAAgB;IACf,OAAO,CAAC,QAAQ,CAAC,IAAI;IAAjC,YAA6B,IAAI,EAAE,uBAAuB,EAAI;IAE9D,mDAAmD;IAC7C,IAAI,IAAI,OAAO,CAAC,mBAAmB,CAAC,CAkBzC;IAED,gEAAgE;IAChE,WAAW,IAAI,MAAM,CAapB;IAED;mFAC+E;IAC/E,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG;QAAE,MAAM,EAAE,aAAa,EAAE,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,CAoBlE;IAED,OAAO,CAAC,WAAW;IAsCnB,OAAO,CAAC,UAAU;CAgCnB;AAaD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAY5D"}

package/dist/autophase/auto-phase-runner.d.ts

@@ -0,0 +1,79 @@
+import type { AutoPhaseOptions, PhaseExecutionContext, PhaseGraph, PhaseNode, PhaseProgress, PhaseTemplate } from './types.js';
+export interface AutoPhaseRunnerOptions extends AutoPhaseOptions {
+    /** Project title. */
+    title: string;
+    description?: string | undefined;
+    /** Phase templates. */
+    phases: PhaseTemplate[];
+    /** Function that executes a task. */
+    executeTask: PhaseExecutionContext['executeTask'];
+    /** Optional verification gate. */
+    verifyPhase?: PhaseExecutionContext['verifyPhase'] | undefined;
+    /** Optional repair pass after verification failure. */
+    repairPhase?: PhaseExecutionContext['repairPhase'] | undefined;
+    /** Optional resolver for worktree merge conflicts. */
+    resolveConflict?: PhaseExecutionContext['resolveConflict'] | undefined;
+    /** Optional Brain arbiter. */
+    brain?: PhaseExecutionContext['brain'] | undefined;
+    /** Called when a phase completes. */
+    onPhaseComplete?: ((phase: PhaseNode) => void) | undefined;
+    /** Called when a phase fails. */
+    onPhaseFail?: (phase: PhaseNode, error: Error) => void;
+    /** Called on every orchestrator tick. */
+    onTick?: (ctx: {
+        activePhases: PhaseNode[];
+        readyPhases: PhaseNode[];
+    }) => void;
+    /** Called when progress changes. */
+    onProgress?: ((progress: PhaseProgress) => void) | undefined;
+    /** Safety net that stops a phase graph if cleanup is bypassed. Default: 24h. */
+    maxRunDurationMs?: number | undefined;
+    /** Called when the graph completes. */
+    onComplete?: ((graph: PhaseGraph) => void) | undefined;
+    /** Called when the graph fails. */
+    onFail?: (graph: PhaseGraph, failedPhase: PhaseNode, error: Error) => void;
+}
+/**
+ * AutoPhaseRunner - high-level API for managing the whole autonomous phase flow from one entry point.
+ *
+ * Usage:
+ *   const runner = new AutoPhaseRunner({
+ *     title: 'Auth Refactor',
+ *     phases: [...],
+ *     executeTask: async (task, phaseId) => { ... },
+ *     onProgress: (p) => console.log(`${p.percentComplete}% done`),
+ *   });
+ *   await runner.start();
+ */
+export declare class AutoPhaseRunner {
+    private graph;
+    private orchestrator;
+    private opts;
+    private progressInterval;
+    private maxRunTimer;
+    private readonly graphCompletedHandler;
+    private readonly graphFailedHandler;
+    /** Stores the unsubscribe function returned by EventBus.on() */
+    private unsubscribeCompleted;
+    private unsubscribeFailed;
+    constructor(opts: AutoPhaseRunnerOptions);
+    start(): Promise<PhaseGraph>;
+    pause(): void;
+    resume(): void;
+    stop(): void;
+    getProgress(): PhaseProgress | null;
+    getGraph(): PhaseGraph | null;
+    isRunning(): boolean;
+    isPaused(): boolean;
+    assignAgent(phaseId: string, agentId: string): void;
+    releaseAgent(phaseId: string, agentId: string): void;
+    private cleanup;
+}
+/**
+ * Quick-start helper: create an AutoPhaseRunner from an existing TaskGraph.
+ */
+export declare function createAutoPhaseFromTaskGraph(taskGraph: import('../types/task-graph.js').TaskGraph, options: Omit<AutoPhaseRunnerOptions, 'phases' | 'title'> & {
+    title?: string | undefined;
+    tasksPerPhase?: number | undefined;
+}): Promise<AutoPhaseRunner>;
+//# sourceMappingURL=auto-phase-runner.d.ts.map

package/dist/autophase/auto-phase-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"auto-phase-runner.d.ts","sourceRoot":"","sources":["../../src/autophase/auto-phase-runner.ts"],"names":[],"mappings":"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"}

package/dist/autophase/checkpoint.d.ts

@@ -0,0 +1,49 @@
+import type { PhaseStore } from './phase-store.js';
+import type { PhaseGraph, PhaseNode } from './types.js';
+export interface Checkpoint {
+    id: string;
+    graphId: string;
+    phaseId: string;
+    phaseStatus: PhaseNode['status'];
+    taskStatuses: Array<{
+        taskId: string;
+        status: string;
+        title: string;
+    }>;
+    timestamp: number;
+    label?: string | undefined;
+}
+export interface CheckpointManagerOptions {
+    store: PhaseStore;
+    maxCheckpoints?: number | undefined;
+    /** Max age in ms before a checkpoint is eligible for TTL-based pruning. Default: 7 days. */
+    maxCheckpointAgeMs?: number | undefined;
+    baseDir?: string | undefined;
+}
+/**
+ * CheckpointManager - saves and restores snapshots of the phase graph.
+ *
+ * Usage:
+ *   const cm = new CheckpointManager({ store });
+ *   await cm.saveCheckpoint(graph, 'Before risky refactor');
+ *   // ... if something goes wrong ...
+ *   const restored = await cm.restoreCheckpoint(checkpointId);
+ */
+export declare class CheckpointManager {
+    private store;
+    private maxCheckpoints;
+    private maxCheckpointAgeMs;
+    private checkpoints;
+    private baseDir;
+    constructor(opts: CheckpointManagerOptions);
+    initialize(): Promise<void>;
+    saveCheckpoint(graph: PhaseGraph, label?: string): Promise<Checkpoint>;
+    restoreCheckpoint(checkpointId: string): Promise<PhaseGraph | null>;
+    listCheckpoints(graphId?: string): Checkpoint[];
+    deleteCheckpoint(checkpointId: string): Promise<boolean>;
+    private saveToDisk;
+    private deleteFromDisk;
+    private loadFromDisk;
+    private pruneCheckpoints;
+}
+//# sourceMappingURL=checkpoint.d.ts.map

package/dist/autophase/checkpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint.d.ts","sourceRoot":"","sources":["../../src/autophase/checkpoint.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAExD,MAAM,WAAW,UAAU;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC;IACjC,YAAY,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvE,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B;AAED,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,UAAU,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,4FAA4F;IAC5F,kBAAkB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B;AAYD;;;;;;;;GAQG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,KAAK,CAAa;IAC1B,OAAO,CAAC,cAAc,CAAS;IAC/B,OAAO,CAAC,kBAAkB,CAAS;IACnC,OAAO,CAAC,WAAW,CAAiC;IACpD,OAAO,CAAC,OAAO,CAAS;IAExB,YAAY,IAAI,EAAE,wBAAwB,EAMzC;IAEK,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAGhC;IAEK,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAkC3E;IAEK,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAgCxE;IAED,eAAe,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,UAAU,EAAE,CAI9C;IAEK,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAQ7D;YAEa,UAAU;YAyBV,cAAc;YAkCd,YAAY;YAqCZ,gBAAgB;CA0B/B"}

package/dist/autophase/index.d.ts

@@ -0,0 +1,9 @@
+export { AutoPhaseRunner, createAutoPhaseFromTaskGraph, type AutoPhaseRunnerOptions, } from './auto-phase-runner.js';
+export { PhaseOrchestrator, type PhaseOrchestratorOptions, } from './phase-orchestrator.js';
+export { PhaseGraphBuilder, type PhaseGraphBuilderOptions, } from './phase-graph-builder.js';
+export { AutoPhasePlanner, extractJSONArray as extractAutoPhaseJSONArray, type AutoPhasePlannerOptions, type AutoPhasePlanResult, } from './auto-phase-planner.js';
+export type { PhaseGraph, PhaseNode, PhaseStatus, PhaseProgress, PhaseEventMap, PhaseEventName, PhaseExecutionContext, AutoPhaseOptions, PhaseFilter, PhaseSort, PhaseTemplate, } from './types.js';
+export { PHASE_EVENT_NAMES } from './types.js';
+export { PhaseStore, type PhaseStoreOptions } from './phase-store.js';
+export { CheckpointManager, type CheckpointManagerOptions, type Checkpoint, } from './checkpoint.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/autophase/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/autophase/index.ts"],"names":[],"mappings":"AAmBA,OAAO,EACL,eAAe,EACf,4BAA4B,EAC5B,KAAK,sBAAsB,GAC5B,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EACL,iBAAiB,EACjB,KAAK,wBAAwB,GAC9B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,iBAAiB,EACjB,KAAK,wBAAwB,GAC9B,MAAM,0BAA0B,CAAC;AAElC,OAAO,EACL,gBAAgB,EAChB,gBAAgB,IAAI,yBAAyB,EAC7C,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,GACzB,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EACV,UAAU,EACV,SAAS,EACT,WAAW,EACX,aAAa,EACb,aAAa,EACb,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EAChB,WAAW,EACX,SAAS,EACT,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE/C,OAAO,EAAE,UAAU,EAAE,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EACL,iBAAiB,EACjB,KAAK,wBAAwB,EAC7B,KAAK,UAAU,GAChB,MAAM,iBAAiB,CAAC"}

package/dist/autophase/phase-graph-builder.d.ts

@@ -0,0 +1,46 @@
+import { type TaskStore } from '../tasking/index.js';
+import type { TaskGraph } from '../types/task-graph.js';
+import type { PhaseGraph, PhaseTemplate } from './types.js';
+export interface PhaseGraphBuilderOptions {
+    title: string;
+    description?: string | undefined;
+    /** Ordered phase templates. */
+    phases: PhaseTemplate[];
+    /** Autonomous mode. */
+    autonomous?: boolean | undefined;
+    /** Stop on failure. */
+    stopOnFailure?: boolean | undefined;
+    /** Optional external TaskStore. */
+    externalTaskStore?: TaskStore | undefined;
+}
+/**
+ * PhaseGraphBuilder - builds project phases and a task graph for each phase.
+ *
+ * Usage:
+ *   const builder = new PhaseGraphBuilder({
+ *     title: 'Auth System Refactor',
+ *     phases: [
+ *       { name: 'Discovery', description: '...', priority: 'high', estimateHours: 2, parallelizable: false },
+ *       { name: 'Design', description: '...', priority: 'critical', estimateHours: 4, parallelizable: false },
+ *       { name: 'Implementation', description: '...', priority: 'critical', estimateHours: 12, parallelizable: false },
+ *       { name: 'Testing', description: '...', priority: 'high', estimateHours: 6, parallelizable: true },
+ *       { name: 'Deployment', description: '...', priority: 'medium', estimateHours: 2, parallelizable: false },
+ *     ]
+ *   });
+ *   const graph = await builder.build();
+ */
+export declare class PhaseGraphBuilder {
+    private readonly opts;
+    constructor(opts: PhaseGraphBuilderOptions);
+    build(): Promise<PhaseGraph>;
+    /**
+     * Create phases from an existing TaskGraph.
+     * Groups tasks into phases using topological sort so dependencies
+     * stay in the same phase wherever possible.
+     */
+    static fromTaskGraph(taskGraph: TaskGraph, options: Omit<PhaseGraphBuilderOptions, 'phases'> & {
+        /** Number of tasks per phase. Defaults to 5. */
+        tasksPerPhase?: number | undefined;
+    }): Promise<PhaseGraph>;
+}
+//# sourceMappingURL=phase-graph-builder.d.ts.map

package/dist/autophase/phase-graph-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase-graph-builder.d.ts","sourceRoot":"","sources":["../../src/autophase/phase-graph-builder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiC,KAAK,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACpF,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,wBAAwB,CAAC;AACtE,OAAO,KAAK,EAAE,UAAU,EAAa,aAAa,EAAE,MAAM,YAAY,CAAC;AAEvE,MAAM,WAAW,wBAAwB;IACvC,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,+BAA+B;IAC/B,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB,uBAAuB;IACvB,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACjC,uBAAuB;IACvB,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACpC,mCAAmC;IACnC,iBAAiB,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;CAC3C;AAED;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,iBAAiB;IAChB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAAjC,YAA6B,IAAI,EAAE,wBAAwB,EAAI;IAEzD,KAAK,IAAI,OAAO,CAAC,UAAU,CAAC,CA6EjC;IAED;;;;OAIG;IACH,MAAM,CAAC,aAAa,CAClB,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,IAAI,CAAC,wBAAwB,EAAE,QAAQ,CAAC,GAAG;QAClD,gDAAgD;QAChD,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;KACpC,GACA,OAAO,CAAC,UAAU,CAAC,CA4GrB;CACF"}

package/dist/autophase/phase-orchestrator.d.ts

@@ -0,0 +1,150 @@
+import type { TaskNode } from '../types/task-graph.js';
+import type { AutoPhaseOptions, PhaseExecutionContext, PhaseGraph, PhaseNode, PhaseProgress } from './types.js';
+export interface PhaseOrchestratorOptions extends AutoPhaseOptions {
+    graph: PhaseGraph;
+    ctx: PhaseExecutionContext;
+}
+/**
+ * PhaseOrchestrator - dependency-aware engine for running phases autonomously.
+ *
+ * Features:
+ * - Automatically starts the next phase as each phase completes in autonomous mode
+ * - Supports parallel phases with parallelizable=true
+ * - Assigns and releases agents
+ * - Integrates with the event bus
+ * - Supports pause and resume
+ */
+export declare class PhaseOrchestrator {
+    private graph;
+    private ctx;
+    private opts;
+    private events;
+    private stopped;
+    private paused;
+    private runningPhases;
+    private tickInterval;
+    private trackerCache;
+    private taskRetryCounts;
+    private readonly worktrees?;
+    /** Per-phase worktree handles, keyed by phase id. */
+    private readonly phaseWorktrees;
+    /** Serializes all merges back to the base branch (one at a time). */
+    private mergeQueue;
+    /** Per-phase merge promise, so a phase merges only after its deps do. */
+    private readonly phaseMergePromise;
+    constructor(opts: PhaseOrchestratorOptions);
+    /**
+     * Start the full phase flow.
+     * In autonomous mode, starts root phases and automatically starts the next phase when they finish.
+     */
+    start(): Promise<void>;
+    /**
+     * Make a (possibly resumed) graph runnable. A graph loaded from disk after an
+     * interrupted run can carry transient state from the dead process: phases left
+     * `running` and tasks left `in_progress`. The scheduler only starts `pending`
+     * phases (getReadyPhases) and only runs `pending` tasks (getExecutableTasks),
+     * so without this a resumed phase/task would stall forever. Reset that
+     * transient state to `pending`; terminal phases (completed/failed/skipped) and
+     * already-completed tasks are untouched, so completed work is never re-run.
+     * For a freshly built graph this is a no-op.
+     */
+    private normalizeForResume;
+    /** Wait for all pending phase merges, dependency-ordered and globally serialized. */
+    private drainMerges;
+    /** Pause: active phases continue, but no new phase starts. */
+    pause(): void;
+    /** Resume: new phases may start again. */
+    resume(): void;
+    /** Stop completely, including active phases. */
+    stop(): void;
+    private tick;
+    private startPhase;
+    /**
+     * Run the verification gate for a phase whose tasks all succeeded. Verifies in
+     * the phase's worktree; on failure, runs the repair pass and re-verifies, up to
+     * `maxVerifyAttempts` repairs. Returns the final verdict. When no `verifyPhase`
+     * callback is wired the gate is a no-op and always passes.
+     */
+    private runVerifyGate;
+    /** Worktree env (cwd/branch) for a phase, or undefined if it runs on the shared tree. */
+    private worktreeEnv;
+    /** Shared failure bookkeeping for a phase whose tasks ran but the phase failed. */
+    private failPhaseAfterTasks;
+    /**
+     * A phase whose tasks all succeeded was marked `completed` and queued for
+     * merge, but the merge back into the base branch failed. Its work is NOT
+     * integrated, so correct the graph: move the phase out of `completedPhaseIds`
+     * into `failedPhaseIds` and flip its status to `failed`. Without this the
+     * persisted graph (and the board) would claim the phase succeeded while a
+     * `phase.failed` event fired — an inconsistency that hides un-merged work.
+     * Idempotent: safe to call more than once for the same phase.
+     */
+    private markPhaseMergeFailed;
+    /** Trim long verifier output so it fits cleanly in an event/error message. */
+    private truncate;
+    /**
+     * Commit the phase's worktree changes, then enqueue the merge back into the
+     * base branch. Merges run dependency-ordered (a phase merges only after its
+     * `dependsOn` phases) and globally serialized (one at a time) to avoid
+     * concurrent writes to the base tree.
+     */
+    private commitAndEnqueueMerge;
+    /**
+     * Squash-merge one phase. When a `resolveConflict` callback is wired, a merge
+     * conflict is handed to it (a resolver subagent) before giving up; only if
+     * that fails does the worktree fall to needs-review and the run continues.
+     */
+    private mergeOne;
+    private shouldAttemptConflictResolution;
+    private setIntegrationMetadata;
+    /** A failed phase keeps its worktree on disk for inspection (no merge). */
+    private keepWorktreeForReview;
+    private executePhaseTasks;
+    private executeSingleTask;
+    private markTaskCompleted;
+    private markTaskFailed;
+    private getReadyPhases;
+    private getActivePhases;
+    private getExecutableTasks;
+    private getTrackerForPhase;
+    private getFailedTaskCount;
+    private getCompletedTaskCount;
+    private updatePhaseStatus;
+    private isComplete;
+    private onGraphComplete;
+    private onGraphFailed;
+    getProgress(): PhaseProgress;
+    getGraph(): PhaseGraph;
+    isRunning(): boolean;
+    isPaused(): boolean;
+    assignAgent(phaseId: string, agentId: string): void;
+    releaseAgent(phaseId: string, agentId: string): void;
+    /** Find the phase whose task graph currently holds `taskId`. */
+    findPhaseOfTask(taskId: string): PhaseNode | undefined;
+    /**
+     * Move a task to another phase's task graph. Edges that referenced the task
+     * are dropped (cross-phase dependencies are not modeled). No-op when the task
+     * or target phase is missing, or it is already in the target phase.
+     */
+    moveTask(taskId: string, toPhaseId: string): boolean;
+    /** (Re)assign a task to a specific agent (or clear with agentName/agentId omitted). */
+    setTaskAssignee(taskId: string, agentId?: string, agentName?: string): boolean;
+    /** Add a new task to a phase. Returns the created task id, or null if the phase is missing. */
+    addTask(phaseId: string, spec: {
+        title: string;
+        description?: string | undefined;
+        type?: TaskNode['type'] | undefined;
+        priority?: TaskNode['priority'] | undefined;
+    }): string | null;
+    /**
+     * Requeue a task to `pending` (clearing its retry counter) and nudge a
+     * terminal/paused phase back to `ready` so the loop re-runs it. Backs both the
+     * board's "retry" and "start" affordances.
+     */
+    requeueTask(taskId: string): boolean;
+    private emit;
+    private createNoopEventBus;
+    private waitWhilePaused;
+    private delay;
+}
+//# sourceMappingURL=phase-orchestrator.d.ts.map

package/dist/autophase/phase-orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase-orchestrator.d.ts","sourceRoot":"","sources":["../../src/autophase/phase-orchestrator.ts"],"names":[],"mappings":"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"}

package/dist/autophase/phase-store.d.ts

@@ -0,0 +1,29 @@
+import type { PhaseGraph } from './types.js';
+export interface PhaseStoreOptions {
+    baseDir: string;
+}
+/**
+ * PhaseStore - persistence layer for saving and loading PhaseGraph objects on disk.
+ */
+export declare class PhaseStore {
+    readonly baseDir: string;
+    constructor(opts: PhaseStoreOptions);
+    save(graph: PhaseGraph): Promise<void>;
+    load(graphId: string): Promise<PhaseGraph | null>;
+    delete(graphId: string): Promise<void>;
+    list(): Promise<Array<{
+        id: string;
+        title: string;
+        updatedAt: number;
+        status: string;
+    }>>;
+    private getFilePath;
+    private serializeGraph;
+    private serializePhase;
+    private serializeTaskGraph;
+    private serializeTaskNode;
+    private deserializeGraph;
+    private deserializePhase;
+    private deserializeTaskGraph;
+}
+//# sourceMappingURL=phase-store.d.ts.map

package/dist/autophase/phase-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"phase-store.d.ts","sourceRoot":"","sources":["../../src/autophase/phase-store.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAa,MAAM,YAAY,CAAC;AAExD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;CACjB;AA4ED;;GAEG;AACH,qBAAa,UAAU;IACrB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,YAAY,IAAI,EAAE,iBAAiB,EAElC;IAEK,IAAI,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAO3C;IAEK,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAStD;IAEK,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAO3C;IAEK,IAAI,IAAI,OAAO,CAAC,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CA2B7F;IAED,OAAO,CAAC,WAAW;IAInB,OAAO,CAAC,cAAc;IAoBtB,OAAO,CAAC,cAAc;IAsBtB,OAAO,CAAC,kBAAkB;IAa1B,OAAO,CAAC,iBAAiB;IAIzB,OAAO,CAAC,gBAAgB;IAiCxB,OAAO,CAAC,gBAAgB;IAsBxB,OAAO,CAAC,oBAAoB;CAiB7B"}