qlogicagent 2.18.2 → 2.18.4

package/dist/types/runtime/prompt/environment-context.d.ts

@@ -55,12 +55,24 @@ export declare function shellGuidanceLines(shellInfo: ShellInfo | undefined, she
  */
 export declare function createEnvironmentContextSection(cwdOverride?: string, shellInfo?: ShellInfo): SystemPromptSection;
 /**
- * Create the task guidance system prompt section.
- * Domain-aware: selects appropriate guidance based on detected or overridden task domain.
+ * Domain-specific guidance ONLY — the small, genuinely per-turn-variable block.
+ * Excludes universalGuidance() (which is domain-INVARIANT and lives in its own
+ * stable section, see createUniversalGuidanceSection). This is the single source
+ * of truth for domain content, so the combined section and the split sections
+ * never drift.
  *
  * @param domain - Task domain from auto-detection or host override.
  */
-export declare function createTaskGuidanceSection(domain?: TaskDomain): SystemPromptSection;
+export declare function renderDomainGuidanceBlock(domain?: TaskDomain): string[];
+/**
+ * Universal (domain-INVARIANT) working-approach guidance as a STABLE (memoized)
+ * system section. Byte-identical every turn regardless of the detected domain, so
+ * it belongs in the cacheable system-prompt prefix. The per-turn domain block
+ * (renderDomainGuidanceBlock) is deliberately NOT part of this section — it is
+ * injected as a system message right before the last user message so the system
+ * prompt stays byte-stable when the detected domain switches.
+ */
+export declare function createUniversalGuidanceSection(): SystemPromptSection;
 /**
  * Create a system prompt section that provides tool usage guidance.
  * CC parity: matches claude-code's getUsingYourToolsSection().

package/dist/types/runtime/prompt/fresh-workspace-evidence.d.ts

@@ -33,4 +33,11 @@ export declare function isExplicitNoToolTurn(messages: readonly PromptMessageLik
  * stay subject to the normal evidence filter.)
  */
 export declare function selectFreshWorkspaceEvidenceTools<TTool extends ToolNameLike>(tools: readonly TTool[], policy: FreshWorkspaceEvidencePolicy): TTool[];
+/**
+ * Prompt notice for an explicit "don't use tools" instruction. This INFORMS the
+ * model and leaves the judgment to it — the engine no longer strips the tool list
+ * (toolChoice="none"), which also silently disabled the reactive guards and
+ * misfired on quoted/reported speech ("he said don't use tools").
+ */
+export declare function createExplicitNoToolNoticeSection(): SystemPromptSection;
 export declare function createFreshWorkspaceEvidenceSection(policy: FreshWorkspaceEvidencePolicy): SystemPromptSection | null;

package/dist/types/runtime/prompt/instruction-loader.d.ts

@@ -54,7 +54,6 @@ export declare function loadInstructions(cwd: string, hooks?: HookRegistry): Pro
  */
 export declare function buildInstructionsPrompt(files: InstructionFileInfo[]): string;
 export declare function extractLiteralResponseRequirements(files: InstructionFileInfo[]): LiteralResponseRequirement[];
-export declare function applyLiteralResponseRequirements(content: string, requirements: readonly LiteralResponseRequirement[]): string;
 /**
  * Get conditional rules that match a target file path.
  * CC parity: getManagedAndUserConditionalRules() + getMemoryFilesForNestedDirectory()

package/dist/types/runtime/session/inbound-upload-persistence.d.ts

@@ -34,6 +34,10 @@ export declare function persistInboundUploadUrl(url: string, projectId: string,
 /**
  * Persist + rewrite the inbound uploads on the LAST user message of a turn (the new message;
  * resumed history already carries persisted local URLs). Mutates and returns the message array.
+ *
+ * Failure parity with the document path (appendLocalDocumentNotesToText): when a media upload
+ * could NOT be persisted, the message gets a model-visible note instead of silently keeping a
+ * transport URL that expires with the turn — the model must know the reference is short-lived.
  */
 export declare function persistInboundUploadsForTurn(messages: ChatMessage[], projectId: string | undefined, sessionId: string | undefined): Promise<ChatMessage[]>;
 /**

package/dist/types/runtime/session/session-catalog.d.ts

@@ -1,4 +1,12 @@
 import type { SessionListEntry } from "./session-types.js";
 export declare function listSessions(limit: number | undefined, projectRoot: string): Promise<SessionListEntry[]>;
 export declare function deleteSession(sessionId: string, projectRoot: string): Promise<void>;
+/**
+ * ⚠️ Destructive cascade with NO user-visible confirmation: every pruned session goes through
+ * deleteSession, which permanently removes its transcript + metadata + checkpoints + uploads.
+ * Currently has NO caller. If you wire this up, the deletions must be surfaced to the user
+ * (count + which sessions) — silently reaping MAX_SESSIONS-overflow would be exactly the kind of
+ * invisible data loss docs/judgment-over-mechanism.md forbids. Also note listSessions skips
+ * unreadable-metadata sessions, so a prune pass under fs errors could mis-rank what "oldest" is.
+ */
 export declare function pruneOldSessions(projectRoot: string): Promise<number>;

package/dist/types/runtime/session/session-resume.d.ts

@@ -1,4 +1,9 @@
 import type { PersistedSession } from "./session-types.js";
+/** Coded error: the session's project root cannot be read at all (deleted dir, unplugged drive,
+ *  permissions). Distinguishable from the `null` return, which strictly means "this session has no
+ *  persisted transcript" — conflating the two made every caller silently start a NEW empty session
+ *  on a read failure (docs/judgment-over-mechanism.md: "read failed" ≠ "does not exist"). */
+export declare const PROJECT_ROOT_UNAVAILABLE = "PROJECT_ROOT_UNAVAILABLE";
 export declare function loadSessionForResume(sessionId: string, projectRoot: string, options?: {
     includeDisplayMetadata?: boolean;
 }): Promise<PersistedSession | null>;

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

@@ -6,10 +6,17 @@ export interface TranscriptLoadResult {
     /** 1-based line numbers that failed to parse (bounded to the first MAX_REPORTED_CORRUPT_LINES). */
     corruptLineNumbers: number[];
 }
+/**
+ * Outcome of an appendMessage call. "skipped-deleted" (the session was deleted — a LEGAL late-write
+ * no-op) is deliberately distinguishable from "failed" (the write itself failed — the message is
+ * LOST and callers must leave a trace / surface it), per docs/judgment-over-mechanism.md:
+ * "does not exist" and "write failed" must never be conflated into one silent boolean.
+ */
+export type AppendMessageOutcome = "appended" | "skipped-deleted" | "failed";
 export declare function appendMessage(sessionId: string, message: ChatMessage, projectRoot: string, turnId?: string, metadata?: {
     usage?: TokenUsage;
     displayMetadata?: MessageDisplayMetadata;
-}): Promise<boolean>;
+}): Promise<AppendMessageOutcome>;
 export declare function countTranscriptMessages(sessionId: string, projectRoot: string): Promise<number | null>;
 export declare function loadTranscript(sessionId: string, projectRoot: string, options?: {
     includeDisplayMetadata?: boolean;

package/dist/types/skills/mcp/mcp-manager.d.ts

@@ -1,4 +1,4 @@
-import type { PortableTool } from "../portable-tool.js";
+import type { PortableTool, PortableToolResult } from "../portable-tool.js";
 interface ToolRegistryLike {
     addTools(tools: PortableTool[]): void;
     getToolNames(): string[];
@@ -35,6 +35,17 @@ export interface McpSecurityIssue {
     code: "dangerous_egress" | "persistence" | "ioc_public_key";
     message: string;
 }
+/**
+ * A configured server that is NOT serving tools this session. Surfaced (not just logged)
+ * so capability queries (e.g. mcp_connectors_list) can disclose "configured but unavailable"
+ * instead of the server silently vanishing from the tool pool.
+ */
+export interface McpServerFailure {
+    name: string;
+    /** "config" = entry invalid, skipped before connect; "connect" = every connect attempt failed. */
+    phase: "config" | "connect";
+    error: string;
+}
 export interface McpManagerConfig {
     servers: McpServerEntry[];
     log?: {
@@ -67,7 +78,10 @@ export declare class McpManager {
     private toolCatalog?;
     private serverToolFilters;
     private serverOAuth;
+    private failedServers;
     constructor(config: McpManagerConfig);
+    /** Record (and loudly report) a server that will serve NO tools this session. */
+    private markServerFailed;
     private toServerDefinition;
     /**
      * Connect to all configured MCP servers and snapshot their tools.
@@ -81,6 +95,8 @@ export declare class McpManager {
     refreshServerTools(serverName: string): Promise<number>;
     /** Get names of all connected servers. */
     getConnectedServers(): string[];
+    /** Configured servers serving NO tools this session (invalid config or terminal connect failure). */
+    getFailedServers(): McpServerFailure[];
     /** Get total number of MCP tools across all servers. */
     getToolCount(): number;
     /**
@@ -95,6 +111,14 @@ export declare class McpManager {
     private registerTools;
     private removeRegisteredTool;
 }
+/**
+ * Flatten an MCP CallToolResult into a text-bearing PortableToolResult.
+ * Non-text blocks (image/audio/resource…) cannot be dropped silently: content is
+ * the only channel the model sees, so the omission is disclosed in the text —
+ * "(no text output)" for a result that DID produce blocks is a lie.
+ * Exported for unit tests only.
+ */
+export declare function toPortableResult(result: unknown): PortableToolResult;
 export declare function validateMcpToolWorkspaceBoundary(toolName: string, args: unknown, workspaceRoot: string | undefined): string | null;
 export declare function parseMcpConfig(json: unknown): McpServerEntry[];
 export declare function filterMcpTools<T extends {

package/dist/types/skills/memory/fts-segment.d.ts

@@ -0,0 +1,20 @@
+/**
+ * FTS pre-segmentation for CJK-aware keyword search.
+ *
+ * SQLite FTS5's unicode61 tokenizer does not segment CJK: a run of Chinese
+ * characters indexes as ONE token, so a query like 咖啡 can never match a
+ * memory containing 用户喜欢喝美式咖啡. Instead of switching tokenizers
+ * (trigram misses 2-char Chinese words, ICU is not bundled), we index a
+ * pre-segmented shadow column (`memories.text_seg`) and segment queries with
+ * the SAME function:
+ *   - Latin/digit runs stay whole words ("docker", "v2")
+ *   - CJK runs become character bigrams (咖啡, 啡因) + the single char for
+ *     1-char runs — the same scheme the near-duplicate gate already uses.
+ *
+ * Index side and query side MUST share this function; drift between them
+ * silently zeroes recall.
+ */
+/** Segment text into FTS-friendly tokens (lowercased). */
+export declare function segmentForFts(text: string): string[];
+/** Render the segmented shadow text stored in memories.text_seg. */
+export declare function segmentTextForFts(text: string): string;

package/dist/types/skills/memory/local-memory-provider.d.ts

@@ -9,7 +9,7 @@
  *   - Without embedding: FTS-only search (still useful for exact/keyword matches)
  */
 import type { MemoryProvider, MemorySearchResult, MemorySearchOptions, MemoryIngestMessage, MemoryIngestOptions } from "../../protocol/wire/index.js";
-import type { MemoryClaimRecord, MemoryConflictRecord, MemoryUpdateInput, SqliteDatabase } from "./local-store.js";
+import type { MemoryClaimRecord, MemoryConflictRecord, MemoryProposalRecord, MemoryUpdateInput, SqliteDatabase } from "./local-store.js";
 import { type AdoptedAttachment } from "./memory-attachment-store.js";
 import { type LocalEmbeddingConfig } from "./local-embedding.js";
 import { type ExtractedMemoryItem, type MemoryConsolidationResult } from "./memory-consolidation.js";
@@ -32,6 +32,12 @@ export declare class LocalMemoryProvider implements MemoryProvider {
     private attachmentStore;
     private userIdPrefix;
     private dbPath;
+    private attachmentsDir;
+    /** Active embedding model id — stamped onto stored vectors and used to skip
+     * incomparable vectors at search time (model switch = silent noise otherwise). */
+    private embeddingModelId;
+    /** One-shot flag: the embedding-degradation trace is logged once per provider instance. */
+    private embeddingFailureLogged;
     constructor(config: LocalMemoryProviderConfig);
     /** Persist an uploaded attachment (orphan until linked at commit). */
     adoptAttachment(input: {
@@ -57,9 +63,18 @@ export declare class LocalMemoryProvider implements MemoryProvider {
     /** Persist the understood/extracted text on an attachment row. */
     setAttachmentText(id: string, text: string): void;
     private resolveUserId;
+    /**
+     * The embedding API failing silently downgrades every search to FTS-only —
+     * leave one error-level trace per provider instance (deduped so a broken
+     * endpoint does not flood the log on every query).
+     */
+    private noteEmbeddingFailure;
     private buildEmbedding;
     search(query: string, userId: string, options?: MemorySearchOptions): Promise<MemorySearchResult[]>;
     ingest(messages: MemoryIngestMessage[], userId: string, options?: MemoryIngestOptions): Promise<void>;
+    /** Public embedding access for task-distillation signatures (R3). Null when
+     * the embedding provider is unavailable — callers must degrade, not throw. */
+    embedText(text: string): Promise<Float32Array | null>;
     addText(text: string, userId: string, options?: MemoryIngestOptions & {
         category?: string;
         importance?: number;
@@ -68,12 +83,47 @@ export declare class LocalMemoryProvider implements MemoryProvider {
     }>;
     remove(memoryId: string): Promise<boolean>;
     update(memoryId: string, input: MemoryUpdateInput): Promise<boolean>;
+    /**
+     * Prompt-injection screen for L2 writes. The memory-tool path already checks
+     * this, but implicit extraction / distillation / RPC ingestion used to write
+     * UNSCREENED — recalled memories land in a system message, so this is the
+     * last write-side gate. Rejections are traced, never silent.
+     */
+    private screenUnsafeItems;
     /**
      * Commit extracted memory items through the single consolidation pipeline.
      */
     ingestExtracted(items: ExtractedMemoryItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationResult>;
     observeExtracted(items: ExtractedMemoryItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationResult>;
     proposeExtracted(items: ExtractedMemoryItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationResult>;
+    /**
+     * Consume the pending-proposal backlog (the "proposals black hole" fix).
+     *
+     * Trust ladder, mirroring V3's graduated autonomy:
+     *   - CORROBORATED facts — the same fact proposed again from an independent
+     *     context (different session or different source) — commit automatically,
+     *     with a trace. Evidence, not a confidence score, is the auto gate.
+     *   - Feedback-distillation proposals commit alone: their >=2-evidence bar
+     *     was already enforced upstream (idempotency-keyed sweep, §10).
+     *   - dream-source proposals never commit alone; they only corroborate.
+     *   - Everything else waits for corroboration and EXPIRES after the TTL —
+     *     visibly (status=expired), not by silent deletion.
+     */
+    consumePendingProposals(userId: string, opts?: {
+        now?: number;
+        ttlMs?: number;
+        maxCommitsPerPass?: number;
+    }): Promise<{
+        committed: number;
+        merged: number;
+        expiredIds: string[];
+        pendingLeft: number;
+    }>;
+    /** Proposals for the memory candidate surface: pending (default) or the
+     * read-only expired history. Other statuses stay internal. */
+    listPendingProposals(userId: string, limit?: number, status?: "pending" | "expired"): MemoryProposalRecord[];
+    /** Resolve one pending proposal from the UI: confirm -> commit now; dismiss -> rejected. */
+    resolveProposal(userId: string, proposalId: string, action: "confirm" | "dismiss"): Promise<boolean>;
     listClaims(userId: string): MemoryClaimRecord[];
     listConflicts(userId: string): MemoryConflictRecord[];
     /**
@@ -95,13 +145,16 @@ export declare class LocalMemoryProvider implements MemoryProvider {
      * Trigger memory decay - multi-strategy (temporal + staleness + noise).
      * Also enforces capacity limit and runs vacuum for space reclamation.
      */
-    triggerDecay(userId: string, _maxAgeDays?: number): Promise<{
+    triggerDecay(userId: string): Promise<{
         decayed: number;
     }>;
     /**
      * Apply feedback to a memory (useful/irrelevant/outdated/wrong).
      * Adjusts importance or archives/deletes based on signal.
      */
+    /** V3 promote/demote: archive(技能接棒,记忆退役)与 unarchive(降格回归)成对。
+     * claims 状态随动,防 archived 记忆的 claim 继续参与冲突/召回。 */
+    setMemoryArchived(memoryId: string, archived: boolean): boolean;
     feedback(memoryIds: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong"): Promise<{
         affected: number;
     }>;
@@ -230,7 +283,8 @@ export declare class LocalMemoryProvider implements MemoryProvider {
         metadata?: Record<string, unknown>;
     }>;
     /**
-     * Health check - always healthy for local store.
+     * Health check — a real probe, not a constant: reports the actual active row
+     * count and turns DB access errors into status "error" instead of "healthy".
      */
     health(): Promise<{
         status: string;
@@ -242,7 +296,15 @@ export declare class LocalMemoryProvider implements MemoryProvider {
      */
     count(userId: string): number;
     /**
-     * Reset all memories for a user.
+     * Reset ALL long-term memory state for a user: every SQLite table (memories,
+     * observations, proposals, claims, conflicts, attachments index, profile KV),
+     * the attachment files on disk, and the task-distillation working stores
+     * (candidate prompts are stored in clear text — they are memory-domain data
+     * and must not survive a "clear my memory"). promotion-proposals.json is
+     * deliberately KEPT: it is the audit trail of the user's own promote/demote
+     * decisions and the demote map for already-created skills.
+     *
+     * Returns the number of memory rows removed (wire-compat with the old shape).
      */
     resetUser(userId: string): Promise<number>;
     /**

package/dist/types/skills/memory/local-store-records.d.ts

@@ -38,6 +38,9 @@ export interface MemoryInsertInput {
     eventDate?: string;
     tags?: string[];
     embedding?: Float32Array;
+    /** Provenance of `embedding` (model id). Vectors from different models are not
+     * comparable; search skips rows whose model/dims mismatch the query's. */
+    embeddingModel?: string;
 }
 export interface MemoryUpdateInput {
     text?: string;
@@ -47,6 +50,8 @@ export interface MemoryUpdateInput {
     eventDate?: string;
     tags?: string[];
     embedding?: Float32Array | null;
+    /** Provenance of the replacement embedding (see MemoryInsertInput). */
+    embeddingModel?: string;
 }
 export interface MemorySearchHit {
     id: string;
@@ -97,7 +102,7 @@ export interface MemoryAtlasResult {
 }
 export type MemorySourceKind = "manual" | "explicit" | "document" | "image" | "video" | "auto" | "turn" | "dream" | "agent" | "feedback";
 export type MemoryClaimStatus = "active" | "superseded" | "conflicted" | "archived" | "pending_confirmation";
-export type MemoryProposalStatus = "pending" | "accepted" | "merged" | "conflicted" | "rejected";
+export type MemoryProposalStatus = "pending" | "accepted" | "merged" | "conflicted" | "rejected" | "expired";
 export interface MemoryObservationInput {
     userId: string;
     text: string;

package/dist/types/skills/memory/local-store.d.ts

@@ -12,7 +12,7 @@
  *   - memories_fts: FTS5 full-text index for keyword search
  *   - profiles: user profile KV (future)
  */
-import type { MemoryAtlasResult, MemoryClaimInput, MemoryClaimRecord, MemoryClaimStatus, MemoryConflictRecord, MemoryInsertInput, MemoryObservationInput, MemoryProposalInput, MemoryProposalStatus, MemoryRecord, MemorySearchHit, MemoryUpdateInput, SqliteDatabase } from "./local-store-records.js";
+import type { MemoryAtlasResult, MemoryClaimInput, MemoryClaimRecord, MemoryClaimStatus, MemoryConflictRecord, MemoryInsertInput, MemoryObservationInput, MemoryProposalInput, MemoryProposalRecord, MemoryProposalStatus, MemoryRecord, MemorySearchHit, MemoryUpdateInput, SqliteDatabase } from "./local-store-records.js";
 export { resolveMemoryDbPath } from "./memory-db-path.js";
 export type { MemoryAtlasBucket, MemoryAtlasCluster, MemoryAtlasResult, MemoryAtlasWindowCursor, MemoryAttachmentRef, MemoryClaimInput, MemoryClaimRecord, MemoryClaimStatus, MemoryConflictRecord, MemoryInsertInput, MemoryObservationInput, MemoryObservationRecord, MemoryProposalInput, MemoryProposalRecord, MemoryProposalStatus, MemoryRecord, MemorySearchHit, MemorySourceKind, MemoryUpdateInput, SqliteDatabase, SqliteStatement, } from "./local-store-records.js";
 /** Full attachment index row (DB-backed; file bytes live on disk under the attachments dir). */
@@ -41,7 +41,11 @@ export interface MemoryAttachmentInsert {
 }
 export declare class LocalMemoryStore {
     private db;
+    /** Stamped onto rows whose embedding arrives without explicit provenance
+     * (the consolidation pipeline passes bare vectors). Set by the provider. */
+    private defaultEmbeddingModel;
     constructor(db: SqliteDatabase);
+    setDefaultEmbeddingModel(model: string): void;
     private initSchema;
     /**
      * Insert a new memory record. Returns the generated ID.
@@ -51,15 +55,23 @@ export declare class LocalMemoryStore {
      * Full-text search using FTS5. Returns ranked results.
      */
     searchFts(query: string, userId: string, limit?: number): MemorySearchHit[];
+    /** One-shot flag: embedding provenance mismatches are traced once per store instance. */
+    private embeddingMismatchLogged;
     /**
      * Vector similarity search using pre-computed embeddings.
      * Performs brute-force cosine similarity (efficient for <100k records per user).
+     *
+     * Rows whose embedding provenance (dims, and model when both sides are known)
+     * differs from the query's are SKIPPED, not scored: cosine between vectors of
+     * different models/dims is numeric noise, and truncated dot products silently
+     * corrupt ranking. Legacy rows (no provenance columns) are accepted when their
+     * dimension happens to match — dropping them all would blank historical recall.
      */
-    searchVector(queryEmbedding: Float32Array, userId: string, limit?: number, minScore?: number): MemorySearchHit[];
+    searchVector(queryEmbedding: Float32Array, userId: string, limit?: number, minScore?: number, expectedModel?: string): MemorySearchHit[];
     /**
      * Hybrid search: FTS5 + vector similarity, de-duplicated and merged.
      */
-    searchHybrid(query: string, queryEmbedding: Float32Array | null, userId: string, limit?: number): MemorySearchHit[];
+    searchHybrid(query: string, queryEmbedding: Float32Array | null, userId: string, limit?: number, expectedModel?: string): MemorySearchHit[];
     /**
      * Get all memories for a user (paginated).
      */
@@ -89,7 +101,7 @@ export declare class LocalMemoryStore {
     /**
      * Update memory text and bump updatedAt.
      */
-    updateText(id: string, text: string, embedding?: Float32Array): boolean;
+    updateText(id: string, text: string, embedding?: Float32Array, embeddingModel?: string): boolean;
     /**
      * Update editable memory fields and bump updatedAt.
      */
@@ -103,6 +115,8 @@ export declare class LocalMemoryStore {
      * Used by dedup gate when a similar but newer memory supersedes an older one.
      */
     archive(id: string): boolean;
+    /** V3 demote(降格)恢复:archived procedure 回归召回池,与 archive 成对。 */
+    unarchive(id: string): boolean;
     /**
      * Temporal expiry: archive event/plan memories whose event_date has passed
      * beyond a grace period (e.g., "meeting tomorrow" 3 days after it happened).
@@ -118,6 +132,15 @@ export declare class LocalMemoryStore {
      * Memories written by the agent but never recalled are likely noise.
      */
     decayNoiseArchival(userId: string, minAgeDays?: number, maxImportance?: number): number;
+    /**
+     * Observation retention: memory_observations is an append-only audit trail
+     * (every propose/commit writes one) with NO reader of its own — without a
+     * retention window it grows forever, the same disease the proposals table
+     * had before the consumer existed. Delete rows older than the window that
+     * are NOT referenced by any claim's evidence_ids or proposal's
+     * observation_ids (referenced rows are live audit evidence and stay).
+     */
+    decayObservations(userId: string, retentionDays?: number): number;
     /**
      * Run all decay strategies. Returns total affected count.
      */
@@ -203,14 +226,30 @@ export declare class LocalMemoryStore {
      * Record an access (for importance/relevance boosting).
      */
     recordAccess(id: string): void;
+    /** Total active memory rows across ALL users (health reporting). */
+    countAll(): number;
     /**
      * Get total memory count for a user.
      */
     count(userId: string, activeOnly?: boolean): number;
     /**
-     * Delete all memories for a user.
-     */
-    resetUser(userId: string): number;
+     * Delete ALL long-term memory state for a user — every table, not just
+     * `memories`. Claims carry entity/predicate/value facts in clear text and
+     * observations carry raw conversation excerpts; leaving them behind after a
+     * "clear my memory" is a broken privacy promise, not a smaller reset.
+     *
+     * Returns the attachment rel_paths so the caller can delete the on-disk
+     * files (the store only owns the index rows).
+     */
+    resetUser(userId: string): {
+        memories: number;
+        observations: number;
+        proposals: number;
+        claims: number;
+        conflicts: number;
+        profiles: number;
+        attachmentRelPaths: string[];
+    };
     /**
      * Run SQLite VACUUM to reclaim space after deletions/archival.
      * Should be called periodically (e.g. after decay cycles).
@@ -226,10 +265,13 @@ export declare class LocalMemoryStore {
         freePages: number;
     };
     /**
-     * Export archived memories as JSONL (for cold storage / backup).
-     * Deletes exported records from the database to reclaim space.
+     * List the oldest archived memories for cold-storage export. Read-only:
+     * purging is a SEPARATE step (purgeMemoriesByIds) the caller performs only
+     * after the export has durably landed on disk. The old fused
+     * export-then-delete shape destroyed data whenever the caller dropped the
+     * return value.
      */
-    exportAndPurgeArchived(userId: string, maxExport?: number): Array<{
+    listArchivedForExport(userId: string, maxExport?: number): Array<{
         id: string;
         text: string;
         category: string;
@@ -238,6 +280,8 @@ export declare class LocalMemoryStore {
         archivedAt: number;
         tags: string[];
     }>;
+    /** Physically delete memory rows by id (post-export purge step). */
+    purgeMemoriesByIds(ids: string[]): number;
     /**
      * Enforce capacity limit: if active memories exceed maxCount,
      * archive the oldest lowest-importance ones.
@@ -251,6 +295,15 @@ export declare class LocalMemoryStore {
      * a duplicate crash-safely (the key survives a worker restart mid-sweep).
      */
     findProposalByIdempotencyKey(userId: string, idempotencyKey: string): string | null;
+    /**
+     * List proposals by status (oldest first) — the read side of the proposal
+     * consumer. Pending proposals from implicit-extract / feedback / dream used
+     * to have NO reader at all: they accumulated forever and never became
+     * searchable memories.
+     */
+    listProposalsByStatus(userId: string, status: MemoryProposalStatus, limit?: number): MemoryProposalRecord[];
+    /** Bulk status transition for the proposal consumer (corroborated / expired). */
+    markProposalsStatus(ids: string[], status: MemoryProposalStatus): number;
     updateProposalStatus(id: string, status: MemoryProposalStatus, relatedClaimIds?: string[]): boolean;
     insertClaim(input: MemoryClaimInput): string;
     listClaims(userId: string, statuses?: MemoryClaimStatus[]): MemoryClaimRecord[];

package/dist/types/skills/memory/memdir.d.ts

@@ -1,4 +1,4 @@
-/** Max bytes (UTF-8) for INDEX.md to inject into system prompt (CC uses 25KB, we use 12KB). */
+/** Max bytes (UTF-8) for INDEX.md to inject into system prompt. */
 export declare const INDEX_MAX_CHARS = 12288;
 /** Max lines for INDEX.md injection. */
 export declare const INDEX_MAX_LINES = 200;
@@ -8,6 +8,14 @@ export declare const TOPIC_FILE_MAX_CHARS = 8192;
 export declare function getMemdirPath(projectRoot: string): string;
 /** Full path to INDEX.md */
 export declare function getIndexPath(projectRoot: string): string;
+/** Global-layer size budget: a cheat-sheet, not a memory store. */
+export declare const USER_INDEX_MAX_CHARS = 2048;
+export declare const USER_INDEX_MAX_LINES = 40;
+/** Full path to the user-level global INDEX.md (owner profile scoped). */
+export declare function getUserIndexPath(): string;
+/** Read the global layer for prompt injection, capped by the cheat-sheet budget.
+ * Returns null when absent/empty — the section simply doesn't render. */
+export declare function readUserIndexForPrompt(): string | null;
 export interface MemdirFileInfo {
     name: string;
     /** Size in bytes */
@@ -25,10 +33,9 @@ export interface MemdirResult {
     /** Current INDEX.md char usage */
     indexUsage?: string;
 }
-export declare function isMemoryContentSafe(text: string): boolean;
+export { isMemoryContentSafe } from "./memory-tool.js";
 export declare class Memdir {
     private readonly root;
-    private indexCache;
     constructor(projectRoot: string);
     /** Get the root directory path of this MEMDIR. */
     getRootPath(): string;
@@ -89,6 +96,12 @@ export declare class Memdir {
     private writeIndex;
     private writeIndexUnlocked;
     private ensureDir;
-    /** Append an entry to the file listing section of INDEX.md (idempotent). */
+    /**
+     * Append an entry to the file listing section of INDEX.md (idempotent).
+     * Returns whether the entry is present afterwards. On overflow it first
+     * tries the same auto-compaction as addToIndex; a false return means the
+     * file exists but is INVISIBLE to recall — callers must surface that
+     * (the old behavior skipped silently and quietly orphaned topic files).
+     */
     private appendIndexEntry;
 }

package/dist/types/skills/memory/memory-consolidation.d.ts

@@ -54,4 +54,11 @@ export declare class MemoryConsolidator {
      */
     private findNearDuplicateMemory;
 }
+/** Containment threshold above which two texts count as the same memory.
+ * Exported: the proposal consumer uses the SAME bar to group same-fact proposals. */
+export declare const NEAR_DUPLICATE_CONTAINMENT = 0.82;
+/** Latin/digit words plus CJK character bigrams from normalized text. */
+export declare function dedupTokens(text: string): Set<string>;
+/** True when either side has a digit-bearing token the other side lacks. */
+export declare function digitTokensDiffer(a: Set<string>, b: Set<string>): boolean;
 export declare function sourcePriorityOf(source: string): number;

package/dist/types/skills/memory/proposal-consumer.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Proposal consumer (P0 — the factual-memory half of the promotion ladder).
+ *
+ * implicit-extract / feedback-distillation / dream all write PROPOSALS
+ * (status=pending). Before this module existed nothing ever read them back:
+ * the three automatic learning paths burned model calls writing dead rows.
+ *
+ * Trust ladder — evidence gates autonomy, mirroring the V3 skill-promotion
+ * doctrine (automatic only when the data says so; visible; revertible):
+ *   - CORROBORATED: the same fact proposed >=2 times from independent
+ *     contexts (different session, or different source) -> auto-commit as
+ *     source "corroborated" (priority 70, so it actually becomes an active
+ *     searchable memory — committing with the original implicit-extract
+ *     priority 40 would just create another pending claim, i.e. the black
+ *     hole one level deeper).
+ *   - feedback-distillation proposals commit ALONE: their >=2-evidence bar
+ *     was already enforced upstream (MIN_EVIDENCE + idempotency key, §10).
+ *   - dream-tier sources (priority <= 20) never commit alone; they only
+ *     corroborate facts seen elsewhere.
+ *   - Everything else waits, and past the TTL flips to status "expired" —
+ *     a visible terminal state, not a silent delete; the memory surface can
+ *     still show expired proposals for manual rescue.
+ *
+ * Pure planning logic — no I/O; the provider executes the plan.
+ */
+import type { MemoryProposalRecord } from "./local-store-records.js";
+import type { ExtractedMemoryItem } from "./memory-consolidation.js";
+/** Uncorroborated proposals older than this flip to "expired". */
+export declare const PROPOSAL_TTL_MS: number;
+/** Independent contexts required for auto-commit. */
+export declare const PROPOSAL_MIN_CORROBORATION = 2;
+/** Idle-pass work cap; the rest stays pending for the next pass. */
+export declare const PROPOSAL_MAX_COMMITS_PER_PASS = 20;
+/** Source stamped on corroborated commits — registered in sourcePriorityOf. */
+export declare const CORROBORATED_SOURCE = "corroborated";
+export interface ProposalCommitGroup {
+    proposalIds: string[];
+    item: ExtractedMemoryItem;
+    /** Source used for the commit (drives claim authority). */
+    source: string;
+}
+export interface ProposalConsumptionSummary {
+    commitGroups: ProposalCommitGroup[];
+    expiredIds: string[];
+}
+export interface ProposalConsumptionOptions {
+    now?: number;
+    ttlMs?: number;
+    maxCommitsPerPass?: number;
+}
+export declare function planProposalConsumption(pending: readonly MemoryProposalRecord[], opts?: ProposalConsumptionOptions): ProposalConsumptionSummary;

package/dist/types/skills/memory/sqlite-memory-mappers.d.ts

@@ -1,6 +1,7 @@
-import type { MemoryClaimRecord, MemoryConflictRecord, MemoryRecord } from "./local-store-records.js";
+import type { MemoryClaimRecord, MemoryConflictRecord, MemoryProposalRecord, MemoryRecord } from "./local-store-records.js";
 export declare function rowToRecord(row: unknown): MemoryRecord;
 export declare function rowToClaimRecord(row: unknown): MemoryClaimRecord;
+export declare function rowToProposalRecord(row: unknown): MemoryProposalRecord;
 export declare function rowToConflictRecord(row: unknown): MemoryConflictRecord;
 export declare function parseJsonObject(raw: unknown): Record<string, unknown>;
 export declare function parseJsonArray(raw: unknown): string[];