qlogicagent 2.20.2 → 2.20.3

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

package/dist/types/runtime/ports/memory-provider.d.ts

@@ -1,22 +1,19 @@
 import type { MemoryWriter } from "./memory-writer.js";
+import type { MemoryClaimRelation } from "../../host-contract/memory-category.js";
 export interface MemorySearchOptions {
     limit?: number;
-    minScore?: number;
-    preferredCategories?: string[];
     llmConfig?: unknown;
+    /** Foreground-turn identity. When present, Host records every considered
+     * candidate and applies the task-relevance injection decision. */
+    recallContext?: {
+        sessionId: string;
+        turnId: string;
+    };
     /** Drop hits whose tags contain ALL strings of any group (resident-layer exclusion). */
     excludeTagGroups?: string[][];
 }
 export interface MemorySearchResult {
-    blockId: string;
-    /** [A8] REQUIRED — host guarantees id === blockId on every search hit. When id/content
-     * were optional, the {blockId,text} ↔ {id,path,content} drift silently type-checked:
-     * the LRU dedup key was always "" (dedup dead) and byte accounting always 0. */
     id: string;
-    /** Historical field: L2 hits never carry a path (kept optional for legacy readers). */
-    path?: string;
-    text: string;
-    /** [A8] REQUIRED — host guarantees content === text on every search hit (see id). */
     content: string;
     score: number;
     source?: string;
@@ -26,6 +23,8 @@ export interface MemoryIngestOptions {
     llmConfig?: unknown;
     source?: string;
     sessionId?: string;
+    /** Transport-only cancellation; adapters must not serialize this into Host business params. */
+    requestSignal?: AbortSignal;
 }
 export interface MemoryExtractionItem {
     text: string;
@@ -35,6 +34,14 @@ export interface MemoryExtractionItem {
     source?: string;
     event_date?: string;
     tags?: string[];
+    /** Atomic claim identity produced by the evidence extractor and validated again by Host. */
+    claim?: {
+        scope: "global" | "project" | "session";
+        entity: string;
+        predicate: string;
+        relation: MemoryClaimRelation;
+        value: Record<string, unknown>;
+    };
     /** Ids of already-uploaded attachments to link to this memory on commit. */
     attachmentIds?: string[];
     /** Evidence trail for distillation-style sources (feedback — §10): audit refs + crash-safe dedup key. */
@@ -43,6 +50,8 @@ export interface MemoryExtractionItem {
         refs: string[];
         idempotencyKey: string;
     };
+    /** The source turn explicitly retracts or replaces an earlier decision. */
+    correction?: boolean;
 }
 export interface MemoryConsolidationWriteResult {
     memoriesAdded?: number;
@@ -77,9 +86,12 @@ export interface MemoryToolLocalProvider {
         category?: string;
         importance?: number;
     }): Promise<unknown>;
-    /** B3(X7)异步化:16 面 host-state proxy 方法(host 模式经 x/host.request 跨进程)。 */
+    /** B3(X7)异步化:Host 契约方法(host 模式经 x/host.request 跨进程)。 */
     synthesizeTimeline(userId: string, startMs: number, endMs: number): Promise<string>;
-    feedback(ids: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong"): Promise<{
+    feedback(ids: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong", context?: {
+        sessionId?: string;
+        silent?: boolean;
+    }): Promise<{
         affected: number;
     }>;
 }
@@ -138,9 +150,9 @@ export interface MemoryUpdatePatch {
     tags?: string[];
 }
 export interface MemoryHandlerProvider extends MemoryProvider {
-    /** B3(X7)异步化:16 面 host-state proxy 方法(host 模式经 x/host.request 跨进程)。 */
+    /** B3(X7)异步化:Host 契约方法(host 模式经 x/host.request 跨进程)。 */
     getAtlas?(userId: string, options?: Record<string, unknown>): Promise<MemoryAtlasResult>;
-    /** B3(X7)异步化:16 面 host-state proxy 方法。 */
+    /** B3(X7)异步化:Host 契约方法。 */
     getActivitySummary?(userId: string, days: number): Promise<MemoryActivitySummary>;
     observeExtracted?(items: MemoryExtractionItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationWriteResult>;
     proposeExtracted?(items: MemoryExtractionItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationWriteResult>;
@@ -201,10 +213,13 @@ export interface MemoryDreamProvider {
     }): 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;
     }>;
-    /** B3(X7)异步化:以下四个 16 面 host-state proxy 方法签名统一 Promise(host 模式经 x/host.request 跨进程)。 */
+    /** B3(X7)异步化:以下 Host 契约方法签名统一 Promise(host 模式经 x/host.request 跨进程)。 */
     getActivitySummary?(userId: string, days?: number): Promise<MemoryActivitySummary>;
     synthesizeTimeline?(userId: string, startMs: number, endMs: number): Promise<string>;
     getProfile?(userId: string, key: string): string | null;

package/dist/types/runtime/ports/memory-writer.d.ts

@@ -1,21 +1,70 @@
+import type { HostMemoryExtractionTurnInput, HostPendingMemoryExtractionTurn, MemoryClaimRelation } from "../../host-contract/index.js";
 export interface MemoryWriteMetadata {
     source?: string;
     category?: string;
     importance?: number;
     eventDate?: string;
+    sessionId?: string;
     [key: string]: unknown;
 }
+export interface StructuredMemoryClaim {
+    scope: "global" | "project" | "session";
+    entity: string;
+    predicate: string;
+    relation: MemoryClaimRelation;
+    value: Record<string, unknown>;
+}
+export interface MemoryWriterExtractionItem {
+    text: string;
+    category?: string;
+    importance?: number;
+    confidence?: number;
+    event_date?: string;
+    tags?: string[];
+    claim?: StructuredMemoryClaim;
+    evidence?: {
+        kind: string;
+        refs: string[];
+        idempotencyKey: string;
+    };
+    /** The source turn explicitly retracts or replaces an earlier decision. */
+    correction?: boolean;
+}
 export interface MemoryWriter {
     addText(text: string, userId: string, metadata?: MemoryWriteMetadata): Promise<unknown>;
-    proposeExtracted?(items: Array<{
-        text: string;
-        category?: string;
-        importance?: number;
-    }>, userId: string, metadata?: MemoryWriteMetadata): Promise<{
+    ingestExtracted?(items: MemoryWriterExtractionItem[], userId: string, metadata?: MemoryWriteMetadata): Promise<{
+        memoriesAdded?: number;
+        items?: Array<{
+            outcome: "created" | "merged" | "conflicted" | "pending" | "rejected";
+        }>;
+    }>;
+    proposeExtracted?(items: MemoryWriterExtractionItem[], userId: string, metadata?: MemoryWriteMetadata): Promise<{
         proposalsAdded?: number;
     }>;
     findRelatedEvents?(text: string, userId: string): Promise<Array<{
         id: string;
     }>>;
-    feedback?(ids: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong"): Promise<unknown>;
+    feedback?(ids: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong", context?: {
+        sessionId?: string;
+        silent?: boolean;
+    }): Promise<unknown>;
+}
+export interface MemoryExtractionQueue {
+    enqueueExtractionTurn(input: HostMemoryExtractionTurnInput, userId: string): Promise<{
+        jobId: string;
+        created: boolean;
+    }>;
+    claimPendingExtractionTurns(userId: string, workerId: string, options?: {
+        limit?: number;
+        leaseMs?: number;
+    }): Promise<HostPendingMemoryExtractionTurn[]>;
+    completeExtractionTurn(jobId: string, userId: string, workerId: string): Promise<{
+        deleted: boolean;
+    }>;
+    releaseExtractionTurn(jobId: string, userId: string, workerId: string): Promise<{
+        released: boolean;
+    }>;
+    recordExtractionTurnFailure(jobId: string, userId: string, workerId: string, error: string): Promise<{
+        updated: boolean;
+    }>;
 }

package/dist/types/runtime/ports/permission-contracts.d.ts

@@ -116,6 +116,8 @@ export interface PermissionRuleEnginePort {
     setMode(mode: PermissionMode): void;
     getRules(): readonly PermissionRuleEntry[];
     replaceRules(rules: PermissionRuleEntry[]): void;
+    /** Session-approved writable roots used by the OS sandbox projection. */
+    getAllowedWriteDirectories?(): string[];
 }
 export interface PermissionApprovalResolver {
     resolveApproval(response: ApprovalResponse): void;

package/dist/types/runtime/ports/tool-contracts.d.ts

@@ -48,8 +48,9 @@ export interface ToolCatalog {
 }
 export interface ToolBootstrapProgress {
     output: string;
+    progressSnapshot: string;
     elapsedTimeSeconds: number;
-    totalLines: number;
+    visibleLines: number;
     totalBytes: number;
 }
 export interface ToolBootstrapConfig {
@@ -65,6 +66,7 @@ export interface ToolBootstrapConfig {
     };
     getTaskScopeKey?(): string | undefined;
     getCurrentTurnId?(): string | undefined;
+    isGroupSecurityMode?(): boolean;
     sendNotification?(method: string, params: Record<string, unknown>): void;
     onExecProgress?(progress: ToolBootstrapProgress): void;
     /** Lazy host-owned tunable overrides; web registration must not call it until first invoke. */

package/dist/types/runtime/prompt/identity-section.d.ts

@@ -13,5 +13,7 @@ export interface IdentityInfo {
     provider?: string;
     /** 本轮解析出的真实模型 id */
     model?: string;
+    /** Exact tool names enabled for this turn; capability claims are derived from these. */
+    availableToolNames?: readonly string[];
 }
 export declare function createIdentitySection(info: IdentityInfo): SystemPromptSection;

package/dist/types/runtime/session/session-permission-store.d.ts

@@ -0,0 +1,6 @@
+export interface SessionPermissionStorePathOptions {
+    /** Test-only path override; production always uses the centralized session directory. */
+    sessionDir?: string;
+}
+export declare function loadSessionAllowedDirectories(sessionId: string, projectRoot: string, options?: SessionPermissionStorePathOptions): string[];
+export declare function appendSessionAllowedDirectory(sessionId: string, projectRoot: string, pathPrefix: string, options?: SessionPermissionStorePathOptions): Promise<void>;

package/dist/types/runtime/tasks/task-types.d.ts

@@ -64,6 +64,8 @@ export interface TaskStateBase {
      * the client and agent mint turn ids in separate namespaces (they never match),
      * but the session id is shared across the boundary. */
     launchSessionId?: string;
+    /** Root turn that launched this task. */
+    launchTurnId?: string;
     /** Execution depth (0 = root). */
     depth: number;
     /** Maximum turns before forced stop. */