qlogicagent 2.17.10 → 2.18.2

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

@@ -16,6 +16,8 @@ export interface TurnCoreRequest {
     tools: ToolDefinition[];
     /** Live tool-manifest rebuild for same-turn activation (forwarded to the loop). */
     refreshTools?: () => ToolDefinition[];
+    /** Mid-turn guidance drain (运行中引导) — forwarded to the tool loop. */
+    drainPendingGuidance?: () => string[];
     systemPrompt: string;
     config: TurnConfig;
 }

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

@@ -28,6 +28,7 @@ export interface ProductCallbacks {
         inputTokens: number;
         outputTokens: number;
         changedFiles: string[];
+        acceptanceUnverified?: boolean;
     }) => void;
     onTaskFailed?: (productId: string, taskId: string, error: string) => void;
     onCheckpointed?: (productId: string, timestamp: string) => void;
@@ -83,7 +84,12 @@ export declare class ProductOrchestrator {
      */
     create(params: ProductCreateParams): Promise<string>;
     /** Resume a product from persisted state. */
-    resume(productId: string, cwd?: string): Promise<void>;
+    resume(productId: string, cwd?: string, opts?: {
+        additionalBudget?: {
+            maxTotalTokens?: number;
+            maxDuration?: number;
+        };
+    }): Promise<void>;
     /**
      * Pause a running product — the SINGLE pause path (I9).
      *
@@ -121,6 +127,10 @@ export declare class ProductOrchestrator {
      */
     replayTask(productId: string, taskId: string): Promise<void>;
     /** Get product status. */
+    /** P2-1: the native (codex/claude) session id captured for a delegation's single worker, so the
+     *  DelegationCoordinator can resume it on the next same-(chat×agent) delegation. undefined for a
+     *  multi-instance product, an own agent, or before the worker's first task settles. */
+    getDelegationNativeSessionId(productId: string): string | undefined;
     getStatus(productId: string): ProductStatus | null;
     /** Live DAG progress snapshot for a product (for the planner's execution-phase leader). */
     getProgressSnapshot(productId: string): {

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

@@ -15,3 +15,15 @@ import { type AcpDetector } from "../runtime/infra/acp-detector.js";
  *  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[];
+/**
+ * User-PICKED worker ids that did NOT make it into the roster (unready: not installed / not logged in
+ * / not in the catalog). Excludes the leader (always force-included). Empty when nothing was dropped
+ * or when the pool was omitted. Callers surface this so a picked worker doesn't vanish silently and
+ * collapse the team to just 小智 (honesty over silence — goal used to degrade with no notice).
+ */
+export declare function computeUnavailablePicks(allowedAgents: string[] | undefined, rosterIds: readonly string[]): string[];
+/** buildAgentRoster + the diagnostics of which picked workers were dropped as unavailable. */
+export declare function buildAgentRosterWithDiagnostics(detector: AcpDetector, configStore: AgentConfigStoreData | null, allowedAgents?: string[]): {
+    roster: AgentRosterEntry[];
+    unavailablePicks: string[];
+};

package/dist/types/orchestration/dag-scheduler.d.ts

@@ -34,6 +34,7 @@ export interface Node {
     inputTokens?: number;
     outputTokens?: number;
     changedFiles?: string[];
+    acceptanceUnverified?: boolean;
     runIndex: number;
     maxIterations?: number;
     iteration?: number;
@@ -89,6 +90,7 @@ export declare class DagScheduler {
         inputTokens?: number;
         outputTokens?: number;
         changedFiles?: string[];
+        acceptanceUnverified?: boolean;
     }): void;
     markFailed(id: string, error: string): void;
     markPaused(id: string): void;
@@ -188,6 +190,7 @@ export interface SerializedNode {
     inputTokens?: number;
     outputTokens?: number;
     changedFiles?: string[];
+    acceptanceUnverified?: boolean;
     runIndex: number;
     maxIterations?: number;
     iteration?: number;

package/dist/types/orchestration/delegation-coordinator.d.ts

@@ -11,10 +11,20 @@ export interface DelegationDeps {
         warn(m: string): void;
     };
 }
-type DelegationStatus = "running" | "completed" | "failed" | "cancelled";
+type DelegationStatus = "running" | "completed" | "failed" | "cancelled" | "timed_out";
 export declare class DelegationCoordinator {
     private readonly deps;
     private readonly active;
+    /** Per-(chat×agent) tail promise — the next same-conversation delegation chains after it so they run
+     *  strictly sequentially (single writer to the shared reused worktree + native session). One entry per
+     *  active (chat×agent) pair (keyed, overwritten — not per-delegation), so it stays bounded. */
+    private readonly convChains;
+    /** Per-(chat×agent) native (codex/claude) session id — the background analogue of the foreground U5
+     *  convergence. Seeded from the first delegation's captured session id; passed as resumeNativeSessionId on
+     *  every subsequent same-conversation delegation so context accumulates (git AND non-git projects).
+     *  In-memory (one entry per active pair); an engine restart resets it → the next delegation starts fresh,
+     *  same as a cold foreground turn whose pool was evicted. */
+    private readonly nativeSessions;
     constructor(deps: DelegationDeps);
     /** Active + recent delegations for this project (x/mention.list). */
     list(): {
@@ -40,6 +50,11 @@ export declare class DelegationCoordinator {
         delegationId: string;
     };
     private run;
+    /** Collect a delegation's produced artifacts: the union of the worktree diff (tasks[].changedFiles,
+     *  omitted by the wire type but carried at runtime) and the mtime-isolated capture of project-root files
+     *  (for workers that write straight to the workspace), plus the worker task + terminal phase. Shared by
+     *  the normal terminal path AND the timeout path, so a timed-out run still hands back its partial output. */
+    private collectProducts;
     private settle;
 }
 export {};

package/dist/types/orchestration/goal-loop-coordinator.d.ts

@@ -3,7 +3,10 @@ export interface LeaderPort {
     deriveChecklist(goal: string): Promise<AcceptanceCriterion[]>;
     planPhase(goal: string, summary: string, drained: GoalQueuedMessage[], checklist: AcceptanceChecklist, agentPool: string[]): Promise<PhaseSpec>;
     critiquePlan(spec: PhaseSpec, goal: string, checklist: AcceptanceChecklist, agentPool: string[]): Promise<PhaseSpec>;
-    assess(productId: string, checklist: AcceptanceChecklist): Promise<AcceptanceDelta[]>;
+    assess(productId: string, checklist: AcceptanceChecklist): Promise<{
+        deltas: AcceptanceDelta[];
+        producedFiles: boolean;
+    }>;
     compact(prevSummary: string, deltas: AcceptanceDelta[]): Promise<string>;
 }
 export interface PhaseRunnerPort {

package/dist/types/orchestration/goal-mode-adapters.d.ts

@@ -75,7 +75,9 @@ export interface PhaseRunnerAdapterDeps {
     };
 }
 export declare function createPhaseRunnerAdapter(deps: PhaseRunnerAdapterDeps): PhaseRunnerPort;
-export declare function parsePhaseSpec(reply: string, availableAgentIds: string[]): PhaseSpec;
+export declare function parsePhaseSpec(reply: string, availableAgentIds: string[], log?: {
+    warn?(m: string): void;
+}): PhaseSpec;
 /**
  * B (evidence-gating): goal-mode's assess() is the SOLE acceptance authority (Product's per-task judge
  * is a no-op for a session-less goal-mode run), so a criterion may only flip to `passed` when it is

package/dist/types/orchestration/goal-run-types.d.ts

@@ -1,5 +1,6 @@
 /** Loop tunables (single source of truth — I9). */
 export declare const GOAL_NO_PROGRESS_LIMIT = 3;
+export declare const GOAL_SOFT_NO_PROGRESS_LIMIT = 8;
 export declare const GOAL_DRAIN_TIMEOUT_MS: number;
 export declare const GOAL_UNREACHABLE_MIN_STREAK = 2;
 export type GoalRunStatus = "running" | "ended";
@@ -76,6 +77,7 @@ export interface PersistedGoalRunState {
     pauseState: GoalPauseState;
     phaseIndex: number;
     noProgressCount: number;
+    noFlipStreak?: number;
     unreachableStreak?: Record<string, number>;
     progressSummary: string;
     acceptanceChecklist: AcceptanceChecklist;

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

@@ -43,6 +43,19 @@ export declare class ProductBudgetTracker {
      * - "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. (input/output optional for back-compat with older snapshots.) */
     restore(data: {
         usedTokens: number;

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

@@ -30,6 +30,10 @@ export interface PersistedProductState {
      * PlanningSession is strings / arrays / plain objects (no functions, dates, or class instances).
      */
     leaderDialogue?: PlanningSession;
+    /** P2-1: run tasks in the project cwd instead of per-task worktrees (see
+     *  ProductCreateParams.runInProjectCwd) — persisted so a delegation resumed after an engine restart
+     *  keeps running in the project cwd, not a fresh isolated worktree. */
+    runInProjectCwd?: boolean;
 }
 export interface ProductPersistenceOptions {
     pathService?: PathService;

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

@@ -165,8 +165,12 @@ export declare class ProductPlanner {
     listSessions(): PlanningSession[];
     /**
      * Ask the leader to judge whether a worker task's output satisfies its acceptanceCriteria.
-     * Returns { pass: true } immediately when there is no leader session (fail-open).
-     * If the response cannot be parsed at all, defaults to { pass: true } (lenient, like solo.specJudge).
+     *
+     * 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;
@@ -177,6 +181,7 @@ export declare class ProductPlanner {
     }): Promise<{
         pass: boolean;
         feedback?: string;
+        unverified?: boolean;
     }>;
     /**
      * Ask leader to evaluate execution state and propose DAG mutations.

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

@@ -25,6 +25,7 @@ export interface ProductLeaderCoordinator {
     }): Promise<{
         pass: boolean;
         feedback?: string;
+        unverified?: boolean;
     }>;
     /** Snapshot the leader's PlanningSession for checkpoint persistence (durable execution). */
     serializeSession(productId: string): PlanningSession | null;

package/dist/types/orchestration/workflow/budget-permission-gate.d.ts

@@ -31,6 +31,15 @@ export type WorkflowTriggerKind = "manual" | "schedule" | "im-message" | "webhoo
  * (set / if / loop / merge / passthrough / trigger) are NOT here — they cannot escape the engine.
  */
 export declare const SENSITIVE_KINDS: ReadonlySet<string>;
+/**
+ * The distinct sensitive (side-effecting) kinds present among these node kinds — i.e. the
+ * capabilities a workflow will need authorized to run unattended. Pure; drives upfront disclosure at
+ * ACTIVATION so the user authorizes these knowingly, instead of the first unattended run hard-failing
+ * at the gate (the old surprise: "activated fine, then the 3am schedule died at a channel send").
+ */
+export declare function requiredUnattendedPermissions(nodeKinds: Iterable<string>): string[];
+/** Required unattended permissions NOT yet granted — exactly what activation should ask to authorize. */
+export declare function missingUnattendedAuthorizations(nodeKinds: Iterable<string>, granted: readonly string[] | undefined): string[];
 /** Hard, non-resumable denial: an unauthorized side-effecting kind under an unattended trigger. */
 export declare class WorkflowPermissionDenied extends Error {
     readonly nodeId: string;

package/dist/types/orchestration/workflow/node-schema.d.ts

@@ -207,8 +207,11 @@ export interface ApprovalHostRequest {
     workflowId?: string;
     /** Plain-language question shown to the owner (默认 "继续执行?"). */
     prompt?: string;
-    /** Auto-deny deadline; default 24h. */
+    /** Deadline for a decision; default 24h. What happens at the deadline is timeoutAction (default reject). */
     timeoutMs?: number;
+    /** Timeout policy (default "reject"): "reject" fails the node but ANNOUNCES it (not a silent auto-deny);
+     *  "approve" auto-continues; "keepPending" stays suspended (persisted; re-prompts on restart). */
+    timeoutAction?: "approve" | "reject" | "keepPending";
     input: DataItem[];
     signal?: AbortSignal;
 }

package/dist/types/orchestration/workflow/workflow-trigger.d.ts

@@ -28,7 +28,11 @@ export type TriggerDef = {
     aliases?: string[];
     /** 开启语义兜底(确定性未命中时一次 LLM 分类;有成本,默认关)。 */
     semantic?: boolean;
-    /** 命中后是否弹确认(默认 true;关闭=说出即跑)。 */
+    /**
+     * 命中后是否弹确认。显式 true/false = 用户的判断,恒生效(false=说出即跑)。
+     * 缺省时由客户端按 intentIndex 的 sideEffectKinds 证据决定:无副作用节点→直接跑;
+     * 有副作用→弹确认(确认条上可选「总是直接运行」,持久化为 confirm:false)。
+     */
     confirm?: boolean;
     /** 生效界面;缺省 = 欢迎页+对话页都生效。 */
     surfaces?: ("welcome" | "chat")[];

package/dist/types/protocol/wire/acp-agent-management.d.ts

@@ -337,6 +337,22 @@ export interface ProductCreateParams {
         maxTotalTokens?: number;
         maxDuration?: number;
     };
+    /**
+     * P2-1: run ALL tasks directly in the project cwd (`cwd`) instead of isolated per-task git worktrees.
+     * Set by DelegationCoordinator so a background @mention shares the project workspace exactly like
+     * foreground @codex — its native session then lives under a STABLE cwd (git or not) and resumes across
+     * delegations. Omitted everywhere else (per-task worktree isolation stays the default for parallel
+     * product/goal/solo tasks).
+     */
+    runInProjectCwd?: boolean;
+    /**
+     * P2-1: native (codex/claude) session id to RESUME for this delegation (ACP session/load), so repeated
+     * background @mention to the same (chat×agent) accumulates context — the background analogue of the
+     * foreground U4 resume. The DelegationCoordinator tracks it per (chat×agent): undefined on the first
+     * delegation (→ fresh session, whose id it then captures), the prior id thereafter. Validated by `has()`
+     * before use, so a stale id falls back to a fresh session. Git-independent (id, not cwd, drives reuse).
+     */
+    resumeNativeSessionId?: string;
 }
 /**
  * product.plan RPC params — starts an interactive planning session.

package/dist/types/protocol/wire/agent-events.d.ts

@@ -13,7 +13,7 @@
  * Turn-lifecycle events relayed to the Control UI WebSocket.
  * These are the "chat session" events that every UI client needs.
  */
-export declare const AGENT_WS_EVENT_NAMES: readonly ["turn.start", "turn.delta", "turn.end", "turn.error", "turn.recovery", "turn.file_changes", "turn.tool_call", "turn.tool_result", "turn.tool_blocked", "turn.reasoning_delta", "turn.approval_request", "turn.skill_instruction", "turn.ask_user", "turn.media_result", "turn.media_progress", "turn.media_usage", "turn.media_capability_check", "turn.plan_update", "turn.suggestions", "turn.sidechain_started", "turn.subagent_started", "turn.subagent_delta", "turn.subagent_ended", "turn.sidechain_completed", "turn.task_updated", "turn.todos_updated", "turn.exec_progress", "turn.progress", "turn.tool_use_summary", "turn.tool_selection_policy", "turn.lifecycle", "turn.document_maintenance", "turn.artifact_contract", "turn.usage_update", "team.member.notification", "session.info", "session.recovery_pending", "memory.updated", "skills.updated", "pet.soul_ready", "pet.reaction", "pet.growth", "pet.state", "pet.confirm", "pet.asset.updated", "system.activity", "workflow.created", "workflow.updated", "workflow.deleted", "workflow.runStarted", "workflow.runCompleted", "workflow.runFailed", "workflow.nodeStatus", "workflow.triggerDropped", "workflow.alert", "workflow.approvalRequested"];
+export declare const AGENT_WS_EVENT_NAMES: readonly ["turn.start", "turn.delta", "turn.end", "turn.error", "turn.recovery", "turn.file_changes", "turn.tool_call", "turn.tool_result", "turn.tool_blocked", "turn.reasoning_delta", "turn.approval_request", "turn.skill_instruction", "turn.ask_user", "turn.media_result", "turn.media_progress", "turn.media_usage", "turn.media_capability_check", "turn.plan_update", "turn.suggestions", "turn.sidechain_started", "turn.subagent_started", "turn.subagent_delta", "turn.subagent_ended", "turn.sidechain_completed", "turn.task_updated", "turn.todos_updated", "turn.exec_progress", "turn.progress", "turn.tool_use_summary", "turn.tool_selection_policy", "turn.lifecycle", "turn.document_maintenance", "turn.artifact_contract", "turn.usage_update", "team.member.notification", "session.info", "session.recovery_pending", "memory.updated", "skills.updated", "pet.soul_ready", "pet.reaction", "pet.growth", "pet.state", "pet.confirm", "pet.asset.updated", "system.activity", "workflow.created", "workflow.updated", "workflow.deleted", "workflow.runStarted", "workflow.runCompleted", "workflow.runFailed", "workflow.nodeStatus", "workflow.triggerDropped", "workflow.alert", "workflow.approvalRequested", "workflow.approvalTimedOut"];
 /**
  * Agent Team events (Solo Mode, Product Mode, Plan lifecycle).
  * Relayed to the UI's team/orchestration panel.
@@ -23,7 +23,7 @@ export declare const AGENT_TEAM_WS_EVENT_NAMES: readonly ["solo.progress", "solo
  * All agent notifications that Gateway should relay to WS clients.
  * Union of session events + team events.
  */
-export declare const ALL_AGENT_WS_EVENT_NAMES: readonly ["turn.start", "turn.delta", "turn.end", "turn.error", "turn.recovery", "turn.file_changes", "turn.tool_call", "turn.tool_result", "turn.tool_blocked", "turn.reasoning_delta", "turn.approval_request", "turn.skill_instruction", "turn.ask_user", "turn.media_result", "turn.media_progress", "turn.media_usage", "turn.media_capability_check", "turn.plan_update", "turn.suggestions", "turn.sidechain_started", "turn.subagent_started", "turn.subagent_delta", "turn.subagent_ended", "turn.sidechain_completed", "turn.task_updated", "turn.todos_updated", "turn.exec_progress", "turn.progress", "turn.tool_use_summary", "turn.tool_selection_policy", "turn.lifecycle", "turn.document_maintenance", "turn.artifact_contract", "turn.usage_update", "team.member.notification", "session.info", "session.recovery_pending", "memory.updated", "skills.updated", "pet.soul_ready", "pet.reaction", "pet.growth", "pet.state", "pet.confirm", "pet.asset.updated", "system.activity", "workflow.created", "workflow.updated", "workflow.deleted", "workflow.runStarted", "workflow.runCompleted", "workflow.runFailed", "workflow.nodeStatus", "workflow.triggerDropped", "workflow.alert", "workflow.approvalRequested", "solo.progress", "solo.specProgress", "solo.agentDelta", "solo.agentActivity", "solo.agentUsage", "solo.evaluation", "product.taskStarted", "product.taskOutput", "product.members", "product.agentActivity", "product.taskCompleted", "product.taskFailed", "product.budgetUpdate", "product.budgetWarning", "product.checkpointed", "product.completed", "product.dagTopology", "plan.interrupted", "goal.run_state_changed", "goal.phase_boundary", "goal.goal_edited", "goal.message_queued", "goal.acceptance_updated"];
+export declare const ALL_AGENT_WS_EVENT_NAMES: readonly ["turn.start", "turn.delta", "turn.end", "turn.error", "turn.recovery", "turn.file_changes", "turn.tool_call", "turn.tool_result", "turn.tool_blocked", "turn.reasoning_delta", "turn.approval_request", "turn.skill_instruction", "turn.ask_user", "turn.media_result", "turn.media_progress", "turn.media_usage", "turn.media_capability_check", "turn.plan_update", "turn.suggestions", "turn.sidechain_started", "turn.subagent_started", "turn.subagent_delta", "turn.subagent_ended", "turn.sidechain_completed", "turn.task_updated", "turn.todos_updated", "turn.exec_progress", "turn.progress", "turn.tool_use_summary", "turn.tool_selection_policy", "turn.lifecycle", "turn.document_maintenance", "turn.artifact_contract", "turn.usage_update", "team.member.notification", "session.info", "session.recovery_pending", "memory.updated", "skills.updated", "pet.soul_ready", "pet.reaction", "pet.growth", "pet.state", "pet.confirm", "pet.asset.updated", "system.activity", "workflow.created", "workflow.updated", "workflow.deleted", "workflow.runStarted", "workflow.runCompleted", "workflow.runFailed", "workflow.nodeStatus", "workflow.triggerDropped", "workflow.alert", "workflow.approvalRequested", "workflow.approvalTimedOut", "solo.progress", "solo.specProgress", "solo.agentDelta", "solo.agentActivity", "solo.agentUsage", "solo.evaluation", "product.taskStarted", "product.taskOutput", "product.members", "product.agentActivity", "product.taskCompleted", "product.taskFailed", "product.budgetUpdate", "product.budgetWarning", "product.checkpointed", "product.completed", "product.dagTopology", "plan.interrupted", "goal.run_state_changed", "goal.phase_boundary", "goal.goal_edited", "goal.message_queued", "goal.acceptance_updated"];
 /** Type-level event name for session events. */
 export type AgentWsEventName = (typeof AGENT_WS_EVENT_NAMES)[number];
 /** Type-level event name for team events. */

package/dist/types/protocol/wire/agent-methods.d.ts

@@ -20,6 +20,8 @@ export interface AgentCapabilities {
     supportsResume: boolean;
     supportsUsageUpdate: boolean;
     skillsDirs?: string[];
+    /** 会话历史来源:native-cwd=有本地按 cwd 可发现的原生会话;省略/own=只显示自有会话 */
+    sessionHistory?: "native-cwd" | "own";
 }
 /** Descriptor for a discovered or registered agent. */
 export interface AgentDescriptor {
@@ -719,6 +721,7 @@ export interface AgentRpcMethodMap extends GatewayRpcMethodMap {
         params: {
             modelId: string;
             enabled: boolean;
+            purpose?: string;
         };
         result: {
             ok: true;

package/dist/types/protocol/wire/gateway-rpc.d.ts

@@ -241,6 +241,7 @@ export interface GatewayRpcMethodMap {
         result: {
             messages: unknown[];
             total: number;
+            corruptLines?: number;
         };
     };
     "project.list": {

package/dist/types/runtime/execution/streaming-tool-executor.d.ts

@@ -28,6 +28,8 @@ export interface StreamingToolExecutorConfig {
     toolInvoker: ToolInvoker;
     hooks?: HookRegistry;
     sessionId: string;
+    /** Turn workspace/cwd - routes oversized tool-result spillover to the session data dir. */
+    projectRoot?: string;
     turnId: string;
     log: AgentLogger;
     signal?: AbortSignal;

package/dist/types/runtime/execution/tool-result-storage.d.ts

@@ -48,7 +48,7 @@ export declare function generatePreview(content: string, maxBytes: number): {
     preview: string;
     hasMore: boolean;
 };
-export declare function persistToolResult(content: string, toolCallId: string, sessionId: string): Promise<PersistedToolResult | null>;
+export declare function persistToolResult(content: string, toolCallId: string, sessionId: string, projectRoot: string | undefined): Promise<PersistedToolResult | null>;
 /**
  * Build a reference message for large tool results (CC buildLargeToolResultMessage parity).
  */
@@ -58,7 +58,7 @@ export declare function buildLargeToolResultMessage(result: PersistedToolResult)
  * Falls back to hard truncation if persistence fails.
  * Called at tool execution time in streaming-tool-executor.ts.
  */
-export declare function maybePersistLargeToolResult(content: string, toolCallId: string, sessionId: string, threshold?: number): Promise<string>;
+export declare function maybePersistLargeToolResult(content: string, toolCallId: string, sessionId: string, projectRoot: string | undefined, threshold?: number): Promise<string>;
 interface MessageLike {
     role: string;
     content?: string | unknown;
@@ -78,10 +78,12 @@ interface MessageLike {
  * replaced later (would break prompt cache).
  *
  * @param state — MUTATED in place (seenIds and replacements updated)
- * @returns messages with replacements applied + count of new replacements
+ * @returns messages with replacements applied + count of new replacements +
+ *          total original bytes spilled this pass (so the caller can surface it)
  */
-export declare function enforceToolResultBudget(messages: MessageLike[], state: ContentReplacementState, sessionId: string, limit?: number): Promise<{
+export declare function enforceToolResultBudget(messages: MessageLike[], state: ContentReplacementState, sessionId: string, projectRoot: string | undefined, limit?: number): Promise<{
     messages: MessageLike[];
     newlyReplacedCount: number;
+    newlyPersistedBytes: number;
 }>;
 export {};

package/dist/types/runtime/infra/acp-detector.d.ts

@@ -6,13 +6,14 @@
  *
  * Reference: AionUI AcpDetector + ACP_BACKENDS_ALL registry.
  */
-import type { AcpBackendConfig, AgentDescriptor, AgentConfigStoreData, AuthPreference } from "../../protocol/wire/acp-agent-management.js";
+import type { AcpBackendConfig, AgentDescriptor, CustomAgentDef, AgentConfigStoreData, AuthPreference } from "../../protocol/wire/acp-agent-management.js";
 export declare const ACP_BACKENDS: Record<string, AcpBackendConfig>;
 export declare const AGENT_CATALOG_IDS: readonly ["claude", "codex", "gemini", "copilot", "cursor", "qwen", "kimi", "glm", "opencode", "kiro", "qoder", "openclaw", "hermes"];
 /** Merged catalog entry (base ACP config + grid/install metadata) for one id. */
 export declare function getCatalogEntry(id: string): AcpBackendConfig | undefined;
 /** Ordered curated catalog: base ACP config merged with grid/install metadata. */
 export declare function getAgentCatalog(): AcpBackendConfig[];
+export declare function buildInternalAgentDescriptors(): AgentDescriptor[];
 export declare function resolveWindowsCopilotLoader(): string | null;
 export declare function getNpmInstallPackageName(command: string | undefined): string | null;
 export declare function compareSemverVersions(a: string, b: string): number;
@@ -134,6 +135,24 @@ export declare function resolveCatalogKeyEnv(entry: AcpBackendConfig | undefined
  * Returns [] when not in account mode (or the agent has no account path — claude is coerced to auto).
  */
 export declare function resolveSuppressEnvKeys(entry: AcpBackendConfig | undefined, mode: AuthPreference, sources?: CatalogKeySources): string[];
+/**
+ * Build a backend's descriptor from already-resolved cliPath/version (+ the caller-resolved
+ * hasConfig flag). Shared by AcpDetector's sync and async detection paths so they can never drift
+ * (status rules, copilot's version-required gate, etc.) — extracted to a standalone, IO-free, pure
+ * function (not a class method) so it is directly unit-testable without spawning a real CLI.
+ *
+ * sessionHistory (Task 1.2, third-party native session discovery): "native-cwd" only for an
+ * INSTALLED (status "available") codex or claude backend — the two agents whose native CWD-scoped
+ * session stores we've actually adapted to. Every other case — not-installed codex/claude, any other
+ * backend regardless of install state — falls back to "own". Unadapted agents ALWAYS get "own"; this
+ * is a hard invariant, not a default that later widens implicitly.
+ */
+export declare function assembleBackendDescriptor(backend: AcpBackendConfig, cliPath: string | null, version: string | null, hasConfig: boolean): AgentDescriptor;
+/** Build a user-registered custom agent's descriptor. Extracted to a standalone, IO-free, pure
+ *  function for the same testability reason as {@link assembleBackendDescriptor}. Custom agents are
+ *  never adapted for native session discovery — regardless of what id/name the user gives them —
+ *  so sessionHistory is always "own" (the hard own-by-default invariant). */
+export declare function assembleCustomAgentDescriptor(custom: CustomAgentDef, cliPath: string | null, hasConfig: boolean): AgentDescriptor;
 export declare class AcpDetector {
     private cache;
     private configStore;
@@ -176,13 +195,9 @@ export declare class AcpDetector {
     private detectBackend;
     /** Async, NON-BLOCKING twin of {@link detectBackend} — identical detection, async probes. */
     private detectBackendAsync;
-    /** Build a backend's descriptor from already-resolved cliPath/version. Shared by the sync and async
-     *  detection paths so they can never drift (status rules, copilot's version-required gate, etc.). */
-    private assembleBackendDescriptor;
     private detectCustomAgent;
     /** Async, NON-BLOCKING twin of {@link detectCustomAgent}. */
     private detectCustomAgentAsync;
-    private assembleCustomAgentDescriptor;
     private hasAgentConfig;
     /**
      * Descriptor for qlogicagent participating in Solo/Product as a self-hosted ACP agent.
@@ -201,6 +216,21 @@ export declare class AcpDetector {
      * Returns null if the agent is not available.
      */
     buildExternalDescriptor(agentId: string): import("../../protocol/wire/acp-agent-management.js").ExternalAgentDescriptor | null;
+    /**
+     * Async, NON-BLOCKING twin of {@link buildExternalDescriptor} — identical output for the same
+     * detector state, but resolves the agent list via {@link scanAsync} (a real probe, awaited, when
+     * the cache is cold) instead of the sync {@link list}'s cache-or-empty shortcut. Load-bearing for
+     * `agents.warm` (agents-handler.ts): the sync path's detect calls are cache-fronted today, but
+     * that non-blocking guarantee is an implementation detail of `list()` — routing the RPC path
+     * through this method instead makes "never synchronously probe on this path" an explicit
+     * contract that can't silently regress if `list()`'s internals change later.
+     */
+    buildExternalDescriptorAsync(agentId: string): Promise<import("../../protocol/wire/acp-agent-management.js").ExternalAgentDescriptor | null>;
+    /** Shared descriptor-assembly logic for {@link buildExternalDescriptor} and
+     *  {@link buildExternalDescriptorAsync} — everything AFTER "locate this agentId's AgentDescriptor
+     *  in an already-resolved list", so the sync/async twins can never drift on behavior, only on how
+     *  they obtain `agents`. */
+    private assembleExternalDescriptorFromAgents;
     /**
      * Whether an agent is ready to compete in Solo/Product: installed/available AND configured.
      * qlogicagent self-resolves from the owner profile (always ready). External agents need a usable

package/dist/types/runtime/infra/acp-protocol-adapter.d.ts

@@ -16,6 +16,12 @@
  */
 import type { ChildProcess } from "node:child_process";
 import type { AcpInitializeResult, AcpSessionResult, AcpPromptResponse, McpServerConfig } from "../../protocol/wire/acp-agent-management.js";
+interface AcpPromptTimeoutOptions {
+    timeoutMs?: number;
+    getLastActivityAt?: () => number | undefined;
+    checkIntervalMs?: number;
+}
+type AcpPromptTimeoutInput = number | AcpPromptTimeoutOptions;
 /**
  * Handler for agent→host requests (fs, terminal, permission, elicitation).
  * Host implementations should implement the methods they support. This is intentionally loose
@@ -137,6 +143,7 @@ export declare class AcpProtocolAdapter {
     private requireConn;
     /** Race a connection call against a timeout; optionally run a side effect (e.g. cancel) on timeout. */
     private withTimeout;
+    private withActivityTimeout;
     /**
      * Perform the ACP initialize handshake. Sends standard clientInfo + clientCapabilities plus the
      * qlogicagent extension capability (forwarded verbatim by the SDK).
@@ -151,13 +158,26 @@ export declare class AcpProtocolAdapter {
         mcpServers?: McpServerConfig[];
         additionalDirectories?: string[];
         systemPrompt?: string;
+        /** Platform/managed model to select over ACP after session/new (see selectSessionModel). */
+        model?: string;
     }): Promise<AcpSessionResult>;
+    /**
+     * Select the platform/managed model over ACP after session/new. External CLIs (notably
+     * claude-code-acp) default to their OWN model (e.g. Sonnet 4.5) and merely EXPOSE the injected
+     * ANTHROPIC_MODEL/OPENAI_MODEL as an "available" option — they do NOT select it. Left on the default,
+     * the first prompt fails ("issue with the selected model …") because the platform shelf has no such
+     * model, and it surfaces as a cryptic "Agent process stdio closed". Best-effort: when the agent
+     * advertised its models, only switch if it offers `desired` and isn't already on it; otherwise attempt
+     * anyway and swallow rejection (the session still exists on its default model — the wrong-model prompt
+     * error is the backstop). Uses the generic sendRequest because the SDK has no typed set_model yet.
+     */
+    private selectSessionModel;
     /**
      * Send a prompt to a running ACP session (session/prompt). Content streams back via session/update
      * notifications during execution; the response carries only { stopReason, usage? }. On timeout the
      * turn is cancelled (session/cancel) so the agent stops cleanly.
      */
-    sendPrompt(_child: ChildProcess, sessionId: string, content: string, timeoutMs?: number): Promise<AcpPromptResponse>;
+    sendPrompt(_child: ChildProcess, sessionId: string, content: string, timeoutInput?: AcpPromptTimeoutInput): Promise<AcpPromptResponse>;
     /**
      * Resume an existing ACP session (session/load — replays history via notifications).
      * Only valid when the agent advertised the loadSession capability.
@@ -165,6 +185,7 @@ export declare class AcpProtocolAdapter {
     resumeSession(_child: ChildProcess, sessionId: string, options?: {
         cwd?: string;
         mcpServers?: McpServerConfig[];
+        model?: string;
     }): Promise<AcpSessionResult>;
     /**
      * Translate an ACP notification into qlogicagent's internal format.
@@ -176,3 +197,4 @@ export declare class AcpProtocolAdapter {
      */
     static translateNotification(method: string, params: unknown): TranslatedNotification | null;
 }
+export {};

package/dist/types/runtime/infra/agent-process.d.ts

@@ -52,6 +52,14 @@ export interface AgentProcessConfig {
     mcpServers?: McpServerConfig[];
     /** System prompt to inject into ACP session. */
     systemPrompt?: string;
+    /**
+     * Cut 5 — RESUME a third-party native session (ACP session/load, replays history) instead of
+     * creating a fresh one. The id is the agent's OWN native session id (codex rollout id / claude
+     * UUID). Only honored when the agent advertised loadSession at initialize (handle.supportsResume);
+     * otherwise spawn throws — we never silently open a blank session ("fake continuation" is forbidden
+     * by the Phase 2 design).
+     */
+    resumeSessionId?: string;
 }
 export declare function buildExternalAcpSpawnCommand(cliPath: string, acpArgs: string[]): {
     command: string;
@@ -296,6 +304,13 @@ export declare class AgentProcessManager {
     isAlive(memberId: string): boolean;
     /** Get usage tracker for an ACP agent (returns null for internal agents). */
     getUsageTracker(memberId: string): AcpUsageTracker | null;
+    /**
+     * The agent-assigned native session id (from ACP session/new or session/load) for a pooled member,
+     * once its session exists — undefined before creation. For native-cwd agents (codex/claude) this is
+     * the id under which the agent persists its OWN transcript (e.g. claude's ~/.claude uuid), distinct
+     * from the engine/stream id; used to converge on a single session identity (own/native unification).
+     */
+    getNativeSessionId(memberId: string): string | undefined;
     /**
      * Feed token usage into the tracker from a child notification (Tier 1). Handles all three shapes a
      * child may use so the tracker is actually populated:

package/dist/types/runtime/infra/external-agent-pool.d.ts

@@ -44,6 +44,18 @@ export declare function poolKey(agentId: string, cwd: string, sessionId?: string
 export declare function getAlivePooledAgent(key: string): PooledAgentEntry | undefined;
 /** Register a freshly-spawned entry, evicting any stale same-key entry and enforcing MAX_POOL. */
 export declare function registerPooledAgent(key: string, entry: PooledAgentEntry): void;
+/**
+ * Move a live pooled entry from one key to another without disposing it — the same ACP process keeps
+ * running, only its pool key changes. Disposes any stale occupant of the destination key. Returns the
+ * moved entry, or undefined if `fromKey` has no live entry (a dead one is reaped). No-op returning the
+ * existing entry when the keys are equal.
+ *
+ * Merge note (session-identity-alignment): the second caller this was extracted for — the transient→native
+ * X→Y re-key after a native agent reported its own id — is GONE. Under canonical-id-stable, the frontend
+ * never converges to Y, so the pool key never changes mid-conversation; the sole caller is adoptWarmedAgent
+ * (warm → real session key). Kept as the general re-key primitive.
+ */
+export declare function rekeyPooledAgent(fromKey: string, toKey: string): PooledAgentEntry | undefined;
 /**
  * Re-key a pre-warmed entry (spawned before a session existed, under WARM_SESSION) onto the real
  * session key, so the first turn adopts the warmed process and skips the cold start. Does not