@giovannijecha/jecode 0.2.4 → 0.3.1

package/README.md

@@ -25,13 +25,14 @@
   <a href="https://github.com/giovannijecha/jecode/releases">Releases</a>
 </p>
 
-> Jecode is an early 0.2.x release. The core loop is usable today; commands and
+> Jecode is an early 0.3.x release. The core loop is usable today; commands and
 > terminal interactions may still evolve before 1.0.
 
 ## Why Jecode
 
 - **One controller.** One visible loop talks to the model, runs tools, and returns
-  control to you. There are no hidden workers or delegated agents.
+  control to you. Independent reads can overlap inside one step; writes and
+  commands remain ordered. There are no hidden workers or delegated agents.
 - **Terminal-native.** The transcript, composer, searchable menus, tool output,
   diffs, approvals, reasoning, and status all share one full-screen TUI.
 - **Permission-aware.** Reads stay transparent; dangerous actions ask first.

package/dist/accounts.js

@@ -3,7 +3,7 @@ import { chmod, mkdir } from "node:fs/promises";
 import { readFileSync } from "node:fs";
 import * as path from "node:path";
 import { atomicWrite } from "./atomic.js";
-import { withAccountLock } from "./account-lock.js";
+import { withStoreLock } from "./store-lock.js";
 import { userDataLabel, userDataPath } from "./user-data.js";
 let cached;
 export function openAICodexAccount() {
@@ -36,7 +36,7 @@ export async function updateOpenAICodexAccount(change, signal) {
     await mkdir(directory, { recursive: true, mode: 0o700 });
     if (process.platform !== "win32")
         await chmod(directory, 0o700);
-    return withAccountLock(file, async () => {
+    return withStoreLock(file, async () => {
         const current = readStore(file);
         const next = await change(current.accounts["openai-codex"]);
         const accounts = { ...current.accounts };

package/dist/controller.js

@@ -6,6 +6,8 @@
 import { isToolCall } from "./types.js";
 import { findTool, runTool, toolSpecs } from "./tools/index.js";
 export const MAX_TOOL_CALLS_PER_STEP = 32;
+/** Independent read calls share one bounded execution wave. */
+export const MAX_CONCURRENT_TOOL_CALLS = 4;
 /**
  * Run one user turn to completion: keep exchanging with the model until it
  * stops asking for tools. `history` is mutated in place, so an aborted turn
@@ -44,25 +46,35 @@ export async function runTurn(history, options, events, signal) {
                 events.onUsage?.(assistant.usage);
             return; // the model is done — hand back to the user
         }
-        // Calls run one after another because approval prompts serialise anyway,
-        // but every result from this step goes back in a SINGLE message. Splitting
-        // them teaches the model to stop batching its calls.
+        // Consecutive shared reads run together. An exclusive call is an ordered
+        // barrier, so writes, approvals, and commands never overlap other work.
+        // Every result still goes back in a SINGLE message and in call order.
         const results = [];
         const announced = new Set();
         try {
             if (assistant.usage !== undefined)
                 events.onUsage?.(assistant.usage);
-            for (let index = 0; index < calls.length; index++) {
-                throwIfAborted(signal);
-                const call = calls[index];
-                events.onToolProgress?.(index + 1, calls.length);
-                const preview = await look(call, options, signal);
-                throwIfAborted(signal);
-                announced.add(call.id);
-                events.onToolCall(call, preview);
-                const { result, summary } = await settle(call, options, events, signal, preview);
-                results.push(result);
-                events.onToolResult(call, result, summary);
+            while (results.length < calls.length) {
+                const start = results.length;
+                const batch = nextBatch(calls, start, options.tools);
+                const prepared = [];
+                for (let offset = 0; offset < batch.length; offset++) {
+                    throwIfAborted(signal);
+                    const call = batch[offset];
+                    events.onToolProgress?.(start + offset + 1, calls.length);
+                    const preview = await look(call, options, signal);
+                    throwIfAborted(signal);
+                    announced.add(call.id);
+                    events.onToolCall(call, preview);
+                    prepared.push({ call, preview });
+                }
+                const runs = await Promise.all(prepared.map(({ call, preview }) => settle(call, options, events, signal, preview)));
+                for (let offset = 0; offset < runs.length; offset++) {
+                    const call = prepared[offset]?.call;
+                    const run = runs[offset];
+                    results.push(run.result);
+                    events.onToolResult(call, run.result, run.summary);
+                }
             }
         }
         catch (error) {
@@ -96,6 +108,24 @@ export async function runTurn(history, options, events, signal) {
     }
     throw new Error(`gave up after ${options.maxSteps} steps without finishing (raise --max-steps)`);
 }
+function nextBatch(calls, start, tools) {
+    const first = calls[start];
+    if (first === undefined)
+        return [];
+    if (!shared(findTool(tools, first.name)))
+        return [first];
+    const batch = [];
+    for (let index = start; index < calls.length && batch.length < MAX_CONCURRENT_TOOL_CALLS; index++) {
+        const call = calls[index];
+        if (!shared(findTool(tools, call.name)))
+            break;
+        batch.push(call);
+    }
+    return batch;
+}
+function shared(tool) {
+    return tool?.concurrency === "shared" && !tool.dangerous;
+}
 function assertToolCallIds(calls) {
     const seen = new Set();
     for (const call of calls) {

package/dist/credentials.js

@@ -13,6 +13,7 @@ import { chmod, mkdir } from "node:fs/promises";
 import { readFileSync } from "node:fs";
 import * as path from "node:path";
 import { atomicWrite } from "./atomic.js";
+import { withStoreLock } from "./store-lock.js";
 import { legacyUserDataPath, userDataLabel, userDataPath } from "./user-data.js";
 /** Keys this session was given but not asked to keep. Dies with the window. */
 const held = new Map();
@@ -69,22 +70,30 @@ export function hold(name, value) {
  */
 export async function keep(name, value) {
     const file = storePath();
-    const all = { ...fromDisk(), [name]: value };
-    await persist(file, all);
-    hold(name, value);
-    saved = all;
-    return file;
+    await prepare(file);
+    return withStoreLock(file, async () => {
+        const all = { ...readSavedStore(), [name]: value };
+        await persist(file, all);
+        hold(name, value);
+        saved = all;
+        return file;
+    });
 }
 /** Remove only the saved copy. An environment or session value is untouched. */
 export async function forgetSaved(name) {
-    const all = { ...fromDisk() };
-    if (use(all[name]) === undefined)
-        return false;
-    delete all[name];
     const file = storePath();
-    await persist(file, all);
-    saved = all;
-    return true;
+    await prepare(file);
+    return withStoreLock(file, async () => {
+        const all = { ...readSavedStore() };
+        if (use(all[name]) === undefined) {
+            saved = all;
+            return false;
+        }
+        delete all[name];
+        await persist(file, all);
+        saved = all;
+        return true;
+    });
 }
 export function storePath() {
     return userDataPath("credentials.json");
@@ -126,11 +135,13 @@ function readStore(file) {
         return error.code === "ENOENT" ? undefined : {};
     }
 }
-async function persist(file, values) {
+async function prepare(file) {
     const directory = path.dirname(file);
     await mkdir(directory, { recursive: true, mode: 0o700 });
     if (process.platform !== "win32")
         await chmod(directory, 0o700);
+}
+async function persist(file, values) {
     await atomicWrite(file, `${JSON.stringify(values, null, 2)}\n`, { mode: 0o600 });
 }
 /** An empty variable is an unset variable — an exported "" is not a key. */

package/dist/executable.js

@@ -0,0 +1,70 @@
+// Resolve optional native helpers without ever executing workspace content.
+import { accessSync, constants, realpathSync, statSync } from "node:fs";
+import * as path from "node:path";
+/** Return one canonical executable from PATH, skipping empty and rejected entries. */
+export function resolveExecutable(name, options = {}) {
+    if (name === "" || path.basename(name) !== name)
+        return undefined;
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const rejected = options.rejectUnder === undefined
+        ? undefined
+        : canonical(options.rejectUnder);
+    const searchPath = options.searchPath ?? process.env["PATH"] ?? "";
+    for (const raw of searchPath.split(path.delimiter)) {
+        const entry = unquote(raw.trim());
+        // An empty PATH entry means the current directory. That is exactly the
+        // workspace-controlled lookup this resolver exists to exclude.
+        if (entry === "")
+            continue;
+        const directory = path.resolve(cwd, entry);
+        for (const candidate of executableNames(name)) {
+            const executable = usable(path.join(directory, candidate));
+            if (executable === undefined)
+                continue;
+            if (rejected !== undefined && within(rejected, executable))
+                continue;
+            return executable;
+        }
+    }
+    return undefined;
+}
+function executableNames(name) {
+    if (process.platform !== "win32" || path.extname(name) !== "")
+        return [name];
+    return [`${name}.com`, `${name}.exe`];
+}
+function usable(file) {
+    try {
+        const resolved = realpathSync.native(file);
+        if (!statSync(resolved).isFile())
+            return undefined;
+        accessSync(resolved, process.platform === "win32" ? constants.F_OK : constants.X_OK);
+        return resolved;
+    }
+    catch {
+        return undefined;
+    }
+}
+function canonical(directory) {
+    try {
+        return realpathSync.native(directory);
+    }
+    catch {
+        return path.resolve(directory);
+    }
+}
+function within(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative === "" || (relative !== ".." &&
+        !relative.startsWith(`..${path.sep}`) &&
+        !path.isAbsolute(relative));
+}
+function unquote(value) {
+    if (value.length < 2)
+        return value;
+    const first = value[0];
+    const last = value[value.length - 1];
+    return (first === '"' && last === '"') || (first === "'" && last === "'")
+        ? value.slice(1, -1)
+        : value;
+}

package/dist/external-browser.js

@@ -1,6 +1,8 @@
 // Open one HTTPS URL without involving a shell or interpolating commands.
 import { spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
+import * as path from "node:path";
+import { resolveExecutable } from "./executable.js";
 export async function openExternal(url) {
     const target = new URL(url);
     if (target.protocol !== "https:")
@@ -21,15 +23,26 @@ export async function openExternal(url) {
         });
     });
 }
-function browserCommand(url) {
+export function browserCommand(url) {
     if (process.platform === "win32") {
-        return { file: "rundll32.exe", args: ["url.dll,FileProtocolHandler", url] };
+        const windows = process.env["SystemRoot"] ?? process.env["WINDIR"];
+        const file = windows === undefined
+            ? undefined
+            : resolveExecutable("rundll32.exe", {
+                searchPath: path.join(windows, "System32"),
+                rejectUnder: process.cwd(),
+            });
+        return file === undefined ? undefined : { file, args: ["url.dll,FileProtocolHandler", url] };
     }
+    const name = launcherName();
+    const searchPath = process.platform === "darwin" ? "/usr/bin" : undefined;
+    const file = resolveExecutable(name, { searchPath, rejectUnder: process.cwd() });
+    return file === undefined ? undefined : { file, args: [url] };
+}
+function launcherName() {
     if (process.platform === "darwin")
-        return { file: "open", args: [url] };
-    if (isWsl())
-        return { file: "explorer.exe", args: [url] };
-    return { file: "xdg-open", args: [url] };
+        return "open";
+    return isWsl() ? "explorer.exe" : "xdg-open";
 }
 export function headlessEnvironment() {
     if (isWsl() || process.env["SSH_CONNECTION"] !== undefined || process.env["SSH_TTY"] !== undefined) {

package/dist/settings.js

@@ -6,6 +6,7 @@ import { atomicWrite } from "./atomic.js";
 import { EFFORTS } from "./effort.js";
 import { providerNames } from "./providers/index.js";
 import { parseOllamaEndpoint } from "./providers/ollama-endpoint.js";
+import { withStoreLock } from "./store-lock.js";
 import { userDataLabel, userDataPath } from "./user-data.js";
 export { EFFORTS } from "./effort.js";
 let saved;
@@ -15,15 +16,17 @@ export function readSettings() {
     return copy(saved);
 }
 export async function updateSettings(patch) {
-    const next = normalize({ ...readSettings(), ...patch });
     const file = settingsPath();
     const directory = path.dirname(file);
     await mkdir(directory, { recursive: true, mode: 0o700 });
     if (process.platform !== "win32")
         await chmod(directory, 0o700);
-    await atomicWrite(file, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
-    saved = next;
-    return file;
+    return withStoreLock(file, async () => {
+        const next = normalize({ ...readStore(file), ...patch });
+        await atomicWrite(file, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+        saved = next;
+        return file;
+    });
 }
 export function settingsPath() {
     return userDataPath("settings.json");
@@ -35,9 +38,9 @@ export function settingsLabel() {
 export function reloadSettings() {
     saved = undefined;
 }
-function readStore() {
+function readStore(file = settingsPath()) {
     try {
-        return normalize(JSON.parse(readFileSync(settingsPath(), "utf8")));
+        return normalize(JSON.parse(readFileSync(file, "utf8")));
     }
     catch {
         // Missing, unreadable, and malformed stores all fall back safely. A bad

package/dist/{account-lock.js → store-lock.js}

@@ -1,24 +1,24 @@
-// A tiny cross-process lock for rotating OAuth credentials.
+// A tiny cross-process lock for persistent user-store mutations.
 //
-// Refresh tokens may rotate after one use. Two Jecode processes refreshing
-// the same account concurrently would make one of them persist a dead token,
-// so account mutations serialize through an atomic lock directory.
-import { mkdir, open, readFile, rename, rmdir, stat, unlink } from "node:fs/promises";
+// Every writer rereads inside the lock. That prevents two Jecode processes
+// from replacing unrelated settings, API keys, or rotated OAuth credentials
+// with snapshots they cached before the other process wrote.
 import { randomUUID } from "node:crypto";
+import { mkdir, open, readFile, rmdir, stat, unlink } from "node:fs/promises";
 import * as path from "node:path";
 const WAIT_MS = 50;
 const WAIT_LIMIT_MS = 20_000;
 const STALE_MS = 60_000;
-export async function withAccountLock(accountFile, body, signal) {
+export async function withStoreLock(file, body, signal) {
     throwIfAborted(signal);
-    const directory = `${accountFile}.lock`;
+    const directory = `${file}.lock`;
     const token = `${process.pid}:${randomUUID()}`;
     const started = Date.now();
     while (!(await acquire(directory, token))) {
         if (signal?.aborted === true)
             throw abortReason(signal);
         if (Date.now() - started >= WAIT_LIMIT_MS) {
-            throw new Error("timed out waiting for the account store");
+            throw new Error(`timed out waiting for ${path.basename(file)}`);
         }
         await recoverStale(directory);
         await wait(WAIT_MS, signal);
@@ -59,10 +59,12 @@ async function recoverStale(directory) {
         const details = await stat(directory);
         if (Date.now() - details.mtimeMs < STALE_MS)
             return;
-        const quarantined = `${directory}.${randomUUID()}.stale`;
-        await rename(directory, quarantined);
-        await unlink(path.join(quarantined, "owner")).catch(() => undefined);
-        await rmdir(quarantined).catch(() => undefined);
+        if (await ownerIsAlive(directory))
+            return;
+        // Remove the owner first, then the now-empty directory. `rmdir` cannot
+        // erase a fresh lock acquired after another waiter wins this recovery,
+        // whereas renaming the shared path can steal that new lock in an ABA race.
+        await removeLock(directory);
     }
     catch (error) {
         const code = error.code;
@@ -70,6 +72,36 @@ async function recoverStale(directory) {
             throw error;
     }
 }
+async function ownerIsAlive(directory) {
+    let token;
+    try {
+        token = await readFile(path.join(directory, "owner"), "utf8");
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT")
+            return false;
+        if (code === "EACCES" || code === "EPERM")
+            return true;
+        throw error;
+    }
+    const match = /^([1-9]\d*):/.exec(token.trim());
+    if (match === null)
+        return false;
+    const pid = Number(match[1]);
+    if (!Number.isSafeInteger(pid) || pid > 0x7fff_ffff)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // ESRCH is the one portable proof that the owner no longer exists.
+        // Permission failures and unknown platform errors must not authorize a
+        // second writer to enter the same store.
+        return error.code !== "ESRCH";
+    }
+}
 async function release(directory, token) {
     try {
         const owner = path.join(directory, "owner");

package/dist/tools/fs.js

@@ -2,7 +2,7 @@
 import { constants } from "node:fs";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { optionalBool, optionalInt, requireString } from "./args.js";
+import { optionalBool, optionalInt, optionalString, requireString } from "./args.js";
 import { assertDirectWritableInRoot, displayPath, resolveDirectWritableInRoot, resolveExistingInRoot, } from "./paths.js";
 import { assertEditableText, assertReplacementFits, MAX_EDITABLE_CHARS, MAX_EDITABLE_LINES, readEditableText, } from "./text-boundary.js";
 import { atomicWrite } from "../atomic.js";
@@ -15,6 +15,7 @@ export const readFile = {
     description: "Read a regular UTF-8 text file inside the workspace. Optionally start at a line " +
         "(1-based) and cap how many lines come back. Large files are truncated.",
     dangerous: false,
+    concurrency: "shared",
     input: {
         type: "object",
         properties: {
@@ -45,6 +46,7 @@ export const listDir = {
     name: "list_dir",
     description: "List the entries of a directory inside the workspace. Directories end with a slash.",
     dangerous: false,
+    concurrency: "shared",
     input: {
         type: "object",
         properties: {
@@ -54,7 +56,9 @@ export const listDir = {
     },
     async run(args, ctx) {
         const root = await resolveExistingInRoot(ctx.root, ".");
-        const target = await resolveExistingInRoot(root, args.path === undefined ? "." : requireString(args, "path"));
+        const requested = optionalString(args, "path");
+        const relative = requested === undefined || requested.trim() === "" ? "." : requested;
+        const target = await resolveExistingInRoot(root, relative);
         const entries = [];
         let chars = 0;
         let truncated = false;
@@ -91,6 +95,7 @@ export const writeFile = {
         `${MAX_EDITABLE_CHARS} characters and ${MAX_EDITABLE_LINES} lines. ` +
         "To change part of an existing file, prefer edit_file.",
     dangerous: true,
+    concurrency: "exclusive",
     input: {
         type: "object",
         properties: {
@@ -131,6 +136,7 @@ export const editFile = {
         `Whole-file changes are limited to ${MAX_EDITABLE_CHARS} characters and ` +
         `${MAX_EDITABLE_LINES} lines.`,
     dangerous: true,
+    concurrency: "exclusive",
     input: {
         type: "object",
         properties: {

package/dist/tools/ripgrep.js

@@ -0,0 +1,230 @@
+// Optional native acceleration for bounded literal search.
+import { spawn } from "node:child_process";
+import * as path from "node:path";
+import { shellEnvironment } from "../credential-safety.js";
+import { resolveExecutable } from "../executable.js";
+const MAX_BATCH_FILES = 256;
+const MAX_BATCH_BYTES = 16_000_000;
+const MAX_COMMAND_CHARS = 12_000;
+const MAX_QUERY_CHARS = 4_000;
+const MAX_EVENT_CHARS = 8_000_000;
+const MAX_STDERR_CHARS = 16_000;
+/** Return undefined when ripgrep is unavailable or cannot preserve the contract. */
+export async function trySearchWithRipgrep(options) {
+    if (options.files.length === 0)
+        return { matches: [], binaryPaths: [] };
+    if (options.query.length > MAX_QUERY_CHARS || options.query.includes("\0"))
+        return undefined;
+    const executable = resolveExecutable("rg", { rejectUnder: options.root });
+    if (executable === undefined)
+        return undefined;
+    const matches = [];
+    const binaryPaths = new Set();
+    try {
+        for (const batch of batches(options.files, options.query.length)) {
+            throwIfAborted(options.signal);
+            const searched = await searchBatch(executable, batch, options);
+            if (searched === undefined)
+                return undefined;
+            for (const match of searched.matches) {
+                if (matches.length >= options.limit)
+                    break;
+                matches.push(match);
+            }
+            for (const file of searched.binaryPaths)
+                binaryPaths.add(file);
+            if (matches.length >= options.limit)
+                break;
+        }
+    }
+    catch (error) {
+        if (options.signal?.aborted === true)
+            throw abortReason(options.signal);
+        return undefined;
+    }
+    return { matches, binaryPaths: [...binaryPaths] };
+}
+function batches(files, queryChars) {
+    const groups = [];
+    let group = [];
+    let bytes = 0;
+    let chars = queryChars;
+    for (const file of files) {
+        const nextChars = chars + file.path.length + 1;
+        if (group.length > 0 &&
+            (group.length >= MAX_BATCH_FILES ||
+                bytes + file.bytes > MAX_BATCH_BYTES ||
+                nextChars > MAX_COMMAND_CHARS)) {
+            groups.push(group);
+            group = [];
+            bytes = 0;
+            chars = queryChars;
+        }
+        group.push(file);
+        bytes += file.bytes;
+        chars += file.path.length + 1;
+    }
+    if (group.length > 0)
+        groups.push(group);
+    return groups;
+}
+function searchBatch(executable, files, options) {
+    throwIfAborted(options.signal);
+    const args = [
+        "--json",
+        "--no-config",
+        "--fixed-strings",
+        "--max-filesize",
+        "1000000",
+        "--max-count",
+        String(options.limit),
+        ...(options.caseSensitive ? [] : ["--ignore-case"]),
+        "--",
+        options.query,
+        ...files.map((file) => file.path),
+    ];
+    return new Promise((resolve, reject) => {
+        let child;
+        try {
+            child = spawn(executable, args, {
+                cwd: path.dirname(executable),
+                env: shellEnvironment(),
+                windowsHide: true,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch {
+            resolve(undefined);
+            return;
+        }
+        const matches = [];
+        const binaryPaths = new Set();
+        let buffered = "";
+        let stderr = "";
+        let invalid = false;
+        let overLimit = false;
+        let settled = false;
+        const onAbort = () => child.kill();
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        if (options.signal?.aborted === true)
+            onAbort();
+        const finish = (value, error) => {
+            if (settled)
+                return;
+            settled = true;
+            options.signal?.removeEventListener("abort", onAbort);
+            if (error !== undefined)
+                reject(error);
+            else
+                resolve(value);
+        };
+        const consume = (line) => {
+            if (line === "" || invalid || overLimit)
+                return;
+            try {
+                const event = JSON.parse(line);
+                const parsed = ripgrepEvent(event);
+                if (parsed?.kind === "match") {
+                    // `rg --max-count` is per file, not global. Once the raw stream
+                    // exceeds the requested result count, stop the accelerator and let
+                    // the portable scanner produce the exact bounded answer. Returning
+                    // early here would lose the later binary-file end marker.
+                    if (matches.length >= options.limit) {
+                        overLimit = true;
+                        child.kill();
+                        return;
+                    }
+                    matches.push(parsed.match);
+                }
+                if (parsed?.kind === "binary")
+                    binaryPaths.add(parsed.path);
+            }
+            catch {
+                invalid = true;
+                child.kill();
+            }
+        };
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            buffered += chunk;
+            if (buffered.length > MAX_EVENT_CHARS) {
+                invalid = true;
+                child.kill();
+                return;
+            }
+            let newline = buffered.indexOf("\n");
+            while (newline !== -1) {
+                consume(buffered.slice(0, newline));
+                buffered = buffered.slice(newline + 1);
+                newline = buffered.indexOf("\n");
+            }
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr = `${stderr}${chunk}`.slice(-MAX_STDERR_CHARS);
+        });
+        child.on("error", (error) => {
+            if (options.signal?.aborted === true)
+                finish(undefined, abortReason(options.signal));
+            else if (error.code === "ENOENT")
+                finish(undefined);
+            else
+                finish(undefined);
+        });
+        child.on("close", (code) => {
+            if (options.signal?.aborted === true) {
+                finish(undefined, abortReason(options.signal));
+                return;
+            }
+            consume(buffered);
+            if (invalid || overLimit || (code !== 0 && code !== 1) || stderr.trim() !== "") {
+                finish(undefined);
+                return;
+            }
+            const order = new Map(files.map((file, index) => [file.path, index]));
+            finish({
+                matches: matches
+                    .filter((match) => !binaryPaths.has(match.path))
+                    .sort((a, b) => ((order.get(a.path) ?? Number.MAX_SAFE_INTEGER) -
+                    (order.get(b.path) ?? Number.MAX_SAFE_INTEGER) ||
+                    a.line - b.line)),
+                binaryPaths: [...binaryPaths],
+            });
+        });
+    });
+}
+function ripgrepEvent(value) {
+    if (!record(value) || !record(value["data"]))
+        return undefined;
+    const data = value["data"];
+    const file = textField(data["path"]);
+    if (file === undefined)
+        return undefined;
+    if (value["type"] === "match") {
+        const line = data["line_number"];
+        const text = textField(data["lines"]);
+        if (typeof line !== "number" || !Number.isInteger(line) || text === undefined)
+            return undefined;
+        return {
+            kind: "match",
+            match: { path: file, line, text: text.replace(/\r?\n$/, "") },
+        };
+    }
+    if (value["type"] === "end" && typeof data["binary_offset"] === "number") {
+        return { kind: "binary", path: file };
+    }
+    return undefined;
+}
+function textField(value) {
+    return record(value) && typeof value["text"] === "string" ? value["text"] : undefined;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted === true)
+        throw abortReason(signal);
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error ? signal.reason : new Error("interrupted");
+}

package/dist/tools/search.js

@@ -3,18 +3,24 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { optionalBool, optionalInt, optionalString, requireString } from "./args.js";
 import { displayPath, resolveExistingInRoot } from "./paths.js";
+import { trySearchWithRipgrep } from "./ripgrep.js";
 const DEFAULT_RESULTS = 100;
 const MAX_RESULTS = 500;
 const MAX_VISITED = 20_000;
 const MAX_FILE_BYTES = 1_000_000;
 const MAX_MATCH_LINE = 500;
 const MAX_GLOB_CHARS = 512;
+const RG_PREFIX_BYTES = 2_000_000;
+const RG_PREFIX_FILES = 500;
+const MIN_RG_TAIL_BYTES = 2_000_000;
+const MIN_RG_TAIL_FILES = 500;
 const SKIP = new Set([".git", ".hg", ".svn", "node_modules"]);
 export const findFiles = {
     name: "find_files",
     description: "Find files inside the workspace by glob (for example **/*.ts). Skips dependency and VCS " +
         "directories, never follows symlinks, and returns a bounded list.",
     dangerous: false,
+    concurrency: "shared",
     input: {
         type: "object",
         properties: {
@@ -51,6 +57,7 @@ export const searchText = {
     description: "Search UTF-8 text files inside the workspace for a literal string. Skips dependencies, VCS " +
         "directories, symlinks, binary files, and files over 1 MB; results are bounded.",
     dangerous: false,
+    concurrency: "shared",
     input: {
         type: "object",
         properties: {
@@ -75,7 +82,11 @@ export const searchText = {
         const match = pattern === undefined || pattern === "" ? () => true : glob(pattern);
         const limit = resultLimit(args);
         const found = [];
+        const tail = [];
         let skipped = 0;
+        let prefixBytes = 0;
+        let prefixFiles = 0;
+        let tailBytes = 0;
         const walked = await walk(start, scoped, async (lexical) => {
             const relative = displayPath(scoped.root, lexical);
             if (!match(relative))
@@ -86,33 +97,35 @@ export const searchText = {
                 skipped++;
                 return false;
             }
-            let text;
-            try {
-                const data = await fs.readFile(file);
-                if (data.includes(0)) {
-                    skipped++;
-                    return false;
-                }
-                text = data.toString("utf8");
-            }
-            catch (error) {
-                if (skippable(error)) {
-                    skipped++;
-                    return false;
-                }
-                throw error;
-            }
-            for (const [index, line] of text.replace(/\r\n?/g, "\n").split("\n").entries()) {
-                checkAbort(ctx.signal);
-                const haystack = sensitive ? line : line.toLocaleLowerCase();
-                if (!haystack.includes(needle))
-                    continue;
-                found.push(`${relative}:${index + 1}:${clip(line)}`);
-                if (found.length >= limit)
-                    return true;
+            const candidate = { path: file, bytes: info.size };
+            if (prefixFiles + 1 > RG_PREFIX_FILES ||
+                prefixBytes + info.size > RG_PREFIX_BYTES) {
+                tail.push(candidate);
+                tailBytes += info.size;
+                return false;
             }
-            return false;
+            prefixFiles++;
+            prefixBytes += info.size;
+            const searched = await portableSearch([candidate], scoped, needle, sensitive, limit - found.length);
+            found.push(...searched.matches);
+            skipped += searched.skipped;
+            return found.length >= limit;
         });
+        const accelerated = preferRipgrep(tail, tailBytes)
+            ? await trySearchWithRipgrep({
+                root: scoped.root,
+                files: tail,
+                query,
+                caseSensitive: sensitive,
+                limit: limit - found.length,
+                signal: ctx.signal,
+            })
+            : undefined;
+        const portable = accelerated === undefined && tail.length > 0
+            ? await portableSearch(tail, scoped, needle, sensitive, limit - found.length)
+            : undefined;
+        found.push(...(portable?.matches ?? accelerated?.matches.map((match) => (`${displayPath(scoped.root, match.path)}:${match.line}:${clip(match.text)}`)) ?? []));
+        skipped += portable?.skipped ?? accelerated?.binaryPaths.length ?? 0;
         const extra = skipped === 0 ? "" : ` · skipped ${skipped} binary/large/unreadable`;
         return {
             output: found.length === 0 ? "[no matches]" : found.join("\n"),
@@ -120,6 +133,42 @@ export const searchText = {
         };
     },
 };
+async function portableSearch(files, ctx, needle, sensitive, limit) {
+    const found = [];
+    let skipped = 0;
+    for (const file of files) {
+        checkAbort(ctx.signal);
+        let text;
+        try {
+            const data = await fs.readFile(file.path);
+            if (data.includes(0)) {
+                skipped++;
+                continue;
+            }
+            text = data.toString("utf8");
+        }
+        catch (error) {
+            if (skippable(error)) {
+                skipped++;
+                continue;
+            }
+            throw error;
+        }
+        for (const [index, line] of text.replace(/\r\n?/g, "\n").split("\n").entries()) {
+            checkAbort(ctx.signal);
+            const haystack = sensitive ? line : line.toLocaleLowerCase();
+            if (!haystack.includes(needle))
+                continue;
+            found.push(`${displayPath(ctx.root, file.path)}:${index + 1}:${clip(line)}`);
+            if (found.length >= limit)
+                return { matches: found, skipped };
+        }
+    }
+    return { matches: found, skipped };
+}
+function preferRipgrep(files, bytes) {
+    return files.length >= MIN_RG_TAIL_FILES || bytes >= MIN_RG_TAIL_BYTES;
+}
 async function walk(start, ctx, visit) {
     const pending = [start];
     let seen = 0;

package/dist/tools/shell.js

@@ -1,8 +1,10 @@
 // Shell tool. One command, captured output, a timeout, and a hard cap on how
 // much of it comes back.
 import { spawn } from "node:child_process";
+import * as path from "node:path";
 import { optionalInt, requireString } from "./args.js";
 import { credentialRedactor, redactCredentials, shellEnvironment } from "../credential-safety.js";
+import { resolveExecutable } from "../executable.js";
 const DEFAULT_TIMEOUT_MS = 120_000;
 const MAX_TIMEOUT_MS = 2_147_483_647;
 const MAX_OUTPUT_CHARS = 30_000;
@@ -13,6 +15,7 @@ export const runCommand = {
         "and stderr. The shell is not a filesystem sandbox, so calls ask for approval by default. Output is " +
         "truncated past 30000 characters.",
     dangerous: true,
+    concurrency: "exclusive",
     input: {
         type: "object",
         properties: {
@@ -61,13 +64,15 @@ function execute(command, cwd, timeoutMs, signal, onOutput) {
         let drainTimer;
         const timer = setTimeout(() => {
             timedOut = true;
-            stopTree(child.pid, false);
-            forceTimer = setTimeout(() => stopTree(child.pid, true), 500);
+            requestStop();
         }, timeoutMs);
+        const requestStop = () => {
+            stopTree(child.pid, false);
+            forceTimer ??= setTimeout(() => stopTree(child.pid, true), 500);
+        };
         const onAbort = () => {
             aborted = signal === undefined ? new Error("aborted") : abortReason(signal);
-            stopTree(child.pid, false);
-            forceTimer = setTimeout(() => stopTree(child.pid, true), 500);
+            requestStop();
         };
         signal?.addEventListener("abort", onAbort, { once: true });
         const cleanup = () => {
@@ -100,6 +105,11 @@ function execute(command, cwd, timeoutMs, signal, onOutput) {
             reject(error);
         });
         child.on("exit", (code) => {
+            // The group can outlive its leader. Once a requested stop makes the
+            // shell exit, force the remaining descendants before cleanup cancels the
+            // fallback timer.
+            if (timedOut || aborted !== undefined)
+                stopTree(child.pid, true);
             // `close` normally follows once both pipes drain. A detached descendant
             // can inherit those descriptors after the command itself has exited,
             // though, so bound that final drain instead of hanging the tool on it.
@@ -152,8 +162,28 @@ function stopTree(pid, force) {
         return;
     if (process.platform === "win32") {
         const args = ["/pid", String(pid), "/T", ...(force ? ["/F"] : [])];
-        const killer = spawn("taskkill", args, { windowsHide: true, stdio: "ignore" });
-        killer.on("error", () => undefined);
+        const windows = process.env["SystemRoot"] ?? process.env["WINDIR"];
+        const taskkill = windows === undefined
+            ? undefined
+            : resolveExecutable("taskkill.exe", {
+                searchPath: path.join(windows, "System32"),
+                rejectUnder: process.cwd(),
+            });
+        if (taskkill !== undefined) {
+            const killer = spawn(taskkill, args, {
+                cwd: path.dirname(taskkill),
+                windowsHide: true,
+                stdio: "ignore",
+            });
+            killer.on("error", () => undefined);
+            return;
+        }
+        try {
+            process.kill(pid, force ? "SIGKILL" : "SIGTERM");
+        }
+        catch {
+            // The process may already be gone, or the platform helper unavailable.
+        }
         return;
     }
     try {

package/dist/transcript.js

@@ -1,7 +1,7 @@
 // A portable transcript: screen blocks in, Markdown out.
 import { terminalText } from "./ui/terminal-text.js";
 export function defaultTranscriptName(now = new Date()) {
-    return `jecode-transcript-${now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z")}.md`;
+    return `jecode-transcript-${now.toISOString().replace(/[-:.]/g, "")}.md`;
 }
 export function transcriptMarkdown(blocks) {
     const out = ["# jecode transcript", ""];

package/dist/tui/components/tool.js

@@ -136,7 +136,7 @@ function statusInk(tone, pal) {
         return pal.ink.removed;
     if (tone === "pending" || tone === "deny")
         return pal.ink.attention;
-    return pal.ink.muted;
+    return pal.ink.added;
 }
 function failureLine(line) {
     return line.startsWith("✖") || line.startsWith("×") || line.includes("AssertionError") || /\bfailed\b/i.test(line);

package/dist/ui/theme.js

@@ -1,25 +1,26 @@
 // Jecode's fixed terminal identity. Components depend on semantic tokens, not
 // literal colours, while the product exposes one deliberate dark Steel look.
-// Jecode's fixed dark Steel baseline. Components depend on these semantic
-// roles rather than embedding presentation values of their own.
+// Jecode's fixed dark Steel baseline. Structural blues, semantic outcomes,
+// and slate surfaces keep the transcript vivid without turning it decorative.
+// Components depend on these roles rather than embedding presentation values.
 export const STEEL = {
-    accent: [138, 190, 183],
-    accentSoft: [0, 215, 255],
-    focus: [95, 135, 255],
-    rule: [80, 80, 80],
+    accent: [102, 155, 210],
+    accentSoft: [131, 213, 245],
+    focus: [102, 155, 210],
+    rule: [53, 80, 110],
     ink: {
-        fg: [212, 212, 212],
-        bright: [212, 212, 212],
-        muted: [128, 128, 128],
-        attention: [255, 255, 0],
-        added: [181, 189, 104],
-        removed: [204, 102, 102],
+        fg: [212, 218, 225],
+        bright: [235, 239, 244],
+        muted: [112, 124, 137],
+        attention: [230, 191, 95],
+        added: [134, 203, 146],
+        removed: [232, 112, 112],
     },
     surface: {
-        subtle: [52, 53, 65],
-        inset: [40, 40, 50],
-        added: [40, 50, 40],
-        removed: [60, 40, 40],
-        attention: [58, 58, 74],
+        subtle: [31, 38, 47],
+        inset: [18, 24, 31],
+        added: [22, 55, 34],
+        removed: [62, 24, 27],
+        attention: [62, 50, 19],
     },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.2.4",
+  "version": "0.3.1",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {