qlogicagent 2.20.2 → 2.20.4

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

@@ -168,6 +168,8 @@ export interface TurnSuggestionsNotification {
 export interface TurnMemoryRecallNotification {
     sessionId: string;
     turnId: string;
+    /** How the single Host retrieval chain was entered. */
+    source: "automatic" | "tool";
     count: number;
     /** Truncated texts of the memories actually injected (post-cap), for the expanded list. */
     titles: string[];
@@ -191,6 +193,20 @@ export interface TurnSubagentDeltaNotification {
     subagentId?: string;
     text: string;
 }
+export type TurnSubagentActivityStatus = "running" | "completed" | "failed" | "blocked";
+/** Tool-level sub-agent progress. Never carries hidden reasoning or raw model chain-of-thought. */
+export interface TurnSubagentActivityNotification {
+    turnId: string;
+    parentTurnId: string;
+    subagentId: string;
+    agentType: string;
+    displayName: string;
+    activityId?: string;
+    toolName?: string;
+    conciseStatus: string;
+    status: TurnSubagentActivityStatus;
+    observedAt: string;
+}
 /** Sidechain completed execution. */
 export interface TurnSidechainCompletedNotification {
     turnId: string;
@@ -306,7 +322,7 @@ export interface TurnTodosUpdatedNotification {
 export interface TurnExecProgressNotification {
     output: string;
     elapsedTimeSeconds: number;
-    totalLines: number;
+    visibleLines: number;
     totalBytes: number;
 }
 /**
@@ -557,6 +573,27 @@ export interface SoloEvaluationNotification {
     soloId: string;
     winnerId: string;
     reasoning: string;
+    /** Present (true) only on the solo.select adoption event; absent on the auto-judge recommendation. */
+    adopted?: boolean;
+    /** displayId of the agent that acted as judge (trust caveat when it is also a racer). */
+    judgedBy?: string;
+    /** True when an independent, non-competing agent judged the race. */
+    judgeExternal?: boolean;
+    /** True when the verdict is a fallback (judge failed / unparseable) — flag for manual review. */
+    degraded?: boolean;
+}
+/** Full unified diff of one competitor's worktree, emitted when a turn settles (initial run or
+ *  follow-up). Carries the same capped diff the judge scores, so the user sees what the judge sees. */
+export interface SoloAgentDiffNotification {
+    soloId: string;
+    agentId: string;
+    diff: string;
+}
+/** Run-level Solo state transition (e.g. entering/leaving "evaluating"), so the UI can show the
+ *  auto-judge phase instead of a silent gap between all-done and the verdict. */
+export interface SoloStateNotification {
+    soloId: string;
+    state: "running" | "evaluating" | "completed" | "failed" | "cancelled";
 }
 /** Solo agent streaming delta. */
 export interface SoloAgentDeltaNotification {
@@ -611,6 +648,17 @@ export interface ProductBudgetWarningNotification {
     maxTotalTokens: number;
     percentage: number;
 }
+/**
+ * Product budget hard limit hit (100%) — the run auto-paused. The counterpart of the 80% warning, and
+ * the louder of the two: the run has stopped. `maxTotalTokens` is absent for a time-only budget, so
+ * `reason` is what states WHICH ceiling tripped.
+ */
+export interface ProductBudgetExceededNotification {
+    productId: string;
+    usedTokens: number;
+    maxTotalTokens?: number;
+    reason: string;
+}
 /** Product completed (all tasks done or terminal). */
 export interface ProductCompletedNotification {
     productId: string;
@@ -777,8 +825,14 @@ export interface ProjectUnarchivedNotification {
 /** A sub-agent was spawned. */
 export interface TurnSubagentStartedNotification {
     turnId: string;
+    parentTurnId: string;
     subagentId: string;
     agentType: string;
+    displayName: string;
+    delegatedTask: string;
+    mode: "foreground" | "background";
+    startedAt: string;
+    /** @deprecated Use delegatedTask. */
     prompt?: string;
 }
 /** A sub-agent finished. */
@@ -790,6 +844,41 @@ export interface TurnSubagentEndedNotification {
     outputPreview?: string;
     error?: string;
 }
+export interface TurnSubagentEvidenceItem {
+    source: "tool" | "artifact" | "verification";
+    label: string;
+    status: "passed" | "failed" | "observed";
+}
+export interface TurnSubagentTokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    totalTokens: number;
+}
+/** Canonical terminal lifecycle event for foreground and background sub-agents. */
+export interface TurnSubagentCompletedNotification {
+    turnId: string;
+    parentTurnId: string;
+    subagentId: string;
+    agentType: string;
+    displayName: string;
+    status: "completed" | "failed" | "cancelled";
+    resultSummary?: string;
+    evidence: TurnSubagentEvidenceItem[];
+    toolsUsed: string[];
+    durationMs: number;
+    tokenUsage: TurnSubagentTokenUsage;
+    error?: string;
+    finishedAt: string;
+}
+/** Explicit parent synthesis decision; absence remains truthfully "pending", never inferred. */
+export interface TurnSubagentDecisionNotification {
+    turnId: string;
+    parentTurnId: string;
+    subagentId: string;
+    decision: "adopted" | "partially_adopted" | "rejected";
+    summary?: string;
+    decidedAt: string;
+}
 /** A task lifecycle state changed. */
 export interface TaskUpdatedNotification {
     taskId: string;
@@ -930,9 +1019,12 @@ export interface NotificationMethodMap {
     "turn.memory_written": TurnMemoryWrittenNotification;
     "turn.sidechain_started": TurnSidechainStartedNotification;
     "turn.subagent_delta": TurnSubagentDeltaNotification;
+    "turn.subagent_activity": TurnSubagentActivityNotification;
     "turn.sidechain_completed": TurnSidechainCompletedNotification;
     "turn.subagent_started": TurnSubagentStartedNotification;
     "turn.subagent_ended": TurnSubagentEndedNotification;
+    "turn.subagent_completed": TurnSubagentCompletedNotification;
+    "turn.subagent_decision": TurnSubagentDecisionNotification;
     "turn.annotations": TurnAnnotationsNotification;
     "turn.media_result": TurnMediaResultNotification;
     "turn.media_progress": TurnMediaProgressNotification;
@@ -968,11 +1060,14 @@ export interface NotificationMethodMap {
     "solo.evaluation": SoloEvaluationNotification;
     "solo.agentDelta": SoloAgentDeltaNotification;
     "solo.agentUsage": SoloAgentUsageNotification;
+    "solo.agentDiff": SoloAgentDiffNotification;
+    "solo.state": SoloStateNotification;
     "product.taskStarted": ProductTaskStartedNotification;
     "product.taskCompleted": ProductTaskCompletedNotification;
     "product.taskFailed": ProductTaskFailedNotification;
     "product.checkpointed": ProductCheckpointedNotification;
     "product.budgetWarning": ProductBudgetWarningNotification;
+    "product.budgetExceeded": ProductBudgetExceededNotification;
     "product.completed": ProductCompletedNotification;
     "product.dagTopology": ProductDagTopologyNotification;
     "product.budgetUpdate": ProductBudgetUpdateNotification;

package/dist/types/protocol/wire/web-capability.d.ts

@@ -1,4 +1,4 @@
-export declare const WEB_CAPABILITY_ID_VALUES: readonly ["web_search", "web_fetch", "deep_research", "browser_execution"];
+export declare const WEB_CAPABILITY_ID_VALUES: readonly ["web_search", "web_fetch", "web_research", "browser_execution"];
 export type WebCapabilityId = (typeof WEB_CAPABILITY_ID_VALUES)[number];
 export declare const WEB_CAPABILITY_FAMILY_VALUES: readonly ["web-intelligence", "browser-execution"];
 export type WebCapabilityFamily = (typeof WEB_CAPABILITY_FAMILY_VALUES)[number];
@@ -16,7 +16,7 @@ export declare const TOOL_RISK_LEVEL_VALUES: readonly ["read", "write", "system"
 export type ToolRiskLevel = (typeof TOOL_RISK_LEVEL_VALUES)[number];
 export declare const WEB_ACTION_SCOPE_VALUES: readonly ["read-page", "read-authenticated-page", "fill-form", "submit-form", "download-file", "reuse-session"];
 export type WebActionScope = (typeof WEB_ACTION_SCOPE_VALUES)[number];
-export declare const WEB_DEGRADATION_TARGET_VALUES: readonly ["web_search", "web_fetch", "deep_research", "blocked"];
+export declare const WEB_DEGRADATION_TARGET_VALUES: readonly ["web_search", "web_fetch", "web_research", "blocked"];
 export type WebDegradationTarget = (typeof WEB_DEGRADATION_TARGET_VALUES)[number];
 export declare const WEB_ESCALATION_REASON_VALUES: readonly ["requires-interaction", "requires-login-state", "requires-rendered-dom", "requires-persistent-session", "requires-state-changing-action"];
 export type WebEscalationReason = (typeof WEB_ESCALATION_REASON_VALUES)[number];

package/dist/types/runtime/community/community-consent-client.d.ts

@@ -1,4 +1,5 @@
 import type { ConfigPort } from "../ports/index.js";
+import type { HostCommunityClient } from "../../transport/host-community-client.js";
 export interface CommunityRuntimeResolution {
     id: string;
     platform: string;
@@ -62,4 +63,6 @@ export interface CommunityConsentClient {
     resolveRuntime(id: string, platform: string): Promise<CommunityRuntimeResolution>;
 }
 export declare function createCommunityConsentClient(options: CommunityConsentClientOptions): CommunityConsentClient;
+/** Supervised desktop path: the Runtime Host owns refresh and performs authenticated Hub reads. */
+export declare function createHostCommunityConsentClient(host: HostCommunityClient): CommunityConsentClient;
 export declare function createDefaultCommunityConsentClient(configPort?: ConfigPort): CommunityConsentClient | null;

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

@@ -220,12 +220,6 @@ export interface TunableDefaults {
     dreamCooldownMs: number;
     dreamMaxDurationMs: number;
     teamBudgetTokens: number;
-    braveApiKey: string;
-    exaApiKey: string;
-    serperApiKey: string;
-    searxngBaseUrl: string;
-    crawl4aiBaseUrl: string;
-    searchSvcBaseUrl: string;
 }
 /**
  * Snapshot of all current tunable values.

package/dist/types/runtime/execution/bounded-output-tail.d.ts

@@ -0,0 +1,7 @@
+export interface BoundedOutputTail {
+    output: string;
+    totalBytes: number;
+    truncated: boolean;
+}
+/** Read at most maxBytes from the end of an append-only UTF-8 output file. */
+export declare function readBoundedOutputTail(path: string, maxBytes: number): Promise<BoundedOutputTail>;

package/dist/types/runtime/execution/dream-agent.d.ts

@@ -205,8 +205,8 @@ export interface DreamRunDeps {
         search(query: string, userId: string, options?: {
             limit?: number;
         }): Promise<Array<{
-            blockId: string;
-            text: string;
+            id: string;
+            content: string;
             score: number;
         }>>;
         proposeExtracted?(items: Array<{
@@ -219,11 +219,14 @@ export interface DreamRunDeps {
         }): Promise<{
             proposalsAdded?: number;
         }>;
-        feedback?(memoryIds: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong"): Promise<{
+        feedback?(memoryIds: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong", context?: {
+            sessionId?: string;
+            silent?: boolean;
+        }): Promise<{
             affected: number;
         }>;
         /** Recent activity summary for temporal context injection into Dream.
-         * B3(X7)异步化:16 面 host-state proxy 方法(host 模式经 x/host.request 跨进程)。 */
+         * B3(X7)异步化:Host 契约方法(host 模式经 x/host.request 跨进程)。 */
         getActivitySummary?(userId: string, days?: number): Promise<{
             dailyCounts: Array<{
                 date: string;
@@ -238,7 +241,7 @@ export interface DreamRunDeps {
         }>;
         /** Synthesize a timeline narrative for a time range. B3(X7)异步化。 */
         synthesizeTimeline?(userId: string, startMs: number, endMs: number): Promise<string>;
-        /** Get/set user profile entries. B3(X7):setProfile/getAllProfiles 异步化(16 面);getProfile 面外保持同步。 */
+        /** Get/set user profile entries. B3(X7):setProfile/getAllProfiles 异步化;getProfile 为本地同步读取。 */
         getProfile?(userId: string, key: string): string | null;
         setProfile?(userId: string, key: string, value: string): Promise<void>;
         getAllProfiles?(userId: string): Promise<Record<string, string>>;

package/dist/types/runtime/execution/dream-category-context.d.ts

@@ -1,8 +1,8 @@
-import type { QMemoryCategory } from "../memory/categories.js";
+import type { LongTermMemoryCategory } from "../../host-contract/memory-category.js";
 /** A memory file with its inferred category and metadata. */
 export interface CategorizedMemoryFile {
     filename: string;
-    category: QMemoryCategory | "uncategorized";
+    category: LongTermMemoryCategory | "uncategorized";
     /** First line description. */
     description: string;
     /** File size bytes. */
@@ -36,7 +36,7 @@ export declare function scanCategoryManifest(memoryRoot: string): Promise<Catego
  * - patterns: merge (consolidate duplicates into one authoritative entry)
  * - decisions: update (add "update" section if decision changed)
  */
-export declare const CATEGORY_MERGE_RULES: Record<QMemoryCategory | "uncategorized", string>;
+export declare const CATEGORY_MERGE_RULES: Record<LongTermMemoryCategory | "uncategorized", string>;
 /**
  * Format the category manifest and merge rules as an injection block
  * for the dream consolidation prompt.

package/dist/types/runtime/execution/structured-tool-progress.d.ts

@@ -0,0 +1,21 @@
+export declare const STRUCTURED_TOOL_PROGRESS_PREFIX = "::xiaozhiclaw-progress-v1::";
+export interface StructuredToolProgressEvent {
+    source: string;
+    stage: string;
+    elapsedMs: number;
+    heartbeat: boolean;
+    completed?: number;
+    total?: number;
+    unit?: string;
+}
+export interface ExtractedStructuredToolProgress {
+    cleanOutput: string;
+    events: StructuredToolProgressEvent[];
+}
+/**
+ * Extracts the shared, producer-neutral progress envelope from process output.
+ * Unknown sources and stages are accepted when they use bounded public tokens;
+ * malformed or extended records remain visible as ordinary command output.
+ */
+export declare function extractStructuredToolProgress(output: string): ExtractedStructuredToolProgress;
+export declare function formatStructuredToolProgress(event: StructuredToolProgressEvent): string;

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

@@ -1,6 +1,6 @@
 import type { HookRegistry } from "../../contracts/hooks.js";
 import type { MemoryProvider } from "../ports/memory-provider.js";
-import type { MemoryWriter } from "../ports/memory-writer.js";
+import type { MemoryExtractionQueue, MemoryWriter } from "../ports/memory-writer.js";
 import type { MemoryRecallSource } from "../ports/memory-recall-source.js";
 export declare const MEMORY_PREFETCH_CONFIG: {
     readonly MAX_SESSION_BYTES: number;
@@ -12,12 +12,13 @@ export declare const MEMORY_PREFETCH_CONFIG: {
  * skills/memory/task-distillation PROCEDURE_TAG (runtime cannot import skills
  * per the architecture boundary; task-distillation.test.ts asserts equality).
  */
-export declare const PROCEDURE_TAG_FALLBACK = "distilled@v1";
 export interface MemoryHooksDeps {
     /** QMemory adapter (MemoryProvider with search/health). */
     memoryProvider?: MemoryProvider;
     /** Local memory provider for direct writes (auto-extract). */
     localMemoryProvider?: MemoryWriter;
+    /** Host-owned durable hand-off for completed turns awaiting semantic extraction. */
+    memoryExtractionQueue?: MemoryExtractionQueue;
     /** User ID for memory lookups. */
     userId: string;
     /** Logger. */
@@ -30,22 +31,33 @@ export interface MemoryHooksDeps {
     /** Access to last assistant response (for implicit extraction). Set externally per turn. */
     getLastAssistantMessage?: () => string | undefined;
     /** Background LLM for implicit extraction. If provided, enables Layer 2. */
-    llmExtract?: (prompt: string) => Promise<string | null>;
+    llmExtract?: (prompt: string, signal?: AbortSignal) => Promise<string | null>;
+    /** Shared process lane: queues learning work and aborts it for foreground turns. */
+    scheduleBackgroundMemoryWork(label: string, work: (signal: AbortSignal) => Promise<void>): Promise<boolean>;
     /** 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 维度与负反馈计数落盘目录。 */
-    /** V3.2: tag marking a distilled procedure memory (recall filter). cli injects so runtime never imports skills. */
-    procedureTag?: string;
+    /** Tag marking a distilled procedure memory. CLI injects it to preserve the runtime/skills boundary. */
+    procedureTag: string;
     /** V3.2: record distilled procedures whose text reached the prompt (positive reuse signal). cli-injected.
      * [A7] Called from memory.after_recall with the post-cap injected subset — NOT from
      * before_recall: search hits the model never saw must not build promotion evidence. */
-    recordProcedureRecalls?: (procedureIds: string[], sessionId: string) => void;
+    recordProcedureRecalls(procedureIds: string[], sessionId: string): void;
     /** V3.2: record negative feedback against distilled procedures (failed turn). cli-injected. */
-    recordProcedureNegatives?: (procedureIds: string[]) => void;
+    recordProcedureNegatives(procedureIds: string[]): void;
     /** [A7] Host-side access ledger (memories.access_count/last_accessed_at): report the L2 ids
      * actually injected this turn. cli-injected (fire-and-forget; Host stays the single writer —
      * search() no longer counts hits, so skipping this call means the memory goes uncounted). */
-    recordInjectedAccess?: (memoryIds: string[]) => void;
+    recordInjectedAccess(memoryIds: string[], context: {
+        sessionId: string;
+        turnId: string;
+    }): void;
+    /** Host-owned recall outcome ledger. Best-effort accounting must never block a turn. */
+    recordRecallOutcome(input: {
+        sessionId: string;
+        turnId: string;
+        event: "used" | "helped" | "harmed" | "unattributed";
+    }): void;
 }
 /** Session-scoped state for dedup and byte budget (CC parity). */
 export interface MemoryPrefetchState {

package/dist/types/runtime/infra/background-tasks.d.ts

@@ -42,6 +42,8 @@ export interface StartAgentTaskOptions {
      * background work that session spawned). Keyed by session — turn ids don't
      * cross the client/agent boundary, session ids do. */
     launchSessionId?: string;
+    /** Parent/root turn that owns this background task. */
+    launchTurnId?: string;
     /**
      * Idle (no-progress) reclaim window (ms): the task is force-failed as `timeout`
      * only after `idleMs` with no progress signal — an actively-producing task is
@@ -58,6 +60,8 @@ export interface RegisterBashTaskOptions {
     label?: string;
     pid?: number;
     handle: BashTaskHandle;
+    launchSessionId?: string;
+    launchTurnId?: string;
 }
 export interface TaskOutputSnapshot {
     task: TaskState;
@@ -168,7 +172,7 @@ export declare class BackgroundTaskManager {
      * superseded-turn abort or a natural turn-end, which leave background tasks
      * running. Returns the ids actually cancelled.
      */
-    cancelTasksForSession(sessionId: string): string[];
+    cancelTasksForSession(sessionId: string, parentTurnId?: string): string[];
     /** Cancel every non-terminal task (session teardown). Returns cancelled ids. */
     cancelAllRunning(): string[];
 }

package/dist/types/runtime/infra/cloud-auth-host-authority.d.ts

@@ -0,0 +1,4 @@
+import type { HostCloudAuthClient } from "../../transport/host-cloud-auth-client.js";
+/** Process-lifetime binding installed after ACP Host capability negotiation. */
+export declare function configureHostCloudAuthAuthority(resolver: () => HostCloudAuthClient | undefined): void;
+export declare function getHostCloudAuthAuthority(): HostCloudAuthClient | undefined;

package/dist/types/runtime/infra/llmrouter-access-token.d.ts

@@ -9,5 +9,4 @@ export interface LlmrouterFetchResult {
     refreshedToken: boolean;
 }
 export declare function isJwtExpiredOrNearExpiry(token: string | undefined, skewSeconds?: number): boolean;
-export declare function refreshLlmrouterAccessToken(baseUrl: string, options?: Pick<LlmrouterFetchOptions, "fetchFn" | "signal">): Promise<boolean>;
 export declare function fetchWithLlmrouterAccess(path: string, options?: LlmrouterFetchOptions): Promise<LlmrouterFetchResult>;

package/dist/types/runtime/infra/subagent-turn-snapshot.d.ts

@@ -0,0 +1,32 @@
+import type { TurnSubagentActivityNotification, TurnSubagentCompletedNotification, TurnSubagentDecisionNotification, TurnSubagentStartedNotification } from "../../protocol/wire/notification-payloads.js";
+export interface PersistedSubagentSnapshot {
+    subagentId: string;
+    agentType: string;
+    displayName?: string;
+    delegatedTask?: string;
+    mode?: "foreground" | "background";
+    status: "running" | "completed" | "failed" | "cancelled";
+    activities?: Array<{
+        activityId?: string;
+        toolName?: string;
+        conciseStatus: string;
+        status: "running" | "completed" | "failed" | "blocked";
+        observedAt: string;
+    }>;
+    toolsUsed?: string[];
+    resultSummary?: string;
+    evidence?: TurnSubagentCompletedNotification["evidence"];
+    durationMs?: number;
+    tokenUsage?: TurnSubagentCompletedNotification["tokenUsage"];
+    decision?: "pending" | "adopted" | "partially_adopted" | "rejected";
+    decisionSummary?: string;
+    error?: string;
+    startedAt?: string;
+    finishedAt?: string;
+}
+export declare function recordSubagentStarted(payload: TurnSubagentStartedNotification): PersistedSubagentSnapshot;
+export declare function recordSubagentActivity(payload: TurnSubagentActivityNotification): PersistedSubagentSnapshot;
+export declare function recordSubagentCompleted(payload: TurnSubagentCompletedNotification): PersistedSubagentSnapshot;
+export declare function recordSubagentDecision(payload: TurnSubagentDecisionNotification): PersistedSubagentSnapshot | undefined;
+export declare function subagentActivityBlock(snapshot: PersistedSubagentSnapshot): Record<string, unknown>;
+export declare function clearSubagentTurnSnapshotsForTests(): void;

package/dist/types/runtime/infra/turn-telemetry-store.d.ts

@@ -1,3 +1,4 @@
+import type { HostDelegationTelemetrySummary } from "../../host-contract/index.js";
 export type AgentMode = "chat" | "solo" | "product" | "workflow" | "unknown";
 export interface TurnTelemetryUsage {
     inputTokens?: number;
@@ -27,6 +28,7 @@ export interface TurnTelemetrySnapshot {
     usage?: TurnTelemetryUsage;
     toolSummary?: TurnTelemetryToolSummary;
     fileContext?: TurnTelemetryFileContext;
+    delegationSummary?: HostDelegationTelemetrySummary;
     createdAt: string;
     finalizedAt?: string;
 }
@@ -38,6 +40,26 @@ export type TurnTelemetryPatch = Partial<Omit<TurnTelemetrySnapshot, "turnId" |
  * same turnId record. Safe to call before the projectId is known; the first call seeds it.
  */
 export declare function recordTurnTelemetry(turnId: string, patch: TurnTelemetryPatch): void;
+export declare function recordTurnDelegationStarted(input: {
+    turnId: string;
+    subagentId: string;
+    agentType: string;
+    mode: "foreground" | "background";
+}): void;
+export declare function recordTurnDelegationCompleted(input: {
+    turnId: string;
+    subagentId: string;
+    agentType: string;
+    status: "completed" | "failed" | "cancelled";
+    durationMs: number;
+    totalTokens: number;
+}): void;
+export declare function recordTurnDelegationDecision(input: {
+    turnId: string;
+    subagentId: string;
+    decision: "adopted" | "partially_adopted" | "rejected";
+}): void;
+export declare function recordTurnArgumentCorrections(turnId: string, argumentCorrections: HostDelegationTelemetrySummary["argumentCorrections"]): void;
 /**
  * Flush the accumulated telemetry for a turn to disk and drop it from memory. Returns null
  * (after dropping the in-memory record) when no projectId resolved — telemetry, like the turn

package/dist/types/runtime/memory/implicit-extraction.d.ts

@@ -6,19 +6,30 @@
  *   Layer 2: Lightweight LLM pass (async, non-blocking) — extracts structured facts
  *
  * This runs AFTER turn.end, so the user already has their response.
- * Layer 2 fires only for turns with detectable signals. The often-quoted
- * "~10-20% of turns" was calibrated on general chat; this product's corpus is
- * engineering conversation, and the signal table is deliberately narrowed for
- * it (see the [B14] calibration note above SIGNAL_PATTERNS).
+ * With a semantic extractor configured, every completed user turn is eligible
+ * for the bounded Layer 2 pass. The regex detector is only a conservative
+ * no-model fallback and must remain independent of evaluation vocabulary.
  *
  * Reference: claude-code src/services/extractMemories/extractMemories.ts
  */
 import type { MemoryWriter } from "../ports/memory-writer.js";
+import { type LongTermMemoryCategory, type MemoryClaimRelation } from "../../host-contract/memory-category.js";
 export interface ExtractedFact {
     text: string;
-    category: "personal_fact" | "preference" | "event" | "lesson" | "pattern" | "decision";
+    /** Exact evidence span copied from the current user message; never assistant prose. */
+    evidenceQuote: string;
+    /** True only when this atomic fact replaces or cancels prior state. */
+    correction?: boolean;
+    category: LongTermMemoryCategory;
     importance: number;
+    confidence: number;
     eventDate?: string;
+    evidenceKind: "direct_user_statement" | "inference";
+    scope: "global" | "project" | "session";
+    entity: string;
+    predicate: string;
+    relation: MemoryClaimRelation;
+    value: Record<string, unknown>;
 }
 export interface ImplicitExtractionDeps {
     /** Local memory provider for writing extracted facts. */
@@ -34,9 +45,14 @@ export interface ImplicitExtractionDeps {
      * LLM invocation function (uses background/cheap model).
      * Returns structured JSON string or null if unavailable.
      */
-    llmExtract?: (prompt: string) => Promise<string | null>;
+    llmExtract?: (prompt: string, signal?: AbortSignal) => Promise<string | null>;
+    signal?: AbortSignal;
+    sessionId?: string;
+    /** Durable Host extraction-job id used to make preemption/restart replay idempotent. */
+    idempotencyNamespace?: string;
 }
 export interface TurnPair {
+    priorUserMessage?: string;
     userMessage: string;
     assistantMessage: string;
 }
@@ -51,7 +67,7 @@ export declare function hasExtractionSignal(userMessage: string): boolean;
  * Layer 2: Use a lightweight LLM to extract structured facts from a turn pair.
  * Only called when Layer 1 signals are detected.
  */
-export declare function extractFactsViaLlm(turn: TurnPair, llmExtract: (prompt: string) => Promise<string | null>, today: string): Promise<ExtractedFact[]>;
+export declare function extractFactsViaLlm(turn: TurnPair, llmExtract: (prompt: string) => Promise<string | null>, today: string, onDiagnostic?: (message: string) => void): Promise<ExtractedFact[]>;
 /**
  * Run the full implicit extraction pipeline for a completed turn.
  * This is async and non-blocking — call it after turn.end.

package/dist/types/runtime/ports/agent-runtime-ports.d.ts

@@ -1,10 +1,6 @@
 import type { HookRegistry } from "../../contracts/hooks.js";
 import type { OpenAiToolCall } from "./tool-call-contracts.js";
 import type { AgentLogger, ToolDefinition, ToolInvoker } from "./agent-execution-contracts.js";
-export interface RecallCategoryHint {
-    preferred: string[];
-    deprioritized: string[];
-}
 export interface RuntimeCompressibleMessage {
     role: string;
     content?: string | unknown;
@@ -76,6 +72,5 @@ export interface ToolLoopRuntimePorts {
 }
 export interface AgentRuntimePorts {
     toolLoop: ToolLoopRuntimePorts;
-    detectRecallCategories(query: string): RecallCategoryHint;
     resolveModelForPurpose(purpose: "smallModel" | string): string | null;
 }

package/dist/types/runtime/ports/index.d.ts

@@ -1,4 +1,4 @@
-export type { MemoryWriter, MemoryWriteMetadata } from "./memory-writer.js";
+export type { MemoryExtractionQueue, MemoryWriter, MemoryWriteMetadata, } from "./memory-writer.js";
 export type { MemoryRecallSource } from "./memory-recall-source.js";
 export type { MemoryProvider, MemorySearchOptions, MemorySearchResult, MemoryIngestOptions, MemoryExtractionItem, MemoryConsolidationWriteResult, MemoryLearningSink, MemoryToolLocalProvider, MemoryActivitySummary, MemoryAtlasRecord, MemoryAtlasResult, MemoryUpdatePatch, MemoryHandlerProvider, MemoryDreamProvider, MemoryDecayProvider, MemoryRuntimeHookProvider, MemoryToolProvider, MemoryDreamRuntimeProvider, } from "./memory-provider.js";
 export type { PathService } from "./path-service.js";
@@ -11,9 +11,8 @@ export type { RuntimeToolContract, ToolBootstrap, ToolBootstrapConfig, ToolBoots
 export { defineToolRegistrationModule } from "./tool-contracts.js";
 export type { Checkpoint, CheckpointBackend, CheckpointResult } from "./checkpoint-contracts.js";
 export type { WorktreeBackend, WorktreeInfo, WorktreeResult } from "./worktree-contracts.js";
-export type { WebSearchBackend, WebSearchOutput, WebSearchResult } from "./web-search-contracts.js";
 export { buildToolResultMessage, type OpenAiToolCall, type ToolResultMessageInput } from "./tool-call-contracts.js";
 export type { AgentLogger, AgentRunRequest, ChatMessage, ForkedAgentRunner, ForkedAgentRunnerFactory, HookRegistry, TokenUsage, ToolDefinition, ToolInvoker, TurnEvent, } from "./agent-execution-contracts.js";
 export type { AccumulatedToolCall, LLMChunk, LLMRequest, LLMTransport, } from "./model-transport-contracts.js";
 export { accumulateToolCalls } from "./model-transport-contracts.js";
-export type { AgentRuntimePorts, ContextCompressionEnginePort, RecallCategoryHint, RuntimeCompressibleMessage, RuntimeCompressionResult, StreamingToolExecutorPort, StreamingToolExecutorPortConfig, ToolExecutionResultPort, ToolLoopRuntimePorts, } from "./agent-runtime-ports.js";
+export type { AgentRuntimePorts, ContextCompressionEnginePort, RuntimeCompressibleMessage, RuntimeCompressionResult, StreamingToolExecutorPort, StreamingToolExecutorPortConfig, ToolExecutionResultPort, ToolLoopRuntimePorts, } from "./agent-runtime-ports.js";