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

package/dist/external-runtimes/claude-code/runtime.d.ts

@@ -61,12 +61,15 @@ export declare class ClaudeCodeRuntime {
     private readonly log;
     private active?;
     private claudeSessionId?;
+    private reportedModel?;
     private closed;
     private firstTurn;
     private turnCount;
     constructor(options: ClaudeRuntimeOptions, hooks?: ClaudeRuntimeHooks);
     /** Claude session id, once the first turn has reported it. Resume key only. */
     get runtimeSessionId(): string | undefined;
+    /** CLI-reported model, falling back to the requested model until reported. */
+    get resolvedModel(): string | undefined;
     /**
      * Run one turn. Resolves when the process exits, which is also when the turn is
      * terminal — `claude -p` is one process per turn.

package/dist/external-runtimes/claude-code/runtime.js

@@ -44,6 +44,7 @@ export class ClaudeCodeRuntime {
     log;
     active;
     claudeSessionId;
+    reportedModel;
     closed = false;
     firstTurn = true;
     turnCount = 0;
@@ -67,6 +68,10 @@ export class ClaudeCodeRuntime {
     get runtimeSessionId() {
         return this.claudeSessionId;
     }
+    /** CLI-reported model, falling back to the requested model until reported. */
+    get resolvedModel() {
+        return this.reportedModel ?? this.options.model;
+    }
     /**
      * Run one turn. Resolves when the process exits, which is also when the turn is
      * terminal — `claude -p` is one process per turn.
@@ -216,6 +221,26 @@ export class ClaudeCodeRuntime {
             this.log("claude.unparsable_line", { bytes: line.length });
             return;
         }
+        // Capture identity before publishing terminal output so post-turn work sees
+        // the model this process actually used, including aliases resolved by Claude.
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+            const message = parsed;
+            // Sub-agent assistant output can name a different model from the root CLI.
+            if (message.parent_tool_use_id == null) {
+                const model = message.type === "system" && message.subtype === "init"
+                    ? message.model
+                    : message.type === "assistant"
+                        ? message.message?.model
+                        : message.type === "stream_event" && message.event?.type === "message_start"
+                            ? message.event.message?.model
+                            : undefined;
+                if (typeof model === "string") {
+                    const identity = model.trim();
+                    if (identity && identity !== "<synthetic>")
+                        this.reportedModel = identity;
+                }
+            }
+        }
         for (const event of translator.translate(parsed))
             emit(event);
         if (!this.claudeSessionId && translator.runtimeSessionId) {

package/dist/external-runtimes/claude-code/text-inference.d.ts

@@ -0,0 +1,22 @@
+import { spawn } from "node:child_process";
+import { type TokenUsage } from "@cjhyy/code-shell-core/extension";
+export interface ClaudeTextInferenceOptions {
+    systemPrompt: string;
+    userMessage: string;
+    /** Trusted foreground directory, preserving the CLI's project auth/provider settings. */
+    cwd?: string;
+    model?: string;
+    signal?: AbortSignal;
+    maxTokens?: number;
+    command?: string;
+    env?: NodeJS.ProcessEnv;
+    timeoutMs?: number;
+}
+/** Fresh CLI inference, with no conversation, Host tools or user customizations. */
+export declare function runClaudeTextInference(options: ClaudeTextInferenceOptions, dependencies?: {
+    spawn?: typeof spawn;
+}): Promise<{
+    text: string;
+    usage?: TokenUsage;
+    stopReason?: string;
+}>;

package/dist/external-runtimes/claude-code/text-inference.js

@@ -0,0 +1,240 @@
+import { spawn } from "node:child_process";
+import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { killProcessGroup } from "@cjhyy/code-shell-core/extension";
+const MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
+const MAX_STDERR_BYTES = 64 * 1024;
+const MAX_INPUT_BYTES = 2 * 1024 * 1024;
+function usageFromResult(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const raw = value;
+    const input = raw.input_tokens;
+    const output = raw.output_tokens;
+    const read = raw.cache_read_input_tokens ?? 0;
+    const write = raw.cache_creation_input_tokens ?? 0;
+    if (![input, output, read, write].every((count) => Number.isSafeInteger(count) && Number(count) >= 0))
+        return undefined;
+    const promptTokens = Number(input) + Number(read) + Number(write);
+    const totalTokens = promptTokens + Number(output);
+    if (!Number.isSafeInteger(totalTokens))
+        return undefined;
+    return {
+        promptTokens,
+        completionTokens: Number(output),
+        totalTokens,
+        ...(raw.cache_read_input_tokens !== undefined ? { cacheReadTokens: Number(read) } : {}),
+        ...(raw.cache_creation_input_tokens !== undefined
+            ? { cacheCreationTokens: Number(write) }
+            : {}),
+    };
+}
+/** Fresh CLI inference, with no conversation, Host tools or user customizations. */
+export async function runClaudeTextInference(options, dependencies = {}) {
+    options.signal?.throwIfAborted();
+    if (!options.systemPrompt?.trim() || !options.userMessage?.trim())
+        throw new Error("Claude text inference requires a system prompt and user message");
+    if (Buffer.byteLength(options.systemPrompt) + Buffer.byteLength(options.userMessage) >
+        MAX_INPUT_BYTES)
+        throw new Error("Claude text inference input exceeds its byte limit");
+    const maxTokens = options.maxTokens ?? 3072;
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    if (!Number.isSafeInteger(maxTokens) || maxTokens < 1 || maxTokens > 128_000)
+        throw new Error("Invalid Claude text inference output budget");
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 3_600_000)
+        throw new Error("Invalid Claude text inference timeout");
+    const privateDir = await mkdtemp(join(tmpdir(), "codeshell-claude-text-"));
+    try {
+        await chmod(privateDir, 0o700);
+        const systemPromptFile = join(privateDir, "system-prompt.txt");
+        await writeFile(systemPromptFile, options.systemPrompt, { mode: 0o600 });
+        await chmod(systemPromptFile, 0o600);
+        options.signal?.throwIfAborted();
+        const args = [
+            "-p",
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--include-partial-messages",
+            "--safe-mode",
+            "--tools",
+            "",
+            "--disallowedTools",
+            "*",
+            "--strict-mcp-config",
+            "--disable-slash-commands",
+            "--no-session-persistence",
+            "--permission-mode",
+            "dontAsk",
+            "--permission-prompts",
+            "none",
+            "--max-turns",
+            "1",
+            "--system-prompt-file",
+            systemPromptFile,
+            ...(options.model ? ["--model", options.model] : []),
+        ];
+        // Safe mode keeps the CLI's auth/provider selection, unlike --bare. Managed
+        // policy (including managed hooks) remains authoritative inside the CLI.
+        const env = {
+            ...(options.env ?? process.env),
+            CLAUDE_CODE_SAFE_MODE: "1",
+            CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(maxTokens),
+            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+            CLAUDE_CODE_DISABLE_TERMINAL_TITLE: "1",
+            CLAUDE_CODE_DISABLE_FILE_MENTIONS: "1",
+        };
+        for (const name of [
+            "CLAUDECODE",
+            "CLAUDE_CODE_ENTRYPOINT",
+            "CLAUDE_CODE_SIMPLE",
+            "CODESHELL_CODEX_MCP_TOKEN",
+            "CODE_SHELL_HOST_MCP_SERVERS",
+            "CODESHELL_MODEL_TRACE_FD",
+        ])
+            delete env[name];
+        return await new Promise((resolve, reject) => {
+            const launch = dependencies.spawn ?? spawn;
+            const child = launch(options.command ?? "claude", args, {
+                cwd: options.cwd ?? privateDir,
+                env,
+                shell: false,
+                detached: process.platform !== "win32",
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            let outputBytes = 0;
+            let stderrBytes = 0;
+            let pending = "";
+            let terminal;
+            let stopReason;
+            let failure;
+            let settling = false;
+            let stopping;
+            const stop = () => {
+                stopping ??= child.pid ? killProcessGroup(child.pid, { graceMs: 250 }) : Promise.resolve();
+                return stopping;
+            };
+            const finish = (code, signal) => {
+                if (settling)
+                    return;
+                settling = true;
+                clearTimeout(timer);
+                options.signal?.removeEventListener("abort", onAbort);
+                void stop().then(() => {
+                    child.stdin.destroy();
+                    child.stdout.destroy();
+                    child.stderr.destroy();
+                    if (failure)
+                        return reject(failure);
+                    if (code !== 0 || signal)
+                        return reject(new Error(`Claude text inference exited without success (${signal ?? code})`));
+                    try {
+                        if (pending.trim())
+                            accept(pending);
+                        if (!terminal)
+                            throw new Error("Claude text inference produced no terminal result");
+                        resolve({
+                            text: terminal.result,
+                            usage: usageFromResult(terminal.usage),
+                            stopReason,
+                        });
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                }, reject);
+            };
+            const fail = (error) => {
+                if (settling || failure)
+                    return;
+                failure = error;
+                void stop().then(() => finish(), reject);
+            };
+            const acceptStopReason = (value) => {
+                if (typeof value !== "string")
+                    return;
+                if (!["end_turn", "stop", "stop_sequence"].includes(value))
+                    throw new Error(`Claude text inference stopped without complete text (${value})`);
+                stopReason = value;
+            };
+            const accept = (line) => {
+                if (!line.trim())
+                    return;
+                let item;
+                try {
+                    item = JSON.parse(line);
+                }
+                catch {
+                    throw new Error("Claude text inference emitted malformed JSON");
+                }
+                if (!item || typeof item !== "object" || Array.isArray(item))
+                    throw new Error("Claude text inference emitted a malformed event");
+                const content = item.message?.content;
+                const block = item.event?.content_block;
+                if (["tool_progress", "tool_use_summary"].includes(item.type) ||
+                    (item.type === "control_request" && item.request?.subtype === "can_use_tool") ||
+                    ["tool_use", "server_tool_use"].includes(block?.type) ||
+                    (Array.isArray(content) &&
+                        content.some((part) => ["tool_use", "server_tool_use", "tool_result"].includes(part?.type))) ||
+                    (item.type === "system" && item.subtype === "init" && item.tools?.length > 0))
+                    throw new Error("Claude text inference attempted to use tools");
+                if (item.type === "assistant")
+                    acceptStopReason(item.message?.stop_reason);
+                if (item.type === "stream_event" && item.event?.type === "message_delta")
+                    acceptStopReason(item.event.delta?.stop_reason);
+                if (item.type !== "result")
+                    return;
+                if (terminal)
+                    throw new Error("Claude text inference emitted multiple terminal results");
+                if (item.is_error !== false ||
+                    item.subtype !== "success" ||
+                    typeof item.result !== "string" ||
+                    !item.result.trim() ||
+                    (Array.isArray(item.errors) && item.errors.length > 0))
+                    throw new Error("Claude text inference returned an incomplete or failed result");
+                acceptStopReason(item.stop_reason);
+                terminal = item;
+            };
+            const onAbort = () => fail(Object.assign(new Error("Claude text inference aborted"), { name: "AbortError" }));
+            const timer = setTimeout(() => fail(new Error(`Claude text inference timed out after ${timeoutMs}ms`)), timeoutMs);
+            child.stdout.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => {
+                if (settling || failure)
+                    return;
+                outputBytes += Buffer.byteLength(chunk);
+                if (outputBytes > MAX_OUTPUT_BYTES)
+                    return fail(new Error("Claude text inference output exceeds its byte limit"));
+                pending += chunk;
+                try {
+                    for (let newline; (newline = pending.indexOf("\n")) >= 0;) {
+                        const line = pending.slice(0, newline);
+                        pending = pending.slice(newline + 1);
+                        accept(line);
+                    }
+                }
+                catch (error) {
+                    fail(error);
+                }
+            });
+            child.stderr.on("data", (chunk) => {
+                stderrBytes += chunk.byteLength;
+                if (stderrBytes > MAX_STDERR_BYTES)
+                    fail(new Error("Claude text inference diagnostics exceed their byte limit"));
+            });
+            child.stdin.on("error", (error) => fail(error));
+            child.stdout.on("error", (error) => fail(error));
+            child.stderr.on("error", (error) => fail(error));
+            child.once("error", (error) => fail(error));
+            child.once("close", finish);
+            options.signal?.addEventListener("abort", onAbort, { once: true });
+            if (options.signal?.aborted)
+                onAbort();
+            else
+                child.stdin.end(options.userMessage);
+        });
+    }
+    finally {
+        await rm(privateDir, { recursive: true, force: true });
+    }
+}

package/dist/external-runtimes/codex/app-server-client.d.ts

@@ -39,6 +39,7 @@ export declare class CodexAppServerClient {
     private requestHandler?;
     private closeHandler?;
     private closed;
+    private closing?;
     private closeReason?;
     /** Buffer lines that arrive before a handler exists, then drain in order. */
     private readonly preHandlerLines;
@@ -69,10 +70,12 @@ export declare class CodexAppServerClient {
     request(method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
     notify(method: string, params?: unknown): void;
     private write;
+    private failInput;
     private failAll;
     /** Why the transport closed, once it has. */
     get closedReason(): string | undefined;
     get isClosed(): boolean;
     /** Stop via stdin EOF, then SIGTERM and SIGKILL if the server does not exit. */
     close(): Promise<void>;
+    private stop;
 }

package/dist/external-runtimes/codex/app-server-client.js

@@ -38,6 +38,7 @@ export class CodexAppServerClient {
     requestHandler;
     closeHandler;
     closed = false;
+    closing;
     closeReason;
     /** Buffer lines that arrive before a handler exists, then drain in order. */
     preHandlerLines = [];
@@ -62,6 +63,8 @@ export class CodexAppServerClient {
     }
     /** Spawn the app-server. Handlers must already be registered. */
     start() {
+        if (this.closed)
+            throw new Error(this.closeReason ?? "app-server client is closed");
         if (this.child)
             return;
         const command = this.options.command ?? "codex";
@@ -74,6 +77,12 @@ export class CodexAppServerClient {
             stdio: ["pipe", "pipe", "pipe"],
             shell: false,
         });
+        this.child.stdin.on("error", (error) => {
+            // Failed spawns have no pid; ChildProcess.error owns their OS diagnostic.
+            if (this.child?.pid === undefined)
+                return;
+            this.failInput(error);
+        });
         this.child.stdout.setEncoding("utf8");
         this.lines = createInterface({ input: this.child.stdout, crlfDelay: Infinity });
         this.lines.on("line", (line) => this.acceptLine(line));
@@ -118,6 +127,8 @@ export class CodexAppServerClient {
         this.handleLine(line);
     }
     handleLine(line) {
+        if (this.closed)
+            return;
         if (line.length > MAX_LINE_BYTES) {
             // Oversized is a transport failure: parsing it would stall the event loop.
             this.failAll("app-server sent an oversized line");
@@ -212,7 +223,17 @@ export class CodexAppServerClient {
                 }, timeoutMs);
             }
             this.pending.set(id, entry);
-            this.write({ id, method, params: params ?? {} });
+            try {
+                this.write({ id, method, params: params ?? {} });
+            }
+            catch (error) {
+                // Invalid caller data was never written. Release only this request;
+                // serialization failures say nothing about the transport's health.
+                this.pending.delete(id);
+                if (entry.timer)
+                    clearTimeout(entry.timer);
+                reject(error);
+            }
         });
     }
     notify(method, params) {
@@ -222,9 +243,27 @@ export class CodexAppServerClient {
     }
     write(payload) {
         const child = this.child;
-        if (!child || child.stdin.destroyed)
+        if (this.closed)
             return;
-        child.stdin.write(`${JSON.stringify(payload)}\n`);
+        if (child && child.pid === undefined)
+            return;
+        if (!child || child.stdin.destroyed || !child.stdin.writable) {
+            this.failInput();
+            return;
+        }
+        const line = `${JSON.stringify(payload)}\n`;
+        try {
+            child.stdin.write(line);
+        }
+        catch (error) {
+            this.failInput(error);
+        }
+    }
+    failInput(error) {
+        this.failAll(`app-server input pipe closed${error?.code ? ` (${diagnosticText(error.code)})` : ""}`);
+        // Reject outstanding RPCs now and terminate even when the process keeps
+        // running after closing fd 0. close() owns one bounded cleanup sequence.
+        void this.close();
     }
     failAll(reason, details = {}) {
         if (this.closed)
@@ -255,10 +294,18 @@ export class CodexAppServerClient {
         return this.closed;
     }
     /** Stop via stdin EOF, then SIGTERM and SIGKILL if the server does not exit. */
-    async close() {
+    close() {
+        if (!this.closing) {
+            // Publish cleanup ownership before notifying callers, whose onClose may
+            // itself call close(). One process must have only one escalation timer.
+            this.closing = Promise.resolve().then(() => this.stop());
+            this.failAll("app-server client closed");
+            this.lines?.close();
+        }
+        return this.closing;
+    }
+    async stop() {
         const child = this.child;
-        this.failAll("app-server client closed");
-        this.lines?.close();
         // Failed spawns have no pid and never emit `exit`. A process already killed
         // by a signal likewise has no numeric exitCode and will not emit it again.
         if (!child || !child.pid || child.exitCode !== null || child.signalCode !== null)

package/dist/external-runtimes/codex/event-translator.js

@@ -48,6 +48,21 @@ function toolArgsOf(item) {
     }
     return args;
 }
+function toolErrorOf(item, type) {
+    const detail = str(asRecord(item.error)?.message) ?? str(item.error);
+    if (detail)
+        return detail;
+    // A completed app-server item means the operation settled, not that its
+    // command succeeded. In particular, nonzero exits often have no error object.
+    if (type === "commandExecution" && Number.isInteger(item.exitCode) && item.exitCode !== 0) {
+        return `Command exited with code ${item.exitCode}.`;
+    }
+    if (item.status === "failed")
+        return `${type} failed.`;
+    if (item.status === "declined")
+        return `${type} was declined.`;
+    return undefined;
+}
 /**
  * Map a Codex turn status onto a CodeShell `TerminalReason`.
  *
@@ -350,8 +365,7 @@ export class CodexEventTranslator {
                 output = String(rawOutput);
             }
         }
-        const error = asRecord(item.error);
-        const errorMessage = str(error?.message) ?? str(item.error);
+        const errorMessage = toolErrorOf(item, type);
         const events = [];
         // Correct the arguments first when they only materialized now, so the
         // recorded call shows what actually ran before its result.

package/dist/external-runtimes/codex/runtime.d.ts

@@ -77,6 +77,7 @@ export declare class CodexRuntime {
     private readonly log;
     private translator?;
     private threadId?;
+    private reportedModel?;
     private started;
     private resumed;
     private firstTurn;
@@ -85,6 +86,8 @@ export declare class CodexRuntime {
     /** Codex thread id, once the thread exists. Protocol routing only — never the
      *  authorization subject (§8.1). */
     get runtimeSessionId(): string | undefined;
+    /** CLI-reported model, falling back to the requested model until reported. */
+    get resolvedModel(): string | undefined;
     /**
      * Spawn the app-server, handshake, and open a thread.
      *

package/dist/external-runtimes/codex/runtime.js

@@ -25,6 +25,7 @@ export class CodexRuntime {
     log;
     translator;
     threadId;
+    reportedModel;
     started = false;
     resumed = false;
     firstTurn = true;
@@ -52,6 +53,10 @@ export class CodexRuntime {
     get runtimeSessionId() {
         return this.threadId;
     }
+    /** CLI-reported model, falling back to the requested model until reported. */
+    get resolvedModel() {
+        return this.reportedModel ?? this.options.model;
+    }
     /**
      * Spawn the app-server, handshake, and open a thread.
      *
@@ -107,6 +112,10 @@ export class CodexRuntime {
             throw new Error(`${this.resumed ? "thread/resume" : "thread/start"} returned no thread id`);
         }
         this.threadId = threadId;
+        const reportedModel = thread?.model;
+        if (typeof reportedModel === "string" && reportedModel.trim()) {
+            this.reportedModel = reportedModel.trim();
+        }
         this.translator = new CodexEventTranslator({
             threadId,
             sessionId: this.options.businessSessionId,

package/dist/external-runtimes/index.d.ts

@@ -35,6 +35,8 @@ export { writeClaudeMcpConfigFile } from "./claude-code/mcp-config.js";
 export { ClaudeEventTranslator } from "./claude-code/event-translator.js";
 export type { ClaudeEventTranslatorOptions } from "./claude-code/event-translator.js";
 export { ClaudeCodeRuntime } from "./claude-code/runtime.js";
+export { runClaudeTextInference } from "./claude-code/text-inference.js";
+export type { ClaudeTextInferenceOptions } from "./claude-code/text-inference.js";
 export { CLAUDE_PERMISSION_MODES, CLAUDE_PERMISSION_PROMPT_TOOL, claudeModeUsesPermissionPrompt, claudePermissionModeFor, withClaudePermissionPrompt, } from "./claude-code/permissions.js";
 export type { ClaudePermissionMode, ClaudePermissionPromptDecider, ClaudePermissionPromptRequest, } from "./claude-code/permissions.js";
 export type { ClaudeRuntimeOptions, ClaudeRuntimeHooks, ClaudeTurnHandle, } from "./claude-code/runtime.js";

package/dist/external-runtimes/index.js

@@ -26,5 +26,6 @@ export { buildClaudeMcpConfig, claudeAllowedToolNames, claudeBridgeArgs, CLAUDE_
 export { writeClaudeMcpConfigFile } from "./claude-code/mcp-config.js";
 export { ClaudeEventTranslator } from "./claude-code/event-translator.js";
 export { ClaudeCodeRuntime } from "./claude-code/runtime.js";
+export { runClaudeTextInference } from "./claude-code/text-inference.js";
 export { CLAUDE_PERMISSION_MODES, CLAUDE_PERMISSION_PROMPT_TOOL, claudeModeUsesPermissionPrompt, claudePermissionModeFor, withClaudePermissionPrompt, } from "./claude-code/permissions.js";
 export { startExternalRuntimeSession } from "./session-factory.js";

package/dist/external-runtimes/session-factory.d.ts

@@ -98,6 +98,8 @@ export interface ExternalRuntimeSession {
     readonly businessSessionId: string;
     /** Runtime-side id (Codex thread / Claude session). Resume + routing only. */
     readonly runtimeSessionId: string | undefined;
+    /** Latest CLI-reported model; requested model is the fallback when unavailable. */
+    readonly resolvedModel?: string;
     /** Tools actually exposed, after the allowlist and visibility guards. */
     listTools(): readonly ToolDefinition[];
     send(input: ExternalRuntimeTurnInput, onEvent?: (event: StreamEvent) => void): Promise<{

package/dist/external-runtimes/session-factory.js

@@ -160,6 +160,9 @@ export async function startExternalRuntimeSession(options) {
         get runtimeSessionId() {
             return activeRuntime.runtimeSessionId;
         },
+        get resolvedModel() {
+            return activeRuntime.resolvedModel;
+        },
         listTools: () => activeHost.listTools(),
         send: async (input, onEvent) => {
             if (turnSink)

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

@@ -356,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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cjhyy/code-shell-capability-coding",
-  "version": "0.9.46",
+  "version": "0.9.47",
   "description": "Coding capability pack for the generic code-shell agent core.",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,7 @@
     "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
   },
   "dependencies": {
-    "@cjhyy/code-shell-core": "0.9.46"
+    "@cjhyy/code-shell-core": "0.9.47"
   },
   "engines": {
     "node": ">=20.10"