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

package/dist/git/utils.js

@@ -9,14 +9,18 @@
  */
 import { execFileSync } from "node:child_process";
 import { realpathSync } from "node:fs";
-import { parseGitLog } from "./parse-log.js";
+import { GIT_LOG_FORMAT, parseGitLog } from "./parse-log.js";
 import { resolveExecutable, resolveGit } from "@cjhyy/code-shell-core/extension";
 // Resolve git/gh through PATH×PATHEXT on Windows so a .cmd/.exe shim is found
 // (bare execFile doesn't walk PATHEXT). No-op on POSIX. See utils/exec.ts.
 const GH_BIN = resolveExecutable("gh");
+/** Run git with an argv array and return its untrimmed stdout. */
+function gitRaw(cwd, args, timeoutMs = 10000) {
+    return execFileSync(resolveGit(), args, { cwd, encoding: "utf-8", timeout: timeoutMs });
+}
 /** Run git with an argv array and return its trimmed stdout. */
 function git(cwd, args, timeoutMs = 10000) {
-    return execFileSync(resolveGit(), args, { cwd, encoding: "utf-8", timeout: timeoutMs }).trim();
+    return gitRaw(cwd, args, timeoutMs).trim();
 }
 /** Run gh with an argv array and return its trimmed stdout. */
 function gh(cwd, args, timeoutMs = 10000) {
@@ -62,13 +66,22 @@ export function getCurrentBranch(cwd) {
     return git(cwd, ["branch", "--show-current"], 5000);
 }
 export function getGitStatus(cwd) {
-    const raw = git(cwd, ["status", "--porcelain"], 10000);
-    if (!raw)
-        return [];
-    return raw.split("\n").map((line) => ({
-        status: line.slice(0, 2).trim(),
-        path: line.slice(3),
-    }));
+    // `-z` output is NUL-terminated and unquoted. It must not be trimmed: the
+    // fixed-width `XY ` prefix of an unstaged entry starts with a space.
+    const records = gitRaw(cwd, ["status", "--porcelain", "-z"], 10000).split("\0");
+    const entries = [];
+    for (let i = 0; i < records.length; i++) {
+        const record = records[i];
+        if (record.length < 4)
+            continue;
+        const xy = record.slice(0, 2);
+        const entry = { status: xy.trim(), path: record.slice(3) };
+        // Rename/copy entries are followed by a separate source-path record.
+        if (xy.includes("R") || xy.includes("C"))
+            entry.origPath = records[++i] ?? "";
+        entries.push(entry);
+    }
+    return entries;
 }
 export function getGitDiff(cwd, opts) {
     const args = ["diff", "--no-color"];
@@ -88,11 +101,17 @@ export function getGitDiffStat(cwd, opts) {
         args.push("--", opts.file);
     return git(cwd, args, 10000);
 }
+/** Untracked, non-ignored files under `cwd`, relative to `cwd` (what `git add .` would add). */
+export function getUntrackedFiles(cwd) {
+    return gitRaw(cwd, ["ls-files", "--others", "--exclude-standard", "-z"], 10000)
+        .split("\0")
+        .filter(Boolean);
+}
 export function getGitLog(cwd, n = 10) {
     // `n` is numeric — coerce/validate to keep the argv clean even if a caller
     // hands us a string.
     const count = Number.isFinite(n) && n > 0 ? Math.floor(n) : 10;
-    const raw = git(cwd, ["log", "--oneline", "--format=%H|%s|%an|%ci", `-${count}`], 10000);
+    const raw = git(cwd, ["log", `--format=${GIT_LOG_FORMAT}`, `-${count}`], 10000);
     if (!raw)
         return [];
     return parseGitLog(raw);

package/dist/git/worktree/crud.d.ts

@@ -89,6 +89,8 @@ export interface RemoveWorktreeResult {
 }
 export interface RemoveWorktreeOptions {
     prefix?: string;
+    /** False lets Git reject working-tree changes made after the caller's preflight. */
+    force?: boolean;
 }
 export interface WorktreeChangeState {
     uncommitted: boolean;

package/dist/git/worktree/crud.js

@@ -48,6 +48,30 @@ export function selectPlatformScript(scripts, platform = process.platform) {
     const trimmed = candidate?.trim();
     return trimmed ? candidate : undefined;
 }
+/** Tail of the pending creations per canonical repository root. */
+const creationQueues = new Map();
+/**
+ * Run one worktree creation at a time per repository. The prechecks and the
+ * rollback below assume that an absent branch/path seen by this call stays
+ * this call's to create; two concurrent identical requests would otherwise
+ * both pass the prechecks, and the loser's rollback would force-remove the
+ * winner's worktree, branch and uncommitted files.
+ */
+async function withRepositoryCreationLock(gitRoot, run) {
+    const previous = creationQueues.get(gitRoot) ?? Promise.resolve();
+    let release;
+    const tail = previous.then(() => new Promise((resolveRelease) => (release = resolveRelease)));
+    creationQueues.set(gitRoot, tail);
+    await previous;
+    try {
+        return await run();
+    }
+    finally {
+        release();
+        if (creationQueues.get(gitRoot) === tail)
+            creationQueues.delete(gitRoot);
+    }
+}
 /**
  * Create an isolated git worktree for an agent session.
  */
@@ -55,6 +79,10 @@ export async function createWorktree(cwd, slug, sessionId, opts = {}) {
     validateWorktreeSlug(slug);
     throwIfAborted(opts.signal);
     const gitRoot = await findGitRoot(cwd);
+    throwIfAborted(opts.signal);
+    return await withRepositoryCreationLock(gitRoot, () => createWorktreeLocked(cwd, gitRoot, slug, sessionId, opts));
+}
+async function createWorktreeLocked(cwd, gitRoot, slug, sessionId, opts) {
     throwIfAborted(opts.signal);
     const branchName = applyPrefix(opts.prefix, slug, sessionId);
     const worktreePath = resolve(gitRoot, "..", `.worktrees/${slug}-${sessionId.slice(0, 8)}`);
@@ -328,7 +356,7 @@ export function removeWorktree(worktreePath, removeBranch = false, opts = {}) {
         }
     }
     try {
-        execGitSync(mainRoot, ["worktree", "remove", worktreePath, "--force"], 30000);
+        execGitSync(mainRoot, ["worktree", "remove", worktreePath, ...(opts.force === false ? [] : ["--force"])], 30000);
     }
     catch (err) {
         throw new Error(`failed to remove worktree ${worktreePath}: ${gitErrorMessage(err)}`, {

package/dist/git/worktree/diff.js

@@ -1,9 +1,7 @@
 /** Git worktree diff support owned by the coding capability. */
-import { gitOutput } from "./git-exec.js";
+import { execGit, gitErrorMessage, gitOutput } from "./git-exec.js";
 export async function getWorktreeDiff(worktreePath, baseRef) {
-    const comparisonBase = baseRef && (await commitRefExists(worktreePath, baseRef))
-        ? baseRef
-        : await findComparisonBaseRef(worktreePath);
+    const comparisonBase = await findSummaryComparisonBase(worktreePath, baseRef);
     return diffSummary(worktreePath, comparisonBase);
 }
 export async function worktreeHasUncommittedChanges(worktreePath) {
@@ -29,11 +27,33 @@ async function commitRefExists(cwd, ref) {
     const out = await gitOutput(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], 5000);
     return out !== undefined;
 }
+async function findSummaryComparisonBase(cwd, baseRef) {
+    const candidates = new Set([
+        ...(baseRef ? [baseRef] : []),
+        "main",
+        "master",
+        "origin/main",
+        "origin/master",
+    ]);
+    for (const ref of candidates) {
+        try {
+            await execGit(cwd, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`], 5000);
+            return ref;
+        }
+        catch (error) {
+            // --verify --quiet exits with 1 for an absent ref. Infrastructure errors
+            // must reach the UI instead of being reported as a clean workspace.
+            if (error.code !== 1)
+                throw error;
+        }
+    }
+    return undefined;
+}
 async function diffSummary(cwd, baseRef) {
     const [dirtyFiles, committedFiles, aheadCommits] = await Promise.all([
         statusFileSet(cwd),
         baseRef ? changedFilesSinceBase(cwd, baseRef) : Promise.resolve(new Set()),
-        baseRef ? aheadCommitCount(cwd, baseRef) : Promise.resolve(0),
+        baseRef ? readAheadCommitCount(cwd, baseRef) : Promise.resolve(0),
     ]);
     const changedFiles = new Set([...dirtyFiles, ...committedFiles]);
     return {
@@ -44,12 +64,26 @@ async function diffSummary(cwd, baseRef) {
     };
 }
 async function changedFilesSinceBase(cwd, baseRef) {
-    const out = await gitOutput(cwd, ["diff", "--name-only", `${baseRef}...HEAD`]);
-    const raw = out ?? (await gitOutput(cwd, ["diff", "--name-only", `${baseRef}..HEAD`])) ?? "";
-    return new Set(raw
-        .split("\n")
-        .map((line) => line.trim())
-        .filter(Boolean));
+    let raw;
+    try {
+        raw = await execGit(cwd, ["diff", "--name-only", "-z", `${baseRef}...HEAD`]);
+    }
+    catch (error) {
+        // Unrelated histories have no merge base. Keep the existing two-dot
+        // comparison for that case, while surfacing timeouts and other failures.
+        if (!/no merge base/i.test(gitErrorMessage(error)))
+            throw error;
+        raw = await execGit(cwd, ["diff", "--name-only", "-z", `${baseRef}..HEAD`]);
+    }
+    return new Set(raw.split("\0").filter(Boolean));
+}
+async function readAheadCommitCount(cwd, baseRef) {
+    const out = await execGit(cwd, ["rev-list", "--count", `${baseRef}..HEAD`]);
+    const count = Number(out.trim());
+    if (!Number.isSafeInteger(count) || count < 0) {
+        throw new Error("Git returned an invalid ahead commit count");
+    }
+    return count;
 }
 async function aheadCommitCount(cwd, baseRef) {
     const out = await gitOutput(cwd, ["rev-list", "--count", `${baseRef}..HEAD`]);
@@ -57,27 +91,21 @@ async function aheadCommitCount(cwd, baseRef) {
     return Number.isFinite(n) ? n : 0;
 }
 async function statusFileSet(cwd) {
-    const raw = (await gitOutput(cwd, ["status", "--porcelain=v1"])) ?? "";
+    // Background summaries must not contend with a foreground Git operation for
+    // the optional index refresh lock. NUL records preserve arbitrary file names.
+    const raw = await execGit(cwd, ["--no-optional-locks", "status", "--porcelain=v1", "-z"]);
     const files = new Set();
-    for (const line of raw.split("\n")) {
-        if (!line.trim())
-            continue;
-        const path = line.slice(3).trim();
+    const records = raw.split("\0");
+    for (let i = 0; i < records.length; i += 1) {
+        const record = records[i];
+        const path = record.slice(3);
         if (!path)
             continue;
-        const renameTarget = path.includes(" -> ") ? path.split(" -> ").at(-1) : path;
-        if (renameTarget)
-            files.add(unquoteGitPath(renameTarget));
+        files.add(path);
+        // In porcelain -z, the destination comes first and the following NUL
+        // record contains the source of a rename or copy.
+        if (/[RC]/.test(record.slice(0, 2)))
+            i += 1;
     }
     return files;
 }
-function unquoteGitPath(path) {
-    if (!path.startsWith('"') || !path.endsWith('"'))
-        return path;
-    try {
-        return JSON.parse(path);
-    }
-    catch {
-        return path.slice(1, -1);
-    }
-}

package/dist/index.capability.js

@@ -5,7 +5,7 @@ import { lspTool, lspToolDef } from "./tools/lsp.js";
 import { notebookEditTool, notebookEditToolDef } from "./tools/notebook-edit.js";
 import { applyPatchTool, applyPatchToolDef } from "./tools/apply-patch/index.js";
 import { parsePatch } from "./tools/apply-patch/parser.js";
-import { patchBackupTargets } from "./tools/apply-patch/backup-targets.js";
+import { patchBackupTargets, patchDiffTargets } from "./tools/apply-patch/backup-targets.js";
 import { enterWorktreeTool, enterWorktreeToolDef, exitWorktreeTool, exitWorktreeToolDef, switchSessionWorkspaceTool, switchSessionWorkspaceToolDef, } from "./tools/worktree.js";
 import { branchExists, isGitWorktreeRoot } from "./git/worktree.js";
 import { checkQuotaTool, checkQuotaToolDef } from "./tools/check-quota.js";
@@ -235,10 +235,23 @@ export const TERMINAL_CODING_PRESET = {
 const CODING_PROMPT_SECTIONS = {
     coding: readFileSync(new URL("./prompt/coding.md", import.meta.url), "utf-8"),
 };
+function notebookMutationTargets(args, cwd) {
+    return typeof args.file_path === "string" &&
+        args.file_path.length > 0 &&
+        (args.action === "insert" || args.action === "replace" || args.action === "delete")
+        ? [resolve(cwd, args.file_path)]
+        : [];
+}
 const CODING_FILE_HISTORY = [
     {
         toolName: "ApplyPatch",
         resolveTargets: (args, cwd) => typeof args.patch === "string" ? patchBackupTargets(args.patch, cwd) : [],
+        resolveDiffTargets: (args, cwd) => typeof args.patch === "string" ? patchDiffTargets(args.patch, cwd) : [],
+    },
+    {
+        toolName: "NotebookEdit",
+        resolveTargets: notebookMutationTargets,
+        resolveDiffTargets: notebookMutationTargets,
     },
 ];
 const CODING_SESSION_WORKSPACE = {

package/dist/index.git.d.ts

@@ -2,3 +2,4 @@
 export * from "./git/worktree.js";
 export * from "./git/utils.js";
 export * from "./review/review-prompt.js";
+export * from "./review/review-target.js";

package/dist/index.git.js

@@ -2,3 +2,4 @@
 export * from "./git/worktree.js";
 export * from "./git/utils.js";
 export * from "./review/review-prompt.js";
+export * from "./review/review-target.js";

package/dist/lsp/client.d.ts

@@ -28,6 +28,7 @@ export declare class LSPClient extends EventEmitter {
     private buffer;
     private contentLength;
     private initialized;
+    private failure;
     constructor(command: string, args?: string[], cwd?: string | undefined);
     start(): Promise<void>;
     initialize(rootUri: string): Promise<unknown>;
@@ -36,6 +37,8 @@ export declare class LSPClient extends EventEmitter {
     shutdown(): Promise<void>;
     get isInitialized(): boolean;
     get isAlive(): boolean;
+    private assertWritable;
+    private fail;
     private handleData;
     private rejectAll;
 }

package/dist/lsp/client.js

@@ -18,6 +18,7 @@ export class LSPClient extends EventEmitter {
     buffer = Buffer.alloc(0);
     contentLength = -1;
     initialized = false;
+    failure;
     constructor(command, args = [], cwd) {
         super();
         this.command = command;
@@ -25,21 +26,56 @@ export class LSPClient extends EventEmitter {
         this.cwd = cwd;
     }
     async start() {
-        this.process = spawn(this.command, this.args, {
+        if (this.isAlive)
+            return;
+        this.failure = undefined;
+        this.initialized = false;
+        this.buffer = Buffer.alloc(0);
+        this.contentLength = -1;
+        const child = spawn(this.command, this.args, {
             cwd: this.cwd,
             stdio: ["pipe", "pipe", "pipe"],
         });
-        this.process.stdout?.on("data", (data) => this.handleData(data));
-        this.process.stderr?.on("data", (_data) => {
+        this.process = child;
+        const fail = (error) => {
+            if (this.process !== child)
+                return;
+            this.fail(error);
+        };
+        child.stdout?.on("data", (data) => {
+            if (this.process === child && !this.failure)
+                this.handleData(data);
+        });
+        child.stderr?.on("data", (_data) => {
             // LSP servers often log to stderr — ignore
         });
-        this.process.on("exit", (code) => {
+        // Pipe errors are emitted on the streams, not on ChildProcess. Keep these
+        // listeners through teardown so late EPIPE events cannot escape the host.
+        child.stdin?.on("error", fail);
+        child.stdout?.on("error", fail);
+        child.stderr?.on("error", fail);
+        child.on("error", fail);
+        child.on("exit", (code, signal) => {
+            if (this.process !== child)
+                return;
+            this.fail(new Error(`LSP server exited with ${signal ? `signal ${signal}` : `code ${code}`}`));
             this.emit("exit", code);
-            this.rejectAll(new Error(`LSP server exited with code ${code}`));
         });
         // Don't keep the event loop alive solely for the LSP child.
         // Call after listeners are wired so event registration doesn't re-ref.
-        this.process.unref();
+        child.unref();
+        await new Promise((resolve, reject) => {
+            const onSpawn = () => {
+                child.off("error", onError);
+                resolve();
+            };
+            const onError = (error) => {
+                child.off("spawn", onSpawn);
+                reject(error);
+            };
+            child.once("spawn", onSpawn);
+            child.once("error", onError);
+        });
     }
     async initialize(rootUri) {
         const result = await this.request("initialize", {
@@ -63,8 +99,7 @@ export class LSPClient extends EventEmitter {
         return result;
     }
     async request(method, params) {
-        if (!this.process?.stdin)
-            throw new Error("LSP server not started");
+        this.assertWritable();
         const id = this.nextId++;
         const message = { jsonrpc: "2.0", id, method, params };
         const content = JSON.stringify(message);
@@ -88,43 +123,79 @@ export class LSPClient extends EventEmitter {
                     reject(err);
                 },
             });
-            this.process.stdin.write(header + content);
+            try {
+                this.process.stdin.write(header + content);
+            }
+            catch (error) {
+                this.fail(error instanceof Error ? error : new Error(String(error)));
+            }
         });
     }
     async notify(method, params) {
-        if (!this.process?.stdin)
-            throw new Error("LSP server not started");
+        this.assertWritable();
         const message = { jsonrpc: "2.0", method, params };
         const content = JSON.stringify(message);
         const header = `Content-Length: ${Buffer.byteLength(content)}\r\n\r\n`;
-        this.process.stdin.write(header + content);
+        try {
+            this.process.stdin.write(header + content);
+        }
+        catch (error) {
+            this.fail(error instanceof Error ? error : new Error(String(error)));
+            throw error;
+        }
     }
     async shutdown() {
-        if (!this.process)
+        const child = this.process;
+        if (!child)
             return;
         try {
-            await this.request("shutdown", {});
-            await this.notify("exit", {});
+            if (this.isAlive && this.initialized) {
+                await this.request("shutdown", {});
+                await this.notify("exit", {});
+            }
         }
         catch {
             // Force kill
         }
-        this.process.stdout?.removeAllListeners();
-        this.process.stderr?.removeAllListeners();
-        this.process.removeAllListeners();
-        this.process.kill();
+        if (this.process !== child)
+            return;
+        this.fail(new Error("LSP server shut down"));
         this.process = undefined;
-        // Drain pending requests
-        for (const { reject } of this.pending.values()) {
-            reject(new Error("LSP server shut down"));
-        }
-        this.pending.clear();
+        child.stdin?.destroy();
+        child.stdout?.destroy();
+        child.stderr?.destroy();
     }
     get isInitialized() {
         return this.initialized;
     }
     get isAlive() {
-        return this.process !== undefined && !this.process.killed;
+        return (!!this.process &&
+            !this.failure &&
+            !this.process.killed &&
+            this.process.exitCode === null &&
+            this.process.signalCode === null);
+    }
+    assertWritable() {
+        if (!this.isAlive || !this.process?.stdin || this.process.stdin.destroyed)
+            throw this.failure ?? new Error("LSP server is not running");
+    }
+    fail(error) {
+        if (this.failure)
+            return;
+        this.failure = error;
+        this.initialized = false;
+        this.rejectAll(error);
+        const child = this.process;
+        if (child?.pid && child.exitCode === null && child.signalCode === null) {
+            child.kill();
+            const timer = setTimeout(() => {
+                if (child.exitCode === null && child.signalCode === null)
+                    child.kill("SIGKILL");
+            }, 500);
+            timer.unref();
+            child.once("exit", () => clearTimeout(timer));
+        }
+        this.emit("failure", error);
     }
     handleData(data) {
         // Append the new chunk as bytes. Buffer.concat avoids the UTF-8

package/dist/lsp/manager.d.ts

@@ -7,6 +7,7 @@ type ServerState = "stopped" | "starting" | "ready" | "error";
 export declare class LSPServerManager {
     private servers;
     private rootUri;
+    private stopping;
     constructor(cwd: string);
     /**
      * Get or start a language server by name.
@@ -33,6 +34,7 @@ export declare class LSPServerManager {
      * Shutdown all servers.
      */
     shutdownAll(): Promise<void>;
+    private stopServers;
 }
 export declare function isCommandAvailable(command: string, env?: NodeJS.ProcessEnv): boolean;
 export declare function initializeLSPManager(cwd: string): LSPServerManager;

package/dist/lsp/manager.js

@@ -11,6 +11,7 @@ import { rootUriToPath } from "./root-path.js";
 export class LSPServerManager {
     servers = new Map();
     rootUri;
+    stopping;
     constructor(cwd) {
         this.rootUri = pathToFileURL(cwd).href;
         // Register all built-in servers
@@ -22,19 +23,25 @@ export class LSPServerManager {
      * Get or start a language server by name.
      */
     async getClient(serverName) {
+        if (this.stopping)
+            return undefined;
         const managed = this.servers.get(serverName);
         if (!managed)
             return undefined;
         if (managed.state === "ready" && managed.client?.isAlive) {
             return managed.client;
         }
-        if (managed.state === "starting") {
-            // Wait for it to be ready
-            await new Promise((r) => setTimeout(r, 2000));
-            return managed.client;
+        if (managed.starting)
+            return managed.starting;
+        const starting = this.startServer(serverName);
+        managed.starting = starting;
+        try {
+            return await starting;
+        }
+        finally {
+            if (managed.starting === starting)
+                managed.starting = undefined;
         }
-        // Try to start
-        return this.startServer(serverName);
     }
     /**
      * Start a specific language server.
@@ -50,17 +57,37 @@ export class LSPServerManager {
             return undefined;
         }
         managed.state = "starting";
+        managed.error = undefined;
+        const client = new LSPClient(managed.config.command, managed.config.args, rootUriToPath(this.rootUri));
+        managed.client = client;
+        client.on("failure", (error) => {
+            if (managed.client !== client)
+                return;
+            managed.state = "error";
+            managed.error = error.message;
+        });
         try {
-            const client = new LSPClient(managed.config.command, managed.config.args, rootUriToPath(this.rootUri));
             await client.start();
+            if (managed.client !== client) {
+                await client.shutdown();
+                return undefined;
+            }
             await client.initialize(this.rootUri);
-            managed.client = client;
+            // Shutdown can retire a startup while initialize is in flight.
+            if (managed.client !== client) {
+                await client.shutdown();
+                return undefined;
+            }
             managed.state = "ready";
             return client;
         }
         catch (err) {
-            managed.state = "error";
-            managed.error = err.message;
+            if (managed.client === client) {
+                managed.state = "error";
+                managed.error = err.message;
+                managed.client = undefined;
+            }
+            await client.shutdown();
             return undefined;
         }
     }
@@ -88,18 +115,32 @@ export class LSPServerManager {
     /**
      * Shutdown all servers.
      */
-    async shutdownAll() {
+    shutdownAll() {
+        // Fence new starts for the entire sweep, including while a previous
+        // server's shutdown handshake is pending. Registry eviction must not leave
+        // a replacement process in a manager that no longer has an owner.
+        if (!this.stopping) {
+            this.stopping = Promise.resolve()
+                .then(() => this.stopServers())
+                .finally(() => {
+                this.stopping = undefined;
+            });
+        }
+        return this.stopping;
+    }
+    async stopServers() {
         for (const server of this.servers.values()) {
-            if (server.client?.isAlive) {
+            const client = server.client;
+            server.state = "stopped";
+            server.client = undefined;
+            if (client) {
                 try {
-                    await server.client.shutdown();
+                    await client.shutdown();
                 }
                 catch {
                     // Force killed
                 }
             }
-            server.state = "stopped";
-            server.client = undefined;
         }
     }
 }

package/dist/prompt/coding.md

@@ -30,6 +30,7 @@ The default job in this preset is software engineering in the current working di
 
 - When referencing specific functions or pieces of code include the pattern file_path:line_number to allow the user to easily navigate to the source code location.
 - When referencing GitHub issues or pull requests, use the owner/repo#123 format so they render as clickable links.
+- Before deleting a task branch, check both its merge target and configured upstream. `git branch -d` can refuse deletion when the branch is merged into local `HEAD` but its upstream still lags. Preserve that protection and report local versus remote integration accurately; do not automatically retry with `-D` or treat the refusal as a failed merge.
 
 ## Opening URLs and local previews
 

package/dist/quota/index.d.ts

@@ -3,7 +3,8 @@
  *
  * Both lookups are verified against the real backends (2026-07-01):
  *   - Codex: GET https://chatgpt.com/backend-api/wham/usage → JSON
- *            rate_limit.{primary_window,secondary_window}.{used_percent,reset_at}.
+ *            rate_limit.{primary_window,secondary_window} contains
+ *            limit_window_seconds, used_percent and reset_at.
  *            Zero cost (no message sent).
  *   - Claude: POST /v1/messages (max_tokens:1) → response headers
  *            anthropic-ratelimit-unified-<window>-{utilization,reset}, where