@nanhara/hara 0.122.2 → 0.122.4

package/dist/memory/store.js

@@ -57,15 +57,16 @@ async function inspectMemoryWrite(path, action) {
         throw error;
     }
 }
-async function commitMemoryText(path, text, action) {
+async function commitMemoryText(path, text, action, signal) {
     const { boundary, snapshot } = await inspectMemoryWrite(path, action);
     await atomicWriteText(boundary.target, text, {
         expected: snapshot?.text ?? null,
         expectedIdentity: snapshot ?? undefined,
         boundary,
+        signal,
     });
 }
-export async function appendMemory(scope, target, content, cwd) {
+export async function appendMemory(scope, target, content, cwd, signal) {
     const f = targetFile(scope, target, cwd);
     const { boundary, snapshot } = await inspectMemoryWrite(f, "append memory");
     const text = (snapshot ? `${snapshot.text}\n` : "") + content.trim() + "\n";
@@ -73,15 +74,16 @@ export async function appendMemory(scope, target, content, cwd) {
         expected: snapshot?.text ?? null,
         expectedIdentity: snapshot ?? undefined,
         boundary,
+        signal,
     });
     return f;
 }
-export async function replaceMemory(scope, target, content, cwd) {
+export async function replaceMemory(scope, target, content, cwd, signal) {
     const f = targetFile(scope, target, cwd);
-    await commitMemoryText(f, content.trim() + "\n", "replace memory");
+    await commitMemoryText(f, content.trim() + "\n", "replace memory", signal);
     return f;
 }
-export async function forgetMemory(scope, target, match, cwd) {
+export async function forgetMemory(scope, target, match, cwd, signal) {
     const f = targetFile(scope, target, cwd);
     if (!match)
         return 0;
@@ -97,6 +99,7 @@ export async function forgetMemory(scope, target, match, cwd) {
         expected: snapshot.text,
         expectedIdentity: snapshot,
         boundary,
+        signal,
     });
     return removed;
 }

package/dist/org/planner.js

@@ -4,6 +4,7 @@
 // at .hara/org/plan.json. This is hara's differentiator: not one agent, an org that plans.
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import { boundedProviderTurn } from "../providers/bounded-turn.js";
 import { runShell } from "../sandbox.js";
 import { readModelContextFileSync, readVerifiedRegularFileSnapshot } from "../fs-read.js";
 import { atomicWriteText, bindAtomicWritePath } from "../fs-write.js";
@@ -15,14 +16,16 @@ Return ONLY a JSON object, no prose:
 {"atoms":[{"id":"a1","title":"imperative step","detail":"how/where","deps":[],"verify":"observable done-criteria","check":"shell command exiting 0 iff done (optional)","role":"<roleId or omit>"}]}
 Rules: short ids (a1,a2,…); deps reference earlier ids only; typically 3-8 atoms; each atom small and verifiable. Prefer a concrete 'check' command (e.g. "npm test", "tsc --noEmit", "test -f src/x.ts") so a step is verified objectively; omit 'check' if none fits.`;
 /** Ask the model to decompose `task` into an atomized, sequenced plan. */
-export async function decompose(provider, task, roles) {
+export async function decompose(provider, task, roles, opts = {}) {
     const roleHint = roles.length ? `\nAvailable roles for the optional "role" field: ${roles.map((r) => r.id).join(", ")}.` : "";
-    const r = await provider.turn({
+    const r = await boundedProviderTurn(provider, {
         system: PLAN_SYSTEM + roleHint,
         history: [{ role: "user", content: `Task: ${task}\n\nReturn the JSON plan.` }],
         tools: [],
         onText: () => { },
-    });
+    }, { timeoutMs: opts.timeoutMs ?? 60_000, signal: opts.signal, label: "plan decomposition" });
+    if (r.stop === "error")
+        return { task, atoms: [], createdAt: new Date().toISOString() };
     return { task, atoms: parsePlan(r.text), createdAt: new Date().toISOString() };
 }
 /** Extract + normalize atoms from the model's (possibly fenced/noisy) JSON reply. */
@@ -124,8 +127,8 @@ export function atomPrompt(atom, plan, done) {
         `Use tools as needed. Finish with a one-line result.`);
 }
 /** Soft verification gate: ask the model whether the atom met its done-criteria. */
-export async function verify(provider, atom, transcriptTail) {
-    const r = await provider.turn({
+export async function verify(provider, atom, transcriptTail, opts = {}) {
+    const r = await boundedProviderTurn(provider, {
         system: "You verify whether a coding step met its done-criteria. " +
             "Reply EXACTLY 'DONE' if met, or 'NEEDSWORK: <short reason>' if not. No other text.",
         history: [
@@ -136,7 +139,9 @@ export async function verify(provider, atom, transcriptTail) {
         ],
         tools: [],
         onText: () => { },
-    });
+    }, { timeoutMs: opts.timeoutMs ?? 30_000, signal: opts.signal, label: "plan verification" });
+    if (r.stop === "error")
+        return { ok: false, reason: r.errorMsg?.slice(0, 200) || "plan verification failed" };
     const t = r.text.trim();
     if (/^done\b/i.test(t))
         return { ok: true, reason: "verified" };

package/dist/org/projects.js

@@ -5,8 +5,8 @@ import { isAbsolute, join, resolve } from "node:path";
 import { homedir } from "node:os";
 import { randomUUID } from "node:crypto";
 import { loadRoles, loadGlobalRoles } from "./roles.js";
+import { sleepSync } from "../sync-sleep.js";
 const PROJECT_NAME = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/;
-const sleepCell = new Int32Array(new SharedArrayBuffer(4));
 const LOCK_ATTEMPTS = 500;
 const LOCK_WAIT_MS = 10;
 function haraDir() {
@@ -101,7 +101,7 @@ function withProjectsLock(fn) {
                     continue;
                 }
             }
-            Atomics.wait(sleepCell, 0, 0, LOCK_WAIT_MS);
+            sleepSync(LOCK_WAIT_MS);
             continue;
         }
         const candidate = { pid: process.pid, token: randomUUID() };
@@ -132,7 +132,7 @@ function withProjectsLock(fn) {
                     rmSync(reclaim, { force: true });
             }
         }
-        Atomics.wait(sleepCell, 0, 0, LOCK_WAIT_MS);
+        sleepSync(LOCK_WAIT_MS);
     }
     if (!claim)
         throw new Error("projects registry is busy; retry the operation");

package/dist/process-identity.js

@@ -0,0 +1,52 @@
+// Cross-process birth identity used by file leases. Only a same-version, unequal identity proves PID reuse;
+// missing probes and format upgrades are deliberately "unknown" so callers fail closed.
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+/** Stable for one OS process lifetime. Unknown platforms/probe failures return null. */
+export function defaultProcessIdentity(pid) {
+    if (!Number.isSafeInteger(pid) || pid <= 0)
+        return null;
+    try {
+        if (process.platform === "linux") {
+            const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+            const close = stat.lastIndexOf(")");
+            if (close < 0)
+                return null;
+            // Fields after the comm closing parenthesis begin at field 3; starttime is field 22.
+            const startTicks = stat.slice(close + 1).trim().split(/\s+/)[19];
+            if (!/^\d+$/.test(startTicks ?? ""))
+                return null;
+            const bootId = readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim().toLowerCase();
+            if (!/^[a-f0-9-]{16,64}$/.test(bootId))
+                return null;
+            return `linux-v1:${bootId}:${startTicks}`;
+        }
+        if (process.platform === "darwin") {
+            // `lstart` is rendered in the child process' timezone. Fix both locale and TZ so the same live PID keeps
+            // one identity even if Hara's environment or the host timezone changes between lock acquisition/check.
+            const started = execFileSync("/bin/ps", ["-o", "lstart=", "-p", String(pid)], {
+                encoding: "utf8",
+                env: { ...process.env, LC_ALL: "C", TZ: "UTC0" },
+                maxBuffer: 1_024,
+                timeout: 1_000,
+                stdio: ["ignore", "pipe", "ignore"],
+            }).trim().replace(/\s+/g, " ");
+            return started ? `darwin-v1:${started}` : null;
+        }
+    }
+    catch {
+        return null;
+    }
+    return null;
+}
+export function compareProcessIdentity(expected, current) {
+    if (!expected || !current)
+        return "unknown";
+    const expectedSeparator = expected.indexOf(":");
+    const currentSeparator = current.indexOf(":");
+    if (expectedSeparator <= 0 || currentSeparator <= 0)
+        return "unknown";
+    if (expected.slice(0, expectedSeparator) !== current.slice(0, currentSeparator))
+        return "unknown";
+    return expected === current ? "same" : "different";
+}

package/dist/providers/bounded-turn.js

@@ -0,0 +1,42 @@
+const errorResult = (message) => ({ text: "", toolUses: [], stop: "error", errorMsg: message });
+/**
+ * Execute a one-shot provider call behind both cooperative cancellation and a hard Promise boundary.
+ *
+ * Passing only an AbortSignal is insufficient: third-party SDKs and custom providers may ignore it and
+ * leave their Promise pending forever. This helper aborts the request for cooperative providers while also
+ * resolving the caller independently. The abandoned provider Promise always retains rejection handling.
+ */
+export async function boundedProviderTurn(provider, args, options) {
+    const timeoutMs = Number.isFinite(options.timeoutMs) ? Math.max(1, Math.trunc(options.timeoutMs)) : 60_000;
+    const label = options.label?.trim() || "model call";
+    const parent = options.signal ?? args.signal;
+    if (parent?.aborted)
+        return errorResult(`${label} cancelled`);
+    const controller = new AbortController();
+    let stopResolve;
+    const stopped = new Promise((resolve) => (stopResolve = resolve));
+    let stopSettled = false;
+    const stop = (message) => {
+        if (stopSettled)
+            return;
+        stopSettled = true;
+        controller.abort(new Error(message));
+        stopResolve(errorResult(message));
+    };
+    const onParentAbort = () => stop(`${label} cancelled`);
+    parent?.addEventListener("abort", onParentAbort, { once: true });
+    // Keep this timer referenced. In a short-lived headless process it may be the only active handle keeping
+    // the hard boundary alive while a deliberately non-cooperative test/provider returns a handle-less Promise.
+    const timer = setTimeout(() => stop(`${label} timed out after ${timeoutMs}ms`), timeoutMs);
+    const turn = Promise.resolve()
+        // Cancellation may happen synchronously after this async function returns but before its provider
+        // microtask starts. Re-check here so an already-cancelled auxiliary call never incurs a request/cost.
+        .then(() => controller.signal.aborted ? errorResult(`${label} cancelled`) : provider.turn({ ...args, signal: controller.signal }))
+        .catch((error) => errorResult(error instanceof Error ? error.message : String(error)));
+    const result = await Promise.race([turn, stopped]);
+    clearTimeout(timer);
+    parent?.removeEventListener("abort", onParentAbort);
+    stopSettled = true;
+    // A parent cancellation remains authoritative if it raced a provider's late success.
+    return parent?.aborted ? errorResult(`${label} cancelled`) : result;
+}

package/dist/recall.js

@@ -4,7 +4,7 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { mkdirSync, writeFileSync, existsSync } from "node:fs";
-import { walkFiles } from "./fs-walk.js";
+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;
@@ -75,6 +75,74 @@ export function searchAssets(query, limit = 5, roots) {
     hits.sort((a, b) => b.score - a.score || b.boost - a.boost || a.path.length - b.path.length);
     return hits.slice(0, limit).map(({ boost, ...r }) => r);
 }
+/** Interruptible lexical search for agent/CLI paths. All roots and file reads share one wall budget. */
+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);
+    if (!words.length)
+        return [];
+    const timeoutMs = Number.isFinite(options.timeoutMs) ? Math.max(0, Math.floor(options.timeoutMs)) : 2_000;
+    const maxFiles = Number.isFinite(options.maxFiles) ? Math.max(0, Math.floor(options.maxFiles)) : 8_000;
+    const maxDirectories = Number.isFinite(options.maxDirectories) ? Math.max(0, Math.floor(options.maxDirectories)) : 20_000;
+    const maxEntries = Number.isFinite(options.maxEntries) ? Math.max(0, Math.floor(options.maxEntries)) : 100_000;
+    const startedAt = Date.now();
+    let filesLeft = maxFiles;
+    let directoriesLeft = maxDirectories;
+    let entriesLeft = maxEntries;
+    const hits = [];
+    for (const dir of dirs) {
+        if (options.signal?.aborted)
+            throw options.signal.reason instanceof Error ? options.signal.reason : new Error("asset search cancelled");
+        const remainingMs = timeoutMs - (Date.now() - startedAt);
+        if (remainingMs <= 0 || filesLeft <= 0 || directoriesLeft <= 0 || entriesLeft <= 0)
+            break;
+        if (!existsSync(dir))
+            continue;
+        const inventory = await walkFilesAsync(dir, {
+            maxFiles: filesLeft,
+            maxDirectories: directoriesLeft,
+            maxEntries: entriesLeft,
+            timeoutMs: remainingMs,
+            signal: options.signal,
+            yieldEvery: options.yieldEvery,
+        });
+        filesLeft = Math.max(0, filesLeft - inventory.files.length);
+        directoriesLeft = Math.max(0, directoriesLeft - inventory.directoriesVisited);
+        entriesLeft = Math.max(0, entriesLeft - inventory.entriesVisited);
+        let fileIndex = 0;
+        for (const rel of inventory.files) {
+            if (!rel.endsWith(".md"))
+                continue;
+            if (options.signal?.aborted)
+                throw options.signal.reason instanceof Error ? options.signal.reason : new Error("asset search cancelled");
+            if (Date.now() - startedAt >= timeoutMs)
+                break;
+            if (fileIndex++ > 0 && fileIndex % 32 === 0) {
+                await new Promise((resolveTurn) => setImmediate(resolveTurn));
+                if (options.signal?.aborted)
+                    throw options.signal.reason instanceof Error ? options.signal.reason : new Error("asset search cancelled");
+            }
+            let text;
+            try {
+                text = readModelContextFileSync(join(dir, rel), MAX_RECALL_SOURCE_BYTES);
+            }
+            catch {
+                continue;
+            }
+            const hay = (rel + "\n" + text).toLowerCase();
+            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) });
+        }
+        if (Date.now() - startedAt >= timeoutMs || inventory.truncated)
+            break;
+    }
+    hits.sort((a, b) => b.score - a.score || b.boost - a.boost || a.path.length - b.path.length);
+    return hits.slice(0, limit).map(({ boost, ...recalled }) => recalled);
+}
 /** Create the assets dir with an example snippet + README. Returns files written. */
 export function scaffoldAssets() {
     const dir = assetsDir();

package/dist/runtime.js

@@ -2,6 +2,30 @@ export const MIN_NODE_MAJOR = 22;
 // Commander 15 (a direct runtime dependency) requires this exact floor. Keep package engines, startup,
 // doctor, and docs aligned so an early Node 22 release gets an upgrade hint before dependencies load.
 export const MIN_NODE_VERSION = "22.12.0";
+/** Node's `os.homedir()` ignores HOME on Windows and prefers USERPROFILE. Git Bash, portable launchers,
+ *  and hermetic automation conventionally override HOME, so mirror that explicit override before the
+ *  rest of Hara is imported. This keeps every ~/.hara consumer on the same private root. */
+export function applyPortableHomeEnv(env = process.env, runtimePlatform = process.platform) {
+    if (runtimePlatform !== "win32")
+        return false;
+    const home = normalizePortableWindowsHome(env.HOME ?? "");
+    if (!home || env.USERPROFILE === home)
+        return false;
+    env.USERPROFILE = home;
+    return true;
+}
+/** Convert the MSYS/Git-Bash forms seen by native Windows Node into native drive/UNC paths. */
+export function normalizePortableWindowsHome(value) {
+    const home = value.trim();
+    const drive = /^\/([a-zA-Z])(?:\/(.*))?$/u.exec(home);
+    if (drive)
+        return `${drive[1].toUpperCase()}:\\${(drive[2] ?? "").replace(/\//g, "\\")}`;
+    if (/^\/\/[^/]/u.test(home))
+        return `\\\\${home.slice(2).replace(/\//g, "\\")}`;
+    if (/^[a-zA-Z]:[\\/]/u.test(home))
+        return home[0].toUpperCase() + home.slice(1).replace(/\//g, "\\");
+    return home;
+}
 function supportedNodeVersion(version) {
     const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
     if (!match)

package/dist/sandbox.js

@@ -8,13 +8,38 @@
 // emitted from runShell so every entry point — REPL, -p, org, cron — surfaces it). Only the `bash`
 // shell is sandboxed; hara's own file tools are in-process, explicit, and gated by the approval flow.
 import { spawn, spawnSync } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
 import { platform } from "node:os";
+import { win32 as winPath } from "node:path";
 import { existingSensitiveSeatbeltMasks, sensitiveFilesAllowed, sensitiveShellCommandReason, } from "./security/sensitive-files.js";
 import { terminateSubprocessTree, toolSubprocessEnv } from "./security/subprocess-env.js";
+import { homeWorkspaceActionError, isHomeWorkspace } from "./context/workspace-scope.js";
 // Windows shell resolution. hara (and the model) speak POSIX shell — the agent writes `ls`, `grep`,
 // `cat`, pipes, `&&`. So on Windows we PREFER a real bash (Git Bash or WSL, which most Windows devs
 // have) and only fall back to cmd.exe when none is found. Memoized: the PATH probe runs at most once.
 let _winBash;
+/** Conventional Git-for-Windows installations are not always added to PATH (the installer makes that
+ *  an explicit choice). Keep candidate construction pure so non-Windows CI can cover it. */
+export function windowsBashCandidates(env = process.env) {
+    const roots = [
+        env.ProgramFiles,
+        env["ProgramFiles(x86)"],
+        env.LocalAppData ? winPath.join(env.LocalAppData, "Programs") : undefined,
+        "C:\\Program Files",
+        "C:\\Program Files (x86)",
+    ].filter((value) => !!value?.trim());
+    return [...new Set(roots.map((root) => winPath.join(root, "Git", "bin", "bash.exe")))];
+}
+export function firstInstalledWindowsBash(candidates, isFile) {
+    return candidates.find((path) => {
+        try {
+            return isFile(path);
+        }
+        catch {
+            return false;
+        }
+    }) ?? null;
+}
 function findWindowsBash() {
     if (_winBash !== undefined)
         return _winBash;
@@ -23,7 +48,7 @@ function findWindowsBash() {
     // (a huge PATH, a dead network drive on PATH) hangs hara at startup with nothing able to interrupt it.
     const onPath = spawnSync("where", ["bash"], { encoding: "utf8", timeout: 3000 });
     const hit = onPath.status === 0 ? String(onPath.stdout).split(/\r?\n/).find((l) => l.trim()) : "";
-    _winBash = (hit && hit.trim()) || null;
+    _winBash = (hit && hit.trim()) || firstInstalledWindowsBash(windowsBashCandidates(), (path) => (existsSync(path) && statSync(path).isFile()));
     return _winBash;
 }
 /** Pure shell-argv resolution — split out so the platform branching is unit-testable without spawning.
@@ -99,6 +124,10 @@ let warnedUnsandboxed = false; // emit the "macOS-only" notice at most once per
 /** Build the (sandboxed, when supported) argv for a shell command — shared by runShell + background jobs
  *  so the seatbelt write-confinement is identical for both. */
 export function shellCommand(command, cwd, mode) {
+    // Shell syntax can recursively traverse arbitrary paths, so unlike explicit read/write tools it is not
+    // safe at the Home root. Check before protected-file mask discovery, which itself would have to walk ~/.
+    if (isHomeWorkspace(cwd))
+        throw new Error(homeWorkspaceActionError("run shell commands"));
     const protectedReason = sensitiveShellCommandReason(command, cwd);
     if (protectedReason) {
         throw new Error(`shell command crosses Hara's protected secret boundary (${protectedReason}). ` +
@@ -135,6 +164,8 @@ export function maybeWarnUnsandboxed(mode) {
     }
 }
 export function runShell(command, cwd, mode, opts) {
+    if (opts.signal?.aborted)
+        return Promise.reject(new Error("interrupted before command start"));
     const { cmd, args } = shellCommand(command, cwd, mode);
     return new Promise((resolve, reject) => {
         // Non-interactive by contract: there is no terminal to answer a credential prompt, so a git
@@ -144,6 +175,7 @@ export function runShell(command, cwd, mode, opts) {
         const env = toolSubprocessEnv(process.env, {
             GIT_TERMINAL_PROMPT: process.env.GIT_TERMINAL_PROMPT ?? "0",
             GCM_INTERACTIVE: process.env.GCM_INTERACTIVE ?? "never",
+            ...(opts.env ?? {}),
         });
         // A dedicated POSIX process group lets timeout/output-cap termination reach grandchildren (shell →
         // node/npm → worker). Windows uses taskkill /T in terminateSubprocessTree instead.
@@ -152,6 +184,7 @@ export function runShell(command, cwd, mode, opts) {
         let stdout = "";
         let stderr = "";
         let timedOut = false;
+        let aborted = false;
         let killedForSize = false;
         let done = false;
         let receivedBytes = 0;
@@ -194,6 +227,7 @@ export function runShell(command, cwd, mode, opts) {
                 return;
             done = true;
             clearTimeout(timer);
+            opts.signal?.removeEventListener("abort", abortRun);
             cancelTermination?.();
             if (error) {
                 reject(Object.assign(error, { stdout, stderr }));
@@ -205,6 +239,9 @@ export function runShell(command, cwd, mode, opts) {
             else if (timedOut) {
                 reject(Object.assign(new Error(`timed out after ${opts.timeout}ms`), { stdout, stderr }));
             }
+            else if (aborted) {
+                reject(Object.assign(new Error("interrupted by agent run deadline or cancellation"), { stdout, stderr }));
+            }
             else if (code !== 0) {
                 reject(Object.assign(new Error(`exit code ${code}`), { stdout, stderr, code }));
             }
@@ -216,6 +253,19 @@ export function runShell(command, cwd, mode, opts) {
             timedOut = true;
             stopTree();
         }, opts.timeout);
+        const abortRun = () => {
+            if (done || timedOut || killedForSize || aborted)
+                return;
+            aborted = true;
+            stopTree();
+        };
+        opts.signal?.addEventListener("abort", abortRun, { once: true });
+        if (opts.signal?.aborted)
+            abortRun();
+        // A hook may exit successfully without reading stdin. Swallow the resulting benign EPIPE and let the
+        // child's authoritative close status settle the operation, matching spawnSync's historical behavior.
+        child.stdin.on("error", () => { });
+        child.stdin.end(opts.input);
         // Kill a runaway command once its total output passes maxBuffer — don't let it stream GBs to the UI
         // until the timeout just because we stopped retaining the bytes.
         const checkOverflow = () => {
@@ -225,7 +275,7 @@ export function runShell(command, cwd, mode, opts) {
             }
         };
         child.stdout.on("data", (d) => {
-            if (done || timedOut || killedForSize)
+            if (done || timedOut || killedForSize || aborted)
                 return;
             const s = d.toString();
             receivedBytes += d.length;
@@ -235,7 +285,7 @@ export function runShell(command, cwd, mode, opts) {
             checkOverflow();
         });
         child.stderr.on("data", (d) => {
-            if (done || timedOut || killedForSize)
+            if (done || timedOut || killedForSize || aborted)
                 return;
             const s = d.toString();
             receivedBytes += d.length;
@@ -248,7 +298,7 @@ export function runShell(command, cwd, mode, opts) {
             settle(null, e);
         });
         child.on("close", (code) => {
-            if ((timedOut || killedForSize) && !forceIssued) {
+            if ((timedOut || killedForSize || aborted) && !forceIssued) {
                 closeBeforeForce = true;
                 closeBeforeForceCode = code;
                 return;

package/dist/search/embed.js

@@ -3,6 +3,11 @@ const DEFAULT_MODEL = {
     qwen: "text-embedding-v3",
     openai: "text-embedding-3-small",
 };
+const EMBED_TIMEOUT_MS = 30_000;
+const embedSignal = (parent) => {
+    const timeout = AbortSignal.timeout(EMBED_TIMEOUT_MS);
+    return parent ? AbortSignal.any([parent, timeout]) : timeout;
+};
 /** Build an Embedder from config, or null if embeddings are off/unconfigured (→ lexical fallback). */
 export function getEmbedder(cfg) {
     const provider = cfg.embedProvider;
@@ -11,13 +16,16 @@ export function getEmbedder(cfg) {
     const model = cfg.embedModel || DEFAULT_MODEL[provider] || "embed";
     if (provider === "ollama") {
         const base = (cfg.embedBaseURL || "http://localhost:11434").replace(/\/$/, "");
-        return async (texts) => {
+        return async (texts, signal) => {
             const out = [];
             for (const input of texts) {
+                if (signal?.aborted)
+                    throw new Error("embedding request interrupted");
                 const r = await fetch(`${base}/api/embeddings`, {
                     method: "POST",
                     headers: { "content-type": "application/json" },
                     body: JSON.stringify({ model, prompt: input }),
+                    signal: embedSignal(signal),
                 });
                 if (!r.ok)
                     throw new Error(`ollama embeddings ${r.status}`);
@@ -29,11 +37,14 @@ export function getEmbedder(cfg) {
     // qwen (DashScope compatible-mode) + any OpenAI-compatible endpoint: POST /embeddings { model, input[] }
     const base = (cfg.embedBaseURL || (provider === "qwen" ? "https://dashscope.aliyuncs.com/compatible-mode/v1" : cfg.baseURL || "https://api.openai.com/v1")).replace(/\/$/, "");
     const key = cfg.embedApiKey || cfg.apiKey || "";
-    return async (texts) => {
+    return async (texts, signal) => {
+        if (signal?.aborted)
+            throw new Error("embedding request interrupted");
         const r = await fetch(`${base}/embeddings`, {
             method: "POST",
             headers: { "content-type": "application/json", authorization: `Bearer ${key}` },
             body: JSON.stringify({ model, input: texts }),
+            signal: embedSignal(signal),
         });
         if (!r.ok)
             throw new Error(`embeddings ${r.status}`);

package/dist/search/hybrid.js

@@ -1,21 +1,24 @@
 // Hybrid search — lexical (always) blended with semantic (when an index + embedder are configured).
 // One entry point for `recall` and `memory_search`: semantic hits lead (more relevant), lexical fills the
 // rest, deduped by path. With no index/embedder it's exactly the lexical result — zero behaviour change.
-import { searchAssets, titleOf } from "../recall.js";
+import { searchAssetsAsync, titleOf } from "../recall.js";
 import { loadConfig } from "../config.js";
 import { getEmbedder } from "./embed.js";
 import { queryIndex, indexExists } from "./semindex.js";
 export async function searchHybrid(query, cwd, opts) {
     const limit = opts.limit ?? 5;
-    const lex = searchAssets(query, limit, opts.roots);
+    const lex = await searchAssetsAsync(query, limit, opts.roots, { signal: opts.signal, timeoutMs: opts.timeoutMs });
     const embed = getEmbedder(loadConfig());
     if (!embed || !indexExists(opts.indexName, cwd))
         return lex;
     let sem;
     try {
-        sem = await queryIndex(opts.indexName, query, embed, cwd, limit);
+        sem = await queryIndex(opts.indexName, query, embed, cwd, limit, opts.signal);
     }
     catch {
+        if (opts.signal?.aborted) {
+            throw opts.signal.reason instanceof Error ? opts.signal.reason : new Error("hybrid search cancelled");
+        }
         return lex; // embedding endpoint down → degrade to lexical
     }
     const out = [];