qlogicagent 2.24.1 → 2.24.2

package/dist/types/orchestration/product-budget.d.ts

@@ -1,94 +0,0 @@
-/**
- * Product Budget — token/time budget enforcement for Product Mode.
- *
- * Tracks cumulative token usage and elapsed time across all agent instances.
- * Emits 80% warning and enforces 100% hard limit.
- */
-import type { ProductBudget } from "../protocol/wire/acp-agent-management.js";
-import type { AcpUsageTracker } from "../runtime/infra/acp-usage-tracker.js";
-/** Budget state and enforcement result. */
-export type BudgetAction = "ok" | "warning" | "exceeded";
-export interface BudgetCheck {
-    action: BudgetAction;
-    percentage: number;
-    usedTokens: number;
-    maxTotalTokens?: number;
-    elapsed: number;
-    maxDuration?: number;
-}
-/**
- * The persisted budget shape — SINGLE source of truth, owned here and consumed by
- * product-persistence's execution and planning snapshots.
- *
- * It must stay round-trippable: `serialize()` is the only writer and `resume()` rebuilds the tracker
- * from these exact fields. The ceilings are live state (raiseBudget mutates them), not construction
- * config, so dropping them from the snapshot silently removes every guard from a resumed run.
- */
-export interface PersistedBudgetState {
-    maxTotalTokens?: number;
-    maxDuration?: number;
-    usedTokens: number;
-    startedAt: number;
-    warningEmitted: boolean;
-    /**
-     * Absent on a planning snapshot: a planning session carries only the ceilings, and nothing has run
-     * yet, so there is no in/out split to record. Present on every execution snapshot.
-     */
-    inputTokens?: number;
-    outputTokens?: number;
-}
-export declare class ProductBudgetTracker {
-    private maxTotalTokens?;
-    private maxDuration?;
-    private usedTokens;
-    private inputTokens;
-    private outputTokens;
-    private startedAt;
-    private warningEmitted;
-    constructor(budget?: {
-        maxTotalTokens?: number;
-        maxDuration?: number;
-    });
-    /** Add tokens from a usage tracker snapshot. */
-    addUsage(inputTokens: number, outputTokens: number): void;
-    /** Add tokens from an ACP usage tracker. */
-    addFromTracker(tracker: AcpUsageTracker): void;
-    /** Get current elapsed time in ms. */
-    getElapsed(): number;
-    /** Get the budget snapshot. */
-    getBudget(): ProductBudget;
-    /**
-     * Check budget status. Returns:
-     * - "ok": within budget
-     * - "warning": 80%+ but not exceeded
-     * - "exceeded": over 100%, should pause
-     */
-    check(): BudgetCheck;
-    /**
-     * Grant additional budget headroom — the escape hatch out of a budget-exhausted pause. Without it,
-     * resume just restores usedTokens (already >= max), re-checks, and immediately re-pauses forever
-     * (a permanent deadlock with no "add budget" entry). With no explicit amount, grants one more of the
-     * current quota's worth of headroom measured from where usage stands now; an explicit amount adds
-     * exactly that. Re-arms the 80% warning so the fresh quota warns again. Time budgets get a fresh
-     * window from now (elapsed already includes paused wall-clock, so extending the raw ceiling wouldn't
-     * help). The user's act of resuming a paused-at-budget run IS the decision to spend more.
-     */
-    raiseBudget(additional?: {
-        maxTotalTokens?: number;
-        maxDuration?: number;
-    }): void;
-    /**
-     * Restore from persisted budget data. Also re-applies the persisted ceilings so a single
-     * `restore()` fully rebuilds the tracker — callers that already passed them to the constructor
-     * are unaffected (same values), and callers that forget can no longer end up unbounded.
-     * A planning snapshot has no in/out split yet, so those default to 0 rather than being required.
-     */
-    restore(data: PersistedBudgetState): void;
-    /**
-     * Serialize for persistence. MUST emit the ceilings: they are live state (raiseBudget mutates
-     * them) and resume() rebuilds the tracker from this snapshot alone. Omitting them made every
-     * resumed or rolled-back run unbounded, because check() short-circuits on a falsy ceiling.
-     * Absent ceilings stay absent so an unbudgeted run is not accidentally given one.
-     */
-    serialize(): PersistedBudgetState;
-}

package/dist/types/orchestration/product-checkpoint.d.ts

@@ -1,50 +0,0 @@
-/**
- * Product Checkpoint — automatic and manual checkpoint triggers.
- *
- * Rules:
- *  - Auto-checkpoint on task completion
- *  - 5 min periodic safety checkpoint for active products
- *  - 30 min timer for long-running products (>48h)
- *  - Manual checkpoint via product.checkpoint RPC
- */
-import type { PersistedProductState } from "./product-persistence.js";
-import type { HostRunStateAuthority } from "./run-state-host-authority.js";
-export interface CheckpointCallbacks {
-    /** Called after each checkpoint save. */
-    onCheckpoint?: (productId: string, timestamp: string) => void;
-    /** Called when an unattended periodic checkpoint cannot reach the Host authority. */
-    onError?: (productId: string, error: unknown) => void;
-    /** Return current state snapshot for periodic auto-saves. */
-    getState?: () => PersistedProductState | null;
-    log?: {
-        info(msg: string): void;
-        warn(msg: string): void;
-    };
-}
-export declare class ProductCheckpointManager {
-    private callbacks;
-    private readonly runStateAuthority;
-    /** Safety interval (5 min default, 30 min for >48h long-running). */
-    private static readonly DEFAULT_INTERVAL;
-    private static readonly LONG_RUNNING_INTERVAL;
-    private static readonly LONG_RUNNING_THRESHOLD;
-    private timer;
-    private lastCheckpointAt;
-    private checkpointTail;
-    constructor(callbacks: CheckpointCallbacks | undefined, runStateAuthority: HostRunStateAuthority);
-    /** Start periodic checkpointing for a product. */
-    start(): void;
-    /** Stop periodic checkpointing. */
-    stop(): void;
-    /** Get the appropriate checkpoint interval based on elapsed time. */
-    getInterval(elapsedMs: number): number;
-    /** Check if a checkpoint is due based on elapsed time since last checkpoint. */
-    isDue(elapsedMs: number): boolean;
-    /**
-     * Perform a checkpoint through the captured Host RunState authority and notify.
-     * Called on task completion or by periodic timer.
-     */
-    checkpoint(state: PersistedProductState): Promise<void>;
-    /** Get the time of last checkpoint. */
-    getLastCheckpointAt(): number;
-}

package/dist/types/orchestration/product-dag-mutation-applier.d.ts

@@ -1,10 +0,0 @@
-import type { DagMutation } from "./product-planner.js";
-import type { DagScheduler } from "./dag-scheduler.js";
-export interface ProductDagMutationApplyResult {
-    applied: DagMutation[];
-    errors: Array<{
-        mutation: DagMutation;
-        error: string;
-    }>;
-}
-export declare function applyProductDagMutations(dag: DagScheduler, mutations: readonly DagMutation[]): ProductDagMutationApplyResult;

package/dist/types/orchestration/product-persistence.d.ts

@@ -1,90 +0,0 @@
-/**
- * Product persistence facade over the Gateway-owned RunStateStore.
- */
-import type { ProductCreateParams, ProductPhase, ProductInstanceDef } from "../protocol/wire/acp-agent-management.js";
-import type { PersistedBudgetState } from "./product-budget.js";
-import type { SerializedNode } from "./dag-scheduler.js";
-import type { PlanningSession } from "./product-planner.js";
-import { type HostRunStateAuthority } from "./run-state-host-authority.js";
-export interface PersistedProductState {
-    productId: string;
-    projectId: string;
-    name: string;
-    phase: ProductPhase;
-    cwd: string;
-    instances: ProductInstanceDef[];
-    tasks: SerializedNode[];
-    /** Owned by ProductBudgetTracker — see PersistedBudgetState for the round-trip contract. */
-    budget: PersistedBudgetState;
-    createdAt: string;
-    lastCheckpointAt: string;
-    /** Last durably announced attempt number for each stable task id. */
-    taskAttempts?: Record<string, number>;
-    /** Host-owned abnormal-worker handoffs, retained across Gateway restarts for bounded retry/audit. */
-    taskHandoffs?: Record<string, Array<{
-        from: string;
-        to: string;
-        error: string;
-        at: string;
-    }>>;
-    /** Parent Goal turn policy, retained so recovered Product workers do not change execution policy. */
-    turnContext?: ProductCreateParams["turnContext"];
-    /**
-     * Snapshot of the leader's multi-turn planning dialogue, so the leader regains its planning
-     * context after a resume. JSON-safe:
-     * PlanningSession is strings / arrays / plain objects (no functions, dates, or class instances).
-     */
-    leaderDialogue?: PlanningSession;
-}
-/** Host checkpoint used before a Product plan transitions into DAG execution. */
-export interface PersistedProductPlanningState {
-    stateKind: "planning";
-    productId: string;
-    projectId: string;
-    canonicalSessionId: string;
-    name: string;
-    phase: PlanningSession["phase"];
-    cwd: string;
-    instances: ProductInstanceDef[];
-    tasks: SerializedNode[];
-    /** Owned by ProductBudgetTracker — see PersistedBudgetState for the round-trip contract. */
-    budget: PersistedBudgetState;
-    createdAt: string;
-    lastCheckpointAt: string;
-    planningSession: PlanningSession;
-}
-export interface ProductPersistenceOptions {
-    authority?: HostRunStateAuthority;
-}
-/** Save Product execution state through the Gateway-owned RunState service. */
-export declare function saveProductState(state: PersistedProductState, options?: ProductPersistenceOptions): Promise<void>;
-export declare function saveProductPlanningState(session: PlanningSession, options?: ProductPersistenceOptions): Promise<PersistedProductPlanningState>;
-/** Load Product execution state through the Gateway-owned RunState service. */
-export declare function loadProductState(productId: string, options?: ProductPersistenceOptions): Promise<PersistedProductState | undefined>;
-export declare function loadProductPlanningState(productId: string, owner: {
-    projectId: string;
-    canonicalSessionId: string;
-    cwd: string;
-}, options?: ProductPersistenceOptions): Promise<PersistedProductPlanningState | undefined>;
-/** Delete a Product run through Gateway authority. */
-export declare function deleteProductState(productId: string, options?: ProductPersistenceOptions): Promise<boolean>;
-/**
- * Save a full state snapshot into Gateway checkpoint history.
- * Uses `state.lastCheckpointAt` as the logical id (must be set before calling).
- * Prunes old snapshots to keep at most MAX_CHECKPOINT_SNAPSHOTS entries.
- */
-export declare function saveProductCheckpointSnapshot(state: PersistedProductState, options?: ProductPersistenceOptions): Promise<void>;
-/**
- * Load a specific checkpoint snapshot by its original ISO timestamp.
- * Returns undefined if the snapshot does not exist.
- */
-export declare function loadProductCheckpointSnapshot(productId: string, timestamp: string, options?: ProductPersistenceOptions): Promise<PersistedProductState | undefined>;
-/**
- * List all checkpoint timestamps for a product, sorted ascending (oldest first).
- */
-export declare function listProductCheckpointTimestamps(productId: string, options?: ProductPersistenceOptions): Promise<string[]>;
-/**
- * Restore a specific checkpoint as the latest Product state.
- * Returns undefined if the Host no longer has that checkpoint.
- */
-export declare function restoreProductCheckpoint(productId: string, timestamp: string, options?: ProductPersistenceOptions): Promise<PersistedProductState | undefined>;

package/dist/types/orchestration/product-planner.d.ts

@@ -1,332 +0,0 @@
-/**
- * Product Planner — Interactive multi-turn planning + persistent leader management.
- *
- * Architecture (aligned with CrewAI hierarchical + LangGraph durable execution):
- *
- * Phase 1 — PLANNING (multi-turn dialogue):
- *   1. product.plan → spawn leader agent → leader engages user in multi-turn dialogue
- *   2. Leader asks clarifying questions, proposes module decomposition
- *   3. User responds via product.message → leader refines plan
- *   4. Leader outputs structured plan → client presents to user
- *
- * Phase 2 — CONFIRMATION:
- *   5. product.confirm → user confirms/modifies plan → transition to execution
- *
- * Phase 3 — EXECUTION (leader as persistent manager):
- *   6. Leader manages DAG: dispatches tasks, monitors, handles failures
- *   7. Leader can dynamically mutate DAG: add/retry/reassign tasks
- *   8. User can intervene via product.message at any time
- *   9. Each state transition is checkpointed for crash recovery
- *
- * Key mechanisms from reference projects:
- *   - CrewAI: hierarchical process (manager auto-delegates/verifies)
- *   - CrewAI: checkpoint serialization (mid-task state)
- *   - LangGraph: durable execution (persist after each node)
- */
-import type { HostAgentProviderDirectory } from "../runtime/infra/host-agent-provider-directory.js";
-import type { DelegateBridge } from "./delegate-bridge.js";
-import type { ProductPlanParams, ProductPlan, ProductConfirmParams } from "../protocol/wire/acp-agent-management.js";
-import { type HostRunStateAuthority } from "./run-state-host-authority.js";
-export type PlanningPhase = "planning" | "awaiting_confirmation" | "confirmed" | "executing" | "paused" | "completed" | "failed" | "cancelled";
-export interface PlanningMessage {
-    role: "leader" | "user";
-    content: string;
-    timestamp: string;
-}
-export interface PlanningSession {
-    productId: string;
-    projectId: string;
-    canonicalSessionId: string;
-    goal: string;
-    cwd: string;
-    leaderAgentId: string;
-    leaderMemberId?: string;
-    activeDelegationId?: string;
-    phase: PlanningPhase;
-    plan?: ProductPlan;
-    /** Final user-approved execution payload, durably captured before DAG creation starts. */
-    confirmedExecution?: Pick<ProductConfirmParams, "instances" | "tasks" | "budget">;
-    /** Multi-turn conversation history during planning. */
-    dialogue: PlanningMessage[];
-    budget?: {
-        maxTotalTokens?: number;
-        maxDuration?: number;
-    };
-    /**
-     * User-supplied allow-list of agent ids the leader may assign tasks to (planning AND execution-phase
-     * reassignment). Persisted AS-IS so the execution phase reuses the SAME constraint and a failure-driven
-     * reassign cannot pull in a non-participating agent. PRESENCE-based (must survive uncollapsed end to
-     * end): undefined → all ready agents; `[]` → ONLY the selected leader (user deselected every worker);
-     * `[ids]` → those + selected leader. See buildAgentRoster for the always-include-leader rule.
-     */
-    allowedAgents?: string[];
-    createdAt: string;
-    /** Last checkpoint timestamp for durable execution. */
-    lastCheckpoint?: string;
-    /** A leader turn is currently running (planning is async/fire-and-forget) — block concurrent turns. */
-    turnInFlight?: boolean;
-    failedReason?: string;
-}
-export interface ProductPlanningOwner {
-    projectId: string;
-    canonicalSessionId: string;
-    cwd: string;
-    authority?: HostRunStateAuthority;
-}
-export interface ProductPlanAskQuestion {
-    question: string;
-    header: string;
-    options?: Array<{
-        label: string;
-        description?: string;
-    }>;
-    multiSelect?: boolean;
-}
-export interface PlannerCallbacks {
-    log?: {
-        info(msg: string): void;
-        warn(msg: string): void;
-    };
-    /** Leader produced a structured plan — client presents to user. */
-    onPlanReady?: (productId: string, plan: ProductPlan) => void | Promise<void>;
-    /** Planning failed. */
-    onPlanFailed?: (productId: string, error: string) => void | Promise<void>;
-    /** Streaming text from leader during planning dialogue. */
-    onPlanningDelta?: (productId: string, text: string) => void;
-    /** Leader sent a message to user (multi-turn). */
-    onLeaderMessage?: (productId: string, message: string) => void | Promise<void>;
-    /** Leader asked a structured clarifying question (turn-boundary); client renders an ask panel. */
-    onLeaderAsk?: (productId: string, askId: string, questions: ProductPlanAskQuestion[]) => void | Promise<void>;
-    /** Leader dynamically mutated the DAG during execution. */
-    onDagMutated?: (productId: string, mutation: DagMutation) => void;
-    /** Live DAG progress for the execution-phase leader (filled by the orchestrator). */
-    getProgress?: (productId: string) => {
-        total: number;
-        completed: number;
-        running: number;
-        failed: number;
-    };
-    /** Required Gateway delegate access; planning fails loud when the Host rail is unavailable. */
-    getDelegateBridge?: () => DelegateBridge | undefined;
-}
-/** Describes a DAG mutation performed by the leader. */
-export interface DagMutation {
-    type: "add_task" | "remove_task" | "retry_task" | "reassign_task" | "update_prompt" | "add_dependency" | "remove_dependency";
-    taskId: string;
-    details?: Record<string, unknown>;
-}
-/**
- * Human-readable form of an execution-phase leader reply.
- *
- * The raw reply is prose plus a JSON mutation array. Showing it verbatim puts machine payload in the
- * conversation; showing nothing leaves the user's question unanswered. So: prose without the JSON
- * block, and when the leader answered only in JSON, a line naming what it actually changed.
- */
-export declare function describeExecutionReply(response: string, mutations: DagMutation[]): string;
-export declare class ProductPlanner {
-    private providerDirectory;
-    private callbacks;
-    private sessions;
-    private sessionAuthorities;
-    /** Issues from the most recent plan semantic check, quoted back in the reprompt (empty = passed). */
-    private lastPlanIssues;
-    constructor(providerDirectory: HostAgentProviderDirectory, callbacks?: PlannerCallbacks);
-    private resolveOwnerAuthority;
-    private assertSessionOwner;
-    private getOrRestoreSession;
-    /**
-     * Phases where the ORCHESTRATOR owns this run's RunState key. The planner and the orchestrator write
-     * the SAME key for the same productId; ownership hands over at markExecuting() and never comes back
-     * (markAwaitingConfirmation only rolls back a create() that never started executing).
-     */
-    private static readonly EXECUTION_OWNED_PHASES;
-    /** True once execution owns the checkpoint — the planner must neither write it nor mutate phase. */
-    private executionHasTakenOver;
-    /**
-     * Persist the planning snapshot — unless execution has taken the key over.
-     *
-     * A leader turn is dispatched detached (`void runLeaderTurn`) with a 10-minute ceiling, so it can land
-     * long after the user confirmed and the DAG started. It used to write unconditionally, stamping a
-     * `stateKind:"planning"` snapshot over the live execution checkpoint — after which loadProductState()
-     * returns undefined for that run (it rejects planning snapshots), so a crash in that window made the
-     * executing run unresumable and reset usedTokens/task states. Dropping the stale write is correct:
-     * the planning dialogue it carried is no longer the authority for this run.
-     */
-    private checkpointPlanningSession;
-    private publishNotification;
-    /**
-     * Start an interactive planning session (Phase 1).
-     * Spawns the leader agent and begins multi-turn dialogue.
-     */
-    plan(params: ProductPlanParams): Promise<{
-        productId: string;
-        plan: ProductPlan;
-    }>;
-    /**
-     * Run one leader planning turn DETACHED from the RPC. Tokens stream live via product.planningDelta
-     * (the member turn.delta relay in product-coordinator); on completion this fires onPlanReady (parsed
-     * a structured plan), onLeaderAsk (a clarifying question), or onLeaderMessage (a non-plan reply).
-     * Never rejects into the caller — planning is fire-and-forget. Concurrent turns on the same session
-     * are blocked (a second prompt would cancel the in-flight one — the source of earlier "cancelled"
-     * turns) — EXCEPT the internal single-shot reprompt (isReprompt=true), which is allowed to run while
-     * turnInFlight is held by its parent turn and is itself guarded against further recursion.
-     */
-    private runLeaderTurn;
-    /**
-     * Route one leader response: plan → onPlanReady, ask → onLeaderAsk, else free-text → onLeaderMessage.
-     *
-     * Crucially, when the response LOOKS LIKE a plan (has a ```json fence or a "tasks" key) but fails to
-     * parse as one — the embedded-fence / unescaped-quote failure modes — we do NOT dump the raw JSON into
-     * the chat bubble. We re-prompt the leader EXACTLY ONCE with a strict "valid JSON only" instruction
-     * (guarded by `isReprompt` so it can't loop), and if that ALSO fails we emit a clean, user-facing
-     * fallback message instead of the raw JSON. A response only reaches onLeaderMessage verbatim when it
-     * does NOT look like a plan (genuine clarification / free-text).
-     */
-    private routeLeaderResponse;
-    /**
-     * Send a user message to the leader (works in planning and execution phases).
-     * Returns the leader's response and optionally a finalized plan.
-     */
-    message(productId: string, content: string, owner?: ProductPlanningOwner): Promise<{
-        response: string;
-        plan?: ProductPlan;
-        mutations?: DagMutation[];
-    }>;
-    /**
-     * Confirm the plan → transition to execution (Phase 2 → Phase 3).
-     */
-    confirm(params: ProductConfirmParams): Promise<{
-        productId: string;
-        ok: true;
-    }>;
-    /** Transition the in-memory leader session before the first execution checkpoint is written. */
-    markExecuting(productId: string): void;
-    markAwaitingConfirmation(productId: string): Promise<void>;
-    getRunStateAuthority(productId: string): HostRunStateAuthority | undefined;
-    /** Mark as completed. */
-    markCompleted(productId: string): void;
-    /** Get planning session by ID. */
-    getSession(productId: string): PlanningSession | undefined;
-    /** Cancel and kill leader process. */
-    cancel(productId: string, owner?: ProductPlanningOwner): Promise<void>;
-    /** List active sessions. */
-    listSessions(): PlanningSession[];
-    /**
-     * Ask the leader to judge whether a worker task's output satisfies its acceptanceCriteria.
-     *
-     * Distinguishes a VERIFIED pass (the judge ran and returned PASS) from an UNVERIFIED pass
-     * (`unverified: true`) — the run continues rather than blocking, but the caller must NOT report
-     * an unverified pass as if the work were checked. Unverified means we could not judge at all: no
-     * leader session, or the judge response was unparseable/errored. (The judging *prompt* itself is
-     * deliberately lenient/evidence-aware — that is a real PASS, not an unverified one.)
-     */
-    reviewTaskOutput(productId: string, review: {
-        taskId: string;
-        instruction: string;
-        acceptanceCriteria: string;
-        output: string;
-        changedFiles?: string[];
-    }): Promise<{
-        pass: boolean;
-        feedback?: string;
-        unverified?: boolean;
-    }>;
-    /**
-     * Ask leader to evaluate execution state and propose DAG mutations.
-     * Called by ProductOrchestrator when tasks fail or progress stalls.
-     */
-    consultLeader(productId: string, context: {
-        progress: {
-            total: number;
-            completed: number;
-            running: number;
-            failed: number;
-        };
-        failedTasks?: Array<{
-            taskId: string;
-            error: string;
-        }>;
-    }): Promise<DagMutation[]>;
-    /**
-     * Serialize session for checkpoint persistence (durable execution).
-     */
-    serializeSession(productId: string): PlanningSession | null;
-    /**
-     * Restore session from checkpoint (crash recovery).
-     */
-    restoreSession(data: PlanningSession, authority?: HostRunStateAuthority): void;
-    private handlePlanningMessage;
-    private handleExecutionMessage;
-    /**
-     * One leader turn over the Gateway delegate.
-     *
-     * `stream` opts INTO product.planningDelta and defaults to off. Only turns the user actually asked
-     * for belong in the conversation: the planning turn and a run-time steering message. The acceptance
-     * judge and the automatic failure consultation are internal machinery — they used to stream too, so
-     * every task acceptance pushed `VERDICT: PASS FEEDBACK: -` into the leader conversation. Nothing
-     * rendered that channel during a run, so the pollution stayed invisible until the run window
-     * surfaced it. Defaulting to silent means a future internal call site cannot leak by omission.
-     */
-    private sendToLeader;
-    /**
-     * Extract a JSON object from the leader's reply. The leader (an LLM) formats the block
-     * inconsistently: ```json on its own line, ```json with the object inline, no language tag, or no
-     * fence at all. A non-greedy fence regex (`/```(?:json)?\s*([\s\S]*?)```/`) is fatally fragile: when a
-     * task/module prompt STRING embeds its own code fence (e.g. a ```bash example inside a task prompt),
-     * the non-greedy match stops at that EMBEDDED closing ```, truncating the block BEFORE the "tasks"
-     * key → a shape-valid-but-incomplete object → plan lost → raw JSON leaks into the chat bubble.
-     *
-     * Instead, scan for a balanced JSON object with string-awareness:
-     *   - Pick a start index: the first `{` AT OR AFTER a ```json (or bare ```) fence opener if present,
-     *     else the first `{` anywhere.
-     *   - From that `{`, walk forward tracking brace depth AND JSON string state (an unescaped `"` toggles
-     *     inString; a `\` inside a string escapes the next char). Count `{`/`}` only when NOT inString.
-     *     Backticks/braces inside string values are thus ignored — embedded ```bash fences can't truncate.
-     *   - When depth returns to 0, return the balanced `{`…`}` substring (trimmed).
-     *   - If no balanced close is found, fall back to first-`{`…last-`}` (jsonrepair still gets a shot).
-     *   - Return null if there is no `{` at all.
-     */
-    private extractJsonBlock;
-    /**
-     * Parse a JSON block that an LLM emitted. LLMs (DeepSeek especially, on Chinese content) routinely
-     * produce JSON with unescaped double quotes inside string values (e.g. 默认有"销售收入""其他收入"),
-     * trailing commas, etc. — strictly invalid, so JSON.parse throws and the whole plan is lost. Fall back
-     * to jsonrepair, which fixes these common LLM mistakes heuristically. Returns null only if even the
-     * repaired text won't parse.
-     */
-    private parseJsonLenient;
-    /**
-     * Build a canonicalizer that maps a leader-written agent identifier (which may be a display NAME like
-     * "小智"/"Claude" OR a canonical catalog id like "qlogicagent"/"claude") to the canonical catalog id.
-     *
-     * WHY: the leader prompt asks for `instances[].agentId` = "花名册里的 id", but leaders routinely emit
-     * the display NAME instead (e.g. agentId:"小智"). Downstream — the confirm pre-check
-     * (isAgentReady) and dispatch (buildExternalDescriptor) — both require a CANONICAL id; a name like
-     * "小智" makes isAgentReady fail (the qlogicagent always-ready short-circuit only matches the id, not
-     * the name) → leader-only Product wrongly blocked. Canonicalizing at parse time guarantees
-     * instances[].agentId is a catalog id regardless of what the leader wrote.
-     *
-     * The map is keyed by BOTH lowercased `id` AND lowercased `name` → canonical `id`, plus the explicit
-     * leader aliases "小智"→"qlogicagent" and "self"→"qlogicagent". Matching is EXACT (trim+lowercase) on
-     * id-or-name only — no partial/fuzzy matching, to avoid mis-mapping one agent onto another.
-     */
-    private buildAgentIdResolver;
-    /**
-     * Normalize every `task.assignee` so it ALWAYS equals an existing `instance.name` (the canonical
-     * convention the execution dispatch keys on — see agent-instance.ts `instances.find(i => i.name === …)`).
-     *
-     * Mutates `instances`/`tasks` in place. For each task:
-     *  - assignee already === some instance.name → keep.
-     *  - else assignee resolves to an agentId that some instance carries → repoint assignee to THAT
-     *    instance's name (pick the first matching instance, preferring a non-leader/worker role when the
-     *    same agentId backs several instances — leaders usually shouldn't also be doing leaf work).
-     *  - else (assignee references an agent with no instance) → append a fresh worker instance
-     *    `{ name: assignee, agentId: resolveAgentId(assignee) ?? assignee, role: "worker" }` and keep
-     *    assignee = that new name (now it matches).
-     * Blank assignees are left untouched (confirm-time validation surfaces them).
-     */
-    private normalizeAssigneesToInstanceName;
-    private tryParsePlan;
-    private tryParseAsk;
-    private parseDagMutations;
-}

package/dist/types/orchestration/product-run-coordinator.d.ts

@@ -1,49 +0,0 @@
-import type { ProductConfirmParams, ProductMessageParams, ProductPlan } from "../protocol/wire/acp-agent-management.js";
-import type { ProductOrchestrator } from "./agent-instance.js";
-import type { DagMutation, PlanningSession, ProductPlanner } from "./product-planner.js";
-import type { HostRunStateAuthority } from "./run-state-host-authority.js";
-export interface ProductLeaderCoordinator {
-    consultLeader(productId: string, context: {
-        progress: {
-            total: number;
-            completed: number;
-            running: number;
-            failed: number;
-        };
-        failedTasks?: Array<{
-            taskId: string;
-            error: string;
-        }>;
-    }): Promise<DagMutation[]>;
-    reviewTaskOutput(productId: string, review: {
-        taskId: string;
-        instruction: string;
-        acceptanceCriteria: string;
-        output: string;
-        /** Relative paths the worker created/changed in its worktree — evidence the text-only judge
-         *  cannot otherwise see. Lets the judge confirm the expected artifacts exist (lenient judging). */
-        changedFiles?: string[];
-    }): Promise<{
-        pass: boolean;
-        feedback?: string;
-        unverified?: boolean;
-    }>;
-    /** Snapshot the leader's PlanningSession for checkpoint persistence (durable execution). */
-    serializeSession(productId: string): PlanningSession | null;
-    /** Restore the leader's PlanningSession from a checkpoint (crash/resume recovery). */
-    restoreSession(data: PlanningSession, authority?: HostRunStateAuthority): void;
-}
-export declare class ProductRunCoordinator {
-    private planner;
-    private orchestrator;
-    constructor(planner: ProductPlanner, orchestrator: ProductOrchestrator);
-    confirmAndStart(params: ProductConfirmParams): Promise<{
-        productId: string;
-        ok: true;
-    }>;
-    message(params: ProductMessageParams, authority?: HostRunStateAuthority): Promise<{
-        response: string;
-        plan?: ProductPlan;
-        mutations?: DagMutation[];
-    }>;
-}

package/dist/types/orchestration/product-worktree.d.ts

@@ -1,19 +0,0 @@
-/**
- * Product Worktree — shared git worktree helpers for Solo and Product Mode.
- */
-/** Find the git repository root from a working directory. */
-export declare function findGitRoot(cwd: string): Promise<string | null>;
-/** Create an isolated git worktree. Returns the worktree path. */
-export declare function createWorktree(gitRoot: string, name: string, baseBranch?: string): Promise<string>;
-export declare function getWorktreeDiff(worktreePath: string): Promise<string>;
-/** List the relative paths of files changed in a worktree (tracked diff vs HEAD + untracked).
- *  Used to surface "produced files" on a Product task before the worktree is torn down. */
-export declare function listWorktreeChangedFiles(worktreePath: string): Promise<string[]>;
-/** Copy the changed files from a task worktree back into the product workspace. */
-export declare function materializeWorktreeChanges(worktreePath: string, targetRoot: string): Promise<void>;
-/** Remove a git worktree. When `branch` is given, also delete the worktree's throwaway branch
- *  (created by createWorktree's `-B solo/<name>`); best effort — the branch never carries commits
- *  of its own, but leaving it behind litters the user's repo with one `solo/*` ref per racer. */
-export declare function removeWorktree(gitRoot: string, path: string, branch?: string): Promise<void>;
-/** Merge a worktree branch into the current branch. */
-export declare function mergeWorktree(gitRoot: string, worktreeBranch: string): Promise<string>;

package/dist/types/orchestration/run-state-host-authority.d.ts

@@ -1,7 +0,0 @@
-import type { HostRunStateClient } from "../transport/host-run-state-client.js";
-export interface HostRunStateAuthority {
-    client: HostRunStateClient;
-    sessionId: string;
-}
-export declare function configureHostRunStateAuthority(resolver: (() => HostRunStateAuthority | undefined) | null): void;
-export declare function requireHostRunStateAuthority(): HostRunStateAuthority;