qlogicagent 2.18.2 → 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/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/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

@@ -33,6 +33,10 @@ export interface ProductCallbacks {
     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: {

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/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;

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

@@ -60,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
@@ -88,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

@@ -5,6 +5,10 @@ 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. */
@@ -44,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 {
@@ -85,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/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/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/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 提供)。 */