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

package/dist/services/dream-consolidation.js

@@ -13,17 +13,17 @@
  * The loop is intentionally small and offline:
  *   - No streaming, no UI events — it runs in the background.
  *   - No permission prompts — there is no interactive backend on this path, so
- *     we hard-reject any attempt to Save/Delete in the "user" scope before
- *     dispatching. The "dream" scope is the LLM's workspace and goes through
- *     freely.
+ *     Save/Delete goes through an origin guard before dispatching. Dream may
+ *     maintain origin:dream/auto entries but never touches origin:manual.
  *   - Capped at MAX_TURNS LLM round-trips and MAX_WRITES total mutations to
  *     bound damage on misbehavior.
  */
 import { MemoryManager } from "../session/memory.js";
-import { buildDreamSystemPrompt, buildDreamUserPrompt, } from "./auto-dream.js";
+import { buildDreamSystemPrompt, buildDreamUserPrompt } from "./auto-dream.js";
 import { logger } from "../logging/logger.js";
 const MAX_TURNS = 8;
 const MAX_WRITES = 10;
+const FRESH_ENTRY_GRACE_MS = 10 * 60 * 1000;
 const MEMORY_TOOL_NAMES = ["MemoryList", "MemoryRead", "MemorySave", "MemoryDelete"];
 /**
  * Drive the dream-scope consolidation tool-call loop.
@@ -37,9 +37,7 @@ const MEMORY_TOOL_NAMES = ["MemoryList", "MemoryRead", "MemorySave", "MemoryDele
  */
 export async function runDreamConsolidation(input) {
     const { llmClient, toolRegistry, projectDir, sessionId } = input;
-    const memoryTools = MEMORY_TOOL_NAMES
-        .map((n) => toolRegistry.getTool(n))
-        .filter((t) => t != null);
+    const memoryTools = MEMORY_TOOL_NAMES.map((n) => toolRegistry.getTool(n)).filter((t) => t != null);
     if (memoryTools.length < MEMORY_TOOL_NAMES.length) {
         logger.warn("memory.dream_missing_tools", {
             sessionId,
@@ -52,8 +50,9 @@ export async function runDreamConsolidation(input) {
     const mm = new MemoryManager({ projectDir });
     const userMems = mm.loadScope("user");
     const dreamMems = mm.loadScope("dream");
+    const globalDreamMems = projectDir ? new MemoryManager({ scope: "dream" }).loadAll() : [];
     const systemPrompt = buildDreamSystemPrompt();
-    const userPrompt = buildDreamUserPrompt(userMems, dreamMems);
+    const userPrompt = buildDreamUserPrompt(userMems, dreamMems, globalDreamMems);
     // Strip RegisteredTool down to the shape createMessage expects.
     const toolDefs = memoryTools.map((t) => ({
         name: t.name,
@@ -120,8 +119,8 @@ export async function runDreamConsolidation(input) {
  * Execute one memory tool call inside the dream loop. Enforces the two
  * dream-loop invariants the prompt also states:
  *   - Only the 4 memory tools are dispatchable.
- *   - Save/Delete in "user" scope is refused (returned as a tool error)
- *     because dream runs without an interactive permission backend.
+ *   - Save/Delete is allowed only for origin:auto/origin:dream owned entries.
+ *     Missing origin is manual, and manual is always protected.
  */
 async function dispatchDreamTool(tc, toolRegistry, ctx, consumeWriteBudget) {
     const allowed = new Set(MEMORY_TOOL_NAMES);
@@ -130,17 +129,17 @@ async function dispatchDreamTool(tc, toolRegistry, ctx, consumeWriteBudget) {
     }
     const isWrite = tc.toolName === "MemorySave" || tc.toolName === "MemoryDelete";
     if (isWrite) {
-        const scope = tc.args?.scope;
-        if (scope !== "dream") {
-            return (`Error: dream loop may only write to scope "dream", got "${scope}". ` +
-                `User-scope changes require interactive permission, which is not available here.`);
+        const guard = checkDreamWriteGuard(tc, ctx);
+        if (!guard.ok) {
+            return guard.error;
         }
         if (!consumeWriteBudget()) {
             return "Error: dream write budget exhausted — stop calling write tools and summarize instead.";
         }
     }
     try {
-        const result = await toolRegistry.executeTool(tc.toolName, tc.args, { ctx });
+        const dreamCtx = { ...ctx, __dreamLoop: true };
+        const result = await toolRegistry.executeTool(tc.toolName, tc.args, { ctx: dreamCtx });
         if (result.isError)
             return result.error ?? `Error executing ${tc.toolName}`;
         return result.result ?? "";
@@ -149,3 +148,54 @@ async function dispatchDreamTool(tc, toolRegistry, ctx, consumeWriteBudget) {
         return `Error executing ${tc.toolName}: ${err.message}`;
     }
 }
+function checkDreamWriteGuard(tc, ctx) {
+    const scope = tc.args?.scope;
+    if (scope !== "dream" && scope !== "user") {
+        return {
+            ok: false,
+            error: `Error: dream loop may only write to scope "dream" or "user", got "${scope}".`,
+        };
+    }
+    const location = tc.args?.location === "global" ? "global" : "project";
+    const mm = new MemoryManager({
+        projectDir: location === "project" ? ctx.cwd : undefined,
+        scope,
+    });
+    const id = typeof tc.args?.id === "string" ? tc.args.id : undefined;
+    const name = typeof tc.args?.name === "string" ? tc.args.name : undefined;
+    const targetById = id ? mm.findById(id) : undefined;
+    const targetByName = name ? mm.find(name) : undefined;
+    const targets = [targetById, targetByName].filter((target, index, all) => Boolean(target) && all.findIndex((item) => item?.id === target?.id) === index);
+    const protectedTarget = targets.find((target) => target.origin === "manual" || !target.origin);
+    if (protectedTarget) {
+        return {
+            ok: false,
+            error: `Error: dream loop cannot modify origin:manual memory "${protectedTarget.name}" ` +
+                `(${location}/${scope}/${protectedTarget.id ?? protectedTarget.fileName}).`,
+        };
+    }
+    const target = targetById ?? targetByName;
+    if (!target)
+        return { ok: true };
+    if (target.origin !== "auto" && target.origin !== "dream") {
+        return {
+            ok: false,
+            error: `Error: dream loop can only modify origin:auto or origin:dream memories; ` +
+                `"${target.name}" has origin:${target.origin}.`,
+        };
+    }
+    if (tc.toolName === "MemoryDelete" && isFreshEntry(target.createdAt)) {
+        return {
+            ok: false,
+            error: `Error: dream loop cannot delete freshly-created memory "${target.name}" yet; ` +
+                "leave it for the next consolidation pass.",
+        };
+    }
+    return { ok: true };
+}
+function isFreshEntry(createdAt) {
+    if (!createdAt)
+        return false;
+    const createdMs = new Date(createdAt).getTime();
+    return Number.isFinite(createdMs) && Date.now() - createdMs < FRESH_ENTRY_GRACE_MS;
+}

package/dist/services/extract-memories.d.ts

@@ -18,17 +18,26 @@ export interface ExtractedMemory {
     description: string;
     content: string;
 }
+export interface ExistingMemorySummary {
+    id?: string;
+    name: string;
+    type: string;
+    description: string;
+    location?: "project" | "global";
+    memoryScope?: "user" | "dream";
+    origin?: "manual" | "auto" | "dream";
+    pinned?: boolean;
+    useCount?: number;
+    updateCount?: number;
+    updatedAt?: string;
+}
 /**
  * Build the prompt for extracting memories from a conversation.
  */
 export declare function buildExtractionPrompt(transcript: Array<{
     role: string;
     content: string;
-}>, existingMemories: Array<{
-    name: string;
-    type: string;
-    description: string;
-}>): string;
+}>, existingMemories: ExistingMemorySummary[]): string;
 /** Max memories to accept from a single extraction pass. Code-side cap that
  *  enforces the same limit the prompt asks for — the model occasionally
  *  ignores prompt rules, but this guarantees the cap. */

package/dist/services/extract-memories.js

@@ -12,7 +12,21 @@ export function buildExtractionPrompt(transcript, existingMemories) {
         .map((m) => `[${m.role}]: ${m.content.slice(0, 3000)}`)
         .join("\n\n");
     const existingList = existingMemories.length > 0
-        ? existingMemories.map((m) => `  - [${m.type}] ${m.name}: ${m.description}`).join("\n")
+        ? existingMemories
+            .map((m) => {
+            const meta = [
+                m.id ? `id:${m.id}` : null,
+                m.location ? `location:${m.location}` : null,
+                m.memoryScope ? `scope:${m.memoryScope}` : null,
+                m.origin ? `origin:${m.origin}` : null,
+                typeof m.useCount === "number" ? `use:${m.useCount}` : null,
+                typeof m.updateCount === "number" ? `updates:${m.updateCount}` : null,
+            ]
+                .filter(Boolean)
+                .join(", ");
+            return `  - [${m.type}] ${m.name}${meta ? ` (${meta})` : ""}: ${m.description}`;
+        })
+            .join("\n")
         : "  (none)";
     return `Analyze the following conversation and extract any information worth remembering for future sessions.
 
@@ -23,7 +37,7 @@ ${existingList}
 ${conversationText.slice(0, 30000)}
 
 ## Instructions
-Identify NEW information that should be saved as persistent memories. Categories (type):
+Identify candidate information that may be saved as persistent memories. The extractor only proposes candidates; code will route automatic candidates into dream memory first, never directly into user memory. Categories (type):
 - **user**: Information about the user's role, preferences, or expertise
 - **feedback**: Guidance about how to approach work (corrections or confirmations)
 - **project**: Non-obvious facts about ongoing work, goals, or decisions
@@ -39,7 +53,10 @@ Rules:
 - Extract AT MOST 2 memories per session. Prefer 0 to a marginal one — most sessions are noise.
 - AT MOST 1 of the extracted memories may be "global". The global layer is injected every session, so keep it tiny and high-value. If two candidates both seem global, keep the single most universal one global and make the other "project".
 - Only extract information that would be useful in FUTURE conversations
-- Do not duplicate existing memories (re-read the "Existing Memories" list above carefully)
+- Do not duplicate existing memories (re-read the "Existing Memories" list above carefully).
+- If an existing auto/dream memory has the same durable topic, reuse that topic in the candidate instead of creating a date-stamped variant; the write decision layer will update the existing id.
+- Manual user memories are read-only curated memories. Do not re-extract the same topic just because the wording or date differs.
+- Avoid dates, version stamps, batch names, and progress-snapshot suffixes in names. Names should be stable topic identifiers, not "today" variants.
 - Do not extract code patterns, file structures, or git history (derivable from code)
 - Do not extract ephemeral task details, progress snapshots, or in-flight work state — those belong in the conversation, not memory
 - Do not extract one-off research products (news reports, AI industry summaries, slide deck content, daily progress dumps) — they're done and not "durable, reusable information"

package/dist/services/global-dream-promotion.d.ts

@@ -0,0 +1,23 @@
+import type { ExtractedMemory } from "./extract-memories.js";
+export interface GlobalDreamPromotionInput {
+    candidate: ExtractedMemory;
+    projectDir?: string;
+    baseDir?: string;
+    userDirectGlobal?: boolean;
+    now?: Date;
+}
+export interface GlobalDreamPromotionResult {
+    /** No automatic write to global dream is performed; approval is required. */
+    promoted: false;
+    /** True when this call created a new pending approval item. */
+    pendingSuggested: boolean;
+    originProjects: string[];
+    evidenceCount: number;
+    projectEvidenceSaved: boolean;
+    promotionReason: string;
+}
+export declare function detectUserDirectGlobalPreference(transcript: Array<{
+    role: string;
+    content: string;
+}>): boolean;
+export declare function applyGlobalDreamPromotionGate(input: GlobalDreamPromotionInput): GlobalDreamPromotionResult;

package/dist/services/global-dream-promotion.js

@@ -0,0 +1,112 @@
+import { MemoryManager, resolveMemoryBaseDir } from "../session/memory.js";
+export function detectUserDirectGlobalPreference(transcript) {
+    const userText = transcript
+        .filter((m) => m.role === "user")
+        .map((m) => m.content)
+        .join("\n")
+        .toLowerCase();
+    return (/(?:全局记住|全局保存|所有项目|全部项目|以后所有项目|今后所有项目|以后都|以后默认|我偏好|我的偏好)/u.test(userText) ||
+        /(?:remember globally|global memory|all projects|every project|my preference|i prefer|always remember)/i.test(userText));
+}
+export function applyGlobalDreamPromotionGate(input) {
+    const baseDir = resolveMemoryBaseDir(input.baseDir);
+    const now = input.now ?? new Date();
+    const nowIso = now.toISOString();
+    const promotionReason = input.userDirectGlobal
+        ? "user-direct global preference suggested global dream approval"
+        : "candidate suggested global dream approval";
+    const projectEvidence = input.projectDir
+        ? saveProjectDreamCandidate({
+            baseDir,
+            projectDir: input.projectDir,
+            candidate: input.candidate,
+            nowIso,
+            promotionReason,
+        })
+        : undefined;
+    const originProjects = projectEvidence?.originProjects ?? (input.projectDir ? [input.projectDir] : []);
+    const rejected = projectEvidence?.promotionStatus === "rejected";
+    const pendingSuggested = !rejected &&
+        savePendingGlobalSuggestion({
+            baseDir,
+            projectDir: input.projectDir,
+            candidate: input.candidate,
+            source: projectEvidence,
+            originProjects,
+            nowIso,
+            promotionReason,
+        });
+    return {
+        promoted: false,
+        pendingSuggested,
+        originProjects,
+        evidenceCount: originProjects.length,
+        projectEvidenceSaved: Boolean(projectEvidence),
+        promotionReason,
+    };
+}
+function saveProjectDreamCandidate(input) {
+    const mm = new MemoryManager({
+        baseDir: input.baseDir,
+        projectDir: input.projectDir,
+        scope: "dream",
+    });
+    const existing = mm
+        .loadAll()
+        .find((entry) => entry.name === input.candidate.name &&
+        (entry.origin === "auto" || entry.origin === "dream"));
+    const originProjects = unique([...(existing?.originProjects ?? []), input.projectDir]);
+    const promotionStatus = existing?.promotionStatus === "rejected" ? "rejected" : "pending";
+    const fileName = mm.save({
+        id: existing?.id,
+        name: input.candidate.name,
+        description: input.candidate.description,
+        type: input.candidate.type,
+        content: input.candidate.content,
+        origin: existing?.origin ?? "auto",
+        pinned: existing?.pinned,
+        createdAt: existing?.createdAt,
+        useCount: existing?.useCount,
+        updateCount: existing?.updateCount,
+        lastUsedAt: existing?.lastUsedAt,
+        originProject: input.projectDir,
+        originProjects,
+        evidenceCount: originProjects.length,
+        firstSeenAt: existing?.firstSeenAt ?? existing?.createdAt ?? input.nowIso,
+        lastSeenAt: input.nowIso,
+        promotionReason: input.promotionReason,
+        promotionStatus,
+    }, { forceOrigin: existing?.origin ?? "auto" });
+    return mm.find(fileName);
+}
+function savePendingGlobalSuggestion(input) {
+    const globalDream = new MemoryManager({ baseDir: input.baseDir, scope: "dream" });
+    if (globalDream.loadAll().some((entry) => entry.name === input.candidate.name))
+        return false;
+    const pending = new MemoryManager({ baseDir: input.baseDir, scope: "pending" });
+    const duplicate = pending
+        .loadAll()
+        .some((entry) => entry.name === input.candidate.name &&
+        (entry.originProject ?? "") === (input.projectDir ?? ""));
+    if (duplicate)
+        return false;
+    pending.save({
+        name: input.candidate.name,
+        description: input.candidate.description,
+        type: input.candidate.type,
+        content: input.candidate.content,
+        origin: "dream",
+        originProject: input.projectDir,
+        originProjects: input.originProjects,
+        evidenceCount: input.originProjects.length,
+        firstSeenAt: input.source?.firstSeenAt ?? input.source?.createdAt ?? input.nowIso,
+        lastSeenAt: input.nowIso,
+        promotionReason: input.promotionReason,
+        promotionStatus: "pending",
+        promotionSourceId: input.source?.id,
+    }, { forceOrigin: "dream" });
+    return true;
+}
+function unique(values) {
+    return [...new Set(values.filter((value) => Boolean(value)))];
+}