@cjhyy/code-shell-capability-coding 0.9.44 → 0.9.46

package/dist/review/review-target.js

@@ -0,0 +1,353 @@
+import { execFile } from "node:child_process";
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { isAbsolute, relative, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+import { resolveGit } from "@cjhyy/code-shell-core/extension";
+import { ALL_DIMENSIONS } from "./review-prompt.js";
+const execFileAsync = promisify(execFile);
+const MAX_DIFF_BYTES = 256 * 1024;
+const MAX_ADDED_FILE_BYTES = 64 * 1024;
+const MAX_FILES = 100;
+const DIFF_OPTIONS = [
+    "--no-ext-diff",
+    "--no-textconv",
+    "--no-color",
+    "--no-relative",
+    "--no-renames",
+    "--ignore-submodules=none",
+    "--submodule=short",
+];
+/** Parse slash-command arguments without treating quotes or flags as path fragments. */
+export function parseReviewArguments(input) {
+    const tokens = tokenizeReviewArguments(input);
+    let target;
+    let file;
+    let json = false;
+    let dimensions = [...ALL_DIMENSIONS];
+    let dimensionsSeen = false;
+    let positional = false;
+    const setTarget = (next) => {
+        if (target)
+            throw new Error("Choose only one review scope: --all, --staged, --unstaged, --base, or --commit.");
+        target = next;
+    };
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (!positional && token === "--") {
+            positional = true;
+            continue;
+        }
+        if (!positional && token.startsWith("--")) {
+            if (token === "--json") {
+                if (json)
+                    throw new Error("--json may only be specified once.");
+                json = true;
+            }
+            else if (token === "--all" || token === "--staged" || token === "--unstaged") {
+                setTarget({ kind: "working", mode: token.slice(2) });
+            }
+            else if (/^--(?:base|commit|dimensions)(?:=|$)/.test(token)) {
+                const equals = token.indexOf("=");
+                const flag = equals < 0 ? token : token.slice(0, equals);
+                const value = equals < 0 ? tokens[++index] : token.slice(equals + 1);
+                if (!value || value.startsWith("--"))
+                    throw new Error(`${flag} requires a value.`);
+                if (flag === "--base") {
+                    validateRef(value);
+                    setTarget({ kind: "base", ref: value });
+                }
+                else if (flag === "--commit") {
+                    if (!/^[a-fA-F0-9]{4,64}$/.test(value)) {
+                        throw new Error("--commit requires a hexadecimal commit hash (4–64 characters).");
+                    }
+                    setTarget({ kind: "commit", commit: value });
+                }
+                else {
+                    if (dimensionsSeen)
+                        throw new Error("--dimensions may only be specified once.");
+                    dimensionsSeen = true;
+                    const names = value.split(",").map((name) => name.trim().toLowerCase());
+                    const normalized = names.map((name) => (name === "perf" ? "performance" : name));
+                    const invalid = normalized.filter((name) => !ALL_DIMENSIONS.includes(name));
+                    if (invalid.length)
+                        throw new Error(`Unknown review dimension: ${invalid.join(", ")}. Use correctness, security, performance, or readability.`);
+                    dimensions = ALL_DIMENSIONS.filter((name) => normalized.includes(name));
+                }
+            }
+            else {
+                throw new Error(`Unknown review option: ${token}.`);
+            }
+        }
+        else {
+            if (!positional && token.startsWith("-")) {
+                throw new Error(`Unknown review option: ${token}. Use -- before a dash-prefixed path.`);
+            }
+            if (file !== undefined)
+                throw new Error("Review accepts one file or directory path. Quote paths containing spaces.");
+            if (!token || token.includes("\0"))
+                throw new Error("Invalid review path.");
+            file = token;
+        }
+    }
+    return {
+        target: {
+            ...(target ?? { kind: "working", mode: "all" }),
+            ...(file ? { file } : {}),
+        },
+        json,
+        dimensions,
+    };
+}
+function validateRef(ref) {
+    if (ref.startsWith("-") || /[\x00-\x20\x7f]/.test(ref) || ref.length > 512) {
+        throw new Error("--base requires a valid Git reference.");
+    }
+}
+function tokenizeReviewArguments(input) {
+    const tokens = [];
+    let token = "";
+    let quote;
+    let started = false;
+    for (let index = 0; index < input.length; index++) {
+        const char = input[index];
+        if (quote) {
+            if (char === quote)
+                quote = undefined;
+            else if (char === "\\" && quote === '"' && /["\\]/.test(input[index + 1] ?? ""))
+                token += input[++index];
+            else
+                token += char;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            started = true;
+        }
+        else if (/\s/.test(char)) {
+            if (started)
+                tokens.push(token);
+            token = "";
+            started = false;
+        }
+        else if (char === "\\" && /[\s'"\\]/.test(input[index + 1] ?? "")) {
+            token += input[++index];
+            started = true;
+        }
+        else {
+            token += char;
+            started = true;
+        }
+    }
+    if (quote)
+        throw new Error("Unclosed quote in review arguments.");
+    if (started)
+        tokens.push(token);
+    return tokens;
+}
+/** Collect a complete bounded patch, or fail explicitly before asking the model to review it. */
+export async function collectReviewTarget(cwd, target) {
+    const repoRoot = (await git(cwd, ["rev-parse", "--show-toplevel"])).trim();
+    const file = target.file === undefined ? undefined : repositoryPath(repoRoot, cwd, target.file);
+    const pathspec = file === undefined ? [] : [`:(literal)${file}`];
+    const paths = ["--", ...pathspec];
+    let range;
+    let label;
+    let unbornAll = false;
+    if (target.kind === "base") {
+        validateRef(target.ref);
+        const base = await resolveCommit(repoRoot, target.ref);
+        const head = await resolveCommit(repoRoot, "HEAD");
+        const ancestor = (await git(repoRoot, ["merge-base", base, head])).trim();
+        range = [ancestor, head];
+        label = `branch changes since merge-base with ${target.ref}`;
+    }
+    else if (target.kind === "commit") {
+        if (!/^[a-fA-F0-9]{4,64}$/.test(target.commit))
+            throw new Error("Invalid review commit hash.");
+        const commit = await resolveCommit(repoRoot, target.commit);
+        range = [commit];
+        label = `commit ${commit}`;
+    }
+    else {
+        if (!["all", "staged", "unstaged"].includes(target.mode))
+            throw new Error("Invalid review scope.");
+        const head = await git(repoRoot, ["rev-parse", "--verify", "--quiet", "HEAD^{commit}"], true);
+        unbornAll = target.mode === "all" && head === null;
+        range =
+            target.mode === "staged" ? ["--cached"] : target.mode === "all" && head ? [head.trim()] : [];
+        label = `${target.mode === "all" ? "all uncommitted" : target.mode} changes`;
+        const conflicts = await git(repoRoot, ["ls-files", "--unmerged", "-z", ...paths]);
+        if (conflicts)
+            throw new Error("Review incomplete: resolve unmerged files before reviewing this scope.");
+    }
+    const command = target.kind === "commit" ? "show" : "diff";
+    const prefix = command === "show" ? ["show", "--format=", "--root", "--first-parent"] : ["diff"];
+    const options = [...prefix, ...DIFF_OPTIONS];
+    let content = "";
+    let files = [];
+    if (!unbornAll) {
+        const numstat = (await git(repoRoot, [...options, "--numstat", "-z", ...range, ...paths]));
+        for (const entry of numstat.split("\0").filter(Boolean)) {
+            const [added, removed, ...name] = entry.split("\t");
+            if (added === "-" || removed === "-") {
+                throw new Error(`Review incomplete: binary file ${name.join("\t")} cannot be reviewed as text.`);
+            }
+        }
+        files = nulPaths((await git(repoRoot, [...options, "--name-only", "-z", ...range, ...paths])));
+        enforceFileCount(files.length);
+        content = (await git(repoRoot, [...options, "--patch", "--unified=3", ...range, ...paths]));
+        if (content.includes("\0")) {
+            throw new Error("Review incomplete: the patch contains binary data that cannot be reviewed as text.");
+        }
+    }
+    if (target.kind === "working" && target.mode !== "staged") {
+        const added = nulPaths((await git(repoRoot, ["ls-files", "--others", "--exclude-standard", "-z", ...paths])));
+        if (unbornAll)
+            added.unshift(...nulPaths((await git(repoRoot, ["ls-files", "--cached", "-z", ...paths]))));
+        const uniqueAdded = [...new Set(added)];
+        enforceFileCount(files.length + uniqueAdded.length);
+        for (const path of uniqueAdded) {
+            const patch = await addedFilePatch(repoRoot, path, unbornAll);
+            if (patch === null)
+                continue; // A staged addition deleted before the first commit has no net change.
+            files.push(path);
+            content += `${content && !content.endsWith("\n") ? "\n" : ""}${patch}`;
+            enforceDiffSize(content);
+        }
+    }
+    enforceDiffSize(content);
+    if (file !== undefined && files.length === 0) {
+        throw new Error(`No changes in the selected review scope match ${target.file}.`);
+    }
+    return { content, label: `${label}${target.file ? ` in ${target.file}` : ""}`, files };
+}
+function repositoryPath(root, cwd, file) {
+    if (!file || file.includes("\0"))
+        throw new Error("Invalid review path.");
+    const path = relative(root, resolve(cwd, file));
+    if (path === ".." || path.startsWith(`..${sep}`) || isAbsolute(path))
+        throw new Error("Review path must be inside the Git repository.");
+    return path.split(sep).join("/") || ".";
+}
+async function resolveCommit(cwd, ref) {
+    return (await git(cwd, ["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`])).trim();
+}
+function nulPaths(raw) {
+    return raw.split("\0").filter(Boolean);
+}
+function enforceFileCount(count) {
+    if (count > MAX_FILES)
+        throw new Error(`Review incomplete: scope exceeds ${MAX_FILES} files. Select a narrower scope or path.`);
+}
+function enforceDiffSize(content) {
+    if (Buffer.byteLength(content) > MAX_DIFF_BYTES)
+        throw new Error(`Review incomplete: patch exceeds ${MAX_DIFF_BYTES} bytes. Select a narrower scope or path.`);
+}
+async function git(cwd, args, allowMissing = false) {
+    try {
+        const result = await execFileAsync(resolveGit(), ["--no-pager", "-c", "core.fsmonitor=false", ...args], {
+            cwd,
+            encoding: "buffer",
+            timeout: 30_000,
+            maxBuffer: MAX_DIFF_BYTES,
+            env: { ...process.env, GIT_OPTIONAL_LOCKS: "0" },
+        });
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(result.stdout);
+    }
+    catch (error) {
+        const failure = error;
+        if (allowMissing && failure.code === 1)
+            return null;
+        if (failure.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER")
+            throw new Error(`Review incomplete: Git output exceeds ${MAX_DIFF_BYTES} bytes. Select a narrower scope or path.`, { cause: error });
+        if (failure.code === "ERR_ENCODING_INVALID_ENCODED_DATA") {
+            throw new Error("Review incomplete: Git output contains non-UTF-8 data.", { cause: error });
+        }
+        if (failure.killed)
+            throw new Error("Review incomplete: Git collection timed out.", { cause: error });
+        throw new Error(`Review collection failed: ${String(failure.stderr || failure.message)
+            .trim()
+            .slice(0, 500)}`, { cause: error });
+    }
+}
+async function addedFilePatch(repoRoot, file, allowDeleted) {
+    const absolute = resolve(repoRoot, file);
+    const bounded = repositoryPath(repoRoot, repoRoot, file);
+    let stat;
+    try {
+        // Refuse symlinks in every component, including a directory replaced after ls-files.
+        let component = repoRoot;
+        for (const part of bounded.split("/")) {
+            component = resolve(component, part);
+            const info = await lstat(component);
+            if (info.isSymbolicLink())
+                throw new Error(`Review incomplete: ${file} is a symbolic link.`);
+        }
+        stat = await lstat(absolute);
+    }
+    catch (error) {
+        if (allowDeleted && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    if (!stat.isFile())
+        throw new Error(`Review incomplete: ${file} is not a regular file.`);
+    if (stat.size > MAX_ADDED_FILE_BYTES)
+        throw new Error(`Review incomplete: ${file} exceeds the ${MAX_ADDED_FILE_BYTES}-byte added-file limit.`);
+    const handle = await open(absolute, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    try {
+        const before = await handle.stat();
+        if (!before.isFile() ||
+            before.size > MAX_ADDED_FILE_BYTES ||
+            before.dev !== stat.dev ||
+            before.ino !== stat.ino)
+            throw new Error(`Review incomplete: ${file} changed during collection or exceeds the added-file limit.`);
+        const bytes = Buffer.alloc(MAX_ADDED_FILE_BYTES + 1);
+        const { bytesRead } = await handle.read(bytes, 0, bytes.length, 0);
+        const after = await handle.stat();
+        if (bytesRead > MAX_ADDED_FILE_BYTES ||
+            before.size !== bytesRead ||
+            before.size !== after.size ||
+            before.mtimeMs !== after.mtimeMs ||
+            before.ctimeMs !== after.ctimeMs) {
+            throw new Error(`Review incomplete: ${file} changed during collection or exceeds the added-file limit.`);
+        }
+        const body = bytes.subarray(0, bytesRead);
+        if (body.includes(0))
+            throw new Error(`Review incomplete: binary file ${file} cannot be reviewed as text.`);
+        let text;
+        try {
+            text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(body);
+        }
+        catch {
+            throw new Error(`Review incomplete: ${file} is not valid UTF-8 text.`);
+        }
+        const lines = text ? text.split("\n") : [];
+        const newline = text.endsWith("\n");
+        if (newline)
+            lines.pop();
+        const a = quoteGitPath(`a/${file}`);
+        const b = quoteGitPath(`b/${file}`);
+        return [
+            `diff --git ${a} ${b}`,
+            `new file mode ${stat.mode & 0o111 ? "100755" : "100644"}`,
+            ...(lines.length
+                ? [
+                    "--- /dev/null",
+                    `+++ ${b}`,
+                    `@@ -0,0 +1,${lines.length} @@`,
+                    ...lines.map((line) => `+${line}`),
+                    ...(!newline ? ["\"] : []),
+                ]
+                : []),
+            "",
+        ].join("\n");
+    }
+    finally {
+        await handle.close();
+    }
+}
+function quoteGitPath(path) {
+    return `"${path.replace(/["\\\x00-\x1f\x7f]/g, (char) => (char === '"' || char === "\\" ? `\\${char}` : `\\${char.charCodeAt(0).toString(8).padStart(3, "0")}`))}"`;
+}

package/dist/tools/apply-patch/applier.js

@@ -9,7 +9,7 @@
 //
 // Algorithm uses code adapted from codex-rs/apply-patch/src/lib.rs (Apache-2.0)
 // for the chunk-replacement phase (compute_replacements, apply_replacements).
-import { mkdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
+import { chmod, mkdir, open, unlink, writeFile } from "node:fs/promises";
 import { existsSync, realpathSync } from "node:fs";
 import { dirname, isAbsolute, resolve, sep } from "node:path";
 import { seekSequence } from "./seek-sequence.js";
@@ -47,42 +47,38 @@ async function planHunks(hunks, cwd, workspaceRoots) {
         const original = hunk.path;
         const sourcePath = resolveAgainst(original, cwd, workspaceRoots);
         if (hunk.kind === "add") {
-            const existed = await readIfExists(sourcePath);
+            const existed = await readSnapshotIfExists(sourcePath);
             schedule(sourcePath, {
                 path: sourcePath,
                 newContent: hunk.contents,
-                originalContent: existed,
+                original: existed,
             });
             set.added.push(original);
             continue;
         }
         if (hunk.kind === "delete") {
-            const stats = await safeStat(sourcePath);
-            if (!stats)
+            const snapshot = await readSnapshotIfExists(sourcePath);
+            if (!snapshot)
                 throw new Error(`Failed to delete file: ${sourcePath} not found`);
-            if (stats.isDirectory()) {
-                throw new Error(`Failed to delete file: ${sourcePath} is a directory`);
-            }
-            const content = await readFile(sourcePath, "utf-8");
             schedule(sourcePath, {
                 path: sourcePath,
                 newContent: null,
-                originalContent: content,
+                original: snapshot,
             });
             set.deleted.push(original);
             continue;
         }
         // Update (with optional rename).
-        const stats = await safeStat(sourcePath);
-        if (!stats) {
+        const snapshot = await readSnapshotIfExists(sourcePath);
+        if (!snapshot) {
             throw new Error(`Failed to update file: ${sourcePath} does not exist`);
         }
-        const originalRaw = await readFile(sourcePath, "utf-8");
+        const originalRaw = snapshot.content.toString("utf-8");
         // CRLF handling: patch context lines are LF (the model emits LF). Match in
         // LF space, then write back in the file's original EOL so a CRLF file isn't
         // silently converted to LF (which would diff the whole file). originalText
-        // (LF) is what we compare; originalRaw is preserved for rollback so a
-        // restore writes back the exact bytes. See eol.ts.
+        // (LF) is what we compare; the undecoded snapshot is preserved for rollback
+        // so a restore writes back the exact bytes. See eol.ts.
         const eol = detectEol(originalRaw);
         const originalText = toLf(originalRaw);
         const newText = applyEol(applyChunksToText(originalText, hunk.chunks, sourcePath), eol);
@@ -93,20 +89,21 @@ async function planHunks(hunks, cwd, workspaceRoots) {
                 schedule(sourcePath, {
                     path: sourcePath,
                     newContent: newText,
-                    originalContent: originalRaw,
+                    original: snapshot,
                 });
             }
             else {
-                const destOriginal = await readIfExists(destPath);
+                const destOriginal = await readSnapshotIfExists(destPath);
                 schedule(sourcePath, {
                     path: sourcePath,
                     newContent: null,
-                    originalContent: originalRaw,
+                    original: snapshot,
                 });
                 schedule(destPath, {
                     path: destPath,
                     newContent: newText,
-                    originalContent: destOriginal,
+                    original: destOriginal,
+                    newMode: snapshot.mode,
                 });
             }
             set.modified.push(original);
@@ -115,7 +112,7 @@ async function planHunks(hunks, cwd, workspaceRoots) {
             schedule(sourcePath, {
                 path: sourcePath,
                 newContent: newText,
-                originalContent: originalRaw,
+                original: snapshot,
             });
             set.modified.push(original);
         }
@@ -191,27 +188,27 @@ async function commitPlanned(set, allowPartial) {
         }
         return { added: set.added, modified: set.modified, deleted: set.deleted };
     }
-    // Track which writes have completed so rollback only touches them. We use
-    // the originalContent captured during plan() rather than re-reading from
-    // disk — this avoids a TOCTOU window between planning and committing.
-    const committed = [];
+    // Include the current attempt: writeFile may write partially before failing,
+    // and chmod can fail after the new content has already been written. Restore
+    // the bytes and permissions captured during planning, without re-reading.
+    const attempted = [];
     try {
         for (const change of ordered) {
+            attempted.push(change);
             await writeChange(change);
-            committed.push(change);
         }
     }
     catch (err) {
-        for (let i = committed.length - 1; i >= 0; i--) {
-            const c = committed[i];
+        for (let i = attempted.length - 1; i >= 0; i--) {
+            const c = attempted[i];
             try {
-                if (c.originalContent === null) {
+                if (c.original === null) {
                     // File did not exist before we wrote it — remove our write.
                     if (existsSync(c.path))
                         await unlink(c.path);
                 }
                 else {
-                    await writeFile(c.path, c.originalContent, "utf-8");
+                    await restoreSnapshot(c.path, c.original);
                 }
             }
             catch {
@@ -222,6 +219,25 @@ async function commitPlanned(set, allowPartial) {
     }
     return { added: set.added, modified: set.modified, deleted: set.deleted };
 }
+async function restoreSnapshot(path, snapshot) {
+    const writableMode = snapshot.mode | 0o200;
+    try {
+        // A successful move may have made an existing target read-only. writeFile's
+        // mode only applies to new files, so temporarily allow restoring its bytes.
+        try {
+            await chmod(path, writableMode);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        await writeFile(path, snapshot.content, { mode: writableMode });
+    }
+    finally {
+        // Also restore a read-only snapshot's mode if writing its bytes fails.
+        await chmod(path, snapshot.mode);
+    }
+}
 async function writeChange(change) {
     if (change.newContent === null) {
         if (existsSync(change.path))
@@ -232,7 +248,11 @@ async function writeChange(change) {
     if (!existsSync(parent)) {
         await mkdir(parent, { recursive: true });
     }
-    await writeFile(change.path, change.newContent, "utf-8");
+    await writeFile(change.path, change.newContent, { encoding: "utf-8", mode: change.newMode });
+    if (change.newMode !== undefined) {
+        // The creation mode is masked by umask and ignored for existing targets.
+        await chmod(change.path, change.newMode);
+    }
 }
 // ─── helpers ──────────────────────────────────────────────────────
 /**
@@ -288,19 +308,24 @@ function isInside(child, parent) {
     const p = parent.endsWith(sep) ? parent : parent + sep;
     return child.startsWith(p);
 }
-async function safeStat(path) {
+async function readSnapshotIfExists(path) {
+    let file;
     try {
-        return await stat(path);
+        file = await open(path, "r");
     }
-    catch {
-        return null;
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTDIR")
+            return null;
+        throw error;
     }
-}
-async function readIfExists(path) {
     try {
-        return await readFile(path, "utf-8");
+        const stats = await file.stat();
+        if (stats.isDirectory())
+            throw new Error(`Cannot apply patch to directory: ${path}`);
+        return { content: await file.readFile(), mode: stats.mode & 0o7777 };
     }
-    catch {
-        return null;
+    finally {
+        await file.close();
     }
 }

package/dist/tools/apply-patch/backup-targets.d.ts

@@ -8,3 +8,11 @@
  * up (undo of an add = delete, handled separately if/when /undo grows that).
  */
 export declare function patchBackupTargets(patchText: string, cwd: string): string[];
+/**
+ * Every filesystem destination an ApplyPatch can change. Unlike undo backup
+ * targets, turn diffs need absent paths too: additions and move destinations
+ * must be captured before execution to distinguish creation from overwrite.
+ * Moves are represented by their source and destination; the tracker compares
+ * each path's real before/after state rather than inferring a rename from text.
+ */
+export declare function patchDiffTargets(patchText: string, cwd: string): string[];

package/dist/tools/apply-patch/backup-targets.js

@@ -28,3 +28,27 @@ export function patchBackupTargets(patchText, cwd) {
     // but be defensive — saveSnapshot is idempotent on identical content anyway).
     return [...new Set(out)];
 }
+/**
+ * Every filesystem destination an ApplyPatch can change. Unlike undo backup
+ * targets, turn diffs need absent paths too: additions and move destinations
+ * must be captured before execution to distinguish creation from overwrite.
+ * Moves are represented by their source and destination; the tracker compares
+ * each path's real before/after state rather than inferring a rename from text.
+ */
+export function patchDiffTargets(patchText, cwd) {
+    let parsed;
+    try {
+        parsed = parsePatch(patchText, "lenient");
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const hunk of parsed.hunks) {
+        out.push(resolvePath(cwd, hunk.path));
+        if (hunk.kind === "update" && hunk.movePath) {
+            out.push(resolvePath(cwd, hunk.movePath));
+        }
+    }
+    return [...new Set(out)];
+}

package/dist/tools/apply-patch/parser.js

@@ -108,8 +108,10 @@ function parseOneHunk(lines, offset, lineNumber) {
         }
         const chunks = [];
         while (cursor < lines.length) {
-            // Skip blank lines between chunks.
-            if (lines[cursor].trim() === "") {
+            // Skip blank lines between chunks. The first chunk may omit `@@`, so a
+            // space-marked line there is whitespace context, not a separator.
+            const leadingContext = chunks.length === 0 && lines[cursor].startsWith(" ");
+            if (lines[cursor].trim() === "" && !leadingContext) {
                 cursor++;
                 consumed++;
                 continue;

package/dist/tools/check-quota.js

@@ -5,7 +5,9 @@ export const checkQuotaToolDef = {
     description: "Check remaining usage/rate-limit quota for the external coding-agent CLIs (Claude Code and/or " +
         "Codex) — the same subscription windows their status lines show. Use before or during " +
         "orchestration (DriveAgent) to plan how much work to hand off, whether to wait for a reset, or " +
-        "which provider to use. Returns each window's used-% and reset time. Codex reports 5h/7d; " +
+        "which provider to use. Returns each window's used-% and reset time. " +
+        "Codex labels each window by its reported duration (e.g. 5h, 7d; 'primary'/'secondary' if " +
+        "the duration is missing); " +
         "Claude reports whichever windows apply to the account (5h/7d normally, 'overage' when the " +
         "account is running on overage), and marks the currently binding window with '*'. " +
         "COST: 'codex' is free (reads a usage endpoint). 'claude' costs ~1 token (Anthropic exposes " +