@cjhyy/code-shell-core 0.5.0-rc.0 → 0.5.0-rc.2

package/dist/engine/reactive-threshold.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Reactive-compaction probe gating.
+ *
+ * During streaming the turn loop accumulates an estimate of the response
+ * size and periodically asks the ContextManager whether we're nearing the
+ * context limit. The old gate (`tokens % 2000 === 0`) almost never matched a
+ * running `+= ceil(len/4)` accumulator, so the probe never fired. This fires
+ * once per 2000-token bucket crossed, tracked by `lastBucket`.
+ */
+export declare function crossedReactiveThreshold(accumulatedTokens: number, lastBucket: number): {
+    crossed: boolean;
+    bucket: number;
+};

package/dist/engine/reactive-threshold.js

@@ -0,0 +1,17 @@
+/**
+ * Reactive-compaction probe gating.
+ *
+ * During streaming the turn loop accumulates an estimate of the response
+ * size and periodically asks the ContextManager whether we're nearing the
+ * context limit. The old gate (`tokens % 2000 === 0`) almost never matched a
+ * running `+= ceil(len/4)` accumulator, so the probe never fired. This fires
+ * once per 2000-token bucket crossed, tracked by `lastBucket`.
+ */
+const REACTIVE_BUCKET = 2000;
+export function crossedReactiveThreshold(accumulatedTokens, lastBucket) {
+    const bucket = Math.floor(accumulatedTokens / REACTIVE_BUCKET);
+    if (bucket >= 1 && bucket > lastBucket) {
+        return { crossed: true, bucket };
+    }
+    return { crossed: false, bucket: lastBucket };
+}

package/dist/engine/runtime.js

@@ -35,6 +35,13 @@ export class EngineRuntime {
         let cached = this.sandboxCache.get(key);
         if (!cached) {
             cached = resolveSandboxBackend(config, cwd);
+            // Don't cache a rejection: an explicit-mode probe that throws (e.g.
+            // `seatbelt` on a host without sandbox-exec) must be retryable after the
+            // user fixes the config, not sticky until process restart.
+            cached.catch(() => {
+                if (this.sandboxCache.get(key) === cached)
+                    this.sandboxCache.delete(key);
+            });
             this.sandboxCache.set(key, cached);
         }
         return cached;

package/dist/engine/session-title.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Session title generation — best-effort, one-line LLM title for the sidebar.
+ *
+ * Pure function (no Engine `this`) so it's trivially unit-testable. The Engine
+ * resolves the aux client and wiring; this only does the LLM call + cleanup.
+ */
+import type { LLMClientBase } from "../llm/client-base.js";
+/**
+ * Ask the aux client for a one-line title from the first user message + first
+ * assistant reply. Returns the cleaned title, or null on any failure / empty
+ * output (caller treats null as "keep existing title").
+ */
+export declare function buildSessionTitle(client: LLMClientBase, firstUserText: string, firstAssistantText: string): Promise<string | null>;

package/dist/engine/session-title.js

@@ -0,0 +1,34 @@
+const SYSTEM_PROMPT = "You generate a very short title (≤6 words, no quotes, no trailing punctuation) " +
+    "summarizing a chat, in the same language as the user's message.";
+/** Strip wrapping quotes/whitespace the model sometimes adds. */
+function clean(raw) {
+    return raw
+        .trim()
+        .replace(/^["'“”‘’「『]+/, "")
+        .replace(/["'“”‘’」』]+$/, "")
+        .trim();
+}
+/**
+ * Ask the aux client for a one-line title from the first user message + first
+ * assistant reply. Returns the cleaned title, or null on any failure / empty
+ * output (caller treats null as "keep existing title").
+ */
+export async function buildSessionTitle(client, firstUserText, firstAssistantText) {
+    try {
+        const prompt = `User: ${firstUserText.slice(0, 2000)}\n\n` +
+            `Assistant: ${firstAssistantText.slice(0, 2000)}\n\n` +
+            `Title:`;
+        const resp = await client.createMessage({
+            systemPrompt: SYSTEM_PROMPT,
+            messages: [{ role: "user", content: prompt }],
+            tools: [],
+            maxTokens: 64,
+            reasoning: { mode: "off" },
+        });
+        const title = clean(resp.text ?? "");
+        return title.length > 0 ? title : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/engine/turn-loop.d.ts

@@ -4,12 +4,13 @@
  * Following Claude Code's po_() pattern:
  * pre_check → model_call → post_check → tool_exec → context_mgmt → hook_notify → next turn
  */
-import type { Message, StreamCallback, TerminalReason } from "../types.js";
+import type { Message, StreamCallback, TerminalReason, ContentBlock, ToolResult } from "../types.js";
 import { ModelFacade } from "./model-facade.js";
 import { ToolExecutor } from "../tool-system/executor.js";
 import { ContextManager } from "../context/manager.js";
 import { HookRegistry } from "../hooks/registry.js";
 import { Transcript } from "../session/transcript.js";
+import { type GoalConfig } from "./goal.js";
 export interface TurnLoopConfig {
     maxTurns: number;
     maxToolCallsPerTurn: number;
@@ -22,6 +23,21 @@ export interface TurnLoopConfig {
      * the on-disk turnCount/status frozen at the last completion.
      */
     onTurnBoundary?: (turnCount: number) => void;
+    /**
+     * Goal mode: the normalized GoalConfig (objective + optional token/time
+     * budgets), passed to on_stop handlers via ctx.data.goal so the
+     * GoalStopHook can judge completion. The run-scoped budget tracker reads
+     * the budgets to force-stop an unattended run. Undefined when no goal is
+     * set (on_stop still fires but built-in Goal handler is a no-op without it).
+     */
+    goal?: GoalConfig;
+    /**
+     * Max consecutive times an on_stop handler may block termination before
+     * the loop forces a stop, mirroring Claude Code's stop-hook block cap.
+     * Resets to 0 whenever a turn completes without being blocked. Defaults
+     * to 8. Independent of maxTurns, which still bounds total turns.
+     */
+    maxStopBlocks?: number;
 }
 export interface CtxOverheadStore {
     /** Tokens for system prompt + tool defs, derived from provider's promptTokens. */
@@ -64,6 +80,12 @@ export interface TurnLoopResult {
     reason: TerminalReason;
     messages: Message[];
 }
+/**
+ * 把一个 ToolResult 映射成发给 LLM 的 tool_result ContentBlock。
+ * 有 contentBlocks(view_image 的图片块)就原样用作 content;否则
+ * 用文本(成功用 result,失败用 "Error: ...")。抽成纯函数以便单测。
+ */
+export declare function toolResultToBlock(result: ToolResult): ContentBlock;
 export declare class TurnLoop {
     private readonly deps;
     private readonly config;
@@ -79,6 +101,12 @@ export declare class TurnLoop {
     private currentTurnLog;
     /** Last emitted ctx token estimate; used to skip no-op usage_update events. */
     private lastCtxEmit;
+    /**
+     * Consecutive on_stop blocks (Goal mode kept the agent going). Reset to 0
+     * on any unblocked completion. When it reaches config.maxStopBlocks the
+     * loop forces a stop so a stuck goal can't loop forever.
+     */
+    private stopBlockCount;
     constructor(deps: TurnLoopDeps, config: TurnLoopConfig);
     /**
      * Emit a lifecycle hook with isSubAgent + sessionId auto-merged into data.
@@ -105,13 +133,6 @@ export declare class TurnLoop {
      * If streaming fails, emit tombstone and retry non-streaming.
      */
     private callModelWithFallback;
-    /**
-     * Execute tools with overlap: start concurrent-safe (read-only) tools
-     * immediately in parallel while sequential (write) tools run one-by-one.
-     * Both groups run simultaneously — we don't wait for safe tools to finish
-     * before starting unsafe ones.
-     */
-    private executeToolsOverlapped;
     get currentTurn(): number;
     /**
      * Generate synthetic error tool_results for any dangling tool_use blocks