qlogicagent 2.18.1 → 2.18.3

package/dist/types/agent/tool-loop/budget-continuation-policy.d.ts

@@ -10,6 +10,10 @@ export interface BudgetContinuationPolicyInput {
     thinkingBlocks: readonly ThinkingBlock[];
     getBudgetContinuationMessage(usagePct: number, totalUsed: number, tokenBudget?: number): string;
     log: Pick<AgentLogger, "info">;
+    /** The loop's per-turn recovery trace (surfaced on the final `end` event). Stop
+     * reasons are recorded here as `budget_continuation_stop:<reason>` so an engine-side
+     * end of nudging is visible to callers/UI, not only in the debug log. */
+    recoveryTrace?: Map<string, number>;
 }
 export interface BudgetContinuationPolicyDecision {
     messages: unknown[];

package/dist/types/agent/tool-loop/completion-action-policy.d.ts

@@ -17,7 +17,15 @@ export interface CompletionActionPolicyDecision {
     transition: ToolLoopTransition;
 }
 export declare function findMissingExplicitRequiredFiles(inputMessages: readonly ChatMessage[], messages: unknown[]): string[];
-export declare function buildExplicitRequiredFilesFailureContent(input: {
+/**
+ * Terminal-path NOTE (not a replacement): when a forced stop ends the turn with
+ * explicitly-requested output files still missing, this returns an engine-attributed
+ * note to APPEND to whatever the turn is already ending with. It used to return a
+ * "<FAIL-marker> ..." string that REPLACED the model's final text — an extraction
+ * misfire then handed the user an engine-authored FAIL verdict the model never made
+ * (2026-07-07 review, F5). The engine reports evidence; it does not speak as the model.
+ */
+export declare function buildMissingRequiredFilesNote(input: {
     inputMessages: readonly ChatMessage[];
     messages: unknown[];
     reason: string;

package/dist/types/agent/tool-loop/compression-pipeline.d.ts

@@ -30,6 +30,8 @@ export interface CompressionPipelineDeps {
         turnId: string;
     };
     sessionId: string;
+    /** Turn workspace/cwd — routes oversized tool-result spillover to the session's reachable data dir. */
+    projectRoot: string | undefined;
     currentModel: string;
     log: AgentLogger;
     /** Build + record a recovery event (centralized in the loop's recovery trace). */

package/dist/types/agent/tool-loop/loop-helpers.d.ts

@@ -1,5 +1,6 @@
 import type { ChatMessage } from "../types.js";
 export { isEmptyToolResult } from "./tool-result-classification.js";
+export declare const OUTPUT_REQUEST_CONTEXT_PATTERN: RegExp;
 export declare function findLastToolError(messages: unknown[], _toolName: string): string | undefined;
 export declare function looksLikeBuildRequest(messages?: readonly ChatMessage[]): boolean;
 export declare function isBareIntentPreamble(text: string): boolean;

package/dist/types/agent/tool-loop/tool-failure-policy.d.ts

@@ -5,7 +5,18 @@ export interface VariantBlockedToolCall {
     failCount: number;
     error: string;
 }
-export declare function splitVariantToolCalls(calls: readonly OpenAiToolCall[], toolFailureCounts: ReadonlyMap<string, number>): {
+export declare function splitVariantToolCalls(calls: readonly OpenAiToolCall[], toolFailureCounts: ReadonlyMap<string, number>, 
+/**
+ * Exact call signatures (name::rawArguments) that were variant-blocked at least once and are
+ * eligible for ONE deliberate re-assertion pass. Mutated in place: blocking a call registers
+ * its signature; a verbatim re-issue consumes it and runs. The engine cannot tell "another
+ * variation of the failed thing" from "a genuinely different task in the same family"
+ * (e.g. `pip install A` failing twice must not condemn `pip install C` forever) — so the
+ * MODEL's insistence after seeing the warning is the judgment call. A variation-cycling loop
+ * never re-issues verbatim, so it stays blocked; verbatim spam is capped separately by the
+ * identical-call-repeat guard.
+ */
+reassertedSignatures: Set<string>): {
     allowed: OpenAiToolCall[];
     blocked: VariantBlockedToolCall[];
 };
@@ -15,6 +26,7 @@ export declare function recordToolFailureResult(input: {
     toolName: string;
     toolArguments?: string;
     ok: boolean;
+    /** True when the tool succeeded but returned an empty/no-match result. Kept for caller clarity. */
     softEmpty: boolean;
 }): void;
 export declare function newVariantFailureNudges(input: {

package/dist/types/agent/tool-loop.d.ts

@@ -39,6 +39,14 @@ export interface ToolLoopParams {
     modelMaxOutputTokens?: number;
     /** Tool choice strategy (default "auto") */
     toolChoice?: "auto" | "none" | "required";
+    /**
+     * The turn's request demands fresh tool evidence (file read / command run / media generated).
+     * The prompt section instructs it; this flag arms the loop's REACTIVE one-shot forced retry
+     * when the model answers in prose with zero tool calls anyway. Replaces the retired upstream
+     * tool_choice="required" forcing (judgment-over-mechanism: hint first, force only on the
+     * observed violation).
+     */
+    freshEvidenceRequired?: boolean;
     /**
      * Build/test verification gate (lever ②). Default true. Set false to disable the
      * "fix-and-rerun until the test/build passes" recovery — used for A/B measurement.

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

@@ -124,6 +124,8 @@ export interface TurnConfig {
     modelMaxOutputTokens?: number;
     /** Tool choice strategy: "auto" (default), "none", "required" */
     toolChoice?: "auto" | "none" | "required";
+    /** Turn demands fresh tool evidence — arms the loop's reactive one-shot forced retry. */
+    freshEvidenceRequired?: boolean;
     /** Parent fork depth (0 = top-level, default 0). CC: depth tracking for fork recursion limit. */
     parentDepth?: number;
     /** Per-turn token budget (prompt + completion). 0 or undefined = unlimited. */

package/dist/types/cli/credential-vault.d.ts

@@ -24,6 +24,12 @@ export interface CredentialSummary {
     updatedAt: string;
     /** Secret-free hints for pickers (e.g. apiKey header name, oauth2 scopes). */
     meta?: Record<string, unknown>;
+    /**
+     * Set when the on-disk envelope could not be read/parsed. The entry is unusable (get()
+     * throws) but stays VISIBLE in list() so the list-driven UI shows the loss instead of the
+     * credential silently vanishing; delete works on it.
+     */
+    corrupt?: true;
 }
 /**
  * Secret payload shapes by type (validated on create):

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

@@ -4,6 +4,9 @@
  */
 import { type ModelPurpose } from "../../runtime/infra/model-registry.js";
 import { type UnderstandMediaClient, type UnderstandMediaKind } from "../media-understanding.js";
+import { type InstructionFileInfo } from "../../runtime/prompt/instruction-loader.js";
+import type { HookRegistry } from "../../contracts/hooks.js";
+import type { AppendMessageOutcome } from "../../runtime/session/session-transcript-store.js";
 import type { PermissionMetadataResolver, ToolCatalog } from "../../runtime/ports/index.js";
 import type { ChatMessage, TokenUsage, ToolDefinition, TurnConfig } from "../../agent/types.js";
 import type { AgentRpcRequest } from "../../protocol/wire/agent-rpc.js";
@@ -59,6 +62,40 @@ export interface FirstTurnTitleGenerationDeps {
     log(message: string): void;
 }
 export declare function runFirstTurnTitleGeneration(deps: FirstTurnTitleGenerationDeps): Promise<void>;
+/**
+ * Loud trace for fire-and-forget background persistence work inside the turn pipeline.
+ * Replaces the old silent `.catch(() => {})` pattern (judgment-over-mechanism: a failed write
+ * must at least be diagnosable in the engine log, never swallowed).
+ */
+export declare function logTurnBackgroundFailure(context: string, err: unknown): void;
+/**
+ * Per-turn transcript-persist failure reporter. A lost transcript write means the conversation is
+ * missing messages after a reload — that must be VISIBLE: console.error every failure with turn
+ * context, and emit ONE `turn.recovery` notification per turn (first failure only) so the user is
+ * told without flooding the stream when several writes of the same turn fail.
+ * "skipped-deleted" is the legal late-write no-op on a deleted session — not a failure, no trace.
+ */
+export declare function createTranscriptPersistFailureReporter(deps: {
+    turnId: string;
+    sessionId: string;
+    sendNotification(method: string, params: Record<string, unknown>): void;
+}): (which: string, outcome: AppendMessageOutcome | {
+    rejected: unknown;
+}) => void;
+/**
+ * Load the INSTRUCTIONS.md / project-rules block for a turn. A load failure means the WHOLE turn
+ * runs without the user's standing rules — the old inline catch called that "non-fatal" and left
+ * zero trace. Degrading is still the right call (the turn can proceed), but it must be visible:
+ * console.error + a `turn.recovery` note in the turn event stream.
+ * `loadInstructions` is injectable so tests can force a failure; defaults to getInstructions.
+ */
+export declare function loadInstructionBlockForTurn(deps: {
+    cwd: string;
+    turnId: string;
+    hooks?: HookRegistry;
+    sendNotification(method: string, params: Record<string, unknown>): void;
+    loadInstructions?(cwd: string, hooks?: HookRegistry): Promise<InstructionFileInfo[]>;
+}): Promise<string | undefined>;
 export declare function hydrateTurnConfigFromModelMetadata(config: TurnConfig): TurnConfig;
 export declare function hydrateAttachmentReferenceUrlsForTurn(messages: ChatMessage[]): ChatMessage[];
 export declare function getFocusedAttachmentToolNamesForTurn(messages: ChatMessage[]): Set<string> | null;
@@ -85,8 +122,20 @@ export declare function augmentLastUserMessageContent(messages: ChatMessage[], m
  * invisible to those user-intent scans. The original array/objects are never mutated.
  */
 export declare function injectSkillContextBeforeLastUser(messages: ChatMessage[], skillContext: string): ChatMessage[];
+/**
+ * Insert the per-turn DOMAIN guidance block as a SYSTEM-role message immediately BEFORE the
+ * last user message (LLM view only) — the prompt-cache alignment path.
+ *
+ * Same rationale as injectSkillContextBeforeLastUser: the domain block carries markdown headers
+ * ("# Doing Tasks"), the word "artifact", and example file paths — baking it into the user message
+ * would poison the user-intent scans (final-marker extraction, artifact counting, round/tool
+ * budgets) that read `role === "user"` content. A system message keeps the model bound to the
+ * guidance while staying invisible to those scans. Kept out of the system PROMPT so a domain
+ * switch never re-encodes the byte-stable prefix or the conversation history. The original
+ * array/objects are never mutated.
+ */
+export declare function injectDomainGuidanceBeforeLastUser(messages: ChatMessage[], domainGuidance: string): ChatMessage[];
 export declare function getFocusedAttachmentModelPurposeForTurn(messages: ChatMessage[]): FocusedAttachmentModelPurpose | null;
-export declare function requiresPreToolPreambleForTurn(messages: readonly ChatMessage[]): boolean;
 export declare function refreshPermissionCheckerToolMeta(permissionChecker: PermissionMetadataResolver | null | undefined, tools: ToolDefinition[]): void;
 export declare function handleUserResponse(this: TurnControlHandlerHost, msg: AgentRpcRequest): void;
 /**

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

@@ -152,6 +152,7 @@ export declare function collectActiveIntentWorkflows(this: WorkflowCoordinatorHo
     trigger: Extract<NonNullable<WorkflowRecord["trigger"]>, {
         type: "intent";
     }>;
+    sideEffectKinds: string[];
 }>>;
 /**
  * `workflow.intentIndex` — the deterministic-match index the CLIENT consumes (phrases/aliases/

package/dist/types/cli/memory-coordinator.d.ts

@@ -25,6 +25,10 @@ export interface RegisterMemoryRuntimeHooksDeps {
         apiKey: string;
         model: string;
     } | null;
+    /** Part B recall visibility: forwards turn.memory_recall to the client. */
+    sendNotification?: (method: string, params: Record<string, unknown>) => void;
+    /** V3.2 usage 仪表落盘目录(memory-hooks 记录 procedure 复用维度)。 */
+    profileMemoryDir?: () => string;
 }
 export declare function registerMemoryRuntimeHooks(deps: RegisterMemoryRuntimeHooksDeps): MemoryProviderState;
 export interface RegisterMemoryToolDeps {

package/dist/types/cli/pet-runtime.d.ts

@@ -23,6 +23,8 @@ export interface PetdexForgeOutput {
     spritesheet: Buffer;
     validation: PetdexValidationReport;
     productionRun?: PetdexProductionRun;
+    /** Jobs accepted WITHOUT a working vision-QA verdict (QA call failed → fail-open, but traced). */
+    qaSkippedJobs?: string[];
     mediaUsage?: {
         provider: string;
         model: string;

package/dist/types/cli/rpc-registry.d.ts

@@ -36,7 +36,18 @@ export type RpcMethodHandler = (msg: AgentRpcRequest) => void;
  * The pattern mirrors the existing createDreamHandlerHost / createMultiAgentHandlerHost
  * adapters, just applied uniformly across every RPC domain.
  */
+export interface TaskDistillationRpcSurface {
+    runPass(reason: "manual"): Promise<object>;
+    listProposals(): unknown[];
+    dismissProposal(id: string): boolean;
+    acknowledgeProposal(id: string): boolean;
+    getMetrics(): object;
+    promote(id: string): Promise<object>;
+    demote(id: string): Promise<object>;
+}
 export interface RpcHandlerHosts {
+    /** R3/V3 蒸馏晋升面(惰性:首调时构造 coordinator)。 */
+    getTaskDistillation?: () => TaskDistillationRpcSurface;
     config: ConfigHandlerHost;
     control: ControlHandlerHost;
     session: SessionHandlerHost;

package/dist/types/cli/runtime-hook-bootstrap.d.ts

@@ -28,6 +28,8 @@ export interface RuntimeHookBootstrapDeps {
         apiKey: string;
     };
     sendNotification?(method: string, params: Record<string, unknown>): void;
+    /** V3.2 usage 仪表落盘目录。 */
+    profileMemoryDir?: () => string;
 }
 export interface RuntimeHookBootstrapResult {
     hooks: HookRegistry;

package/dist/types/cli/skill-tools-bootstrap.d.ts

@@ -26,3 +26,8 @@ export declare function configureSkillToolsBootstrap(host: SkillToolsHost, deps:
  * content path, never the raw supporting-file write).
  */
 export declare function resolveSupportingFilePath(skillDir: string, filePath: string): string | null;
+/**
+ * 读技能文件:ENOENT(文件不存在)→ null(语义 = 技能/文件未安装);其余失败
+ * (EPERM/EISDIR 等)抛出真实错误 —— 读失败不能伪装成"技能不存在"。导出仅为单测。
+ */
+export declare function readSkillFileOrNull(label: string, filePath: string): Promise<string | null>;

package/dist/types/cli/stdio-acp-request-host.d.ts

@@ -16,6 +16,7 @@ export type StdioAcpRequestHostSource = Pick<CliAcpRequestHandlerHost, "activeTu
     petRuntime: unknown;
     projectMemoryStoreFactory: unknown;
     toolCatalog: unknown;
+    taskDistillation: unknown;
     cancelBackgroundTasksForSession(sessionId?: string): void;
     configureTurnMedia(config: Record<string, unknown> | undefined, turnId: string): void;
     drainPendingTaskNotifications(): string[];
@@ -25,5 +26,5 @@ export type StdioAcpRequestHostSource = Pick<CliAcpRequestHandlerHost, "activeTu
 };
 /** Host members the shared turn pipeline reads/writes — keep in sync with
  * `grep -oE "this\.[a-zA-Z]+" src/cli/handlers/turn-handler.ts | sort -u`. */
-export declare const TURN_PIPELINE_HOST_MEMBERS: readonly ["activeTurn", "configureTurnMedia", "currentHooks", "currentModel", "currentTurnId", "drainPendingTaskNotifications", "getActiveProjectRoot", "lastAssistantMessageForExtract", "lastUserMessageForAutoExtract", "log", "mcpReady", "memdir", "pendingAskUser", "permissionChecker", "petRuntime", "projectMemoryStoreFactory", "resolveAgent", "resolveClientForPurpose", "sendNotification", "sendResponse", "sessionHistory", "sessionState", "setActiveWorkdir", "toolCatalog"];
+export declare const TURN_PIPELINE_HOST_MEMBERS: readonly ["activeTurn", "configureTurnMedia", "currentHooks", "currentModel", "currentTurnId", "drainPendingTaskNotifications", "getActiveProjectRoot", "lastAssistantMessageForExtract", "lastUserMessageForAutoExtract", "log", "mcpReady", "memdir", "pendingAskUser", "permissionChecker", "petRuntime", "projectMemoryStoreFactory", "resolveAgent", "resolveClientForPurpose", "sendNotification", "sendResponse", "sessionHistory", "sessionState", "setActiveWorkdir", "taskDistillation", "toolCatalog"];
 export declare function createStdioAcpRequestHandlerHost(host: StdioAcpRequestHostSource): CliAcpRequestHandlerHost;

package/dist/types/cli/stdio-rpc-handler-hosts.d.ts

@@ -10,6 +10,7 @@ type DirectStdioRpcHost = RpcHandlerHosts["config"] & RpcHandlerHosts["control"]
     readonly workflowHandlerHost: RpcHandlerHosts["workflow"];
 };
 type StdioRpcAdapterSource = DirectStdioRpcHost & {
+    ensureTaskDistillation(): import("./rpc-registry.js").TaskDistillationRpcSurface;
     activeTurn: RpcHandlerHosts["turn"]["activeTurn"];
     currentSessionId: NonNullable<RpcHandlerHosts["session"]["currentSessionId"]>;
     currentModel: NonNullable<RpcHandlerHosts["session"]["currentModel"]>;

package/dist/types/cli/stdio-server.d.ts

@@ -8,6 +8,7 @@
  * Protocol: each message is a single JSON-RPC 2.0 object.
  * The physical I/O layer is abstracted via the Transport interface.
  */
+import { TaskDistillationCoordinator } from "./task-distillation-coordinator.js";
 import type { Transport } from "./transport.js";
 import type { Agent } from "../agent/agent.js";
 import type { TurnConfig } from "../agent/types.js";
@@ -195,6 +196,9 @@ export declare class StdioServer {
      * Opening the DB is cheap and side-effect-free (list() does not embed).
      */
     ensureMemoryProvider(): void;
+    private _taskDistillation;
+    get taskDistillation(): TaskDistillationCoordinator;
+    ensureTaskDistillation(): TaskDistillationCoordinator;
     resolveAgent(config: TurnConfig): Agent | null;
     private invalidateResolvedLlmCache;
     /** Emit an `agents.status` notification when a child process state changes. */

package/dist/types/cli/task-distillation-coordinator.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Task distillation coordinator (R3 wiring) — 候选采集/空闲窗蒸馏/晋升通知。
+ * 纯逻辑在 skills/memory/task-distillation.ts;本模块只做依赖装配与生命周期:
+ *   · recordTurn: turn-handler 回合完成处调用(轻量,embedding 异步)
+ *   · runPass:   idle 空闲窗(stdio-server onIdle 并联)与 memory.distill RPC 共用入口
+ *   · 蒸馏产物: category=procedure 进长期记忆(tag distilled@v1+sig),召回自然带出;
+ *     LLM 摘要(dream 同款小模型)失败时降级确定性模板 —— 蒸馏永不因模型不可用而丢样本。
+ *   · 晋升(spec:唯一技能入口): accessCount ≥ 阈值且未被负反馈沉底 → system.activity 推荐。
+ */
+import { type PromotionMetrics, type CandidateStoreFile, type PromotionProposal } from "../skills/memory/task-distillation.js";
+export interface TaskDistillationDeps {
+    profileMemoryDir: () => string;
+    /** 签名 embedding;null=不可用(候选照存但不参与聚类,宁严勿松) */
+    embed: (text: string) => Promise<Float32Array | null>;
+    /** 落库:返回是否成功(候选只在成功后标 distilled) */
+    addProcedure: (text: string, tags: string[]) => Promise<boolean>;
+    /** 小模型摘要(dream 同款);null/失败 → 降级模板 */
+    llmExtract?: (prompt: string) => Promise<string | null>;
+    /** 晋升扫描数据源:全部 distilled 条目 {id,text,accessCount,importance} */
+    listDistilled: () => Promise<Array<{
+        id: string;
+        text: string;
+        accessCount: number;
+        importance: number;
+    }>>;
+    /** V3 promote/demote:archive(技能接棒)/unarchive(降格回归) */
+    setMemoryArchived: (id: string, archived: boolean) => boolean;
+    sendNotification: (method: string, params: Record<string, unknown>) => void;
+    log: (message: string) => void;
+}
+export interface RecordTurnInput {
+    sessionId: string;
+    promptHead: string;
+    toolSequence: string[];
+    durationMs: number;
+    ok: boolean;
+}
+export interface DistillPassResult {
+    distilled: number;
+    promotionsNotified: number;
+    pendingCandidates: number;
+}
+export declare class TaskDistillationCoordinator {
+    private readonly deps;
+    private readonly turnIndexBySession;
+    /** 已通知过晋升的条目(进程内防重复打扰;跨重启重复通知无害) */
+    private readonly promotionNotified;
+    constructor(deps: TaskDistillationDeps);
+    /** 回合完成时采集候选。异步(embedding 网络调用),错误吞掉不碰回合主链。 */
+    recordTurn(input: RecordTurnInput): Promise<void>;
+    /** 空闲窗/手动共用的蒸馏 pass。 */
+    runPass(reason: "idle" | "manual"): Promise<DistillPassResult>;
+    private renderProcedure;
+    /** 晋升扫描(spec:技能的唯一产生入口):复用达标且未被负反馈沉底 → 写持久提议。
+     * V3.1:提议是持久待办(promotion-proposals.json),UI 双入口消费;activity 仅作日志。 */
+    private scanPromotions;
+    listProposals(): PromotionProposal[];
+    /** V3.2 仪表(接受率/降格率/自动档解锁态);技能激活计数由 skill-lifecycle useCount 承载。 */
+    getMetrics(): PromotionMetrics;
+    /** 自动升格开场确认卡「知道了」。 */
+    acknowledgeProposal(procedureId: string): boolean;
+    dismissProposal(procedureId: string): boolean;
+    /** 升格执行链:配方→SKILL.md(LLM 格式转换,降级模板)→落盘+lifecycle(默认启用)
+     * →procedure archive(技能接棒,拍板①)→proposal accepted。 */
+    promote(procedureId: string, opts?: {
+        auto?: boolean;
+    }): Promise<{
+        ok: boolean;
+        skillName?: string;
+        error?: string;
+    }>;
+    /** 降格(可撤销是信任基础):删技能+unarchive 回 procedure;proposal 置 dismissed(用户明确否定,不再纠缠)。 */
+    demote(procedureId: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    private renderSkillMarkdown;
+}
+export declare function buildCandidateStoreSnapshot(profileMemoryDir: string): CandidateStoreFile;

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

@@ -32,3 +32,27 @@ export declare function registerLocalCoreTools(context: LocalCoreToolRegistratio
 export declare function validateExecCommand(command: string, workdir: string, groupMode?: boolean): string | null;
 /** office/pdf 文档扩展名 → mime;非文档返回 undefined。导出仅为单测。 */
 export declare function documentMimeForExtension(ext: string): string | undefined;
+export interface RipgrepGrepOutcome {
+    matches: Array<{
+        path: string;
+        line: number;
+        text: string;
+    }>;
+    truncated: boolean;
+    /** Model-facing incompleteness note (search tool appends it to content). */
+    note?: string;
+}
+/**
+ * Map an rg execFile exit to a grep outcome. Returns null for real errors (caller
+ * rejects and falls back to native grep). When rg was killed (30s timeout or the
+ * 10MB maxBuffer cap) the stdout is a partial result set cut mid-stream: it must be
+ * flagged truncated with a model-visible note — otherwise the model treats a
+ * mid-flight kill as the complete match set. Exported for unit tests only.
+ */
+export declare function resolveRipgrepOutcome(err: (Error & {
+    killed?: boolean;
+    code?: number | string | null;
+}) | null, stdout: string, options: {
+    headLimit?: number;
+    offset?: number;
+}): RipgrepGrepOutcome | null;

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

@@ -27,8 +27,6 @@ export interface TurnCoreAgent {
 export interface TurnCoreHooks {
     /** Invoked for every side event handled by `forwardTurnSideEvent` (e.g. tool-call accounting). */
     onSideEvent?: (event: TurnEvent) => void;
-    /** Transform assistant content before it is emitted in `turn.end` (e.g. literal-response requirements). */
-    transformContent?: (content: string) => string;
     /** Extra work after `turn.end` is emitted (usage tracking, `turn.usage_update`, transcript persistence). */
     onEnd?: (event: Extract<TurnEvent, {
         type: "end";
@@ -37,10 +35,6 @@ export interface TurnCoreHooks {
     onError?: (event: Extract<TurnEvent, {
         type: "error";
     }>) => void;
-    /** Handle a `skill_instruction` event (notify + auto-persist). */
-    onSkillInstruction?: (event: Extract<TurnEvent, {
-        type: "skill_instruction";
-    }>) => void;
 }
 export interface TurnCoreResult {
     content: string;

package/dist/types/cli/turn-project-router.d.ts

@@ -13,6 +13,15 @@ export interface TurnProjectRoutingResult {
     sessionProjectId?: string;
     projectHintStale: boolean;
     staleProjectHintContext?: StaleProjectHintContext;
+    /**
+     * Set when the turn's config CARRIES a projectId that could not be resolved to a registered
+     * project. The caller must treat this as fatal for the turn (reject it) — silently falling back
+     * to the active project root would run every file read/write of the turn in the WRONG workspace
+     * (docs/judgment-over-mechanism.md: failures must be visible, never silently degraded).
+     * A session with NO projectId at all (legacy session) is NOT an error — it legitimately anchors
+     * to the active project (sessionProjectRoot) and only leaves a host.log trace.
+     */
+    projectResolutionError?: string;
 }
 export declare function routeTurnProjectContext(params: {
     config?: Record<string, unknown>;

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

@@ -123,6 +123,9 @@ export interface HookContextMap {
     };
     "memory.after_recall": HookTurnContext & {
         blockCount?: number;
+        recalledSummaries?: string[];
+        injectedCount?: number;
+        droppedCount?: number;
     };
     "subagent.started": HookSubagentContext;
     "subagent.stopped": HookSubagentContext;

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

@@ -21,6 +21,14 @@ export type SkillInstruction = SkillCreateInstruction | SkillImproveInstruction;
 export type TurnEvent = {
     type: "start";
     turnId: string;
+    /**
+     * Effective per-turn budgets (rounds / total tool calls) after engine caps and
+     * intent-based floors. Echoed at turn start so gateways/UIs can see the ceiling
+     * the loop actually runs under — a caller request silently clamped to the hard
+     * cap would otherwise be an invisible engine-imposed limit.
+     */
+    effectiveMaxRounds?: number;
+    effectiveMaxToolCalls?: number;
 } | {
     type: "delta";
     turnId: string;
@@ -47,10 +55,6 @@ export type TurnEvent = {
     error: string;
     code?: string;
     usage?: WireTokenUsage;
-} | {
-    type: "skill_instruction";
-    turnId: string;
-    instruction: SkillInstruction;
 } | {
     type: "tool_result";
     turnId: string;

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

@@ -28,10 +28,15 @@ 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;
     onBudgetWarning?: (productId: string, usedTokens: number, maxTotalTokens: number, percentage: number) => void;
+    /** Budget hard limit hit → the run auto-paused. The 100% counterpart of onBudgetWarning (80%): the
+     *  warning notified the user while the actual auto-pause was log-only — the strongest budget
+     *  intervention must be at least as loud as its warning. `reason` says WHICH limit tripped. */
+    onBudgetExceeded?: (productId: string, usedTokens: number, maxTotalTokens: number | undefined, reason: string) => void;
     onCompleted?: (productId: string, summary: string, phase: Extract<ProductPhase, "completed" | "failed">) => void;
     /** DAG topology resolved and sent to client for visualization. */
     onDagTopology?: (productId: string, nodes: {
@@ -83,7 +88,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).
      *

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/context/reactive-compact.d.ts

@@ -12,8 +12,6 @@
  * - Tool delta re-injection (new/removed tools since last compact)
  */
 export interface ReactiveCompactConfig {
-    /** Maximum consecutive auto-compact failures before giving up (CC: 3). */
-    maxConsecutiveFailures: number;
     /** Minimum messages to keep after reactive compact. */
     minMessagesAfterCompact: number;
     /** Target token usage after compact (percentage of context window). */
@@ -50,8 +48,6 @@ export interface PostCompactRestorationPayload {
  */
 export declare function buildPostCompactRestorationMessage(payload: PostCompactRestorationPayload): string | null;
 export interface ReactiveCompactState {
-    /** Number of consecutive compact failures. */
-    consecutiveFailures: number;
     /** Whether reactive compact has been attempted in this turn. */
     attemptedThisTurn: boolean;
     /** Last compact timestamp. */
@@ -61,9 +57,11 @@ export interface ReactiveCompactState {
 }
 export declare function createReactiveCompactState(): ReactiveCompactState;
 /**
- * Determine if reactive compact should be attempted.
+ * Determine if reactive compact should be attempted. The once-per-turn latch is the
+ * real loop guard; there is intentionally no failure counter (a zombie counter that
+ * nothing incremented used to live here).
  */
-export declare function shouldAttemptReactiveCompact(state: ReactiveCompactState, config?: ReactiveCompactConfig): boolean;
+export declare function shouldAttemptReactiveCompact(state: ReactiveCompactState): boolean;
 /**
  * Calculate the tool delta since last compact.
  */

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,7 +11,7 @@ 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;
@@ -50,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/error-handling/retry-loop.d.ts

@@ -1,25 +1,3 @@
-export declare function executeBoundedRetryLoop<TResult>(params: {
-    maxIterations: number;
-    onRetryLimit: (params: {
-        iterations: number;
-        maxIterations: number;
-    }) => Promise<TResult> | TResult;
-    executeIteration: (params: {
-        iteration: number;
-    }) => Promise<{
-        kind: "continue";
-    } | {
-        kind: "return";
-        result: TResult;
-    }>;
-}): Promise<TResult>;
-export declare function resolveScaledRetryIterations(params: {
-    candidateCount: number;
-    baseIterations?: number;
-    perCandidateIterations?: number;
-    minIterations?: number;
-    maxIterations?: number;
-}): number;
 export declare function isForegroundSource(source: string | undefined): boolean;
 /** Is this a transient capacity error (429 or 529/overloaded)? */
 export declare function isTransientCapacityError(status: number | undefined): boolean;