qlogicagent 2.15.9 → 2.16.1

package/dist/types/agent/types.d.ts

@@ -5,7 +5,6 @@
  * protocol/wire/. This file re-exports them and adds
  * internal-only extensions (e.g. backfillObservableInput on ToolDefinition).
  */
-import type { SkillInstruction } from "../orchestration/index.js";
 import type { HookRegistry } from "../contracts/hooks.js";
 import type { AccumulatedToolCall, LLMChunk, LLMRequest, LLMTransport } from "../runtime/ports/index.js";
 import type { ChatMessage as WireChatMessage, ChatMessageRole as WireChatMessageRole, ThinkingBlock as WireThinkingBlock, ToolCallMessage as WireToolCallMessage, ToolDefinition as WireToolDefinition, WireTokenUsage } from "../protocol/wire/index.js";
@@ -30,6 +29,7 @@ export interface ToolDefinition extends WireToolDefinition {
  * (inputTokens, outputTokens, reasoningTokens, cacheRead, cacheWrite).
  */
 export type TokenUsage = WireTokenUsage;
+export type { DecisionStateRecord, GoalReconstructionState, MaintainedDocumentIndex, ReadCycleGuard, SkillCreateInstruction, SkillImproveInstruction, SkillInstruction, TurnEvent, } from "../contracts/turn-event.js";
 /**
  * Why the previous iteration continuedeach variant corresponds to one of
  * the 7 `continue` sites in the main while(true) loop.
@@ -79,7 +79,15 @@ export interface TurnRequest {
     turnId: string;
     sessionId: string;
     messages: ChatMessage[];
+    /** Full registered tool surface before per-turn policy filtering. */
+    availableTools?: ToolDefinition[];
     tools: ToolDefinition[];
+    /**
+     * Live tool-manifest rebuild, consulted each loop iteration (turnCount > 1).
+     * Lets a tool activated mid-turn via tool_search become callable in the SAME
+     * turn instead of only on the next user message.
+     */
+    refreshTools?: () => ToolDefinition[];
     systemPrompt?: string;
     config?: TurnConfig;
 }
@@ -158,136 +166,6 @@ export interface TurnConfig {
     /** MCP server configurations (stdio/sse/http). Passed from host to agent per-turn. */
     mcpServers?: Record<string, unknown>;
 }
-export type TurnEvent = {
-    type: "start";
-    turnId: string;
-} | {
-    type: "delta";
-    turnId: string;
-    text: string;
-} | {
-    type: "tool_call";
-    turnId: string;
-    callId: string;
-    name: string;
-    arguments: string;
-    inputSummary?: string;
-} | {
-    type: "end";
-    turnId: string;
-    content: string;
-    usage?: TokenUsage;
-    model?: string;
-    provider?: string;
-    /** Per-turn recovery trace (action -> count); present only when recoveries fired. */
-    recoveryTrace?: Record<string, number>;
-} | {
-    type: "error";
-    turnId: string;
-    error: string;
-    code?: string;
-    usage?: TokenUsage;
-} | {
-    type: "skill_instruction";
-    turnId: string;
-    instruction: SkillInstruction;
-} | {
-    type: "tool_result";
-    turnId: string;
-    callId: string;
-    name: string;
-    ok: boolean;
-    error?: string;
-    outputPreview?: string;
-    durationMs?: number;
-    exitCode?: number;
-    stdout?: string;
-    stderr?: string;
-    details?: Record<string, unknown>;
-} | {
-    type: "tool_blocked";
-    turnId: string;
-    callId: string;
-    name: string;
-    reason: string;
-} | {
-    type: "recovery";
-    turnId: string;
-    action: string;
-    detail?: string;
-} | {
-    type: "plan_update";
-    turnId: string;
-    slug: string;
-    content: string;
-} | {
-    type: "heartbeat";
-    turnId: string;
-    message: string;
-} | {
-    type: "tool_use_summary";
-    turnId: string;
-    summary: string;
-} | {
-    type: "reasoning_delta";
-    turnId: string;
-    text: string;
-} | {
-    type: "suggestions";
-    turnId: string;
-    items: Array<{
-        text: string;
-        icon?: string;
-        action?: string;
-    }>;
-} | {
-    type: "media_result";
-    turnId: string;
-    mediaType: "image" | "tts" | "video" | "music" | "3d";
-    url: string;
-    model?: string;
-    provider?: string;
-    durationSeconds?: number;
-    width?: number;
-    height?: number;
-    mimeType?: string;
-    billingUnit?: string;
-    billingQuantity?: number;
-    taskId?: string;
-} | {
-    type: "artifact";
-    turnId: string;
-    artifactId: string;
-    artifactType: "code" | "file" | "image" | "document" | "diagram" | "table";
-    title: string;
-    filePath?: string;
-    language?: string;
-    content?: string;
-    mimeType?: string;
-} | {
-    type: "annotations";
-    turnId: string;
-    annotations: Array<{
-        type: string;
-        url?: string;
-        title?: string;
-        [key: string]: unknown;
-    }>;
-} | {
-    type: "subagent_started";
-    turnId: string;
-    subagentId: string;
-    agentType: string;
-    prompt?: string;
-} | {
-    type: "subagent_ended";
-    turnId: string;
-    subagentId: string;
-    agentType: string;
-    ok: boolean;
-    outputPreview?: string;
-    error?: string;
-};
 /**
  * ToolInvoker: request tool execution from the host process (Gateway).
  * In CLI mode this sends a JSON-RPC notification over stdio and waits for result.

package/dist/types/cli/acp-extended-handlers.d.ts

@@ -67,4 +67,5 @@ export declare function handleAcpProductStatus(host: AcpExtendedHost, params: Re
 export declare function handleAcpProductPause(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpProductCancel(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpProductRollback(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
+export declare function handleAcpProductReplay(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;
 export declare function handleAcpProductSubscribe(host: AcpExtendedHost, params: Record<string, unknown>): Promise<unknown>;

package/dist/types/cli/agent-config-coordinator.d.ts

@@ -9,8 +9,19 @@ export declare function resolveLlmrouterProtocolBaseUrl(agentId: string, rawBase
 export declare class AgentConfigCoordinator {
     private readonly deps;
     private store;
+    /** Last resolved managed text model (llmrouterModel), to detect primary-model switches. */
+    private lastLlmrouterModel;
     constructor(deps: AgentConfigCoordinatorDeps);
     get currentStore(): AgentConfigStore | null;
     ensureStore(): Promise<AgentConfigStore>;
     private syncKeySources;
+    /**
+     * When the managed text model (llmrouterModel) actually changes, pooled OpenAI-compat agents
+     * (codex/qwen/opencode) still hold the OLD OPENAI_MODEL baked at spawn. Evict the platform-model
+     * followers — managed (explicit「平台额度」) or auto, NOT explicit account/userKey BYO — so the next
+     * turn respawns on the new model. The model-switch analogue of the credential-switch eviction (Cut 6);
+     * busy turns settle first (handled inside evictPooledAgentsByAgentId). Runs per agents operation via
+     * syncKeySources, so a primary-model switch takes effect on the next message.
+     */
+    private evictModelFollowersIfChanged;
 }

package/dist/types/cli/core-tools/agent-tool-service.d.ts

@@ -10,6 +10,7 @@ export interface AgentToolServiceHost {
     readonly currentTransport: LLMTransport | null;
     readonly currentApiKey: string;
     readonly currentModel: string;
+    readonly currentTurnId?: string;
     sendNotification(method: string, params: Record<string, unknown>): void;
     /** Unified background execution registry. Required for background=true forks. */
     getBackgroundTasks(): BackgroundTaskManager | null;

package/dist/types/cli/handlers/agents-handler.d.ts

@@ -8,6 +8,7 @@ import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/in
 import { AgentProcessManager } from "../../runtime/infra/agent-process.js";
 import type { AgentConfigStore } from "../../runtime/infra/agent-config-store.js";
 import { type AcpDetector } from "../../runtime/infra/acp-detector.js";
+import { type PooledTurnCtx } from "../../runtime/infra/external-agent-pool.js";
 export interface AgentsHandlerHost {
     acpDetector: AcpDetector;
     soloProcessManager: AgentProcessManager | null;
@@ -19,6 +20,13 @@ export interface AgentsHandlerHost {
     sendResponse(id: string | number, result?: unknown, error?: AgentRpcError): void;
     sendNotification?(method: string, params: Record<string, unknown>): void;
 }
+export declare function relayPooledTurnNotification(input: {
+    agentId: string;
+    turn: PooledTurnCtx | null;
+    method: string;
+    payload: unknown;
+    sendNotification?: (method: string, params: Record<string, unknown>) => void;
+}): void;
 /** Resolve a pending external-agent approval with the user's decision (delivered by the gateway). */
 export declare function handleAgentsApprovalResponse(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleAgentsScan(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
@@ -29,12 +37,6 @@ export declare function handleAgentsList(this: AgentsHandlerHost, msg: AgentRpcR
  * summary + source for the confirm dialog (no secrets).
  */
 export declare function handleAgentsCatalog(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
-/**
- * Background update check (VS Code pattern): resolve latest npm versions for installed catalog agents
- * in PARALLEL, off the catalog hot path. The frontend calls this AFTER the (instant) catalog render
- * and merges the results to light up "update available" badges — never blocking the panel from
- * opening. Returns `{ updates: CatalogUpdateInfo[] }` (only agents with a resolved latest version).
- */
 export declare function handleAgentsCheckUpdates(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
 /**
  * One-click install a catalog agent by id. Runs ONLY the official command from the
@@ -42,6 +44,13 @@ export declare function handleAgentsCheckUpdates(this: AgentsHandlerHost, msg: A
  * agent.install.progress notification, then refreshes detection. Returns the outcome.
  */
 export declare function handleAgentsInstall(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
+/**
+ * Open an OS terminal running an agent's interactive login/setup command (e.g. `kimi login`,
+ * `hermes acp --setup`). Lowers the barrier for own-store/oauth agents that can't be driven via
+ * injected credentials — the user completes the CLI's native login without leaving the app. The
+ * command is resolved server-side from the catalog (fixed string, no user input → no injection).
+ */
+export declare function handleAgentsRunSetup(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleAgentsConfig(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleAgentsSetConfig(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleAgentsGetConfig(this: AgentsHandlerHost, msg: AgentRpcRequest): Promise<void>;

package/dist/types/cli/handlers/product-handler.d.ts

@@ -1,6 +1,6 @@
 /**
  * Product mode handlers.
- * Handles: product.plan/confirm/message/create/resume/pause/checkpoint/status/list/delete/cancel/rollback.
+ * Handles: product.plan/confirm/message/create/resume/pause/checkpoint/status/list/delete/cancel/rollback/replay.
  */
 import { type AgentRpcError, type AgentRpcRequest } from "../../protocol/wire/index.js";
 import { type ProductCoordinatorHost } from "../product-coordinator.js";
@@ -31,7 +31,26 @@ export declare function handleProductStatus(this: ProductHandlerHost, msg: Agent
 /** `product.list` - List all products. */
 export declare function handleProductList(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleProductDelete(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
-/** `product.cancel` - Cancel a running product. */
+/**
+ * Cancel a product no matter which lifecycle phase it is in. The orchestrator only knows
+ * POST-confirm (executing) sessions; while the leader is still PLANNING, the product lives in
+ * `ProductPlanner.sessions` instead. Previously cancel only routed to `orchestrator.delete`, so
+ * cancelling a stalled planning leader threw "Product not found" and never killed it.
+ *
+ * Strategy (idempotent):
+ *  1. Try `orchestrator.delete` (post-confirm path).
+ *  2. If that fails because the product isn't an orchestrator session ("not found"), fall back to
+ *     `planner.cancel` (planning-phase path — kills the leader process).
+ *  3. If neither side has the product, resolve ok rather than throwing (cancel is best-effort).
+ */
+export declare function cancelProductAnyPhase(orchestrator: {
+    delete(productId: string): Promise<void>;
+}, planner: {
+    cancel(productId: string): Promise<void>;
+}, productId: string): Promise<void>;
+/** `product.cancel` - Cancel a running product (handles both executing and planning phases). */
 export declare function handleProductCancel(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
 /** `product.rollback` - Rollback a product to a checkpoint. */
 export declare function handleProductRollback(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;
+/** `product.replay` - Re-run from an arbitrary completed/failed task forward, reusing upstream outputs. */
+export declare function handleProductReplay(this: ProductHandlerHost, msg: AgentRpcRequest): Promise<void>;

package/dist/types/cli/handlers/project-handler.d.ts

@@ -19,6 +19,14 @@ export interface ProjectHandlerHost {
 }
 export declare function handleProjectCreate(this: ProjectHandlerHost, msg: AgentRpcRequest): Promise<void>;
 export declare function handleProjectList(this: ProjectHandlerHost, msg: AgentRpcRequest): void;
+/**
+ * Reliable recursive directory removal for Windows. fs.rmSync({recursive,force}) cannot be trusted
+ * here: on git repos it silently leaves read-only object/pack files (and whole subtrees) behind
+ * without throwing. This walks bottom-up, clearing the read-only attribute (chmod) on the EPERM
+ * retry, which deletes git worktrees/repos cleanly. Per-entry failures (e.g. a live EBUSY lock) are
+ * swallowed; the caller verifies via existsSync and decides success/retry.
+ */
+export declare function rmDirRobustSync(target: string): void;
 export declare function handleProjectDelete(this: ProjectHandlerHost, msg: AgentRpcRequest): void;
 export declare function handleProjectPurgeAll(this: ProjectHandlerHost, msg: AgentRpcRequest): void;
 export declare function handleProjectRename(this: ProjectHandlerHost, msg: AgentRpcRequest): void;

package/dist/types/cli/handlers/workflow-handler.d.ts

@@ -39,6 +39,11 @@ export interface WorkflowCoordinatorHost {
     handleMcpToolCall(memberId: string, tool: string, args: Record<string, unknown>): Promise<unknown>;
     sendNotification(method: string, params: Record<string, unknown>): void;
     toolCatalog: ToolCatalog;
+    resolveClientForPurpose?: (purpose: "textGeneration") => {
+        transport: import("../provider-core-facade.js").LLMTransport;
+        apiKey: string;
+        model: string;
+    } | null;
     /** Per-root engine bundles keyed by resolved cwd; built lazily by ensureWorkflowRoot. */
     workflowRoots: Map<string, WorkflowRootBundle> | null;
 }

package/dist/types/cli/tool-bootstrap-core-registration.d.ts

@@ -26,6 +26,11 @@ export interface LocalCoreToolRegistrationContext {
     listToolNames(): string[];
     findRegisteredTool(name: string): RuntimeToolContract | undefined;
     activateRegisteredTool(name: string): boolean;
+    listDeferredTools(): Array<{
+        name: string;
+        description: string;
+        searchHint?: string;
+    }>;
 }
 export declare function setGroupSecurityMode(enabled: boolean): void;
 export declare const localCoreToolRegistrationModule: import("../runtime/ports/tool-contracts.js").ToolRegistrationModule<LocalCoreToolRegistrationContext>;

package/dist/types/cli/turn-core.d.ts

@@ -11,7 +11,11 @@ export interface TurnCoreRequest {
     turnId: string;
     sessionId: string;
     messages: ChatMessage[];
+    /** Full registered tool surface before per-turn policy filtering. */
+    availableTools?: ToolDefinition[];
     tools: ToolDefinition[];
+    /** Live tool-manifest rebuild for same-turn activation (forwarded to the loop). */
+    refreshTools?: () => ToolDefinition[];
     systemPrompt: string;
     config: TurnConfig;
 }

package/dist/types/contracts/index.d.ts

@@ -2,3 +2,4 @@
  * Internal contracts — hooks.
  */
 export * from "./hooks.js";
+export type { DecisionStateRecord, GoalReconstructionState, MaintainedDocumentIndex, ReadCycleGuard, SkillCreateInstruction, SkillImproveInstruction, SkillInstruction, TurnEvent, } from "./turn-event.js";

package/dist/types/contracts/turn-event.d.ts

@@ -0,0 +1,235 @@
+import type { WireTokenUsage } from "../protocol/wire/index.js";
+export interface SkillCreateInstruction {
+    type: "skill.create";
+    /** Suggested skill name derived from tool usage pattern */
+    suggestedName: string;
+    /** Short description of what the skill does */
+    description: string;
+    /** Tool names involved */
+    tools: string[];
+    /** Number of orchestration steps */
+    stepCount: number;
+}
+export interface SkillImproveInstruction {
+    type: "skill.improve";
+    /** Existing skill to improve */
+    skillName: string;
+    /** Reason for improvement */
+    reason: string;
+}
+export type SkillInstruction = SkillCreateInstruction | SkillImproveInstruction;
+export type TurnEvent = {
+    type: "start";
+    turnId: string;
+} | {
+    type: "delta";
+    turnId: string;
+    text: string;
+} | {
+    type: "tool_call";
+    turnId: string;
+    callId: string;
+    name: string;
+    arguments: string;
+    inputSummary?: string;
+} | {
+    type: "end";
+    turnId: string;
+    content: string;
+    usage?: WireTokenUsage;
+    model?: string;
+    provider?: string;
+    /** Per-turn recovery trace (action -> count); present only when recoveries fired. */
+    recoveryTrace?: Record<string, number>;
+} | {
+    type: "error";
+    turnId: string;
+    error: string;
+    code?: string;
+    usage?: WireTokenUsage;
+} | {
+    type: "skill_instruction";
+    turnId: string;
+    instruction: SkillInstruction;
+} | {
+    type: "tool_result";
+    turnId: string;
+    callId: string;
+    name: string;
+    ok: boolean;
+    error?: string;
+    outputPreview?: string;
+    durationMs?: number;
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+    details?: Record<string, unknown>;
+} | {
+    type: "tool_blocked";
+    turnId: string;
+    callId: string;
+    name: string;
+    reason: string;
+} | {
+    type: "recovery";
+    turnId: string;
+    action: string;
+    detail?: string;
+} | {
+    type: "tool_selection_policy";
+    turnId: string;
+    policyId: string;
+    intent: "benchmark_state_maintenance" | "fresh_evidence" | "verification" | "final_answer" | "deferred_tool_discovery" | "tool_recovery" | "lifecycle_reconciliation";
+    reason: string;
+    availableToolNames: string[];
+    enabledToolNamesBefore: string[];
+    enabledToolNamesAfter: string[];
+    suppressedToolNames: string[];
+    nextAction: string;
+} | {
+    type: "plan_update";
+    turnId: string;
+    slug: string;
+    content: string;
+} | {
+    type: "heartbeat";
+    turnId: string;
+    message: string;
+} | {
+    type: "tool_use_summary";
+    turnId: string;
+    telemetrySource?: "agent" | "agent-synthetic";
+    availableToolNames: string[];
+    enabledToolNames: string[];
+    toolCallNames: string[];
+    blockedToolCalls: Array<{
+        name: string;
+        reason: string;
+    }>;
+} | {
+    type: "lifecycle";
+    turnId: string;
+    kind: "stage" | "reopen" | "resume" | "context_compression" | "goal_reconstruction" | "memory_drift" | "artifact_path_drift";
+    stage?: string;
+    status?: string;
+    detail?: string;
+    reconstruction?: GoalReconstructionState;
+    observedAt?: string;
+} | {
+    type: "document_maintenance";
+    turnId: string;
+    checkpointId: string;
+    documents: MaintainedDocumentIndex[];
+    decisionStateTable: DecisionStateRecord[];
+    readCycleFindings: Array<Record<string, unknown>>;
+    readCycleGuard: ReadCycleGuard;
+    observedAt?: string;
+} | {
+    type: "reasoning_delta";
+    turnId: string;
+    text: string;
+} | {
+    type: "suggestions";
+    turnId: string;
+    items: Array<{
+        text: string;
+        icon?: string;
+        action?: string;
+    }>;
+} | {
+    type: "media_result";
+    turnId: string;
+    mediaType: "image" | "tts" | "video" | "music" | "3d";
+    url: string;
+    model?: string;
+    provider?: string;
+    durationSeconds?: number;
+    width?: number;
+    height?: number;
+    mimeType?: string;
+    billingUnit?: string;
+    billingQuantity?: number;
+    taskId?: string;
+} | {
+    type: "artifact";
+    turnId: string;
+    artifactId: string;
+    artifactType: "code" | "file" | "image" | "document" | "diagram" | "table";
+    title: string;
+    filePath?: string;
+    language?: string;
+    content?: string;
+    mimeType?: string;
+} | {
+    type: "artifact_contract";
+    turnId: string;
+    artifactRoot?: string;
+    writePaths: string[];
+    outOfRootWrites: Array<{
+        path: string;
+        artifactRoot: string;
+        toolName: string;
+    }>;
+    devServerUrls: string[];
+    browserVerified: boolean;
+    browserEvidence: string[];
+    requiresBrowserAcceptance: boolean;
+} | {
+    type: "annotations";
+    turnId: string;
+    annotations: Array<{
+        type: string;
+        url?: string;
+        title?: string;
+        [key: string]: unknown;
+    }>;
+} | {
+    type: "subagent_started";
+    turnId: string;
+    subagentId: string;
+    agentType: string;
+    prompt?: string;
+} | {
+    type: "subagent_ended";
+    turnId: string;
+    subagentId: string;
+    agentType: string;
+    ok: boolean;
+    outputPreview?: string;
+    error?: string;
+};
+export interface GoalReconstructionState {
+    goal: string;
+    artifactRoot: string;
+    decisions: string[];
+    defects: string[];
+    acceptanceCriteria: string[];
+    blockers: string[];
+    nextAction: string;
+}
+export interface MaintainedDocumentIndex {
+    name?: string;
+    path?: string;
+    indexed: true;
+    maintained: true;
+    indexVersion: string;
+    contentHash: string;
+    summary: string;
+    lastReviewedTurn: number;
+    fileSizeBytes: number;
+    recordCount: number;
+}
+export interface DecisionStateRecord {
+    id: string;
+    decision: string;
+    status: string;
+    evidence: string;
+    lastConfirmedTurn: number;
+}
+export interface ReadCycleGuard {
+    strategy: string;
+    nextReadPolicy: string;
+    budgetStatus: "within-budget";
+    maxReadsPerDocument: number;
+    observedReadsByPath: Record<string, number>;
+}

package/dist/types/orchestration/agent-instance.d.ts

@@ -24,7 +24,11 @@ export interface ProductCallbacks {
         warn(msg: string): void;
     };
     onTaskStarted?: (productId: string, taskId: string, assignee: string) => void;
-    onTaskCompleted?: (productId: string, taskId: string, result: string) => void;
+    onTaskCompleted?: (productId: string, taskId: string, result: string, meta?: {
+        inputTokens: number;
+        outputTokens: number;
+        changedFiles: string[];
+    }) => void;
     onTaskFailed?: (productId: string, taskId: string, error: string) => void;
     onCheckpointed?: (productId: string, timestamp: string) => void;
     onBudgetWarning?: (productId: string, usedTokens: number, maxTotalTokens: number, percentage: number) => void;
@@ -42,7 +46,29 @@ export interface ProductCallbacks {
     onBudgetUpdate?: (productId: string, inputTokens: number, outputTokens: number, elapsed: number, maxTotalTokens?: number) => void;
     /** Streaming text output from a running task. */
     onTaskOutputDelta?: (productId: string, taskId: string, text: string) => void;
+    /** Team roster resolved at run start — fired once (engine-driven) for both initial start and resume,
+     *  so the run view's 团队成员 panel populates live instead of only on a history reopen. */
+    onMembers?: (productId: string, members: {
+        agentId: string;
+        role: string;
+        name: string;
+    }[]) => void;
 }
+/**
+ * Prepend completed upstream task outputs to a downstream task prompt so the
+ * worker agent can see what its predecessors produced (research→writing, etc.).
+ * If there are no upstream outputs the original prompt is returned unchanged.
+ *
+ * NOTE: Only used for the agent-facing sends (spawn/sendTask/recovery).
+ * The original prompt is kept separate for evidence heuristics
+ * (requiresExplicitCompletionEvidence, assertProductTaskCompletionEvidence,
+ * assertProductTaskMaterializedEvidence) which inspect the task instruction
+ * for specific markers and keywords — the context prefix must not pollute them.
+ */
+export declare function buildTaskContextPrompt(upstream: {
+    taskId: string;
+    output: string;
+}[], prompt: string): string;
 export declare class ProductOrchestrator {
     private processManager;
     private acpDetector;
@@ -66,9 +92,26 @@ export declare class ProductOrchestrator {
     /** Delete a product session, pausing first if active. */
     delete(productId: string): Promise<void>;
     /** Rollback a product to a checkpoint: delete running session then resume from disk. */
-    rollback(productId: string, _checkpoint: string): Promise<void>;
+    rollback(productId: string, checkpoint?: string): Promise<void>;
+    /**
+     * Replay from an arbitrary completed/failed task (CrewAI Crew.replay(taskId) parity).
+     *
+     * Resets the task + all its transitive descendants to pending (clearing their outputs) while
+     * leaving ancestors completed — so the re-run automatically reuses upstream outputs via the
+     * existing task-context injection (getUpstreamOutputs at dispatch). Unlike rollback (which
+     * restores a whole-product checkpoint) or retryNode (which only accepts FAILED nodes), replay
+     * targets a successful-but-wrong task and re-runs forward from it in place.
+     */
+    replayTask(productId: string, taskId: string): Promise<void>;
     /** Get product status. */
     getStatus(productId: string): ProductStatus | null;
+    /** Live DAG progress snapshot for a product (for the planner's execution-phase leader). */
+    getProgressSnapshot(productId: string): {
+        total: number;
+        completed: number;
+        running: number;
+        failed: number;
+    } | null;
     getPersistedStatus(productId: string, cwd?: string): Promise<ProductStatus | null>;
     /** List all products (in-memory + on-disk). */
     list(cwd?: string): Promise<ProductSummary[]>;

package/dist/types/orchestration/agent-roster.d.ts

@@ -0,0 +1,17 @@
+import type { AgentRosterEntry, AgentConfigStoreData } from "../protocol/wire/acp-agent-management.js";
+import { type AcpDetector } from "../runtime/infra/acp-detector.js";
+/** Build the team roster the leader sees during planning: every ready agent with a coarse
+ *  strengths hint + its backing model. Leader-only soft hints — NOT a capability contract.
+ *
+ *  `allowedAgents` is PRESENCE-based (an explicit `[]` is meaningful, NOT the same as omitted):
+ *   - `undefined` / omitted → ALL ready agents (backward compatible — WS probes, other callers, old
+ *     sessions). The allow-set is `null` and the catalog filter applies no constraint.
+ *   - `[]` (explicit empty array) → ONLY the leader 小智 (qlogicagent): the allow-set is an empty Set, so
+ *     the catalog filter drops every non-leader entry; the leader is force-included below → roster = just
+ *     小智. This is the user deliberately deselecting every worker.
+ *   - `[ids]` → those ready ids PLUS the leader 小智 (always included). A picked-but-unready id is dropped.
+ *
+ *  The leader `qlogicagent` (小智) is ALWAYS present (universal coordinator / fallback executor) — appended
+ *  if not already in the roster, so the leader always has ≥1 valid assignee even when the user's picks turn
+ *  out unready (or when the pool is empty). */
+export declare function buildAgentRoster(detector: AcpDetector, _configStore: AgentConfigStoreData | null, allowedAgents?: string[]): AgentRosterEntry[];