@cjhyy/code-shell 0.1.0-alpha.0 → 0.1.0-alpha.1

package/CHANGELOG.md

@@ -8,6 +8,45 @@ breaking.
 
 ## [Unreleased]
 
+## [0.1.0-alpha.1] - 2026-04-30
+
+### Changed (breaking)
+- **Tool timeout system rewritten.** Removed the hardcoded
+  `LEGACY_LONG_TIMEOUT_TOOLS = {Agent, Arena}` whitelist in
+  `tool-system/registry.ts`. Tools now declare their own timeout via
+  `RegisteredTool.timeoutMs` at registration time. Precedence:
+  `executeTool(opts.timeoutMs)` > `tool.timeoutMs` > `DEFAULT_TOOL_TIMEOUT_MS`
+  (120s). Custom long-running tools registered via `engine.registerCustomTool`
+  can now set a higher timeout instead of being silently capped at 120s.
+- **Bash internal 600s cap removed.** `bash.ts` no longer clamps the
+  user-supplied `timeout` argument. The outer registry caps via the tool's
+  declared `timeoutMs` (default 1h for Bash). Long-running shell loops
+  (`until cond; do ...; done`) are now feasible.
+- **Agent `max_turns` upper bound (30) removed.** Sub-agents that need to do
+  more turns (deep research, large refactors) are no longer artificially
+  capped. Default remains 15.
+- **Sub-agent LLM call timeout (60s) removed.** `agent.ts` no longer clamps
+  `subAgentConfig.llm.timeout` to 60s, which was breaking slow models
+  (e.g. extended thinking).
+
+### Added
+- **`Agent(run_in_background: true)`** — fire-and-forget sub-agents. Returns
+  an `agent_id` immediately instead of blocking the parent turn. The agent
+  runs detached in the same process; restarting loses its state.
+- **`AgentStatus(agent_id?)`** — query background agent state
+  (running / completed / failed / cancelled), or list all when `agent_id` is
+  omitted. Returns the result text once completed.
+- **`AgentCancel(agent_id)`** — abort a running background agent.
+- New module `src/tool-system/builtin/agent-registry.ts` — in-process
+  registry for async agent handles.
+
+### Notes
+- Cross-process / restart-survivable long tasks still belong to `RunManager`
+  in `@cjhyy/code-shell/run`, not to `Agent(run_in_background)`. The split
+  mirrors Claude Code's REPL/Agent-tool/Routines architecture.
+
+## [0.1.0-alpha.0] - 2026-04-28
+
 ### Added
 - **`IterativeArena` — multi-model authoring loop.** Pipeline: tournament v1
   (every participant writes a draft, the author merges anonymized drafts into

package/dist/{chunk-6JOOLG6F.js → chunk-AP5F6VYE.js}

@@ -4,7 +4,7 @@ import {
   NoopEvaluator,
   RunManager,
   registerPreset
-} from "./chunk-7RMAR2Y3.js";
+} from "./chunk-JUHRV2XF.js";
 import {
   init_esm_shims
 } from "./chunk-DI7RDLOS.js";
@@ -90,11 +90,14 @@ function defineProduct(definition, runtime) {
       disabledBuiltinTools: adapter?.disableTools,
       customSystemPrompt: presetDef.customPrompt,
       appendSystemPrompt: presetDef.appendPrompt,
+      hooks: adapter?.hooks,
       customTools: customToolEntries.length > 0 ? customToolEntries : void 0
     },
     concurrency: contract?.concurrency ?? 1,
     runsDir,
-    evaluator
+    evaluator,
+    defaultTags: contract?.defaultTags,
+    defaultMetadata: contract?.defaultMetadata
   });
   return { manager, preset: agentPreset, customTools };
 }

package/dist/{chunk-BHGIJ2DJ.js → chunk-FECTK5KJ.js}

@@ -1,7 +1,7 @@
 import {
   FileRunStore,
   RunManager
-} from "./chunk-7RMAR2Y3.js";
+} from "./chunk-JUHRV2XF.js";
 import {
   init_esm_shims
 } from "./chunk-DI7RDLOS.js";
@@ -28,11 +28,14 @@ function createRunManager(options) {
       enabledBuiltinTools: options.enabledBuiltinTools,
       disabledBuiltinTools: options.disabledBuiltinTools,
       customSystemPrompt: options.customSystemPrompt,
-      appendSystemPrompt: options.appendSystemPrompt
+      appendSystemPrompt: options.appendSystemPrompt,
+      hooks: options.hooks
     },
     concurrency: options.concurrency ?? 1,
     runsDir,
-    evaluator: options.evaluator
+    evaluator: options.evaluator,
+    defaultTags: options.defaultTags,
+    defaultMetadata: options.defaultMetadata
   });
 }
 

package/dist/{chunk-7RMAR2Y3.js → chunk-JUHRV2XF.js}

@@ -814,7 +814,7 @@ var bashToolDef = {
       command: { type: "string", description: "The shell command to execute" },
       timeout: {
         type: "number",
-        description: "Timeout in milliseconds (default: 120000, max: 600000)"
+        description: "Timeout in milliseconds (default: 120000). Outer registry caps at 1h."
       },
       description: {
         type: "string",
@@ -828,7 +828,7 @@ var MAX_OUTPUT = 1e5;
 async function bashTool(args) {
   const command = args.command;
   if (!command) return "Error: command is required";
-  const timeout = Math.min(args.timeout || 12e4, 6e5);
+  const timeout = args.timeout || 12e4;
   try {
     const { stdout, stderr } = await execAsync(command, {
       timeout,
@@ -903,6 +903,63 @@ async function askUserTool(args) {
 // src/tool-system/builtin/agent.ts
 init_esm_shims();
 init_plan();
+
+// src/tool-system/builtin/agent-registry.ts
+init_esm_shims();
+var AsyncAgentRegistry = class {
+  agents = /* @__PURE__ */ new Map();
+  register(entry) {
+    this.agents.set(entry.agentId, entry);
+  }
+  get(agentId) {
+    return this.agents.get(agentId);
+  }
+  list() {
+    return [...this.agents.values()];
+  }
+  markCompleted(agentId, result) {
+    const e = this.agents.get(agentId);
+    if (!e) return;
+    if (e.status !== "running") return;
+    e.status = "completed";
+    e.result = result;
+    e.finishedAt = Date.now();
+  }
+  markFailed(agentId, error) {
+    const e = this.agents.get(agentId);
+    if (!e) return;
+    if (e.status !== "running") return;
+    e.status = "failed";
+    e.error = error;
+    e.finishedAt = Date.now();
+  }
+  cancel(agentId) {
+    const e = this.agents.get(agentId);
+    if (!e) return false;
+    if (e.status !== "running") return false;
+    try {
+      e.abort();
+    } catch {
+    }
+    e.status = "cancelled";
+    e.finishedAt = Date.now();
+    return true;
+  }
+  reset() {
+    for (const e of this.agents.values()) {
+      if (e.status === "running") {
+        try {
+          e.abort();
+        } catch {
+        }
+      }
+    }
+    this.agents.clear();
+  }
+};
+var asyncAgentRegistry = new AsyncAgentRegistry();
+
+// src/tool-system/builtin/agent.ts
 import { nanoid } from "nanoid";
 var agentToolDef = {
   name: "Agent",
@@ -921,6 +978,10 @@ var agentToolDef = {
       max_turns: {
         type: "number",
         description: "Maximum turns for the sub-agent (default: 15)"
+      },
+      run_in_background: {
+        type: "boolean",
+        description: "If true, launch the sub-agent in the background and return an agent_id immediately instead of waiting for it to finish. Use AgentStatus(agent_id) to check progress and AgentCancel(agent_id) to stop it. The agent runs in this process; restarting loses its state. Default: false (synchronous wait)."
       }
     },
     required: ["description", "prompt"]
@@ -930,35 +991,21 @@ var _subAgentConfig;
 function setSubAgentConfig(config) {
   _subAgentConfig = config;
 }
-async function agentTool(args) {
-  const prompt = args.prompt;
-  const description = args.description || "sub-agent";
-  if (!prompt) return "Error: prompt is required";
-  if (!_subAgentConfig) {
-    return "Error: Agent tool is not configured.";
-  }
-  const signal = args.__signal;
-  if (signal?.aborted) {
-    return "Agent aborted before starting.";
-  }
-  const maxTurns = Math.min(args.max_turns || 15, 30);
-  const agentId = nanoid(8);
-  const parentStream = _subAgentConfig.onStream;
+async function runSubAgent(opts) {
+  if (!_subAgentConfig) throw new Error("Agent tool is not configured.");
+  const { agentId, description, prompt, maxTurns, signal, parentStream } = opts;
   parentStream?.({ type: "agent_start", agentId, description });
   const childStream = (event) => {
     if (!parentStream) return;
     const tagged = { ...event, agentId };
     parentStream(tagged);
   };
+  const parentWasInPlanMode = isInPlanMode();
+  if (parentWasInPlanMode) resetPlanMode();
   try {
-    const parentWasInPlanMode = isInPlanMode();
-    if (parentWasInPlanMode) {
-      resetPlanMode();
-    }
     const engine = _subAgentConfig.createEngine({
       llm: {
         ..._subAgentConfig.llm,
-        timeout: Math.min(_subAgentConfig.llm.timeout ?? 12e4, 6e4),
         retryMaxAttempts: 2
       },
       cwd: _subAgentConfig.cwd,
@@ -972,27 +1019,142 @@ async function agentTool(args) {
       maxContextTokens: _subAgentConfig.maxContextTokens,
       sessionStorageDir: _subAgentConfig.sessionStorageDir
     });
-    let result;
-    try {
-      result = await engine.run(prompt, { signal, onStream: childStream });
-    } finally {
-      if (parentWasInPlanMode) {
-        restorePlanMode();
-      }
-    }
+    const result = await engine.run(prompt, { signal, onStream: childStream });
     parentStream?.({ type: "agent_end", agentId, description });
-    if (result.text) {
-      return result.text;
-    }
-    return `Agent completed (${result.reason}) but produced no text output.`;
+    return result.text || `Agent completed (${result.reason}) but produced no text output.`;
+  } finally {
+    if (parentWasInPlanMode) restorePlanMode();
+  }
+}
+async function agentTool(args) {
+  const prompt = args.prompt;
+  const description = args.description || "sub-agent";
+  if (!prompt) return "Error: prompt is required";
+  if (!_subAgentConfig) {
+    return "Error: Agent tool is not configured.";
+  }
+  const parentSignal = args.__signal;
+  if (parentSignal?.aborted) {
+    return "Agent aborted before starting.";
+  }
+  const maxTurns = args.max_turns || 15;
+  const runInBackground = args.run_in_background === true;
+  const agentId = nanoid(8);
+  const parentStream = _subAgentConfig.onStream;
+  if (runInBackground) {
+    const controller = new AbortController();
+    asyncAgentRegistry.register({
+      agentId,
+      description,
+      status: "running",
+      startedAt: Date.now(),
+      abort: () => controller.abort()
+    });
+    void runSubAgent({
+      agentId,
+      description,
+      prompt,
+      maxTurns,
+      signal: controller.signal,
+      parentStream
+    }).then((text) => asyncAgentRegistry.markCompleted(agentId, text)).catch((err) => {
+      if (controller.signal.aborted) {
+        return;
+      }
+      asyncAgentRegistry.markFailed(agentId, err.message);
+    });
+    return [
+      `Agent launched in background.`,
+      `agent_id: ${agentId}`,
+      `description: ${description}`,
+      ``,
+      `Use AgentStatus(agent_id="${agentId}") to check progress or fetch the result.`,
+      `Use AgentCancel(agent_id="${agentId}") to stop it.`
+    ].join("\n");
+  }
+  try {
+    return await runSubAgent({
+      agentId,
+      description,
+      prompt,
+      maxTurns,
+      signal: parentSignal ?? new AbortController().signal,
+      parentStream
+    });
   } catch (err) {
     parentStream?.({ type: "agent_end", agentId, description, error: err.message });
-    if (signal?.aborted) {
+    if (parentSignal?.aborted) {
       return "Agent was aborted.";
     }
     return `Agent error: ${err.message}`;
   }
 }
+var agentStatusToolDef = {
+  name: "AgentStatus",
+  description: "Check the status of a background agent launched with Agent(run_in_background=true). Returns running / completed / failed / cancelled, plus the result text once finished. Omit agent_id to list all background agents in this process.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      agent_id: {
+        type: "string",
+        description: "The agent_id returned by Agent(run_in_background=true). Omit to list all."
+      }
+    }
+  }
+};
+async function agentStatusTool(args) {
+  const agentId = args.agent_id;
+  if (!agentId) {
+    const all = asyncAgentRegistry.list();
+    if (all.length === 0) return "No background agents in this process.";
+    return all.map((e2) => {
+      const dur2 = ((e2.finishedAt ?? Date.now()) - e2.startedAt) / 1e3;
+      return `${e2.agentId} [${e2.status}] ${e2.description} (${dur2.toFixed(1)}s)`;
+    }).join("\n");
+  }
+  const e = asyncAgentRegistry.get(agentId);
+  if (!e) return `Error: agent_id "${agentId}" not found.`;
+  const dur = ((e.finishedAt ?? Date.now()) - e.startedAt) / 1e3;
+  const lines = [
+    `agent_id: ${e.agentId}`,
+    `status:   ${e.status}`,
+    `description: ${e.description}`,
+    `duration: ${dur.toFixed(1)}s`
+  ];
+  if (e.status === "completed" && e.result) {
+    lines.push("", "\u2500\u2500 result \u2500\u2500", e.result);
+  } else if (e.status === "failed" && e.error) {
+    lines.push("", "\u2500\u2500 error \u2500\u2500", e.error);
+  } else if (e.status === "running") {
+    lines.push("", "(still running \u2014 call AgentStatus again later)");
+  }
+  return lines.join("\n");
+}
+var agentCancelToolDef = {
+  name: "AgentCancel",
+  description: "Cancel a background agent launched with Agent(run_in_background=true). The agent's current LLM call and any in-flight tools will be aborted.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      agent_id: {
+        type: "string",
+        description: "The agent_id to cancel."
+      }
+    },
+    required: ["agent_id"]
+  }
+};
+async function agentCancelTool(args) {
+  const agentId = args.agent_id;
+  if (!agentId) return "Error: agent_id is required.";
+  const e = asyncAgentRegistry.get(agentId);
+  if (!e) return `Error: agent_id "${agentId}" not found.`;
+  if (e.status !== "running") {
+    return `Agent ${agentId} is already ${e.status}; nothing to cancel.`;
+  }
+  const ok = asyncAgentRegistry.cancel(agentId);
+  return ok ? `Agent ${agentId} cancelled.` : `Failed to cancel agent ${agentId}.`;
+}
 
 // src/tool-system/builtin/index.ts
 init_plan();
@@ -2321,7 +2483,9 @@ var BUILTIN_TOOLS = [
       source: "builtin",
       permissionDefault: "ask",
       isReadOnly: false,
-      isConcurrencySafe: false
+      isConcurrencySafe: false,
+      timeoutMs: 36e5
+      // 1h — supports long-running shell loops (e.g. `until` polling)
     },
     execute: bashTool
   },
@@ -2361,10 +2525,32 @@ var BUILTIN_TOOLS = [
       source: "builtin",
       permissionDefault: "allow",
       isReadOnly: true,
-      isConcurrencySafe: true
+      isConcurrencySafe: true,
+      timeoutMs: 18e5
+      // 30min — sub-agent runs may execute many tool calls
     },
     execute: agentTool
   },
+  {
+    definition: {
+      ...agentStatusToolDef,
+      source: "builtin",
+      permissionDefault: "allow",
+      isReadOnly: true,
+      isConcurrencySafe: true
+    },
+    execute: agentStatusTool
+  },
+  {
+    definition: {
+      ...agentCancelToolDef,
+      source: "builtin",
+      permissionDefault: "allow",
+      isReadOnly: false,
+      isConcurrencySafe: false
+    },
+    execute: agentCancelTool
+  },
   {
     definition: {
       ...enterPlanModeToolDef,
@@ -2647,7 +2833,9 @@ var BUILTIN_TOOLS = [
       source: "builtin",
       permissionDefault: "ask",
       isReadOnly: true,
-      isConcurrencySafe: false
+      isConcurrencySafe: false,
+      timeoutMs: 18e5
+      // 30min — multi-model debate rounds take time
     },
     execute: arenaTool
   }
@@ -2655,6 +2843,7 @@ var BUILTIN_TOOLS = [
 
 // src/tool-system/registry.ts
 init_esm_shims();
+var DEFAULT_TOOL_TIMEOUT_MS = 12e4;
 var ToolRegistry = class {
   tools = /* @__PURE__ */ new Map();
   builtinExecutors = /* @__PURE__ */ new Map();
@@ -2709,10 +2898,7 @@ var ToolRegistry = class {
     if (!executor) {
       throw new ToolExecutionError(name, "No executor registered for this tool");
     }
-    const LONG_TIMEOUT_TOOLS = /* @__PURE__ */ new Set(["Agent", "Arena"]);
-    const isLongRunning = LONG_TIMEOUT_TOOLS.has(name);
-    const defaultTimeout = isLongRunning ? 18e5 : 12e4;
-    const timeout = options?.timeoutMs ?? defaultTimeout;
+    const timeout = options?.timeoutMs ?? tool.timeoutMs ?? DEFAULT_TOOL_TIMEOUT_MS;
     const parentSignal = options?.signal;
     const id = `tool_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
     if (parentSignal?.aborted) {
@@ -3126,7 +3312,7 @@ var InteractiveApprovalBackend = class {
     if (toolRule === "allow") return { approved: true };
     if (toolRule === "deny") return { approved: false };
     if (!this.promptFn) {
-      return { approved: true };
+      return { approved: false, reason: "interactive approval backend has no prompt function" };
     }
     const result = await this.promptFn(req);
     if (result.always && result.approved) {
@@ -3870,6 +4056,8 @@ var GENERAL_BUILTIN_TOOLS = [
   "WebFetch",
   "AskUserQuestion",
   "Agent",
+  "AgentStatus",
+  "AgentCancel",
   "EnterPlanMode",
   "ExitPlanMode",
   "ToolSearch",
@@ -3909,6 +4097,8 @@ var GENERAL_PERMISSION_RULES = [
   { tool: "WebFetch", decision: "allow" },
   { tool: "AskUserQuestion", decision: "allow" },
   { tool: "Agent", decision: "allow" },
+  { tool: "AgentStatus", decision: "allow" },
+  { tool: "AgentCancel", decision: "allow" },
   { tool: "EnterPlanMode", decision: "allow" },
   { tool: "ExitPlanMode", decision: "allow" },
   { tool: "ToolSearch", decision: "allow" },
@@ -4433,19 +4623,19 @@ var TurnLoop = class {
             } catch (retryErr) {
               if (!(retryErr instanceof ContextLimitError)) {
                 this.config.onStream?.({ type: "error", error: retryErr.message });
-                return { text: finalText, reason: "model_error" };
+                return { text: finalText, reason: "model_error", messages };
               }
             }
           }
           if (!recovered) {
             this.patchOrphanedToolUses(messages);
             this.config.onStream?.({ type: "error", error: "Context limit exceeded after 3 recovery attempts" });
-            return { text: finalText, reason: "prompt_too_long" };
+            return { text: finalText, reason: "prompt_too_long", messages };
           }
         } else {
           this.patchOrphanedToolUses(messages);
           this.config.onStream?.({ type: "error", error: err.message });
-          return { text: finalText, reason: "model_error" };
+          return { text: finalText, reason: "model_error", messages };
         }
       }
       if (response.usage?.promptTokens !== void 0) {
@@ -4483,7 +4673,7 @@ var TurnLoop = class {
         response = { ...response, text: combinedText };
       }
       if (this.config.signal?.aborted) {
-        return { text: finalText, reason: "aborted_streaming" };
+        return { text: finalText, reason: "aborted_streaming", messages };
       }
       if (response.text) {
         finalText = response.text;
@@ -4502,7 +4692,8 @@ var TurnLoop = class {
           turnNumber: this.turnCount,
           hasToolUse: false
         });
-        return { text: finalText, reason: "completed" };
+        messages.push({ role: "assistant", content: finalText });
+        return { text: finalText, reason: "completed", messages };
       }
       logger.info("turn.tool_use", { turn: this.turnCount, tools: response.toolCalls.map((t) => t.toolName) });
       const toolCalls = response.toolCalls.slice(0, this.config.maxToolCallsPerTurn);
@@ -4566,7 +4757,8 @@ var TurnLoop = class {
           type: "assistant_message",
           message: { role: "assistant", content: finalText }
         });
-        return { text: finalText, reason: "completed" };
+        messages.push({ role: "assistant", content: finalText });
+        return { text: finalText, reason: "completed", messages };
       }
       if (budgetDecision === "nudge") {
         messages.push({
@@ -4607,9 +4799,10 @@ var TurnLoop = class {
         type: "assistant_message",
         message: { role: "assistant", content: finalText }
       });
+      messages.push({ role: "assistant", content: finalText });
     }
     this.config.onStream?.({ type: "turn_complete", reason: "max_turns" });
-    return { text: finalText, reason: "max_turns" };
+    return { text: finalText, reason: "max_turns", messages };
   }
   /**
    * Call model with streaming fallback.
@@ -4750,6 +4943,9 @@ var Engine = class _Engine {
       })
     });
     this.hooks = new HookRegistry();
+    for (const hook of config.hooks ?? []) {
+      this.hooks.register(hook.event, hook.handler, hook.priority, hook.name);
+    }
     this.sessionManager = new SessionManager(config.sessionStorageDir);
     this.modelPool = new ModelPool();
     try {
@@ -4819,7 +5015,7 @@ var Engine = class _Engine {
     let messages;
     if (options?.sessionId) {
       session = this.sessionManager.resume(options.sessionId);
-      messages = session.transcript.toMessages();
+      messages = this.compactedMessagesBySession.get(options.sessionId) ? [...this.compactedMessagesBySession.get(options.sessionId)] : session.transcript.toMessages();
       if (session.state.costState && this.config.costStore) {
         this.config.costStore.restore(session.state.costState);
       }
@@ -4860,7 +5056,7 @@ var Engine = class _Engine {
       approvalBackend = new AutoApprovalBackend();
     } else {
       approvalBackend = new HeadlessApprovalBackend(
-        mode === "bypassPermissions" ? "approve-all" : mode === "dontAsk" ? "deny-all" : "approve-all"
+        mode === "bypassPermissions" ? "approve-all" : mode === "dontAsk" ? "deny-all" : "deny-all"
       );
     }
     const permission = new PermissionClassifier(defaultRules, mode, approvalBackend);
@@ -4912,6 +5108,8 @@ var Engine = class _Engine {
     if (userContextMsg) {
       messages.unshift(userContextMsg);
     }
+    this.lastSessionId = session.state.sessionId;
+    this.lastMessages = messages;
     contextManager.setTranscriptPath(session.transcript.getFilePath());
     contextManager.setSummarizeFn(async (prompt) => {
       const summaryResponse = await llmClient.createMessage({
@@ -4977,6 +5175,11 @@ var Engine = class _Engine {
       }
     );
     const result = await turnLoop.run(messages);
+    this.lastMessages = result.messages;
+    this.compactedMessagesBySession.set(
+      session.state.sessionId,
+      this.stripUserContextMessage(result.messages, userContextMsg)
+    );
     logger.info("engine.done", {
       sessionId: session.state.sessionId,
       reason: result.reason,
@@ -5059,19 +5262,29 @@ var Engine = class _Engine {
    * Returns token stats before/after.
    */
   forceCompact() {
-    if (!this.lastContextManager || !this.lastMessages) {
+    const sessionId = this.lastSessionId;
+    if (!this.lastContextManager || !sessionId) {
       return { before: 0, after: 0, strategy: "none (no active session)" };
     }
     const { estimateTokens: estimateTokens2 } = (init_compaction(), __toCommonJS(compaction_exports));
-    const before = estimateTokens2(this.lastMessages);
-    this.lastMessages = this.lastContextManager.manage(this.lastMessages);
-    const after = estimateTokens2(this.lastMessages);
+    const sourceMessages = this.compactedMessagesBySession.get(sessionId) ?? this.sessionManager.resume(sessionId).transcript.toMessages();
+    const before = estimateTokens2(sourceMessages);
+    const compacted = this.lastContextManager.manage(sourceMessages);
+    const after = estimateTokens2(compacted);
+    this.compactedMessagesBySession.set(sessionId, compacted);
+    this.lastMessages = compacted;
     return {
       before,
       after,
       strategy: before === after ? "no compaction needed" : "compacted"
     };
   }
+  stripUserContextMessage(messages, userContextMsg) {
+    if (!userContextMsg || messages[0] !== userContextMsg) {
+      return [...messages];
+    }
+    return messages.slice(1);
+  }
   /**
    * Update a config setting at runtime.
    */
@@ -5090,6 +5303,8 @@ var Engine = class _Engine {
   /** Track last context manager and messages for /compact support. */
   lastContextManager;
   lastMessages;
+  lastSessionId;
+  compactedMessagesBySession = /* @__PURE__ */ new Map();
 };
 
 // src/run/types.ts
@@ -5921,6 +6136,7 @@ var EngineRunner = class {
       appendSystemPrompt: this.config.appendSystemPrompt,
       sessionStorageDir: this.config.sessionStorageDir,
       mcpServers: this.config.mcpServers,
+      hooks: this.config.hooks,
       approvalBackend,
       askUser: askUserFn,
       ...context.engineConfigOverrides
@@ -5961,6 +6177,8 @@ var RunManager = class {
   lock;
   heartbeat;
   evaluator;
+  defaultTags;
+  defaultMetadata;
   subscribers = /* @__PURE__ */ new Map();
   abortControllers = /* @__PURE__ */ new Map();
   /** Active execution handles — used to resolve pending approvals/input while Engine is suspended */
@@ -5978,6 +6196,8 @@ var RunManager = class {
       intervalMs: config.heartbeatIntervalMs
     });
     this.evaluator = config.evaluator ?? new NoopEvaluator();
+    this.defaultTags = config.defaultTags ?? [];
+    this.defaultMetadata = config.defaultMetadata ?? {};
     this.queue.setExecutor((runId) => this.executeRun(runId));
   }
   // ─── Submit ────────────────────────────────────────────────────
@@ -6002,8 +6222,8 @@ var RunManager = class {
       latestApprovalId: null,
       summary: null,
       error: null,
-      tags: input.tags ?? [],
-      metadata: input.metadata ?? {}
+      tags: [.../* @__PURE__ */ new Set([...this.defaultTags, ...input.tags ?? []])],
+      metadata: { ...this.defaultMetadata, ...input.metadata ?? {} }
     };
     await this.store.create(snapshot);
     await this.emitRunEvent(runId, "run_created", { objective: input.objective });
@@ -6471,6 +6691,7 @@ export {
   ToolExecutor,
   HeadlessApprovalBackend,
   AutoApprovalBackend,
+  getInteractiveApprovalBackend,
   setInteractiveApprovalFn,
   setRuntimeBypass,
   PermissionClassifier,