@cjhyy/code-shell-core 0.6.0-rc.9 → 0.7.0

package/dist/services/memory-orchestrator.js

@@ -12,12 +12,13 @@
  * The caller supplies `runDream`, which owns the LLM client and tool registry
  * — orchestrator just decides WHEN to trigger.
  */
-import { MemoryManager } from "../session/memory.js";
-import { buildExtractionPrompt, parseExtractionResponse } from "./extract-memories.js";
+import { MemoryManager, } from "../session/memory.js";
+import { buildExtractionPrompt, parseExtractionResponse, } from "./extract-memories.js";
 import { saveSessionMemory, buildSessionMemoryPrompt } from "./session-memory.js";
 import { extractJSON } from "../utils/json.js";
 import { redactSecrets } from "../logging/sanitize-messages.js";
-import { shouldAutoDream, recordSession, recordDreamComplete, buildDreamSystemPrompt, buildDreamUserPrompt } from "./auto-dream.js";
+import { shouldAutoDream, recordSession, recordDreamComplete, buildDreamSystemPrompt, buildDreamUserPrompt, } from "./auto-dream.js";
+import { applyGlobalDreamPromotionGate, detectUserDirectGlobalPreference, } from "./global-dream-promotion.js";
 import { logger } from "../logging/logger.js";
 export class MemoryOrchestrator {
     options;
@@ -45,7 +46,7 @@ export class MemoryOrchestrator {
         else
             try {
                 let t = Date.now();
-                const existing = mm.loadAll();
+                const existing = collectExistingMemorySummaries(mm, this.options.projectDir);
                 const loadMs = Date.now() - t;
                 t = Date.now();
                 const extractionPrompt = buildExtractionPrompt(transcript, existing);
@@ -57,45 +58,130 @@ export class MemoryOrchestrator {
                 const entries = parseExtractionResponse(response, this.options.maxCount);
                 const parseMs = Date.now() - t;
                 t = Date.now();
-                // Route by scope (用户拍板 审批门): "project" memories auto-land in the
-                // per-project store (`mm`). "global" memories do NOT auto-land global —
-                // they go to the GLOBAL pending scope and wait for the user to approve in
-                // the settings panel. Nothing auto-writes the injected global store.
-                let pendingMm = null;
-                let globalCount = 0;
+                let globalDreamCount = 0;
+                let pendingGlobalCount = 0;
+                let projectDreamCount = 0;
+                let addCount = 0;
+                let updateCount = 0;
+                let noopCount = 0;
+                let deleteCount = 0;
+                let guardedManualCount = 0;
+                const userDirectGlobal = detectUserDirectGlobalPreference(transcript);
                 for (const entry of entries) {
-                    const isGlobal = entry.scope === "global";
-                    const target = isGlobal
-                        ? (pendingMm ??= new MemoryManager({ scope: "pending" }))
-                        : mm;
-                    target.save({
-                        type: entry.type,
-                        name: entry.name,
-                        // Defense-in-depth: the extraction prompt forbids secrets, but a prompt
-                        // is not a guarantee. An auto-extracted memory is persisted with no user
-                        // review, so run the model-authored strings through the same
-                        // redactSecrets the logging path uses — a leaked key never lands on disk.
+                    const redactedEntry = {
+                        ...entry,
                         description: redactSecrets(entry.description),
                         content: redactSecrets(entry.content),
-                        // Provenance mark (feedback#18 方案 C): extractor writes are "auto"
-                        // so the UI can tell curated memories from extractor noise.
-                        origin: "auto",
-                        // 审批门: stamp the source project on pending entries so "不批准/降级"
-                        // can fall them back to the project they were extracted in.
-                        ...(isGlobal && this.options.projectDir
-                            ? { originProject: this.options.projectDir }
-                            : {}),
-                    });
-                    if (isGlobal)
-                        globalCount++;
+                    };
+                    const decision = await decideWriteAction(redactedEntry, existing, this.options.callLLM);
+                    switch (decision.action) {
+                        case "ADD": {
+                            const isGlobal = redactedEntry.scope === "global";
+                            if (isGlobal) {
+                                const promotion = applyGlobalDreamPromotionGate({
+                                    projectDir: this.options.projectDir,
+                                    candidate: redactedEntry,
+                                    userDirectGlobal,
+                                });
+                                if (promotion.projectEvidenceSaved)
+                                    projectDreamCount++;
+                                if (promotion.pendingSuggested)
+                                    pendingGlobalCount++;
+                                if (promotion.promoted)
+                                    globalDreamCount++;
+                                addCount++;
+                                break;
+                            }
+                            const target = memoryManagerForDecision("project", "dream", this.options.projectDir);
+                            target.save({
+                                type: redactedEntry.type,
+                                name: redactedEntry.name,
+                                description: redactedEntry.description,
+                                content: redactedEntry.content,
+                                origin: "auto",
+                                ...(isGlobal && this.options.projectDir
+                                    ? { originProject: this.options.projectDir }
+                                    : {}),
+                            }, { forceOrigin: "auto" });
+                            if (isGlobal)
+                                globalDreamCount++;
+                            else
+                                projectDreamCount++;
+                            addCount++;
+                            break;
+                        }
+                        case "UPDATE": {
+                            const targetId = decision.target?.id;
+                            if (!targetId) {
+                                noopCount++;
+                                break;
+                            }
+                            const location = decision.target?.location ?? redactedEntry.scope;
+                            const target = memoryManagerForDecision(location, "dream", this.options.projectDir);
+                            const existingTarget = target.findById(targetId);
+                            if (!existingTarget || !target.isOwnedBy(existingTarget, ["auto", "dream"])) {
+                                noopCount++;
+                                guardedManualCount += existingTarget?.origin === "manual" ? 1 : 0;
+                                break;
+                            }
+                            target.save({
+                                id: targetId,
+                                type: redactedEntry.type,
+                                name: redactedEntry.name,
+                                description: redactedEntry.description,
+                                content: redactedEntry.content,
+                                origin: existingTarget.origin ?? "auto",
+                                pinned: existingTarget.pinned,
+                                createdAt: existingTarget.createdAt,
+                                useCount: existingTarget.useCount,
+                                lastUsedAt: existingTarget.lastUsedAt,
+                                originProject: existingTarget.originProject,
+                            }, { forceOrigin: existingTarget.origin ?? "auto" });
+                            if (location === "global")
+                                globalDreamCount++;
+                            else
+                                projectDreamCount++;
+                            updateCount++;
+                            break;
+                        }
+                        case "DELETE": {
+                            const targetId = decision.target?.id;
+                            const location = decision.target?.location ?? redactedEntry.scope;
+                            const target = memoryManagerForDecision(location, "dream", this.options.projectDir);
+                            if (!targetId) {
+                                noopCount++;
+                                break;
+                            }
+                            const deleteResult = target.deleteIfOwned(targetId, ["auto", "dream"]);
+                            if (deleteResult === "deleted")
+                                deleteCount++;
+                            else {
+                                noopCount++;
+                                if (deleteResult === "protected")
+                                    guardedManualCount++;
+                            }
+                            break;
+                        }
+                        case "NOOP":
+                            noopCount++;
+                            if (decision.guardedManual)
+                                guardedManualCount++;
+                            break;
+                    }
                 }
                 const saveMs = Date.now() - t;
                 extracted = entries.length;
                 logger.info("memory.extraction_done", {
                     sessionId,
                     extracted,
-                    pendingGlobalCount: globalCount, // global candidates queued for approval
-                    projectCount: extracted - globalCount,
+                    globalDreamCount,
+                    pendingGlobalCount,
+                    projectDreamCount,
+                    addCount,
+                    updateCount,
+                    noopCount,
+                    deleteCount,
+                    guardedManualCount,
                     elapsedMs: Date.now() - startTime,
                     loadMs,
                     promptMs,
@@ -224,3 +310,230 @@ export class MemoryOrchestrator {
         return { extracted, dreamTriggered, pruned };
     }
 }
+function memoryManagerForDecision(location, scope, projectDir) {
+    return new MemoryManager({
+        projectDir: location === "project" ? projectDir : undefined,
+        scope,
+    });
+}
+function collectExistingMemorySummaries(projectUserManager, projectDir) {
+    const seen = new Set();
+    const out = [];
+    const add = (entries, location, memoryScope) => {
+        for (const entry of entries) {
+            const key = `${location}:${memoryScope}:${entry.fileName}:${entry.id ?? ""}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({
+                id: entry.id,
+                name: entry.name,
+                type: entry.type,
+                description: entry.description,
+                location,
+                memoryScope,
+                origin: entry.origin ?? "manual",
+                pinned: entry.pinned,
+                useCount: entry.useCount,
+                updateCount: entry.updateCount,
+                updatedAt: entry.updatedAt,
+                entry,
+            });
+        }
+    };
+    add(projectUserManager.loadScope("user"), "project", "user");
+    add(memoryManagerForDecision("project", "dream", projectDir).loadAll(), "project", "dream");
+    add(memoryManagerForDecision("global", "dream", projectDir).loadAll(), "global", "dream");
+    add(memoryManagerForDecision("global", "user", projectDir).loadAll(), "global", "user");
+    return out
+        .sort((a, b) => {
+        const aTime = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
+        const bTime = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
+        return bTime - aTime;
+    })
+        .slice(0, 120);
+}
+async function decideWriteAction(candidate, existing, callLLM) {
+    const fallback = fallbackWriteDecision(candidate, existing);
+    const related = rankRelated(candidate, existing).slice(0, 40);
+    const llmDecision = await askLLMForWriteDecision(candidate, related.map((r) => r.summary), callLLM);
+    if (!llmDecision)
+        return fallback;
+    const target = llmDecision.target?.id
+        ? existing.find((m) => m.id === llmDecision.target?.id)
+        : undefined;
+    if ((llmDecision.action === "UPDATE" || llmDecision.action === "DELETE") && target) {
+        if (target.origin === "manual") {
+            return {
+                action: "NOOP",
+                memory: candidate,
+                reason: "manual memory is protected",
+                guardedManual: true,
+            };
+        }
+        if (target.memoryScope === "dream" && (target.origin === "auto" || target.origin === "dream")) {
+            return {
+                ...llmDecision,
+                memory: candidate,
+                target: {
+                    id: target.id,
+                    location: target.location,
+                    scope: "dream",
+                },
+            };
+        }
+    }
+    // Downgrade unsafe or duplicate ADDs using the deterministic guard.
+    if (llmDecision.action === "ADD" && fallback.action !== "ADD")
+        return fallback;
+    if (llmDecision.action === "NOOP")
+        return { ...llmDecision, memory: candidate };
+    if (llmDecision.action === "ADD")
+        return { ...llmDecision, memory: candidate };
+    return fallback;
+}
+async function askLLMForWriteDecision(candidate, related, callLLM) {
+    if (related.length === 0)
+        return null;
+    try {
+        const relatedText = related
+            .map((m) => `- id:${m.id ?? "(none)"} location:${m.location} scope:${m.memoryScope} origin:${m.origin} ` +
+            `[${m.type}] ${m.name}: ${m.description}`)
+            .join("\n");
+        const response = await callLLM("You are a memory write decision assistant. Output only one JSON object.", [
+            "Decide whether this automatic memory candidate should ADD, UPDATE, NOOP, or DELETE.",
+            "Manual memories are protected: if the target is origin:manual, choose NOOP.",
+            "Automatic extraction writes new entries only to dream. Reuse an existing auto/dream dream id for same-topic updates.",
+            "",
+            "Candidate:",
+            JSON.stringify(candidate),
+            "",
+            "Related existing memories:",
+            relatedText,
+            "",
+            'Respond with JSON: {"action":"ADD|UPDATE|DELETE|NOOP","target":{"id":"...","location":"project|global","scope":"dream|user"},"reason":"short","confidence":"high|medium|low"}',
+        ].join("\n"));
+        const parsed = JSON.parse(extractJSON(response));
+        const action = typeof parsed.action === "string" ? parsed.action.toUpperCase() : "";
+        if (!["ADD", "UPDATE", "DELETE", "NOOP"].includes(action))
+            return null;
+        const location = parsed.target?.location === "global" || parsed.target?.location === "project"
+            ? parsed.target.location
+            : candidate.scope;
+        const scope = parsed.target?.scope === "user" ? "user" : "dream";
+        return {
+            action: action,
+            target: parsed.target?.id ? { id: String(parsed.target.id), location, scope } : undefined,
+            memory: candidate,
+            reason: typeof parsed.reason === "string" ? parsed.reason : "llm decision",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function fallbackWriteDecision(candidate, existing) {
+    const ranked = rankRelated(candidate, existing);
+    const strong = ranked.filter((m) => m.score >= 0.55 || m.canonicalMatch);
+    const manual = strong.find((m) => m.summary.origin === "manual");
+    if (manual) {
+        return {
+            action: "NOOP",
+            memory: candidate,
+            reason: `same topic as manual memory ${manual.summary.id ?? manual.summary.name}`,
+            guardedManual: true,
+        };
+    }
+    const ownedDream = strong.find((m) => m.summary.location === candidate.scope &&
+        m.summary.memoryScope === "dream" &&
+        (m.summary.origin === "auto" || m.summary.origin === "dream") &&
+        m.summary.id &&
+        !m.summary.id.startsWith("legacy:"));
+    if (ownedDream?.summary.id) {
+        return {
+            action: "UPDATE",
+            target: {
+                id: ownedDream.summary.id,
+                location: ownedDream.summary.location,
+                scope: "dream",
+            },
+            memory: candidate,
+            reason: `same topic as auto/dream memory ${ownedDream.summary.id}`,
+        };
+    }
+    return { action: "ADD", memory: candidate, reason: "new automatic candidate" };
+}
+function rankRelated(candidate, existing) {
+    const candidateText = `${candidate.name} ${candidate.description}`;
+    const candidateKey = canonicalKey(candidateText);
+    const candidateTokens = tokenSet(candidateText);
+    return existing
+        .map((summary) => {
+        const existingText = `${summary.name} ${summary.description}`;
+        const existingKey = canonicalKey(existingText);
+        const existingTokens = tokenSet(existingText);
+        return {
+            summary,
+            score: tokenOverlap(candidateTokens, existingTokens),
+            canonicalMatch: candidateKey.length > 0 && candidateKey === existingKey,
+        };
+    })
+        .sort((a, b) => {
+        if (a.canonicalMatch !== b.canonicalMatch)
+            return a.canonicalMatch ? -1 : 1;
+        if (a.score !== b.score)
+            return b.score - a.score;
+        const aOwned = a.summary.origin === "auto" || a.summary.origin === "dream" ? 1 : 0;
+        const bOwned = b.summary.origin === "auto" || b.summary.origin === "dream" ? 1 : 0;
+        if (aOwned !== bOwned)
+            return bOwned - aOwned;
+        const aTime = a.summary.updatedAt ? new Date(a.summary.updatedAt).getTime() : 0;
+        const bTime = b.summary.updatedAt ? new Date(b.summary.updatedAt).getTime() : 0;
+        return bTime - aTime;
+    });
+}
+function canonicalKey(text) {
+    return [...tokenSet(text)].sort().join(" ");
+}
+function tokenSet(text) {
+    const normalized = text
+        .toLowerCase()
+        .replace(/\b\d{4}-\d{2}-\d{2}\b/g, " ")
+        .replace(/\b\d{8}\b/g, " ")
+        .replace(/\b(today|yesterday|tomorrow|本轮|今天|昨天|明天)\b/g, " ")
+        .replace(/\bv\d+\b/g, " ")
+        .replace(/\b(batch|fix-batch)-\d+\b/g, " ")
+        .replace(/\b[a-f0-9]{7,}\b/g, " ")
+        .replace(/[\d]+/g, " ")
+        .replace(/[^a-z0-9\u4e00-\u9fff]+/g, " ");
+    const stop = new Set([
+        "the",
+        "and",
+        "for",
+        "with",
+        "that",
+        "this",
+        "from",
+        "memory",
+        "memories",
+        "should",
+        "must",
+        "不要",
+        "需要",
+        "已经",
+    ]);
+    return new Set(normalized
+        .split(/\s+/)
+        .map((t) => t.trim())
+        .filter((t) => t.length > 2 && !stop.has(t)));
+}
+function tokenOverlap(a, b) {
+    if (a.size === 0 || b.size === 0)
+        return 0;
+    let shared = 0;
+    for (const token of a) {
+        if (b.has(token))
+            shared++;
+    }
+    return shared / Math.min(a.size, b.size);
+}

package/dist/session/memory.d.ts

@@ -12,7 +12,11 @@
  *              auto-extracted entries (extract-memories output). LLM may
  *              only modify these through permission-gated tool calls.
  *   - dream/   The dream pipeline's workspace. The LLM is free to add /
- *              merge / delete entries here; user/ is read-only to dream.
+ *              merge / delete entries here. The dream loop may ALSO maintain
+ *              user/ entries whose origin is `auto` or `dream` (dedup/merge/
+ *              improve), but origin:`manual` user entries — things the user
+ *              explicitly asked to remember — are never touched by dream.
+ *              See dream-consolidation.ts (the origin guard at ~:240).
  *
  * MEMORY.md is the index file (one per scope).
  *
@@ -29,15 +33,20 @@
  *            panel. Keeps the global layer curated — nothing auto-lands global.
  */
 export type MemoryScope = "user" | "dream" | "pending";
+export type MemoryOrigin = "auto" | "manual" | "dream";
 export interface MemoryEntry {
+    /** Stable identity. Legacy files without frontmatter id read as legacy:<scope>:<fileName>. */
+    id?: string;
     name: string;
     description: string;
     type: "user" | "feedback" | "project" | "reference";
     content: string;
     fileName: string;
     scope: MemoryScope;
+    /** Semantic last content update time from frontmatter. */
+    updatedAt?: string;
     /** File mtime in epoch ms — drives maxAge filtering (TODO 8.1). 0 if unknown. */
-    updatedAt?: number;
+    mtimeMs?: number;
     /**
      * 固定/置顶 (feedback#18 方案 A): a pinned memory is exempt from maxAge
      * injection filtering and sorts first in the injected context. UI surfaces
@@ -49,15 +58,20 @@ export interface MemoryEntry {
      * "manual" (or absent — legacy files) = written by the user/UI. Lets the
      * UI distinguish curated memories from extractor noise.
      */
-    origin?: "auto" | "manual";
+    origin?: MemoryOrigin;
     /**
-     * Recall lifecycle (召回 TTL). `usageCount` increments each time MemoryRead
-     * hits this entry; `lastUsed` is the ISO timestamp of that last hit; `created`
-     * is set on first save and preserved across UPDATE. Drives recall-based TTL:
+     * Recall lifecycle (召回 TTL). `useCount` increments each time MemoryRead
+     * hits this entry; `lastUsedAt` is the ISO timestamp of that last hit;
+     * `createdAt` is set on first save and preserved across UPDATE. Drives recall-based TTL:
      * a `project`-type memory not read for N days is pruned. Stored in frontmatter
-     * — no SQLite. Legacy files lacking these fields read back as
-     * {usageCount:0, lastUsed/created ← mtime}, never hidden.
+     * — no SQLite. Legacy `usageCount/lastUsed/created` fields are still read and
+     * exposed through their old aliases for compatibility.
      */
+    useCount?: number;
+    updateCount?: number;
+    lastUsedAt?: string;
+    createdAt?: string;
+    /** Legacy compatibility aliases. New writes use useCount/lastUsedAt/createdAt. */
     usageCount?: number;
     lastUsed?: string;
     created?: string;
@@ -67,6 +81,15 @@ export interface MemoryEntry {
      * user store (not the current one). Absent → fall back to no-repo / global.
      */
     originProject?: string;
+    /** Global dream promotion metadata (P1). */
+    promotionKey?: string;
+    originProjects?: string[];
+    evidenceCount?: number;
+    firstSeenAt?: string;
+    lastSeenAt?: string;
+    promotionReason?: string;
+    promotionStatus?: "pending" | "rejected";
+    promotionSourceId?: string;
 }
 /**
  * Drop memories older than `maxAgeDays` (by file mtime) for context injection
@@ -75,6 +98,12 @@ export interface MemoryEntry {
  * just because we couldn't read its timestamp. Pure + testable.
  */
 export declare function filterByAge(entries: MemoryEntry[], maxAgeDays?: number, now?: number): MemoryEntry[];
+export interface SaveMemoryOptions {
+    /** False for lifecycle-only writes such as recordRecall and pin/unpin. */
+    incrementUpdateCount?: boolean;
+    /** Force provenance regardless of model/tool args. Used by origin guards. */
+    forceOrigin?: MemoryOrigin;
+}
 export interface MemoryManagerOptions {
     /** Project root path; when set, memories are scoped under projects/<hash>/memory. */
     projectDir?: string;
@@ -97,13 +126,18 @@ export declare class MemoryManager {
     getMemoryDir(): string;
     getScope(): MemoryScope;
     /**
-     * Save a memory entry. Creates the file and updates the index.
+     * Save a memory entry. New entries get a stable id and `<id>.md`; entries
+     * carrying an existing id update that file even when name changes.
      */
-    save(entry: Omit<MemoryEntry, "fileName" | "scope">): string;
+    save(entry: Omit<MemoryEntry, "fileName" | "scope">, opts?: SaveMemoryOptions): string;
     /**
      * Load all memory entries.
      */
     loadAll(): MemoryEntry[];
+    findById(id: string): MemoryEntry | undefined;
+    find(nameOrFileOrId: string): MemoryEntry | undefined;
+    isOwnedBy(entry: MemoryEntry | undefined, allowedOrigins: readonly MemoryOrigin[]): boolean;
+    deleteIfOwned(nameOrFileOrId: string, allowedOrigins: readonly MemoryOrigin[]): "deleted" | "not_found" | "protected";
     /**
      * Load a single memory file.
      */
@@ -136,13 +170,14 @@ export declare class MemoryManager {
      */
     pruneByRecall(ttlDays: number, now?: Date): string[];
     /**
-     * Approve a pending memory: move it from the pending scope into the user scope
-     * of the SAME memory root (pending only ever exists at the global root — the
-     * approval门 only gates global writes). Must be called on a pending-scope
-     * manager. Returns the new user filename, or null if not found / wrong scope.
+     * Approve a pending memory: move it from the pending scope into the global
+     * dream scope of the SAME memory root. Pending only ever exists at the global
+     * root; approval gates whether a suggested global dream becomes injected.
+     * Must be called on a pending-scope manager. Returns the new global dream
+     * filename, or null if not found / wrong scope.
      *
-     * 审批门 (用户拍板): the only path that moves an auto-extracted memory into the
-     * curated, injected global user store.
+     * 审批门 (用户拍板): the only path that moves a suggested global dream into the
+     * injected global dream store.
      */
     approvePending(nameOrFile: string): string | null;
     /**
@@ -150,7 +185,12 @@ export declare class MemoryManager {
      * user store (originProject)。无 originProject 时落全局 user(兜底,不丢)。
      */
     demotePending(nameOrFile: string): string | null;
-    /** Shared move for approve(→global user)/demote(→origin-project user). */
+    /**
+     * Reject a pending global-dream suggestion. The project dream entry stays in
+     * place, but is marked so the same source is not suggested again.
+     */
+    rejectPending(nameOrFile: string): boolean;
+    /** Shared move for approve(→global dream)/demote(→origin-project user). */
     private movePending;
     /**
      * Promote a project-level user memory to the GLOBAL user store (用户手动点
@@ -214,5 +254,8 @@ export declare class MemoryManager {
      */
     private ensureIndexCache;
     private writeIndex;
-    private slugify;
+    private generateId;
+    private availableFileNameForId;
+    private fileNameForId;
+    private parseSyntheticLegacyId;
 }