@cjhyy/code-shell-core 0.7.0-beta.1 → 0.7.1

package/dist/engine/types.d.ts

@@ -12,8 +12,8 @@
  */
 import type { ClientDefaults, LLMConfig, SessionOrigin, TerminalReason, TokenUsage } from "../types.js";
 import type { AgentPresetName } from "../preset/index.js";
-import type { GoalConfig } from "./goal.js";
-import type { ApprovalBackend } from "../tool-system/permission.js";
+import type { GoalConfig, GoalTerminationReason } from "./goal.js";
+import type { ApprovalBackend, ApprovalRouter } from "../tool-system/permission.js";
 import type { SandboxConfig } from "../tool-system/sandbox/index.js";
 import type { CostStateStore } from "./cost-store.js";
 import type { AskUserFn } from "../tool-system/builtin/ask-user.js";
@@ -70,6 +70,8 @@ export interface EngineConfig {
     sessionStorageDir?: string;
     maxContextTokens?: number;
     approvalBackend?: ApprovalBackend;
+    /** Connection-scoped permission approval router supplied by an interactive host. */
+    approvalRouter?: ApprovalRouter;
     hooks?: EngineHookConfig[];
     askUser?: AskUserFn;
     /** Browser automation bridge (browser_* tools). Wired by the host (desktop)
@@ -177,6 +179,8 @@ export interface EngineHookConfig {
 export interface EngineResult {
     text: string;
     reason: TerminalReason;
+    /** Goal-specific stop outcome; omitted for ordinary completion/met verdicts. */
+    goalTermination?: GoalTerminationReason;
     sessionId: string;
     turnCount: number;
     usage: TokenUsage;

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

@@ -17,7 +17,10 @@ export interface PlatformScripts {
 }
 export interface CreateWorktreeOptions {
     prefix?: string;
+    signal?: AbortSignal;
 }
+/** Best-effort rollback for an aborted `git worktree add`. */
+export declare function cleanupAbortedWorktree(gitRoot: string, worktreePath: string, branchName: string): Promise<void>;
 /**
  * Pick the setup/cleanup script for the running platform, falling back to
  * `default`. Empty/whitespace-only scripts are treated as absent so a project

package/dist/git/worktree/crud.js

@@ -1,10 +1,25 @@
 import { existsSync, lstatSync, mkdirSync, readdirSync, symlinkSync } from "node:fs";
+import { rm } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { safeSpawnShell } from "../../runtime/safe-spawn.js";
 import { buildSandboxEnv, defaultShellBinary, mergeShellEnv } from "../../runtime/spawn-common.js";
 import { execGit, execGitSync, gitErrorMessage } from "./git-exec.js";
 import { assertBranchNotCheckedOut, currentBranch, findGitRoot } from "./query.js";
 import { applyPrefix, isManagedWorktreeBranch, validateWorktreeSlug } from "./slug.js";
+function throwIfAborted(signal) {
+    signal?.throwIfAborted();
+}
+/** Best-effort rollback for an aborted `git worktree add`. */
+export async function cleanupAbortedWorktree(gitRoot, worktreePath, branchName) {
+    try {
+        await execGit(gitRoot, ["worktree", "remove", worktreePath, "--force"], 30_000);
+    }
+    catch {
+        await rm(worktreePath, { recursive: true, force: true }).catch(() => { });
+        await execGit(gitRoot, ["worktree", "prune"], 10_000).catch(() => { });
+    }
+    await execGit(gitRoot, ["branch", "-D", branchName], 10_000).catch(() => { });
+}
 /**
  * Pick the setup/cleanup script for the running platform, falling back to
  * `default`. Empty/whitespace-only scripts are treated as absent so a project
@@ -27,16 +42,30 @@ export function selectPlatformScript(scripts, platform = process.platform) {
  */
 export async function createWorktree(cwd, slug, sessionId, opts = {}) {
     validateWorktreeSlug(slug);
+    throwIfAborted(opts.signal);
     const gitRoot = await findGitRoot(cwd);
+    throwIfAborted(opts.signal);
     const branchName = applyPrefix(opts.prefix, slug, sessionId);
     const worktreePath = resolve(gitRoot, "..", `.worktrees/${slug}-${sessionId.slice(0, 8)}`);
     await assertBranchNotCheckedOut(gitRoot, branchName);
+    throwIfAborted(opts.signal);
     const originalBranch = await currentBranch(gitRoot);
+    throwIfAborted(opts.signal);
     // The argv form keeps branchName/worktreePath as literal positional
     // arguments even if a future caller bypasses validateWorktreeSlug.
-    await execGit(gitRoot, ["worktree", "add", "-b", branchName, worktreePath], 30000);
-    // Symlink large directories to avoid disk bloat.
-    symlinkLargeDirectories(gitRoot, worktreePath);
+    try {
+        await execGit(gitRoot, ["worktree", "add", "-b", branchName, worktreePath], 30_000, opts.signal);
+        throwIfAborted(opts.signal);
+        // Symlink large directories to avoid disk bloat.
+        symlinkLargeDirectories(gitRoot, worktreePath);
+        throwIfAborted(opts.signal);
+    }
+    catch (error) {
+        if (opts.signal?.aborted) {
+            await cleanupAbortedWorktree(gitRoot, worktreePath, branchName);
+        }
+        throw error;
+    }
     return {
         originalCwd: cwd,
         worktreePath,

package/dist/git/worktree/git-exec.d.ts

@@ -1,7 +1,7 @@
 export declare const GIT_BIN: string;
-export declare function execGit(cwd: string, args: string[], timeout?: number): Promise<string>;
+export declare function execGit(cwd: string, args: string[], timeout?: number, signal?: AbortSignal): Promise<string>;
 export declare function execGitSync(cwd: string, args: string[], timeout?: number): string;
-export declare function gitOutput(cwd: string, args: string[], timeout?: number): Promise<string | undefined>;
+export declare function gitOutput(cwd: string, args: string[], timeout?: number, signal?: AbortSignal): Promise<string | undefined>;
 export declare function gitOutputSync(cwd: string, args: string[], timeout?: number): string | undefined;
 export declare function gitErrorMessage(err: unknown): string;
 export declare function normalizeBranchName(branch: string): string;

package/dist/git/worktree/git-exec.js

@@ -1,16 +1,50 @@
 import { execFile, execFileSync } from "node:child_process";
-import { promisify } from "node:util";
+import { killChildTree } from "../../runtime/spawn-common.js";
 import { resolveExecutable } from "../../utils/exec.js";
 // git resolved via PATH×PATHEXT on Windows (.cmd/.exe shim); no-op on POSIX.
 export const GIT_BIN = resolveExecutable("git");
-const execFileAsync = promisify(execFile);
-export async function execGit(cwd, args, timeout = 10000) {
-    const { stdout } = await execFileAsync(GIT_BIN, args, {
-        cwd,
-        encoding: "utf-8",
-        timeout,
+export async function execGit(cwd, args, timeout = 10000, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        let settled = false;
+        const child = execFile(GIT_BIN, args, { cwd, encoding: "utf-8" }, (error, stdout, stderr) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            if (error) {
+                Object.assign(error, { stdout, stderr });
+                reject(error);
+            }
+            else {
+                resolve(stdout);
+            }
+        });
+        const terminate = (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            killChildTree(child, 1000);
+            reject(error);
+        };
+        const onAbort = () => terminate(signal?.reason ?? Object.assign(new Error("Git command aborted"), { name: "AbortError" }));
+        const timer = setTimeout(() => {
+            terminate(Object.assign(new Error(`Git command timed out after ${timeout}ms`), {
+                code: "ETIMEDOUT",
+            }));
+        }, timeout);
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        if (signal?.aborted)
+            onAbort();
     });
-    return stdout;
 }
 export function execGitSync(cwd, args, timeout = 10000) {
     return execFileSync(GIT_BIN, args, {
@@ -19,11 +53,13 @@ export function execGitSync(cwd, args, timeout = 10000) {
         timeout,
     });
 }
-export async function gitOutput(cwd, args, timeout = 10000) {
+export async function gitOutput(cwd, args, timeout = 10000, signal) {
     try {
-        return await execGit(cwd, args, timeout);
+        return await execGit(cwd, args, timeout, signal);
     }
-    catch {
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
         return undefined;
     }
 }

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

@@ -9,6 +9,7 @@ export interface ListWorktreesFastOptions {
     workspaceOwners?: WorktreeWorkspaceOwner[];
     owners?: WorktreeWorkspaceOwner[];
     prefix?: string;
+    signal?: AbortSignal;
 }
 export interface ListWorktreesOptions extends ListWorktreesFastOptions {
     includeDiffSummary?: boolean;
@@ -26,13 +27,13 @@ export interface WorktreeInfo {
 /**
  * Find the canonical git root (resolves worktree -> main repo).
  */
-export declare function findGitRoot(cwd: string): Promise<string>;
-export declare function findMainWorktreeRoot(cwd: string): Promise<string>;
-export declare function findWorktreeForBranch(cwd: string, branch: string): Promise<string | undefined>;
-export declare function assertBranchNotCheckedOut(cwd: string, branch: string): Promise<void>;
-export declare function branchExists(cwd: string, branch: string): Promise<boolean>;
-export declare function isGitWorktreeRoot(cwd: string): Promise<boolean>;
-export declare function currentBranch(cwd: string): Promise<string | undefined>;
+export declare function findGitRoot(cwd: string, signal?: AbortSignal): Promise<string>;
+export declare function findMainWorktreeRoot(cwd: string, signal?: AbortSignal): Promise<string>;
+export declare function findWorktreeForBranch(cwd: string, branch: string, signal?: AbortSignal): Promise<string | undefined>;
+export declare function assertBranchNotCheckedOut(cwd: string, branch: string, signal?: AbortSignal): Promise<void>;
+export declare function branchExists(cwd: string, branch: string, signal?: AbortSignal): Promise<boolean>;
+export declare function isGitWorktreeRoot(cwd: string, signal?: AbortSignal): Promise<boolean>;
+export declare function currentBranch(cwd: string, signal?: AbortSignal): Promise<string | undefined>;
 export declare function listWorktreesFast(cwd: string, opts?: ListWorktreesFastOptions): Promise<WorktreeInfo[]>;
 /**
  * List active worktrees. Kept for internal/test compatibility; use

package/dist/git/worktree/query.js

@@ -6,51 +6,56 @@ import { isManagedWorktreeBranch } from "./slug.js";
 /**
  * Find the canonical git root (resolves worktree -> main repo).
  */
-export async function findGitRoot(cwd) {
-    return await findMainWorktreeRoot(cwd);
+export async function findGitRoot(cwd, signal) {
+    return await findMainWorktreeRoot(cwd, signal);
 }
-export async function findMainWorktreeRoot(cwd) {
-    const commonDir = (await execGit(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"], 5000)).trim();
+export async function findMainWorktreeRoot(cwd, signal) {
+    const commonDir = (await execGit(cwd, ["rev-parse", "--path-format=absolute", "--git-common-dir"], 5000, signal)).trim();
     return dirname(commonDir);
 }
-export async function findWorktreeForBranch(cwd, branch) {
+export async function findWorktreeForBranch(cwd, branch, signal) {
     const normalized = normalizeBranchName(branch);
-    return (await listWorktreesFast(cwd)).find((entry) => entry.branch === normalized)?.path;
+    return (await listWorktreesFast(cwd, { signal })).find((entry) => entry.branch === normalized)
+        ?.path;
 }
-export async function assertBranchNotCheckedOut(cwd, branch) {
-    const existingPath = await findWorktreeForBranch(cwd, branch);
+export async function assertBranchNotCheckedOut(cwd, branch, signal) {
+    const existingPath = await findWorktreeForBranch(cwd, branch, signal);
     if (existingPath) {
         throw new Error(`branch ${normalizeBranchName(branch)} already checked out at ${existingPath}`);
     }
 }
-export async function branchExists(cwd, branch) {
-    const out = await gitOutput(cwd, ["branch", "--list", normalizeBranchName(branch)], 10000);
+export async function branchExists(cwd, branch, signal) {
+    const out = await gitOutput(cwd, ["branch", "--list", normalizeBranchName(branch)], 10000, signal);
     return (out?.trim().length ?? 0) > 0;
 }
-export async function isGitWorktreeRoot(cwd) {
+export async function isGitWorktreeRoot(cwd, signal) {
     if (!existsSync(join(cwd, ".git")))
         return false;
     try {
-        const inside = (await execGit(cwd, ["rev-parse", "--is-inside-work-tree"], 5000)).trim();
+        const inside = (await execGit(cwd, ["rev-parse", "--is-inside-work-tree"], 5000, signal)).trim();
         if (inside !== "true")
             return false;
-        const topLevel = (await execGit(cwd, ["rev-parse", "--path-format=absolute", "--show-toplevel"], 5000)).trim();
+        const topLevel = (await execGit(cwd, ["rev-parse", "--path-format=absolute", "--show-toplevel"], 5000, signal)).trim();
         return resolve(topLevel) === resolve(cwd);
     }
-    catch {
+    catch (error) {
+        if (signal?.aborted)
+            throw error;
         return false;
     }
 }
-export async function currentBranch(cwd) {
-    const branch = (await gitOutput(cwd, ["branch", "--show-current"], 5000))?.trim();
+export async function currentBranch(cwd, signal) {
+    const branch = (await gitOutput(cwd, ["branch", "--show-current"], 5000, signal))?.trim();
     return branch || undefined;
 }
 export async function listWorktreesFast(cwd, opts = {}) {
     let raw;
     try {
-        raw = (await execGit(cwd, ["worktree", "list", "--porcelain"], 10000)).trim();
+        raw = (await execGit(cwd, ["worktree", "list", "--porcelain"], 10000, opts.signal)).trim();
     }
-    catch {
+    catch (error) {
+        if (opts.signal?.aborted)
+            throw error;
         return [];
     }
     if (!raw)
@@ -74,9 +79,11 @@ export async function listWorktreesFast(cwd, opts = {}) {
         entries.push(current);
     let mainRoot = "";
     try {
-        mainRoot = await findMainWorktreeRoot(cwd);
+        mainRoot = await findMainWorktreeRoot(cwd, opts.signal);
     }
-    catch {
+    catch (error) {
+        if (opts.signal?.aborted)
+            throw error;
         mainRoot = entries[0]?.path ?? "";
     }
     const owners = opts.workspaceOwners ?? opts.owners ?? [];

package/dist/hooks/events.d.ts

@@ -1,6 +1,7 @@
 /**
  * Hook event type definitions.
  */
+import type { GoalTerminationReason } from "../engine/goal.js";
 /**
  * Lifecycle hooks the engine emits.
  *
@@ -104,6 +105,8 @@ export interface HookResult {
      * chain). Ignored for non-on_stop events. Bounded by maxStopBlocks.
      */
     continueSession?: boolean;
+    /** For on_stop: typed Goal-run stop outcome propagated to TurnLoop/Engine. */
+    goalTermination?: GoalTerminationReason;
     /** Modified data to pass along */
     data?: Record<string, unknown>;
     /** Additional messages to inject */

package/dist/hooks/events.js

@@ -1,4 +1 @@
-/**
- * Hook event type definitions.
- */
 export {};

package/dist/hooks/goal-stop-hook.d.ts

@@ -1,8 +1,10 @@
 import type { HookHandler } from "./registry.js";
-import type { LLMResponse } from "../types.js";
+import type { LLMResponse, TokenUsage, ToolResult } from "../types.js";
 import { type GoalConfig } from "../engine/goal.js";
 /** Narrow LLM surface the judge needs — just a one-shot completion. */
 export interface GoalJudgeLLM {
+    /** Main-generation request timeout; the judge derives a shorter ceiling. */
+    readonly timeout?: number;
     createMessage(options: {
         systemPrompt: string;
         messages: {
@@ -11,7 +13,8 @@ export interface GoalJudgeLLM {
         }[];
         stream?: boolean;
         maxTokens?: number;
-        recordUsage?: boolean;
+        billingEnabled?: boolean;
+        requestVisible?: boolean;
         signal?: AbortSignal;
         /** Reasoning control — the judge always asks for it OFF (see call site). */
         reasoning?: import("../llm/reasoning-setting.js").ReasoningSetting;
@@ -53,6 +56,45 @@ export interface GoalStopHookOptions {
      * `() => new Date()`.
      */
     now?: () => Date;
+    /**
+     * Private runtime evidence supplied by TurnLoop immediately before on_stop.
+     * It deliberately lives on this closure rather than HookContext.data so
+     * third-party/public stop hooks do not gain access to tool output.
+     */
+    getJudgeContext: () => GoalJudgeRuntimeContext | undefined;
+    /** Dedicated judge deadline. Defaults to 15s and never exceeds the main timeout. */
+    judgeTimeoutMs?: number;
+    /**
+     * Private usage seam into TurnLoop's Goal ledger. Returning a termination
+     * reason prevents verdict side effects and lets the loop stop immediately.
+     */
+    onJudgeUsage?: (usage: TokenUsage | undefined) => "token_budget_exhausted" | "time_budget_exhausted" | undefined;
+}
+export interface GoalJudgeRuntimeContext {
+    /** Recent irreversible projections from this run, newest evidence retained by TurnLoop. */
+    toolResults: GoalJudgeToolResult[];
+    progress: {
+        turnCount: number;
+        /** One-based natural-stop/judge round for this run. */
+        stopRound: number;
+        elapsedMs: number;
+        tokensUsed: number;
+        tokenBudget?: number;
+        timeBudgetMs?: number;
+        maxTurns?: number;
+        maxStopBlocks?: number;
+    };
+}
+export interface GoalJudgeToolResult {
+    turnCount: number;
+    toolName: string;
+    status: "success" | "error";
+    /** Bounded plain text only; absent for sensitive or purely non-text results. */
+    text?: string;
+    /** True when image/binary/structured blocks were replaced with a placeholder. */
+    omittedNonText?: true;
 }
+/** Build the bounded, irreversible value retained beyond the current model round. */
+export declare function projectGoalJudgeToolResult(result: ToolResult, turnCount: number, sensitiveByMetadata?: boolean): GoalJudgeToolResult;
 export declare function createGoalStopHook(opts: GoalStopHookOptions): HookHandler;
 export {};