@nanhara/hara 0.130.2 → 0.131.1

package/dist/recall.js

@@ -8,6 +8,113 @@ import { walkFiles, walkFilesAsync } from "./fs-walk.js";
 import { skillsDirs } from "./skills/skills.js";
 import { readModelContextFileSync } from "./fs-read.js";
 const MAX_RECALL_SOURCE_BYTES = 256 * 1024;
+const SEARCH_SNIPPET_CHARS = 800;
+const WORD_STOP = new Set("a an and are can could did do for from i in is it me my of on or our please that the this to was we what when where with you your".split(" "));
+const CJK_STOP = new Set(["之前", "以前", "对话", "会话", "搜索", "查找", "记得", "那个", "这个", "一下", "帮我", "关于", "内容", "讨论"]);
+function normalized(value) {
+    return value.normalize("NFKC").toLocaleLowerCase();
+}
+/** Whitespace-only tokenization makes an ordinary Chinese sentence one impossible giant term. Keep
+ * ordinary words, and use overlapping Han bigrams so lexical recall remains useful without a tokenizer
+ * dependency or embeddings. */
+export function lexicalSearchTerms(query) {
+    const segments = [];
+    let kind = null;
+    let current = "";
+    const flush = () => {
+        if (kind && current)
+            segments.push({ kind, text: current });
+        current = "";
+        kind = null;
+    };
+    for (const char of normalized(query)) {
+        const nextKind = /^\p{Script=Han}$/u.test(char)
+            ? "han"
+            : /^[\p{L}\p{N}_.+#@-]$/u.test(char)
+                ? "word"
+                : null;
+        if (!nextKind) {
+            flush();
+            continue;
+        }
+        if (kind && kind !== nextKind)
+            flush();
+        kind = nextKind;
+        current += char;
+    }
+    flush();
+    const terms = new Set();
+    const fallbackTerms = new Set();
+    for (const segment of segments) {
+        if (segment.kind === "han") {
+            const chars = [...segment.text];
+            if (chars.length <= 2) {
+                fallbackTerms.add(segment.text);
+                if (!CJK_STOP.has(segment.text))
+                    terms.add(segment.text);
+            }
+            else {
+                for (let index = 0; index < chars.length - 1; index += 1) {
+                    const pair = `${chars[index]}${chars[index + 1]}`;
+                    fallbackTerms.add(pair);
+                    if (!CJK_STOP.has(pair))
+                        terms.add(pair);
+                }
+            }
+        }
+        else {
+            fallbackTerms.add(segment.text);
+            if (!WORD_STOP.has(segment.text))
+                terms.add(segment.text);
+        }
+    }
+    const all = [...(terms.size ? terms : fallbackTerms)];
+    return all.length <= 48 ? all : [...all.slice(0, 24), ...all.slice(-24)];
+}
+/** Return the most relevant bounded window rather than the first bytes of the file. MEMORY.md and daily
+ * logs grow append-only, so a header-only snippet can report a hit while hiding the matching fact. */
+export function matchCenteredSnippet(text, terms, max = SEARCH_SNIPPET_CHARS) {
+    if (text.length <= max)
+        return text;
+    const haystack = normalized(text);
+    const positions = [];
+    for (const term of terms) {
+        let from = 0;
+        for (let count = 0; count < 16; count += 1) {
+            const found = haystack.indexOf(term, from);
+            if (found < 0)
+                break;
+            positions.push(found);
+            from = found + Math.max(1, term.length);
+        }
+    }
+    if (!positions.length)
+        return `${text.slice(0, max).trimEnd()}…`;
+    let anchor = positions[0];
+    let bestScore = -1;
+    for (const position of positions) {
+        const start = Math.max(0, position - Math.floor(max * 0.35));
+        const end = start + max;
+        const score = terms.reduce((sum, term) => {
+            const found = haystack.indexOf(term, start);
+            return sum + (found >= start && found < end ? 1 : 0);
+        }, 0);
+        if (score > bestScore) {
+            bestScore = score;
+            anchor = position;
+        }
+    }
+    let start = Math.max(0, anchor - Math.floor(max * 0.35));
+    const priorLine = text.lastIndexOf("\n", start);
+    if (priorLine >= 0 && start - priorLine <= 160)
+        start = priorLine + 1;
+    let end = Math.min(text.length, start + max);
+    const nextLine = text.indexOf("\n", end);
+    if (nextLine >= 0 && nextLine - end <= 160)
+        end = nextLine;
+    const excerpt = text.slice(start, end).trim();
+    return `${start > 0 ? "…\n" : ""}${excerpt}${end < text.length ? "\n…" : ""}`;
+}
 export function assetsDir() {
     return process.env.HARA_ASSETS || join(homedir(), ".hara", "code-assets");
 }
@@ -48,7 +155,7 @@ export function metaBoost(text, title, words) {
 export function searchAssets(query, limit = 5, roots) {
     const dirs = roots ?? [assetsDir()];
     const abs = roots !== undefined;
-    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const words = lexicalSearchTerms(query);
     if (!words.length)
         return [];
     const hits = [];
@@ -63,12 +170,12 @@ export function searchAssets(query, limit = 5, roots) {
             catch {
                 continue;
             }
-            const hay = (rel + "\n" + text).toLowerCase();
+            const hay = normalized(rel + "\n" + text);
             const score = words.filter((w) => hay.includes(w)).length; // distinct query words present (dedup threshold uses this)
             if (!score)
                 continue;
             const title = titleOf(text, rel);
-            hits.push({ path: abs ? join(dir, rel) : rel, title, snippet: text.slice(0, 800), score, boost: metaBoost(text, title, words) });
+            hits.push({ path: abs ? join(dir, rel) : rel, title, snippet: matchCenteredSnippet(text, words), score, boost: metaBoost(text, title, words) });
         }
     }
     // rank by relevance, then by the declared-dimension boost (title/tags/lang), then prefer the shorter path
@@ -79,7 +186,7 @@ export function searchAssets(query, limit = 5, roots) {
 export async function searchAssetsAsync(query, limit = 5, roots, options = {}) {
     const dirs = roots ?? [assetsDir()];
     const abs = roots !== undefined;
-    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const words = lexicalSearchTerms(query);
     if (!words.length)
         return [];
     const timeoutMs = Number.isFinite(options.timeoutMs) ? Math.max(0, Math.floor(options.timeoutMs)) : 2_000;
@@ -130,12 +237,12 @@ export async function searchAssetsAsync(query, limit = 5, roots, options = {}) {
             catch {
                 continue;
             }
-            const hay = (rel + "\n" + text).toLowerCase();
+            const hay = normalized(rel + "\n" + text);
             const score = words.filter((word) => hay.includes(word)).length;
             if (!score)
                 continue;
             const title = titleOf(text, rel);
-            hits.push({ path: abs ? join(dir, rel) : rel, title, snippet: text.slice(0, 800), score, boost: metaBoost(text, title, words) });
+            hits.push({ path: abs ? join(dir, rel) : rel, title, snippet: matchCenteredSnippet(text, words), score, boost: metaBoost(text, title, words) });
         }
         if (Date.now() - startedAt >= timeoutMs || inventory.truncated)
             break;

package/dist/search/hybrid.js

@@ -23,11 +23,18 @@ export async function searchHybrid(query, cwd, opts) {
     }
     const out = [];
     const seen = new Set();
+    const lexicalByPath = new Map(lex.map((hit) => [hit.path, hit]));
     for (const s of sem) {
         if (s.score < 0.2 || seen.has(s.file))
             continue;
         seen.add(s.file);
-        out.push({ path: s.file, title: titleOf(s.text, s.file), snippet: s.text.slice(0, 800), score: s.score });
+        const exactLexical = lexicalByPath.get(s.file);
+        // If the same file has a literal hit, keep its match-centered live snippet. The semantic cache may
+        // correctly choose MEMORY.md yet point at a different heading/chunk, hiding the exact fact the user
+        // searched for. Semantic ranking still chooses the file; lexical evidence chooses the excerpt.
+        out.push(exactLexical
+            ? { ...exactLexical, score: Math.max(exactLexical.score, s.score) }
+            : { path: s.file, title: titleOf(s.text, s.file), snippet: s.text.slice(0, 800), score: s.score });
     }
     for (const h of lex) {
         if (out.length >= limit)

package/dist/search/semindex.js

@@ -12,6 +12,7 @@ import { zvecBuild, zvecQueryIds, zvecRemove } from "./zvec-store.js";
 import { isSensitiveFilePath } from "../security/sensitive-files.js";
 import { readModelContextFileSync } from "../fs-read.js";
 import { homeWorkspaceActionError, isUnsafeProjectWorkspace } from "../context/workspace-scope.js";
+import { sanitizeMemoryForPrompt } from "../memory/guard.js";
 import { ensurePrivateStateSubdirectory, readPrivateStateFileSnapshot, removePrivateStateFile, } from "../security/private-state.js";
 import { atomicWriteText, bindHaraPrivateStateWritePath, } from "../fs-write.js";
 // Same code/text extensions codebase_search ranks lexically — keep the two walks in sync.
@@ -79,6 +80,9 @@ function statMtime(p) {
         return 0;
     }
 }
+function indexableText(text, source) {
+    return source === "memory" ? sanitizeMemoryForPrompt(text).text : text;
+}
 /** Split a file into chunks: Markdown by `#` headings, code by ~40-line windows. Heuristic, zero-dep —
  *  also the substrate embeddings reuse. `mtime` (when given) is stamped on every chunk for incremental reuse. */
 export function chunkText(text, file, source, mtime) {
@@ -248,7 +252,9 @@ export function collectDirChunks(dir, source) {
         catch {
             continue;
         }
-        chunks.push(...chunkText(text, abs, source, statMtime(abs)));
+        const safeText = indexableText(text, source);
+        if (safeText.trim())
+            chunks.push(...chunkText(safeText, abs, source, statMtime(abs)));
     }
     return chunks;
 }
@@ -295,7 +301,9 @@ async function chunksFromInventory(root, files, source, absolutePaths, startedAt
         catch {
             continue;
         }
-        chunks.push(...chunkText(text, absolutePaths ? abs : rel, source, statMtime(abs)));
+        const safeText = indexableText(text, source);
+        if (safeText.trim())
+            chunks.push(...chunkText(safeText, absolutePaths ? abs : rel, source, statMtime(abs)));
     }
     return { chunks, truncated: false };
 }
@@ -382,7 +390,7 @@ export async function queryIndex(name, query, embed, cwd, k = 6, signal) {
             return cached;
         let fresh = false;
         try {
-            const text = readModelContextFileSync(path, 200_000);
+            const text = indexableText(readModelContextFileSync(path, 200_000), item.source);
             fresh = contentHash(chunkText(text, item.file, item.source)) === item.contentHash;
         }
         catch {

package/dist/serve/protocol.js

@@ -10,7 +10,7 @@
 //   session.list      {cwd?}                     → {sessions:[{id,title,cwd,model,updatedAt}]}
 //   session.create    {cwd?,approval?}           → {sessionId,model}
 //   session.resume    {sessionId}                → {sessionId,model,history:[{role,text}]}
-//   session.send      {sessionId,text,images?,newTask?} → (streams events, then) {reply,usage,taskId,turnId}
+//   session.send      {sessionId,text,images?,newTask?} → (streams events, then) {reply,usage,taskId,turnId,status?,stopReason?}
 //   session.steer     {sessionId,text,expectedTurnId} → {accepted,taskId,turnId}
 //                      images: [{path,mediaType?}] — pasted screenshots etc., inlined for vision models
 //   session.interrupt {sessionId}                → {}
@@ -41,7 +41,7 @@
 //   session.set-model {sessionId,model?,effort?}  → {sessionId,model,effort} (next turn; refused mid-turn)
 // Server → client notifications (all carry sessionId):
 //   event.text / event.reasoning {delta} · event.tool {name,preview} · event.diff {text}
-//   event.notice {text} · event.turn_end {reply,usage,error?} · approval.request {approvalId,question}
+//   event.notice {text} · event.turn_end {reply,usage,error?,status?,stopReason?} · approval.request {approvalId,question}
 //   event.task_state {version,streamId,sequence,taskId,turnId,objective,state,taskStatus,phase,checkpoint,…}
 //                     authoritative execution plane; clients feature-detect it via capabilities.events
 export const PROTOCOL_VERSION = 1;

package/dist/serve/server.js

@@ -567,6 +567,7 @@ export async function startServe(opts, deps) {
                         cwd: s.meta.cwd,
                         sandbox: deps.sandbox,
                         todoScope: sessionId,
+                        sessionId,
                         spawn: (t, role, signal) => deps.spawnSubagent(s.provider, s.meta.cwd, s.projectContext, s.stats, t, role, signal, {
                             onProviderTurn: (turn) => observeProviderTurn(s, turn),
                             onToolRun: (toolRun) => observeToolRun(s, toolRun),
@@ -624,6 +625,31 @@ export async function startServe(opts, deps) {
                     : outcome.status === "halted"
                         ? "agent turn halted by a safety control"
                         : "agent turn failed");
+                if (outcome.status === "halted" && outcome.stopReason === "deadline") {
+                    // An active-execution deadline is a successful, recoverable checkpoint transition. The typed
+                    // task event already says `paused`; returning a normal RPC result keeps Desktop and other Serve
+                    // clients from rendering the same state as `error:` while still exposing the focused /continue
+                    // guidance to request/response-only clients. Other safety halts remain explicit failures.
+                    broadcast("event.turn_end", {
+                        sessionId,
+                        taskId: s.task.id,
+                        turnId: s.task.turnId,
+                        reply: "",
+                        status: "paused",
+                        stopReason: "deadline",
+                        usage,
+                        ctx,
+                    });
+                    return {
+                        reply: failure,
+                        usage,
+                        ctx,
+                        taskId: s.task.id,
+                        turnId: s.task.turnId,
+                        status: "paused",
+                        stopReason: "deadline",
+                    };
+                }
                 broadcast("event.turn_end", { sessionId, taskId: s.task.id, turnId: s.task.turnId, reply: "", error: failure, status: outcome.status, usage, ctx });
                 throw new Error(failure);
             }

package/dist/session/transfer.js

@@ -0,0 +1,62 @@
+import { canonicalProjectPath } from "../org/projects.js";
+import { forkTaskExecution } from "./task.js";
+import { acquireSessionLock, latestForCwd, newSessionId, releaseSessionLock, saveSession, } from "./store.js";
+export const RECENT_WORKSPACE_TRANSFER_MS = 30 * 60 * 1000;
+/** Find the recent interactive thread a direct `hara --cwd …` launch would otherwise leave behind.
+ * This is deliberately narrow: automated/archived/empty/old sessions never trigger an interactive prompt. */
+export function recentWorkspaceTransferCandidate(launchCwd, targetCwd, at = new Date()) {
+    const source = canonicalProjectPath(launchCwd, true);
+    const target = canonicalProjectPath(targetCwd, true);
+    if (!source || !target || source === target)
+        return null;
+    const session = latestForCwd(source);
+    if (!session || session.meta.archived || (session.meta.source && session.meta.source !== "interactive"))
+        return null;
+    if (session.history.length === 0)
+        return null;
+    const now = typeof at === "string" ? Date.parse(at) : at.getTime();
+    const updated = Date.parse(session.meta.updatedAt);
+    const age = now - updated;
+    if (!Number.isFinite(now) || !Number.isFinite(updated) || age < 0 || age > RECENT_WORKSPACE_TRANSFER_MS)
+        return null;
+    return session;
+}
+/** Copy a conversation into another workspace without mutating or re-routing its source session.
+ * A new identity is required because one session id is permanently bound to one canonical project root. */
+export function workspaceSessionFork(source, targetCwd, at = new Date()) {
+    const target = canonicalProjectPath(targetCwd, true);
+    if (!target)
+        throw new Error(`target workspace is unavailable: ${targetCwd}`);
+    const now = typeof at === "string" ? at : at.toISOString();
+    if (!Number.isFinite(Date.parse(now)))
+        throw new Error("workspace transfer timestamp is invalid");
+    const meta = structuredClone(source.meta);
+    meta.id = newSessionId();
+    meta.cwd = target;
+    meta.createdAt = now;
+    meta.updatedAt = "";
+    meta.source = "interactive";
+    delete meta.sourceName;
+    delete meta.archived;
+    delete meta.gatewayOwner;
+    const task = forkTaskExecution(source.task, now);
+    return {
+        meta,
+        history: structuredClone(source.history),
+        ...(task ? { task } : {}),
+    };
+}
+/** Persist a workspace fork under its own short-lived lock so the relaunched child can safely resume it. */
+export function persistWorkspaceSessionFork(source, targetCwd, at = new Date()) {
+    const fork = workspaceSessionFork(source, targetCwd, at);
+    const lock = acquireSessionLock(fork.meta.id);
+    if (!lock.ok)
+        throw new Error("could not reserve the transferred session id");
+    try {
+        saveSession(fork.meta, fork.history, fork.task);
+        return fork;
+    }
+    finally {
+        releaseSessionLock(fork.meta.id);
+    }
+}

package/dist/tools/all.js

@@ -10,6 +10,7 @@ import "./patch.js"; // apply_patch
 import "./web.js"; // web_search / web_fetch
 import "./agent.js"; // agent (subagent spawn)
 import "./memory.js"; // memory_search/get/write/forget + skill_create
+import "./session-search.js"; // bounded cross-session transcript recall
 import "./skill.js"; // skill loader
 import "./codebase.js"; // codebase_search
 import "./todo.js"; // todo_write

package/dist/tools/memory.js

@@ -5,8 +5,8 @@ import { isAbsolute, resolve, join, relative, sep } from "node:path";
 import { registerTool } from "./registry.js";
 import { searchAssetsAsync, assetSearchRoots } from "../recall.js";
 import { searchHybrid } from "../search/hybrid.js";
-import { memoryRoots, appendMemory, replaceMemory, forgetMemory } from "../memory/store.js";
-import { scanMemory, redactSecrets, scrubLocal } from "../memory/guard.js";
+import { memoryRoots, appendMemory, appendMemoryOnce, forgetMemory } from "../memory/store.js";
+import { scanMemory, redactSecrets, sanitizeMemoryForPrompt, scrubLocal } from "../memory/guard.js";
 import { globalSkillsDir, skillsDir, invalidateSkillsCache } from "../skills/skills.js";
 import { sensitiveFileError } from "../security/sensitive-files.js";
 import { readModelContextFileSync, readVerifiedRegularFileSnapshot } from "../fs-read.js";
@@ -15,7 +15,7 @@ export const MAX_MEMORY_ENTRY_CHARS = 4_000;
 export const MAX_SKILL_DESCRIPTION_CHARS = 500;
 export const MAX_SKILL_BODY_CHARS = 24_000;
 const asTarget = (v) => (["memory", "user", "log"].includes(v) ? v : "memory");
-const asScope = (v) => (v === "global" ? "global" : "project");
+const asScope = (v, target) => v === "global" ? "global" : v === "project" ? "project" : target === "user" ? "global" : "project";
 registerTool({
     name: "memory_search",
     description: "Search your durable memory (facts, decisions, user preferences, daily notes) by keywords. " +
@@ -26,12 +26,29 @@ registerTool({
         required: ["query"],
     },
     kind: "read",
-    concurrencySafe: true,
+    // Keep recall attempts serial so the empty-result breaker can stop after the third call even if a model
+    // emits a large batch of paraphrased searches in one response.
+    concurrencySafe: false,
     async run(input, ctx) {
-        const hits = await searchHybrid(String(input.query ?? ""), ctx.cwd, { indexName: "memory", roots: memoryRoots(ctx.cwd), limit: Math.min(Number(input.limit) || 5, 10), signal: ctx.signal });
-        if (!hits.length)
+        const query = String(input.query ?? "").trim();
+        if (!query)
+            return "Error: memory_search requires a non-empty query.";
+        if (query.length > 512)
+            return "Error: memory_search query is too long (maximum 512 characters).";
+        const limit = Math.max(1, Math.min(10, Math.floor(Number(input.limit) || 5)));
+        const hits = await searchHybrid(query, ctx.cwd, { indexName: "memory", roots: memoryRoots(ctx.cwd), limit, signal: ctx.signal });
+        const safeHits = hits
+            .map((hit) => ({
+            ...hit,
+            // Lexical search derives both fields from editable Markdown. Sanitize the heading as well as the
+            // excerpt so an unsafe first heading cannot bypass the memory load boundary as result metadata.
+            title: sanitizeMemoryForPrompt(hit.title).text.trim() || "memory",
+            snippet: sanitizeMemoryForPrompt(hit.snippet).text.trim(),
+        }))
+            .filter((hit) => hit.snippet);
+        if (!safeHits.length)
             return "(no memory matches)";
-        return hits.map((h) => `${h.path} — ${h.title}\n${h.snippet}`).join("\n\n");
+        return safeHits.map((h) => `${h.path} — ${h.title}\n${h.snippet}`).join("\n\n");
     },
 });
 registerTool({
@@ -53,7 +70,11 @@ registerTool({
         if (!existsSync(p))
             return `Error: no memory file at ${p}.`;
         try {
-            return readModelContextFileSync(p, 64 * 1024).slice(0, 50_000);
+            const raw = readModelContextFileSync(p, 64 * 1024).slice(0, 50_000);
+            const safe = sanitizeMemoryForPrompt(raw);
+            return safe.text.trim()
+                ? safe.text
+                : "Blocked: this memory file contains no content that is safe to load.";
         }
         catch (e) {
             return `Error: ${e.message}`;
@@ -69,9 +90,8 @@ registerTool({
         type: "object",
         properties: {
             content: { type: "string" },
-            target: { type: "string", enum: ["memory", "user", "log"], description: "memory=durable facts, user=user prefs (global), log=today's note. default memory" },
-            scope: { type: "string", enum: ["project", "global"], description: "default project" },
-            mode: { type: "string", enum: ["append", "replace"], description: "default append" },
+            target: { type: "string", enum: ["memory", "user", "log"], description: "memory=durable facts, user=user prefs (global by default), log=today's note. default memory" },
+            scope: { type: "string", enum: ["project", "global"], description: "default global for target=user; project otherwise" },
         },
         required: ["content"],
     },
@@ -86,12 +106,18 @@ registerTool({
         const scan = scanMemory(content);
         if (!scan.ok)
             return `Blocked: this looks unsafe to store (${scan.hits.join(", ")}). Rephrase without secrets/injection text.`;
-        const scope = asScope(input.scope);
         const target = asTarget(input.target);
-        const f = input.mode === "replace"
-            ? await replaceMemory(scope, target, content, ctx.cwd, ctx.signal)
-            : await appendMemory(scope, target, content, ctx.cwd, ctx.signal);
-        return `Saved to ${f}`;
+        const scope = asScope(input.scope, target);
+        if (input.mode === "replace") {
+            return "Blocked: memory_write cannot replace an entire memory file. Use memory_forget for the stale entry, then append the corrected fact.";
+        }
+        if (target === "log") {
+            const f = await appendMemory(scope, target, content, ctx.cwd, ctx.signal);
+            return `Saved to ${f}`;
+        }
+        const entry = content.replace(/\s+/g, " ").trim();
+        const result = await appendMemoryOnce(scope, target, entry, ctx.cwd, ctx.signal);
+        return result.appended ? `Saved to ${result.path}` : `Already remembered in ${result.path}`;
     },
 });
 registerTool({
@@ -206,7 +232,8 @@ registerTool({
     },
     kind: "edit",
     async run(input, ctx) {
-        const n = await forgetMemory(asScope(input.scope), asTarget(input.target), String(input.match ?? ""), ctx.cwd, ctx.signal);
+        const target = asTarget(input.target);
+        const n = await forgetMemory(asScope(input.scope, target), target, String(input.match ?? ""), ctx.cwd, ctx.signal);
         return n ? `Removed ${n} line(s).` : "(no matching lines)";
     },
 });