@wrongstack/core 0.284.1 → 0.285.0

package/dist/coordination/collab-bus.d.ts

@@ -0,0 +1,132 @@
+/**
+ * CollaborationBus — kernel-level pause/resume signal for the
+ * collaboration `controller` role (Phase 3 of idea #13 from IDEAS.md).
+ *
+ * The bus is a single-process singleton. The webui server (which hosts
+ * the agent loop) creates one at boot, passes it to both the agent's
+ * `toolCall` pipeline (as a middleware) and the `CollaborationWsHandler`
+ * (which toggles it on client requests).
+ *
+ * Semantics:
+ *   - `requestPause(by)` flips the bus into the "paused" state. The
+ *     state has no timeout of its own — the *middleware* decides how
+ *     long to wait before auto-resuming (default 60s).
+ *   - `resume()` returns the bus to the running state. Idempotent:
+ *     calling resume() when not paused is a no-op returning `false`.
+ *   - `waitForResume(timeoutMs)` is what the middleware calls. It
+ *     returns `true` if the bus was resumed in time, `false` if the
+ *     timeout fired (in which case it also auto-resumes, so the agent
+ *     loop is never permanently stuck).
+ *   - `getState()` returns a snapshot for observability surfaces
+ *     (UI badges, CLI `/collab status`).
+ *
+ * Why a separate bus object rather than putting state on RunController?
+ *
+ *   - The RunController is per-run; the bus is per-process. A single
+ *     pause signal across the whole webui process is the right
+ *     granularity (the webui hosts exactly one Agent.run at a time).
+ *   - The bus can be unit-tested without spinning up an Agent. The
+ *     middleware can be tested by injecting a fake bus.
+ *   - Future multi-session webui (when the bus is upgraded to filter
+ *     by sessionId) does not require touching the agent loop — the
+ *     middleware already receives the sessionId in its payload.
+ */
+export type CollabBusState = {
+    paused: boolean;
+    pausedAt: string | null;
+    pausedBy: string | null;
+};
+export declare class CollaborationBus {
+    private pausePromise;
+    private pauseResolve;
+    private pausedAtMs;
+    private pausedBy;
+    isPaused(): boolean;
+    getState(): CollabBusState;
+    /**
+     * Pause the agent loop. Idempotent: a second `requestPause` while
+     * already paused is a no-op (the original pause wins; we do not
+     * overwrite `pausedBy`). Returns true when the state actually
+     * transitioned, false when it was already paused.
+     */
+    requestPause(byParticipant: string): boolean;
+    /**
+     * Resume the agent loop. Returns true when the state actually
+     * transitioned from paused → running, false when it was already
+     * running (no-op).
+     */
+    resume(): boolean;
+    /**
+     * Block until the bus is resumed or the timeout fires. Returns:
+     *   - `true`  → bus was resumed in time
+     *   - `false` → timeout fired; bus was auto-resumed as a side effect
+     *
+     * When `timeoutMs` is `0` the wait is unbounded (the middleware must
+     * be paired with an external AbortSignal in that case — we don't
+     * expose one here to keep the API simple).
+     */
+    waitForResume(timeoutMs: number): Promise<boolean>;
+    private readonly injectionQueue;
+    private onConsumed?;
+    /**
+     * Register a listener fired when `collabInjectMiddleware` actually splices a
+     * queued injection into a tool call (Phase 4 feedback loop). The webui's
+     * CollaborationWebSocketHandler uses it to broadcast a
+     * `collab.injection.granted` with phase `'consumed'` so observers learn the
+     * injection was applied (and to which real tool). Last registration wins.
+     */
+    onInjectionConsumed(fn: (info: ConsumedInjectionInfo) => void): void;
+    /**
+     * Invoked by `collabInjectMiddleware` immediately after it replaces a tool
+     * call's result with a queued injection. No-op when no listener is set.
+     */
+    notifyInjectionConsumed(info: ConsumedInjectionInfo): void;
+    /**
+     * Queue a manual tool result. The next time the agent's toolCall
+     * pipeline sees a matching `toolUse.id`, the
+     * `collabInjectMiddleware` consumes this entry and replaces the
+     * real tool execution. Returns `false` if an injection for the
+     * same id is already queued (idempotent — first write wins).
+     */
+    injectToolResult(input: InjectedToolResult): boolean;
+    /**
+     * Pop an injection from the queue. Returns the payload (and
+     * removes it) if one is pending, or `null` when nothing matches.
+     * Called by the middleware on every tool call.
+     */
+    takeInjection(toolUseId: string): InjectedToolResult | null;
+    /** Inspect the queue size (for observability / tests). */
+    pendingInjectionCount(): number;
+}
+/**
+ * Payload for a queued manual tool-call injection. The middleware
+ * splices this into the toolCall pipeline as a synthetic result.
+ */
+export interface InjectedToolResult {
+    toolUseId: string;
+    /** Serialized content the model will see (string, JSON, etc.). */
+    content: unknown;
+    /** When true, the result is rendered as a tool error. */
+    isError: boolean;
+    /**
+     * Free-form context surfaced in the broadcast and the audit log,
+     * e.g. "controller: read returned the right file but with these
+     * contents" or "controller: skipped the destructive bash call".
+     */
+    reason: string;
+    /** Participant id of the controller who issued the injection. */
+    authorId: string;
+}
+/**
+ * Emitted to `onInjectionConsumed` listeners when the middleware splices a
+ * queued injection into a real tool call. Carries the resolved tool NAME
+ * (unknown at queue time — the injection is keyed only by tool_use_id).
+ */
+export interface ConsumedInjectionInfo {
+    toolUseId: string;
+    toolName: string;
+    authorId: string;
+    reason: string;
+    isError: boolean;
+}
+//# sourceMappingURL=collab-bus.d.ts.map

package/dist/coordination/collab-bus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collab-bus.d.ts","sourceRoot":"","sources":["../../src/coordination/collab-bus.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB,CAAC;AAEF,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,YAAY,CAA8B;IAClD,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,QAAQ,CAAuB;IAIvC,QAAQ,IAAI,OAAO,CAElB;IAED,QAAQ,IAAI,cAAc,CAMzB;IAID;;;;;OAKG;IACH,YAAY,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAQ3C;IAED;;;;OAIG;IACH,MAAM,IAAI,OAAO,CAQhB;IAID;;;;;;;;OAQG;IACG,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CA0BvD;IAUD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAyC;IACxE,OAAO,CAAC,UAAU,CAAC,CAAsD;IAEzE;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GAAG,IAAI,CAEnE;IAED;;;OAGG;IACH,uBAAuB,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI,CAEzD;IAED;;;;;;OAMG;IACH,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAInD;IAED;;;;OAIG;IACH,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAK1D;IAED,0DAA0D;IAC1D,qBAAqB,IAAI,MAAM,CAE9B;CACF;AAED;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,OAAO,EAAE,OAAO,CAAC;IACjB,yDAAyD;IACzD,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,iEAAiE;IACjE,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACpC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB"}

package/dist/coordination/collab-debug.d.ts

@@ -0,0 +1,302 @@
+/**
+ * Collaborative Debugging Session — parallel multi-agent debugging on the same problem.
+ *
+ * Architecture:
+ * - BugHunter, RefactorPlanner, and Critic run in parallel on shared file snapshots.
+ * - Findings flow through the FleetBus via structured events: bug.found → refactor.plan → critic.evaluation.
+ * - The Director acts as ResultRouter, collecting outputs and routing them to dependents.
+ * - A shared scratchpad stores intermediate results so agents can read each other's
+ *   conclusions without needing each other's full transcripts.
+ *
+ * Flow:
+ *   1. Director.spawnCollab() creates a CollabSession with a SharedFileSnapshot.
+ *   2. All three agents are spawned simultaneously and receive the same file snapshot.
+ *   3. BugHunter emits bug.found events → Director routes to RefactorPlanner.
+ *   4. RefactorPlanner subscribes to bug.found and emits refactor.plan events.
+ *   5. Critic subscribes to both bug.found and refactor.plan and emits critic.evaluation.
+ *   6. Director collects all results and produces a structured CollabDebugReport.
+ *
+ * Timeout and cancellation:
+ *   - CollabSession agents report budget threshold events to the Director via fleet events.
+ *   - The Director's collabAlert() handler receives warnings for timeout/iteration/tool_call
+ *     thresholds and can decide to cancel the session or let it continue.
+ *   - Director.cancelCollabSession() sends director.cancel_collab to all collab agents,
+ *     causing them to finish early with a 'cancelled' status in the report.
+ *   - The Director reads /btw notes via getLeaderBtwNotes() and can inject them into
+ *     collab agents via task context before making cancellation decisions.
+ */
+import { EventEmitter } from 'node:events';
+/**
+ * Default maximum number of files a collab_debug session may target.
+ * Each of the three agents (BugHunter, RefactorPlanner, Critic) receives
+ * the full file snapshot as context — a large target causes token overflow
+ * and timeout failures. Keep this low (20-30) for reliable sessions.
+ * Used when neither `maxTargetFiles` nor `contextWindow` is provided.
+ */
+export declare const DEFAULT_MAX_TARGET_FILES = 30;
+/**
+ * Alert levels the Director can emit when a collab session needs attention.
+ * These flow through the FleetBus so the host can display them in the UI.
+ */
+export declare enum DirectorAlertLevel {
+    /** The agent is still making progress but has hit a soft budget limit. */
+    WARNING = "warning",
+    /** The agent has hit a hard limit and the session cannot continue. */
+    CRITICAL = "critical",
+    /** The Director has decided to cancel the session (user request or policy). */
+    CANCELLED = "cancelled"
+}
+export interface DirectorAlert {
+    sessionId: string;
+    subagentId: string;
+    role: string;
+    level: DirectorAlertLevel;
+    /** Human-readable message for UI/logs */
+    message: string;
+    /** Budget kind that triggered this alert, if any */
+    budgetKind?: 'timeout' | 'idle_timeout' | 'iterations' | 'tool_calls' | 'tokens' | 'cost' | undefined;
+    /** Elapsed ms at time of alert */
+    elapsedMs?: number | undefined;
+    /** Limit that was hit */
+    limit?: number | undefined;
+    /** /btw notes the director has collected (may be empty) */
+    btwNotes?: string[] | undefined;
+}
+/**
+ * Immutable snapshot of target files at the start of a collab session.
+ * All agents in the session read from this snapshot — they see the same baseline.
+ */
+export interface SharedFileSnapshot {
+    id: string;
+    createdAt: string;
+    files: SharedFileEntry[];
+}
+export interface SharedFileEntry {
+    path: string;
+    content: string;
+    language?: string | undefined;
+    snapshotMtimeMs?: number | undefined;
+    snapshotSizeBytes?: number | undefined;
+}
+/**
+ * Bug finding emitted by BugHunter and consumed by RefactorPlanner + Critic.
+ */
+export interface BugFinding {
+    id: string;
+    type: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    location: {
+        file: string;
+        line: number;
+    };
+    description: string;
+    suggestedFix?: string | undefined;
+}
+/**
+ * Refactoring plan emitted by RefactorPlanner, consuming BugFinding(s).
+ */
+export interface RefactorPlan {
+    id: string;
+    basedOnBugIds: string[];
+    phases: RefactorPhase[];
+    riskScore: 'low' | 'medium' | 'high';
+    estimatedChangeCount: number;
+    rollbackStrategy: string;
+}
+/** One phase within a refactor plan. */
+export interface RefactorPhase {
+    number: number;
+    title: string;
+    tasks: string[];
+    risk: 'low' | 'medium' | 'high';
+}
+/**
+ * Critic evaluation of a bug finding or refactor plan.
+ */
+export interface CriticEvaluation {
+    id: string;
+    subjectType: 'bug_finding' | 'refactor_plan';
+    subjectId: string;
+    score: number;
+    verdict: 'approve' | 'needs_revision' | 'reject';
+    strengths: string[];
+    weaknesses: string[];
+    concerns: CriticConcern[];
+}
+export interface CriticConcern {
+    description: string;
+    location?: {
+        file: string | undefined;
+        line: number;
+    };
+    severity: 'blocking' | 'advisory';
+}
+/**
+ * Full structured report produced when a CollabSession resolves.
+ */
+export interface CollabDebugReport {
+    sessionId: string;
+    startedAt: string;
+    completedAt: string;
+    targetPaths: string[];
+    /** How the session ended. 'completed' = all agents finished normally.
+     * 'cancelled' = Director called cancelCollabSession().
+     * 'timeout' = session-level timeout elapsed before all agents finished.
+     * 'critical_alert' = Director escalated a warning to a cancel decision.
+     */
+    disposition: 'completed' | 'cancelled' | 'timeout' | 'critical_alert';
+    bugs: BugFinding[];
+    refactorPlans: RefactorPlan[];
+    evaluations: CriticEvaluation[];
+    /** Alerts that were raised during the session (may be empty). */
+    alerts: DirectorAlert[];
+    /** Files modified after the initial static snapshot was captured. */
+    snapshotWarnings?: string[] | undefined;
+    /** Overall verdict from the Critic across all evaluated subjects. */
+    overallVerdict: 'approve' | 'needs_revision' | 'reject';
+    /** Markdown-formatted summary for the director's context window. */
+    summary: string;
+}
+/**
+ * Per-agent budget configuration for collab sessions.
+ * Allows the caller (Director) to control the exact limits instead of
+ * using hard-coded defaults that may not match the director's policy.
+ */
+export interface CollabBudgetConfig {
+    maxIterations: number;
+    maxToolCalls: number;
+    timeoutMs: number;
+}
+/**
+ * Budget overrides for specific roles in a collab session.
+ * When a role is not present in the map, the default budget is used.
+ */
+export type CollabBudgetOverrides = Partial<Record<string, CollabBudgetConfig>>;
+export interface BugFoundPayload {
+    finding: BugFinding;
+}
+export interface RefactorPlanPayload {
+    plan: RefactorPlan;
+}
+export interface CriticEvaluationPayload {
+    evaluation: CriticEvaluation;
+}
+/**
+ * Emitted by a collab agent when it hits a soft budget limit.
+ * The Director's fleet handler receives this and calls collabAlert().
+ */
+export interface CollabBudgetWarningPayload {
+    sessionId: string;
+    role: string;
+    kind: 'timeout' | 'idle_timeout' | 'iterations' | 'tool_calls' | 'tokens' | 'cost';
+    used: number;
+    limit: number;
+    timeoutMs?: number | undefined;
+    elapsedMs: number;
+}
+/**
+ * Emitted by the Director to cancel all agents in a collab session.
+ * CollabSession listens for this and causes its agent pool to finish early.
+ */
+export interface DirectorCancelCollabPayload {
+    sessionId: string;
+    reason: string;
+    cancelledAt: string;
+}
+export interface CollabSessionOptions {
+    /** Paths to scan — used to build the SharedFileSnapshot. */
+    targetPaths: string[];
+    /** Files already read and snapshot. When provided, snapshot is skipped. */
+    prebuiltSnapshot?: SharedFileSnapshot | undefined;
+    /** Max time to wait for the session to resolve (ms). Default: 10 min. */
+    timeoutMs?: number | undefined;
+    /**
+     * Maximum number of files to include in the snapshot.
+     * - If set explicitly: use this value (hard override).
+     * - If `contextWindow` is set: calculate dynamically from estimated token budget.
+     * - If neither: use `DEFAULT_MAX_TARGET_FILES` (30).
+     */
+    maxTargetFiles?: number | undefined;
+    /**
+     * Context window size (in tokens) of the model running the subagents.
+     * When provided and `maxTargetFiles` is not set, the limit is computed
+     * dynamically: `floor((contextWindow * 0.4) / AVG_TOKENS_PER_FILE)`.
+     * If not provided, `DEFAULT_MAX_TARGET_FILES` is used as the fallback.
+     */
+    contextWindow?: number | undefined;
+    /**
+     * Budget overrides per role. When provided, these override the hard-coded
+     * defaults so the Director can enforce fleet-wide budget policy.
+     * Keys must match role names: 'bug-hunter', 'refactor-planner', 'critic'.
+     */
+    budgetOverrides?: CollabBudgetOverrides | undefined;
+    /**
+     * Called by the Director when a collab agent hits a soft budget limit.
+     * The Director uses this to decide whether to cancel the session or extend.
+     * Return 'cancel' to stop the session immediately; 'extend' to continue
+     * with the agent's proposed new limits; 'ignore' to let the default
+     * auto-extend logic handle it.
+     */
+    onBudgetWarning?: ((alert: DirectorAlert) => 'cancel' | 'extend' | 'ignore') | undefined;
+}
+export declare class CollabSession extends EventEmitter {
+    readonly sessionId: string;
+    readonly options: CollabSessionOptions;
+    readonly snapshot: SharedFileSnapshot;
+    private readonly director;
+    private readonly fleetBus;
+    private readonly subagentIds;
+    private readonly bugs;
+    private readonly plans;
+    private readonly evaluations;
+    private readonly disposers;
+    private settled;
+    private readonly timeoutMs;
+    private cancelled;
+    private _raceResolved;
+    private readonly alerts;
+    private snapshotWarnings;
+    /** Tracks tool call counts per subagent for progress-based timeout decisions. */
+    private readonly progressBySubagent;
+    /** Last tool call count when a timeout warning was handled. */
+    private readonly lastTimeoutProgress;
+    /** Session-level timeout timer handle (cleared on cancel or natural completion). */
+    private _timeoutTimer?;
+    constructor(director: import('./director.js').Director, fleetBus: import('./fleet-bus.js').FleetBus, options: CollabSessionOptions);
+    get id(): string;
+    getSessionAlerts(): DirectorAlert[];
+    isCancelled(): boolean;
+    /**
+     * Snapshot of role → subagentId map. The Director calls coordinator.stop()
+     * for each agent when cancelling the session, using this map to enumerate
+     * all three collab agents.
+     */
+    getSubagentIds(): ReadonlyMap<string, string>;
+    /**
+     * Returns the effective file limit for this session.
+     * Priority: explicit `maxTargetFiles` > dynamic from `contextWindow` > `DEFAULT_MAX_TARGET_FILES`.
+     */
+    effectiveFileLimit(): number;
+    buildSnapshot(): Promise<SharedFileSnapshot>;
+    /**
+     * Cancel the session. Emits director.cancel_collab on the FleetBus so all
+     * collab agents finish early. The session-level timeout timer is also cleared.
+     * Safe to call multiple times (idempotent after first call).
+     */
+    cancel(reason?: string): void;
+    start(): Promise<CollabDebugReport>;
+    private parseAndEmit;
+    private extractJsonObjects;
+    private budgetForRole;
+    private spawnAgent;
+    private buildBugHunterTask;
+    private buildRefactorPlannerTask;
+    private buildCriticTask;
+    private wireFleetBus;
+    private roleFromSubagentId;
+    private assembleReport;
+    private checkSnapshotFreshness;
+    private buildMarkdownSummary;
+    private cleanup;
+}
+//# sourceMappingURL=collab-debug.d.ts.map

package/dist/coordination/collab-debug.d.ts.map

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

package/dist/coordination/commit-safety.d.ts

@@ -0,0 +1,72 @@
+/**
+ * commit-safety — detect when a commit would sweep up work that this session
+ * did NOT author.
+ *
+ * When several coding agents (or a separate wrongstack process, or a human)
+ * edit the same worktree at once, a blanket `git add .` / commit-all captures
+ * everyone's uncommitted changes — including half-finished work from another
+ * agent. There is no way to un-bake that once it lands in a shared commit.
+ *
+ * This module reads the working tree and cross-references it against the
+ * per-project {@link file-author-tracker} log (which records the sessionId that
+ * created/edited each file). Dirty files whose latest author is a DIFFERENT
+ * session are flagged as "foreign"; dirty files with no recorded author are
+ * "unverified" (a concurrent non-wrongstack agent, a build/format step, or a
+ * human). The result is a plain-text warning callers render before committing.
+ *
+ * Warn-only by design: this never blocks or rewrites what gets committed — it
+ * surfaces the risk so the agent (or user) can scope the commit to its own
+ * files or coordinate first.
+ *
+ * @module commit-safety
+ */
+export interface CommitSafetyOptions {
+    /** Directory to run git in (the agent's cwd is fine). */
+    cwd: string;
+    /** Project root, used to locate the file-author log. */
+    projectRoot: string;
+    /**
+     * The current session's id — the "self" key. Dirty files authored by a
+     * different sessionId are flagged as foreign. When omitted, every authored
+     * file counts as foreign (we cannot prove ownership).
+     */
+    sessionId?: string | undefined;
+    /**
+     * Directory holding the file-author log. Defaults to the resolved per-project
+     * dir (`~/.wrongstack/projects/<slug>`). Mainly an injection seam for tests.
+     */
+    storageDir?: string | undefined;
+    /** Abort signal for the git subprocesses. */
+    signal?: AbortSignal | undefined;
+}
+export interface ForeignFile {
+    /** Repo-relative path. */
+    path: string;
+    /** Human-readable name of the agent that last authored it, if known. */
+    agentName?: string | undefined;
+    /** Session that last authored it, if known. */
+    sessionId?: string | undefined;
+}
+export interface CommitSafetyReport {
+    /** Total uncommitted (staged + unstaged + untracked) paths. */
+    dirtyCount: number;
+    /** Dirty files whose latest recorded author is a DIFFERENT session. */
+    foreignFiles: ForeignFile[];
+    /** Dirty files with no recorded author for any session. */
+    unverifiedFiles: string[];
+    /** Branch names of OTHER active worktrees of this repo (excludes ours). */
+    otherWorktrees: string[];
+    /**
+     * Pre-formatted, plain-text (no ANSI) multi-line warning, or '' when there
+     * is nothing notable to surface. Callers may colorize/wrap as they see fit.
+     */
+    warning: string;
+}
+/**
+ * Assess whether committing now risks capturing another agent's work.
+ *
+ * Best-effort: any git failure (not a repo, git missing, timeout) yields an
+ * empty report rather than throwing — commit-safety must never break a commit.
+ */
+export declare function assessCommitSafety(opts: CommitSafetyOptions): Promise<CommitSafetyReport>;
+//# sourceMappingURL=commit-safety.d.ts.map

package/dist/coordination/commit-safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-safety.d.ts","sourceRoot":"","sources":["../../src/coordination/commit-safety.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAQH,MAAM,WAAW,mBAAmB;IAClC,yDAAyD;IACzD,GAAG,EAAE,MAAM,CAAC;IACZ,wDAAwD;IACxD,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,6CAA6C;IAC7C,MAAM,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CAClC;AAED,MAAM,WAAW,WAAW;IAC1B,0BAA0B;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,+CAA+C;IAC/C,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED,MAAM,WAAW,kBAAkB;IACjC,+DAA+D;IAC/D,UAAU,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,YAAY,EAAE,WAAW,EAAE,CAAC;IAC5B,2DAA2D;IAC3D,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,2EAA2E;IAC3E,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAKD;;;;;GAKG;AACH,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAsE/F"}

package/dist/coordination/consensus-protocol.d.ts

@@ -0,0 +1,106 @@
+/**
+ * ConsensusProtocol — agent voting on proposed changes.
+ *
+ * Enables autonomous approval of code changes without a human. Agents register
+ * as voters with a role weight; changes gather votes; the protocol resolves
+ * the outcome based on configured quorum rules.
+ *
+ * Voting rules (configurable):
+ * - Quorum: minimum fraction of eligible voters required (default: 0.5)
+ * - Approval threshold: minimum fraction of cast votes that must be approve (default: 0.6)
+ * - Veto roles: roles whose 'reject' vote is fatal regardless of count
+ * - Auto-approve: changes with severity=critical bypass voting if the proposer is trusted
+ *
+ * The protocol is stateless — it reads from the KnowledgeGraph and writes results
+ * back to it. This makes it naturally consistent with the shared knowledge model.
+ *
+ * @module consensus-protocol
+ */
+import type { VoteRecord, VoteValue } from './knowledge-graph.js';
+import type { KnowledgeGraph } from './knowledge-graph.js';
+import type { FleetBus } from './fleet-bus.js';
+export interface VoterConfig {
+    agentId: string;
+    agentName: string;
+    role: string;
+    /** Weight multiplier for this voter's vote. Default: 1. */
+    weight: number;
+    /** If true, a 'reject' vote from this role is a hard veto. Default: false. */
+    veto?: boolean;
+    /**
+     * @deprecated Not yet implemented. Auto-approve of low-risk changes is planned
+     * but not wired up in the vote resolution logic.
+     */
+    autoApprovesLowRisk?: boolean;
+}
+export interface QuorumRule {
+    /** Fraction of eligible voters required (0-1). Default: 0.5. */
+    quorumFraction: number;
+    /** Fraction of cast votes that must be approve (0-1). Default: 0.6. */
+    approvalFraction: number;
+    /** Roles whose reject vote is a hard veto regardless of count. */
+    vetoRoles: string[];
+    /** Minimum total weight of approve votes to pass (0-1 of total eligible weight). */
+    approvalWeightFraction?: number | undefined;
+}
+export interface ConsensusResult {
+    changeId: string;
+    outcome: 'approved' | 'rejected' | 'pending' | 'vetoed' | 'quorum_not_met';
+    votes: VoteRecord[];
+    approveCount: number;
+    rejectCount: number;
+    abstainCount: number;
+    totalWeightApprove: number;
+    totalWeightReject: number;
+    eligibleVoters: string[];
+    quorumMet: boolean;
+    approvalMet: boolean;
+    vetoedBy?: string;
+    rationale: string;
+}
+export interface ConsensusOptions {
+    rules?: Partial<QuorumRule>;
+    voters: VoterConfig[];
+    graph: KnowledgeGraph;
+    fleet?: FleetBus | undefined;
+}
+/**
+ * ConsensusProtocol manages voting on ChangeNodes in the KnowledgeGraph.
+ * It is instantiated once per autonomous session and used to initiate votes,
+ * cast votes, and resolve outcomes.
+ */
+export declare class ConsensusProtocol {
+    private readonly graph;
+    private readonly fleet?;
+    private readonly rules;
+    private readonly voters;
+    constructor(opts: ConsensusOptions);
+    /**
+     * Initiate a vote on a proposed change. Updates the change node's status
+     * to 'proposed' and notifies eligible voters via FleetBus.
+     */
+    initiateVote(changeId: string): Promise<void>;
+    /**
+     * Cast a vote. Updates the change node in the graph and re-evaluates
+     * consensus. If the vote triggers a resolution, updates the change status.
+     */
+    castVote(changeId: string, voterId: string, value: VoteValue, rationale?: string): Promise<ConsensusResult>;
+    /**
+     * Resolve the current vote without waiting for all eligible voters.
+     * Useful when a timeout fires or an agent decides to finalize early.
+     */
+    resolveNow(changeId: string): Promise<ConsensusResult>;
+    /**
+     * Register or update a voter's configuration.
+     */
+    registerVoter(config: VoterConfig): void;
+    /**
+     * Get the current vote status for a change.
+     */
+    getStatus(changeId: string): ConsensusResult | null;
+    private _eligibleVoters;
+    private _resolve;
+    private _toChangeStatus;
+    private _notifyVoters;
+}
+//# sourceMappingURL=consensus-protocol.d.ts.map

package/dist/coordination/consensus-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consensus-protocol.d.ts","sourceRoot":"","sources":["../../src/coordination/consensus-protocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAc,UAAU,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI/C,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,WAAW,UAAU;IACzB,gEAAgE;IAChE,cAAc,EAAE,MAAM,CAAC;IACvB,uEAAuE;IACvE,gBAAgB,EAAE,MAAM,CAAC;IACzB,kEAAkE;IAClE,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,oFAAoF;IACpF,sBAAsB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7C;AAED,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,QAAQ,GAAG,gBAAgB,CAAC;IAC3E,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC;IAC5B,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,KAAK,EAAE,cAAc,CAAC;IACtB,KAAK,CAAC,EAAE,QAAQ,GAAG,SAAS,CAAC;CAC9B;AAED;;;;GAIG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAiB;IACvC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAuB;IAC9C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAa;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2B;IAElD,YAAY,IAAI,EAAE,gBAAgB,EAUjC;IAID;;;OAGG;IACG,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAQlD;IAED;;;OAGG;IACG,QAAQ,CACZ,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,EAChB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,eAAe,CAAC,CA0C1B;IAED;;;OAGG;IACG,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAY3D;IAED;;OAEG;IACH,aAAa,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAEvC;IAED;;OAEG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI,CAKlD;IAID,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,QAAQ;IA4HhB,OAAO,CAAC,eAAe;IAUvB,OAAO,CAAC,aAAa;CActB"}

package/dist/coordination/coordinator/error-classifier.d.ts

@@ -0,0 +1,15 @@
+import type { SubagentError } from '../../types/multi-agent.js';
+/**
+ * Map any raw exception thrown out of a subagent's runner into a
+ * structured `SubagentError`. This is the single point where the
+ * coordinator decides "what kind of failure was that" — so callers
+ * (delegate tool output, /agents UI, retry policies) branch on
+ * `kind` instead of substring-matching `error.message`.
+ *
+ * Exported because tests and CLI surfaces want to assert on the
+ * classification without instantiating a coordinator.
+ */
+export declare function classifySubagentError(err: unknown, hints?: {
+    parentAborted?: boolean | undefined;
+}): SubagentError;
+//# sourceMappingURL=error-classifier.d.ts.map

package/dist/coordination/coordinator/error-classifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-classifier.d.ts","sourceRoot":"","sources":["../../../src/coordination/coordinator/error-classifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAqB,MAAM,4BAA4B,CAAC;AAMnF;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,OAAO,EACZ,KAAK,GAAE;IAAE,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAAO,GAClD,aAAa,CA8Df"}