qlogicagent 2.18.1 → 2.18.3

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 {
@@ -57,6 +60,12 @@ export declare class GoalLoopCoordinator {
      *  (finishPhase). Honest-fail ONLY if resume itself throws — a started phase is recovered, never lost,
      *  but progress is never fabricated. Bounded by an abort handle so pause() can still drain it. */
     private recoverCrashedPhase;
+    /** #4: classify how an in-flight phase's throw should land. A user pause aborts the signal (whatever
+     *  error then surfaces → "user_pause"); the adapter's GOAL_DRAIN_TIMEOUT_MS wall throws an AbortError
+     *  WITHOUT the signal being aborted, tagged pauseReason="drain_timeout" (untagged AbortErrors from
+     *  simpler runner ports default to drain_timeout — the only engine-side AbortError source). Anything
+     *  else is a real failure → undefined (the caller honest-FAILs). */
+    private pauseReasonOf;
     /** I3: true when the loaded state shows a phase that started (currentProductId set) but never reached
      *  its assessment/boundary — i.e. a process died mid-phase. Inspects the durable event log because
      *  the snapshot alone can't distinguish "just started" from "started and crashed". */

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

@@ -3,6 +3,12 @@ import type { AcpDetector } from "../runtime/infra/acp-detector.js";
 import type { ProductOrchestrator } from "./agent-instance.js";
 import type { LeaderPort, PhaseRunnerPort } from "./goal-loop-coordinator.js";
 import { type AcceptanceCriterion, type AcceptanceDelta, type PhaseSpec } from "./goal-run-types.js";
+/**
+ * #2 verify 输出的头尾截断:测试/构建命令的失败摘要通常在输出**末尾**(框架的 summary 行),裸
+ * slice(0,N) 保头丢尾会把真正的失败原因截掉,判官只能看到无关的开头。超限时保留头尾各半,并在
+ * 中间插入可见的省略注记(对齐 ASSESS 路径 "…(已截断)" 的风格 —— 截断必须留痕,不静默)。
+ */
+export declare function capVerifyOutput(text: string, cap?: number): string;
 /**
  * Deterministic runtime verification — the cc/codex-style "the runner OBSERVES the result" applied to
  * the judge, run EVERY phase as a continuous regression gate (not a one-time entry ticket). For each
@@ -75,7 +81,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
@@ -86,9 +94,22 @@ export declare function parsePhaseSpec(reply: string, availableAgentIds: string[
  *   - `passed` delta: keep only evidence items with a non-empty `source` AND non-empty `quote`, AND
  *     whose `source` is PRIMARY — i.e. it matches one of the run's actual `changedFiles` (exact or
  *     basename/suffix match, since the judge may cite a relative path) OR is the literal `"output"`.
- *     If, after filtering, a passed delta has zero evidence items, DROP it (do not flip) — and log.
+ *     If, after filtering, a passed delta has zero evidence items, do NOT flip it — demote it to a
+ *     VISIBLE `pending` note delta (#1③: it reaches the phase_assessed event, the progress summary and
+ *     the next phase's "受阻原因", instead of vanishing with only an engine log line).
  *   - `failed` / other deltas: kept as-is (their reason is informational; failed needs no evidence).
  */
 export declare function validateAssessDeltas(rawDeltas: AcceptanceDelta[], changedFiles: string[], log?: {
     warn(msg: string): void;
 }): AcceptanceDelta[];
+/**
+ * #1②: the judge-prompt view of this phase's project changed files. The PROMPT is windowed to stay
+ * bounded, but the truncation is DISCLOSED in-band — a hidden remainder must not read as "没有更多改动"
+ * (and the whitelist gate in assess() always uses the untruncated set, so citing an unlisted-but-real
+ * file still counts as primary evidence).
+ */
+export declare const ASSESS_FILES_WINDOW = 50;
+export declare function buildProjectFilesBlock(allFiles: string[], window?: number): string;
+/** Build the evidence block for the judge from a live Product status (task outputs + changed files).
+ *  Exported for the #3 regression test: the >ASSESS_MAX_TASKS window note must never silently vanish. */
+export declare function buildEvidenceBlock(status: ReturnType<ProductOrchestrator["getStatus"]>): string;

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

@@ -1,9 +1,14 @@
 /** 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";
 export type GoalPauseState = "running" | "draining" | "paused";
+/** Why a run is paused: the user's explicit pause vs the engine's GOAL_DRAIN_TIMEOUT_MS wall expiring
+ *  on its own. Carried on the `paused` event payload, the snapshot and goal.run_state_changed so an
+ *  engine-imposed pause is never indistinguishable from a user action (限制必须可见,不静默)。 */
+export type GoalPauseReason = "user_pause" | "drain_timeout";
 export type GoalEndReason = "done" | "stopped" | "failed";
 export type AcceptanceStatus = "pending" | "passed" | "failed" | "superseded";
 /** FINAL evidence type (I9 — not staged). source = file path / check name; quote = cited excerpt. */
@@ -43,6 +48,10 @@ export interface PhaseSpec {
         criterionId: string;
         reason: string;
     }[];
+    /** fail-open 打标:critique 判官坏 JSON 重试后仍失败,本计划未经精修直接执行。 */
+    critiqueSkipped?: boolean;
+    /** 截断收据:超 MAX_TASKS_PER_PHASE 被丢弃的任务数(其对应标准仍未通过,下一阶段会重新规划)。 */
+    droppedTaskCount?: number;
 }
 /** Output of assess() — one per criterion the phase touched. */
 export interface AcceptanceDelta {
@@ -76,6 +85,7 @@ export interface PersistedGoalRunState {
     pauseState: GoalPauseState;
     phaseIndex: number;
     noProgressCount: number;
+    noFlipStreak?: number;
     unreachableStreak?: Record<string, number>;
     progressSummary: string;
     acceptanceChecklist: AcceptanceChecklist;
@@ -83,6 +93,8 @@ export interface PersistedGoalRunState {
     agentPool: string[];
     wallClockStartedAt: string;
     pausedAt?: string;
+    /** #4: how the run became paused (user_pause / drain_timeout) — cleared on resume. */
+    pauseReason?: GoalPauseReason;
     stopReason?: string;
     endReason?: GoalEndReason;
     failedReason?: string;

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-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/skill-improvement.d.ts

@@ -1,6 +1,11 @@
 /**
- * Skill self-learning: decides whether a completed turn should
- * trigger skill creation or improvement instructions.
+ * Task-pattern learning gates (R3 蒸馏管道的候选判定基建)。
+ *
+ * 原消费者(tool-loop 回合内即时产技能路径)已于 2026-07-07 整链废弃删除——
+ * 即时产出无法验证做法正确性,且其产物是用户永远看不见的默认禁用技能(死链)。
+ * 本模块的门槛判定/模式签名/冷却状态机保留,作为 R3 任务后蒸馏的候选采集核心
+ * (docs/memory-layering-and-distillation-spec.md):蒸馏产 procedure 记忆,
+ * 高复用 procedure 晋升为技能(默认启用——质量闸已前移到真实复用数据)。
  *
  * Guards against proliferation:
  * - Project-level pattern repetition: same workflow signature must appear

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/run-history-store.d.ts

@@ -34,6 +34,8 @@ export interface RunNodeRecord {
     cacheHit?: boolean;
     /** Per-node disposition; "failed" with a surviving run = onError errorPort/continue (D32). */
     nodeStatus?: "completed" | "failed";
+    /** Engine-imposed limit surfaced on this node (e.g. a loop forced out at its iteration cap). */
+    warning?: string;
 }
 export interface RunHistoryEntry {
     runId: string;

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

@@ -59,6 +59,9 @@ export interface NodeRunStats {
     cacheHit: boolean;
     /** Final per-node disposition (errorPort/continue keep the run alive but mark failed). */
     status: "completed" | "failed";
+    /** Engine-imposed limit surfaced on this node (e.g. a loop forced out at its iteration cap) —
+     *  rendered into the run history so caps are visible in the run record, never silent. */
+    warning?: string;
 }
 export interface RunResult {
     status: "completed" | "failed" | "paused";
@@ -156,6 +159,11 @@ export declare class WorkflowRuntime {
     /** Loop entry: fire the "loop" port once to kick the first iteration. */
     private enterLoop;
     private decideLoopBack;
+    /** A loop forced out at its maxIterations cap (the scheduler marks error="loop_cap_reached:N",
+     *  which previously had NO consumer — the run just took the "done" port as if the loop finished
+     *  naturally). Surface it as a node-level warning: a warn log line + a trace entry the run history
+     *  renders (run-history-store.buildNodeRecords), so the engine-imposed cap is visible in the record. */
+    private surfaceLoopCap;
     /** Loop again? No condition → loop until the scheduler's maxIterations cap. */
     private evalLoopCondition;
     /** Collect inputs for a node from completed upstream outputs along forward data edges. */

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

@@ -243,6 +243,9 @@ export interface SoloSpecJudgeParams {
 export interface SoloSpecJudgeResult {
     ok: boolean;
     issues: string[];
+    /** True when ok=true came from a SKIPPED judgement (no LLM / judge call failed) — an unjudged
+     *  soft-gate pass, not a real "spec reviewed OK". Fail-open stays, but honestly labeled. */
+    judgeSkipped?: boolean;
 }
 /** x/workflow.chat RPC params(M4 自动化页对话式搭图/改图)。history 含到本轮的完整对话;
  *  currentWorkflow 为已有图的渲染文本(改图上下文,前端从 store 提供)。 */

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", "turn.memory_recall", "turn.memory_written", "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", "turn.memory_recall", "turn.memory_written", "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/gateway-rpc.d.ts

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

package/dist/types/protocol/wire/memory-provider-lifecycle.d.ts

@@ -58,6 +58,9 @@ export interface MemorySearchOptions {
     llmConfig?: MemoryLlmConfig;
     /** Categories to boost during reranking (e.g. ["lesson", "preference"]). */
     preferredCategories?: string[];
+    /** Drop hits whose tags contain ALL strings of any group (resident-layer exclusion:
+     * entries already injected verbatim via the global INDEX must not be recalled again). */
+    excludeTagGroups?: string[][];
 }
 export interface MemoryIngestOptions {
     llmConfig?: MemoryLlmConfig;

package/dist/types/protocol/wire/notification-payloads.d.ts

@@ -163,6 +163,22 @@ export interface TurnSuggestionsNotification {
         action?: string;
     }>;
 }
+/** Memory recall visibility (Part B): fired when turn-time recall injected memories,
+ * so the UI can render a "based on N memories" disclosure row (recall was invisible before). */
+export interface TurnMemoryRecallNotification {
+    sessionId: string;
+    turnId: string;
+    count: number;
+    /** Truncated texts of the memories actually injected (post-cap), for the expanded list. */
+    titles: string[];
+}
+/** Memory write visibility (Part B): fired on the synchronous agent-remember tool path.
+ * Dream/async consolidation deliberately does NOT emit this (it surfaces via next-turn recall). */
+export interface TurnMemoryWrittenNotification {
+    items: Array<{
+        title: string;
+    }>;
+}
 /** Sidechain started execution. */
 export interface TurnSidechainStartedNotification {
     turnId: string;
@@ -250,6 +266,15 @@ export interface TurnMediaPersistedNotification {
         bytes: number;
         mimeType: string;
     }>;
+    /**
+     * URLs that FAILED to persist locally this turn (result keeps the remote URL / dangling temp
+     * path, which may expire). Present only when at least one file failed — persistence stays
+     * fail-open, but the degradation is surfaced instead of silently swallowed.
+     */
+    failures?: Array<{
+        remoteUrl: string;
+        error?: string;
+    }>;
 }
 /** Task state change. */
 export interface TurnTaskUpdatedNotification {
@@ -1011,6 +1036,8 @@ export interface NotificationMethodMap {
     "turn.reasoning_delta": TurnReasoningDeltaNotification;
     "turn.plan_update": TurnPlanUpdateNotification;
     "turn.suggestions": TurnSuggestionsNotification;
+    "turn.memory_recall": TurnMemoryRecallNotification;
+    "turn.memory_written": TurnMemoryWrittenNotification;
     "turn.sidechain_started": TurnSidechainStartedNotification;
     "turn.subagent_delta": TurnSubagentDeltaNotification;
     "turn.sidechain_completed": TurnSidechainCompletedNotification;

package/dist/types/runtime/config/tunable-defaults.d.ts

@@ -143,6 +143,12 @@ export declare const TASK_PANEL_GRACE_MS = 30000;
 export declare const MEMORY_PREFETCH_MAX_SESSION_BYTES: number;
 /** Max results per memory recall query. */
 export declare const MEMORY_PREFETCH_LIMIT_PER_RECALL = 10;
+/** Min hybrid score for recall injection. The old 0.1 default was a no-op filter —
+ * top-10 got injected wholesale and weak matches crowded the per-turn byte budget. */
+export declare const MEMORY_RECALL_MIN_SCORE = 0.35;
+/** Adaptive cliff cutoff: stop taking results when the next score drops by more than
+ * this ratio vs the previous one (2 relevant hits -> inject 2, don't pad to 10). */
+export declare const MEMORY_RECALL_CLIFF_RATIO = 0.4;
 /** LRU dedup set size for surfaced memory entries. */
 export declare const MEMORY_MAX_SURFACED_ENTRIES = 100;
 /** Min hours between dream consolidation runs. */

package/dist/types/runtime/execution/memory-decay.d.ts

@@ -49,8 +49,12 @@ export interface DecayCycleDeps {
     };
 }
 export interface DecayCycleResult {
-    /** Whether decay actually ran (false = skipped by gate). */
+    /** Whether decay actually ran (false = skipped by gate OR failed — see `failed`). */
     ran: boolean;
+    /** True when the cycle was ATTEMPTED and errored — distinguishes a failure from a cooldown skip. */
+    failed?: boolean;
+    /** Failure reason, present when failed=true. */
+    error?: string;
     /** Number of memories whose importance was reduced. */
     decayed: number;
     /** Number of memories archived (below threshold). */

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/hooks/context-compression.d.ts

@@ -8,6 +8,11 @@ export declare function estimateTokens(msg: CompressibleMessage): number;
 export declare function estimateTotalTokens(messages: CompressibleMessage[]): number;
 export declare function getCompressionMetrics(): import("../context/context-compression-strategies.js").CompressionMetricsSnapshot;
 export declare function getContextEngineRegistry(): ContextEngineRegistry;
+/**
+ * Prefixed onto the sync fallback when the LLM summarize call failed — the model
+ * (and anyone reading the compressed history) must know this stretch is low-fidelity.
+ */
+export declare const DEGRADED_SUMMARY_MARKER = "[summary degraded: LLM summarization failed]";
 /**
  * Create a summarization callback using an injected LLM transport.
  * For CLI mode: uses the same transport that powers the agent loop.

package/dist/types/runtime/hooks/memory-hooks.d.ts

@@ -25,6 +25,16 @@ export interface MemoryHooksDeps {
     getLastAssistantMessage?: () => string | undefined;
     /** Background LLM for implicit extraction. If provided, enables Layer 2. */
     llmExtract?: (prompt: string) => Promise<string | null>;
+    /** Part B write visibility: forwards turn.memory_written on auto-extract commits. */
+    sendNotification?: (method: string, params: Record<string, unknown>) => void;
+    /** V3.2 usage 仪表:procedure 复用的 session 维度与负反馈计数落盘目录。 */
+    profileMemoryDir?: () => string;
+    /** V3.2: tag marking a distilled procedure memory (recall filter). cli injects so runtime never imports skills. */
+    procedureTag?: string;
+    /** V3.2: record distilled procedures recalled this turn (positive reuse signal). cli-injected. */
+    recordProcedureRecalls?: (procedureIds: string[], sessionId: string) => void;
+    /** V3.2: record negative feedback against distilled procedures (failed turn). cli-injected. */
+    recordProcedureNegatives?: (procedureIds: string[]) => void;
 }
 /** Session-scoped state for dedup and byte budget (CC parity). */
 export interface MemoryPrefetchState {

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

@@ -155,6 +155,9 @@ export declare function assembleBackendDescriptor(backend: AcpBackendConfig, cli
 export declare function assembleCustomAgentDescriptor(custom: CustomAgentDef, cliPath: string | null, hasConfig: boolean): AgentDescriptor;
 export declare class AcpDetector {
     private cache;
+    /** Last scan that COMPLETED, surviving clearCache() and failed rescans. list() prefers this
+     *  over an empty [] so a transient probe failure never reads as "no agents installed". */
+    private lastGoodScan;
     private configStore;
     private keySources;
     /** Shared in-flight async scan so concurrent scanAsync() callers (startup warm + a racing RPC)
@@ -188,6 +191,11 @@ export declare class AcpDetector {
      * Return cached results without IO. 冷缓存时后台预热（scanAsync）并返回 []，
      * 绝不在 RPC 路径上同步 scan —— 同步探测（11-18s+）会饿死单线程引擎循环
      * （x/product.confirm 60s 超时的根因）。调用方按"稍后再查"处理空列表。
+     *
+     * A background-scan failure is reported (console.error), never swallowed: a swallowed
+     * failure made list() return [] forever and downstream (product planning) treated
+     * "scan failed" as "no agents installed". When the fresh cache is gone but an older
+     * scan succeeded, that stale-but-real result is returned instead of [].
      */
     list(): AgentDescriptor[];
     /** Clear the detection cache. */

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
@@ -108,6 +114,8 @@ export declare class AcpProtocolAdapter {
     private child;
     private onNotification;
     private hostHandler;
+    /** Sessions whose session/set_model FAILED — running on the agent's default model, not the managed one. */
+    private modelMismatches;
     /**
      * Attach to a child process's stdio for ACP communication.
      * Constructs the official ClientSideConnection over the child's stdin/stdout. The connection's
@@ -137,6 +145,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).
@@ -165,12 +174,20 @@ export declare class AcpProtocolAdapter {
      * error is the backstop). Uses the generic sendRequest because the SDK has no typed set_model yet.
      */
     private selectSessionModel;
+    /**
+     * The recorded session/set_model failure for a session, if any — the session is alive but on
+     * the agent's DEFAULT model instead of the managed/platform one (wrong vendor/billing/capability).
+     */
+    getModelMismatch(sessionId: string): {
+        desired: string;
+        error: string;
+    } | undefined;
     /**
      * 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.
@@ -190,3 +207,4 @@ export declare class AcpProtocolAdapter {
      */
     static translateNotification(method: string, params: unknown): TranslatedNotification | null;
 }
+export {};

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

@@ -291,6 +291,12 @@ export declare class AgentProcessManager {
      * Uses the ACP protocol adapter for lifecycle management.
      */
     private spawnAcpAgent;
+    /**
+     * Surface a recorded session/set_model failure: the session is alive but runs the agent's
+     * DEFAULT model instead of the managed/platform one (wrong vendor/billing/capability). Same
+     * agents.error channel as the other spawn/restart failures.
+     */
+    private reportModelMismatch;
     private syncNativeMcpConfig;
     /** Kill a specific child agent process. */
     kill(memberId: string): void;

package/dist/types/runtime/infra/astraclaw-capabilities.d.ts

@@ -8,6 +8,15 @@ export interface AstraClawCapabilityToolInput {
     availableToolNames?: Iterable<string>;
     currentEnvironment?: string;
     toolCatalog?: ToolCatalog;
+    /**
+     * Configured MCP servers serving NO tools this session (invalid config / connect failure).
+     * Disclosed in mcp_connectors_list so a failed server is visibly missing, not silently absent.
+     */
+    mcpServerFailures?: Array<{
+        name: string;
+        phase?: string;
+        error: string;
+    }>;
 }
 export type AstraClawCapabilityToolResult = {
     handled: false;

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