indusagi-coding-agent 0.2.12 → 0.2.14

package/src/briefing/context-docs.ts

@@ -1,19 +1,151 @@
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import { dirname, extname, isAbsolute, join, parse, resolve } from "node:path";
+import { closeSync, constants, fstatSync, lstatSync, openSync, readFileSync, realpathSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, parse, resolve, sep } from "node:path";
 import type { ContextDoc } from "./contract.js";
 
-export interface GatherContextDocsOptions { readonly maxImportDepth?: number; readonly maxBytesPerDoc?: number; }
+export interface GatherContextDocsOptions {
+  readonly maxImportDepth?: number;
+  readonly maxBytesPerDoc?: number;
+  /** Exact external files the user explicitly approved for this run. */
+  readonly approvedExternalPaths?: readonly string[];
+}
+
 export const DEFAULT_MAX_IMPORT_DEPTH = 5;
 export const DEFAULT_MAX_BYTES_PER_DOC = 40_000;
 export const CANDIDATE_FILES = ["AGENTS.md", "CLAUDE.md", "INDUSAGI.md", "CLAUDE.local.md", "AGENTS.local.md", join(".indusagi", "CLAUDE.md"), join(".claude", "CLAUDE.md")];
-export const TEXT_FILE_EXTENSIONS = new Set([".md", ".markdown", ".txt", ".text", ".json", ".jsonc", ".yaml", ".yml", ".toml", ".xml", ".csv", ".html", ".htm", ".css", ".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".py", ".rb", ".go", ".rs", ".sh", ".env"]);
+export const TEXT_FILE_EXTENSIONS = new Set([".md", ".markdown", ".txt", ".text", ".json", ".jsonc", ".yaml", ".yml", ".toml", ".xml", ".csv", ".html", ".htm", ".css", ".js", ".ts", ".tsx", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".py", ".rb", ".go", ".rs", ".sh"]);
 export const IMPORT_REGEX = /(?:^|\s)@((?:[^\s\\]|\\ )+)/g;
 
-export function shortenPath(path: string, cwd: string, home: string): string { if (cwd && path.startsWith(cwd)) { const rest = path.slice(cwd.length).replace(/^[/\\]+/, ""); return rest ? `./${rest}` : "."; } return home && path.startsWith(home) ? `~${path.slice(home.length)}` : path; }
-export function dirChain(cwd: string): string[] { const chain: string[] = []; let current = cwd; for (let i = 0; i < 256; i++) { chain.push(current); const parent = dirname(current); if (parent === current || current === parse(current).root) break; current = parent; } return chain.reverse(); }
-export function safeRealpath(path: string): string { try { return realpathSync(path); } catch { return path; } }
-export function isTextFile(path: string): boolean { const extension = extname(path).toLowerCase(); return !extension || TEXT_FILE_EXTENSIONS.has(extension); }
-export function readFileBody(path: string): string | null { if (!existsSync(path)) return null; try { const body = readFileSync(path, "utf8").trim(); return body || null; } catch { return null; } }
-export function extractImports(body: string, baseDir: string, home: string): string[] { const out: string[] = []; IMPORT_REGEX.lastIndex = 0; let match: RegExpExecArray | null; while ((match = IMPORT_REGEX.exec(body))) { let spec = match[1]; if (!spec) continue; const hash = spec.indexOf("#"); if (hash >= 0) spec = spec.slice(0, hash); spec = spec.replace(/\\ /g, " ").trim(); if (!spec) continue; const absolute = spec.startsWith("~/") ? join(home, spec.slice(2)) : isAbsolute(spec) ? spec : resolve(baseDir, spec); if (isTextFile(absolute)) out.push(absolute); } return out; }
-export function loadDocTree(path: string, cwd: string, home: string, seen: Set<string>, depth: number, maxDepth: number, maxBytes: number, out: ContextDoc[]): void { const real = safeRealpath(path); if (seen.has(real)) return; seen.add(real); const body = readFileBody(path); if (body === null) return; out.push({ path: shortenPath(path, cwd, home), body: body.length > maxBytes ? body.slice(0, maxBytes) : body }); if (depth >= maxDepth) return; for (const child of extractImports(body, dirname(path), home)) loadDocTree(child, cwd, home, seen, depth + 1, maxDepth, maxBytes, out); }
-export function gatherContextDocs(cwd: string, home: string, opts?: GatherContextDocsOptions): readonly ContextDoc[] { const out: ContextDoc[] = []; try { const seen = new Set<string>(); const roots = dirChain(cwd); if (home) roots.push(home); for (const dir of roots) for (const name of CANDIDATE_FILES) loadDocTree(join(dir, name), cwd, home, seen, 0, opts?.maxImportDepth ?? DEFAULT_MAX_IMPORT_DEPTH, opts?.maxBytesPerDoc ?? DEFAULT_MAX_BYTES_PER_DOC, out); } catch { return out; } return out; }
+const NO_FOLLOW = constants.O_NOFOLLOW ?? 0;
+const SECRET_BASENAMES = new Set([
+  ".env", "credentials", "credentials.json", "id_rsa", "id_dsa", "id_ecdsa", "id_ed25519",
+]);
+const SECRET_EXTENSIONS = new Set([".key", ".pem", ".p12", ".pfx"]);
+
+export function shortenPath(path: string, cwd: string, home: string): string {
+  if (cwd && (path === cwd || path.startsWith(`${cwd}${sep}`))) {
+    const rest = path.slice(cwd.length).replace(/^[/\\]+/, "");
+    return rest ? `./${rest}` : ".";
+  }
+  return home && (path === home || path.startsWith(`${home}${sep}`)) ? `~${path.slice(home.length)}` : path;
+}
+
+/** Retained for API compatibility; context discovery no longer walks this chain. */
+export function dirChain(cwd: string): string[] {
+  const chain: string[] = [];
+  let current = cwd;
+  for (let i = 0; i < 256; i++) {
+    chain.push(current);
+    const parent = dirname(current);
+    if (parent === current || current === parse(current).root) break;
+    current = parent;
+  }
+  return chain.reverse();
+}
+
+export function safeRealpath(path: string): string {
+  try { return realpathSync(path); } catch { return path; }
+}
+
+export function isTextFile(path: string): boolean {
+  const extension = extname(path).toLowerCase();
+  return !extension || TEXT_FILE_EXTENSIONS.has(extension);
+}
+
+export function isLikelySecretFile(path: string): boolean {
+  const name = basename(path).toLowerCase();
+  return SECRET_BASENAMES.has(name) || name.startsWith(".env.") || SECRET_EXTENSIONS.has(extname(name));
+}
+
+export function readFileBody(path: string): string | null {
+  let fd: number | undefined;
+  try {
+    const before = lstatSync(path);
+    if (before.isSymbolicLink() || !before.isFile()) return null;
+    fd = openSync(path, constants.O_RDONLY | NO_FOLLOW);
+    if (!fstatSync(fd).isFile()) return null;
+    const body = readFileSync(fd, "utf8").trim();
+    return body || null;
+  } catch {
+    return null;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+export function extractImports(body: string, baseDir: string, home: string): string[] {
+  const out: string[] = [];
+  IMPORT_REGEX.lastIndex = 0;
+  let match: RegExpExecArray | null;
+  while ((match = IMPORT_REGEX.exec(body))) {
+    let spec = match[1];
+    if (!spec) continue;
+    const hash = spec.indexOf("#");
+    if (hash >= 0) spec = spec.slice(0, hash);
+    spec = spec.replace(/\\ /g, " ").trim();
+    if (!spec) continue;
+    const absolute = spec.startsWith("~/") ? join(home, spec.slice(2)) : isAbsolute(spec) ? spec : resolve(baseDir, spec);
+    if (isTextFile(absolute)) out.push(absolute);
+  }
+  return out;
+}
+
+function canonicalExistingFile(path: string): string | null {
+  try {
+    const before = lstatSync(path);
+    if (before.isSymbolicLink() || !before.isFile()) return null;
+    return realpathSync(path);
+  } catch {
+    return null;
+  }
+}
+
+function isWithin(root: string, candidate: string): boolean {
+  return candidate === root || candidate.startsWith(`${root}${sep}`);
+}
+
+interface LoadPolicy {
+  readonly root: string;
+  readonly approvedExternal: ReadonlySet<string>;
+}
+
+function loadTrustedDocTree(path: string, cwd: string, home: string, seen: Set<string>, depth: number, maxDepth: number, maxBytes: number, out: ContextDoc[], policy: LoadPolicy): void {
+  if (isLikelySecretFile(path)) return;
+  const real = canonicalExistingFile(path);
+  if (real === null || seen.has(real) || isLikelySecretFile(real)) return;
+  if (!isWithin(policy.root, real) && !policy.approvedExternal.has(real)) return;
+  seen.add(real);
+  const body = readFileBody(real);
+  if (body === null) return;
+  out.push({ path: shortenPath(real, cwd, home), body: body.length > maxBytes ? body.slice(0, maxBytes) : body });
+  if (depth >= maxDepth) return;
+  for (const child of extractImports(body, dirname(real), home)) {
+    loadTrustedDocTree(child, cwd, home, seen, depth + 1, maxDepth, maxBytes, out, policy);
+  }
+}
+
+/** Compatibility wrapper with secure default confinement to cwd. */
+export function loadDocTree(path: string, cwd: string, home: string, seen: Set<string>, depth: number, maxDepth: number, maxBytes: number, out: ContextDoc[]): void {
+  let root: string;
+  try { root = realpathSync(cwd); } catch { return; }
+  loadTrustedDocTree(path, root, home, seen, depth, maxDepth, maxBytes, out, { root, approvedExternal: new Set() });
+}
+
+export function gatherContextDocs(cwd: string, home: string, opts: GatherContextDocsOptions = {}): readonly ContextDoc[] {
+  const out: ContextDoc[] = [];
+  try {
+    const root = realpathSync(cwd);
+    const approvedExternal = new Set<string>();
+    for (const path of opts.approvedExternalPaths ?? []) {
+      const real = canonicalExistingFile(path);
+      if (real !== null && !isLikelySecretFile(real)) approvedExternal.add(real);
+    }
+    const policy = { root, approvedExternal };
+    const seen = new Set<string>();
+    for (const name of CANDIDATE_FILES) {
+      loadTrustedDocTree(join(root, name), root, home, seen, 0, opts.maxImportDepth ?? DEFAULT_MAX_IMPORT_DEPTH, opts.maxBytesPerDoc ?? DEFAULT_MAX_BYTES_PER_DOC, out, policy);
+    }
+  } catch {
+    return out;
+  }
+  return out;
+}

package/src/channels/oneshot.ts

@@ -49,6 +49,12 @@ function ndjsonStrategy(): OneshotStrategy {
     },
     onSignal(signal: unknown, ctx: ChannelContext): void {
       const s = signal as { kind: string };
+      // Running shell commands can emit thousands of rolling progress snapshots,
+      // each containing the same bounded output tail. Serializing every snapshot
+      // ignores stdout backpressure and can retain hundreds of megabytes. The
+      // terminal tool result is emitted in full by tool_end, which is the durable
+      // event required by one-shot consumers and benchmark trajectory conversion.
+      if (s.kind === "tool_update") return;
       ctx.out.write(ctx.framer.encodeLine({ type: "signal", name: s.kind, body: s }));
     },
     finish(state: ConductorState, ctx: ChannelContext): number {

package/src/conductor/catalog/catalog.ts

@@ -1,7 +1,8 @@
 import { z } from "zod";
-import { getModels, getProviders } from "indusagi/ai";
+import { getModels, getProviders, modelRegistry } from "indusagi/ai";
 import type { KnownProvider, Model } from "indusagi/ai";
 import type { ModelCardRef } from "../contract.js";
+import { applyCodingAgentModelOverlay } from "../../models.js";
 
 export interface CatalogCard {
   readonly id: string;
@@ -29,6 +30,7 @@ const rawModelGate = z.object({
 });
 
 const EXCLUDED_PROVIDERS = new Set(["mock"]);
+applyCodingAgentModelOverlay(modelRegistry);
 const frameworkSource: CatalogSource = {
   providers: () => getProviders().filter((provider) => !EXCLUDED_PROVIDERS.has(String(provider))),
   models: (provider) => getModels(provider as KnownProvider),

package/src/conductor/conductor.ts

@@ -3,8 +3,9 @@ import type { AgentEvent, AgentMessage, AgentTool, CanUseToolFn, ThinkingLevel }
 import { createZeroUsage } from "indusagi/ai";
 import type { Model, Usage } from "indusagi/ai";
 import * as path from "node:path";
+import { runShell } from "../kit/run-shell.js";
 import { conductorFault } from "./contract.js";
-import type { ApprovalResolver, ConductorFault, ConductorPhase, ConductorState, PermissionMode, SessionConductor, SessionConductorOptions, SessionHead } from "./contract.js";
+import type { ApprovalResolver, CodingAgentThinkingLevel, ConductorFault, ConductorPhase, ConductorState, PermissionMode, SessionConductor, SessionConductorOptions, SessionHead } from "./contract.js";
 import { ModelCatalog, ModelMatcher } from "./catalog/index.js";
 import type { CatalogCard } from "./catalog/index.js";
 import { SignalHub, translateAgentEvent } from "./signal-hub/index.js";
@@ -15,6 +16,7 @@ import { writePlan } from "../capability-deck/cards/plan-file.js";
 import { AUTO_CONDENSE_POLICY, isOverBudget } from "../window-budget/index.js";
 import { DiagnosticsEngine, formatDiagnosticsSummary, hasEslintConfig, hasTsConfig, isTypeScriptOrJs, runEslintDiagnostics, runTscDiagnostics } from "./diagnostics.js";
 import type { DiagnosticsConfig } from "./diagnostics.js";
+import { isReasoningEffortSupported, type CodingAgentModel } from "../models.js";
 
 export interface AgentLike {
   subscribe(fn: (event: AgentEvent) => void): () => void;
@@ -27,7 +29,7 @@ export interface AgentLike {
   setTools(tools: AgentTool[]): void;
   setThinkingLevel?(level: ThinkingLevel): void;
 }
-export interface CondenseOpts { readonly force?: boolean; readonly model?: Model<any>; readonly contextTokens?: number; readonly signal?: AbortSignal; readonly apiKey?: string }
+export interface CondenseOpts { readonly instructions?: string; readonly force?: boolean; readonly model?: Model<any>; readonly contextTokens?: number; readonly signal?: AbortSignal; readonly apiKey?: string }
 export type CondenseFn = (messages: AgentMessage[], opts?: CondenseOpts) => AgentMessage[] | Promise<AgentMessage[]>;
 export const noopCondense: CondenseFn = (messages) => messages;
 export interface RetryPolicy { readonly maxAttempts: number; readonly baseDelayMs: number }
@@ -62,7 +64,7 @@ export function reduceState(prev: ConductorState, action: StateAction): Conducto
 }
 
 const DEFAULT_RETRY = { maxAttempts: 2, baseDelayMs: 250 };
-const THINKING_LADDER: ThinkingLevel[] = ["off", "low", "medium", "high"];
+const DEFAULT_THINKING_LADDER: readonly CodingAgentThinkingLevel[] = ["off", "low", "medium", "high"];
 const PERMISSION_CYCLE: PermissionMode[] = ["default", "acceptEdits", "plan", "bypass"];
 
 function newSessionId(): string { return `s_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`; }
@@ -73,6 +75,10 @@ function accumulateUsage(a: Usage, b: Usage): Usage {
 function errorText(error: unknown): string { return error instanceof Error ? error.message : String(error); }
 function isTransient(error: unknown): boolean { const text = errorText(error).toLowerCase(); return ["429", "rate limit", "overloaded", "timeout", "timed out", "econnreset", "etimedout", "503", "502", "500", "unavailable", "temporarily"].some((part) => text.includes(part)); }
 function isOverloadFault(error: unknown): boolean { const text = errorText(error).toLowerCase(); return text.includes("529") || text.includes("overload"); }
+function thinkingLadderForModel(model: Model<any> | undefined): readonly CodingAgentThinkingLevel[] {
+  const efforts = (model as CodingAgentModel | undefined)?.reasoningEfforts;
+  return efforts?.length ? efforts : DEFAULT_THINKING_LADDER;
+}
 
 export function withGatewayBaseUrl<M extends { baseUrl: string; provider: string }>(model: M, gatewayBaseUrls: Record<string, string> | undefined): M {
   const url = gatewayBaseUrls?.[model.provider];
@@ -129,10 +135,12 @@ class SessionConductorImpl implements SessionConductor {
   #matcher?: ModelMatcher;
   #state: ConductorState;
   #busy = false;
+  #activeWork?: Promise<unknown>;
+  #shellAbort?: AbortController;
   #draining = false;
   #queue: { mode: "steer" | "followUp"; text: string }[] = [];
   #boundModel?: Model<any>;
-  #thinking: ThinkingLevel;
+  #thinking: CodingAgentThinkingLevel;
   #prePlanMode?: PermissionMode;
   #sessionName?: string;
   #gatewayBaseUrls?: Record<string, string>;
@@ -159,12 +167,22 @@ class SessionConductorImpl implements SessionConductor {
   clearQueue() { this.#queue.length = 0; this.#hub.emit({ kind: "queue", count: 0 }); }
   dequeueLast() { const item = this.#queue.pop(); if (item) this.#hub.emit({ kind: "queue", count: this.#queue.length }); return item?.text; }
   steerNow() { const item = this.#queue.pop(); if (!item) return false; this.#queue.unshift({ mode: "steer", text: item.text }); this.agent.abort(); return true; }
-  abort() { this.clearQueue(); this.#condenseAbort?.abort(); this.agent.abort(); const fault = conductorFault("aborted", "turn aborted by caller"); this.#dispatch({ type: "fault", fault }); this.#hub.emit({ kind: "fault", fault }); this.#hub.emit({ kind: "idle" }); }
+  abort() { this.clearQueue(); this.#condenseAbort?.abort(); this.#shellAbort?.abort(); this.agent.abort(); const fault = conductorFault("aborted", "turn aborted by caller"); this.#dispatch({ type: "fault", fault }); this.#hub.emit({ kind: "fault", fault }); this.#hub.emit({ kind: "idle" }); }
 
   async submit(input: string) {
     if (this.#busy) { this.enqueue(input); return this.#state; }
     this.#busy = true;
-    try { await this.#runTurn(input); await this.#drainQueue(); return this.#state; } finally { this.#busy = false; }
+    const work = (async () => {
+      try { await this.#runTurn(input); await this.#drainQueue(); return this.#state; }
+      finally { this.#busy = false; }
+    })();
+    this.#activeWork = work;
+    return work;
+  }
+  async #stopWork() {
+    if (!this.#busy) return;
+    this.abort();
+    await this.#activeWork;
   }
   async #drainQueue() { if (this.#draining) return; this.#draining = true; try { while (this.#queue.length) { const index = this.#queue.findIndex((item) => item.mode === "steer"); const item = index >= 0 ? this.#queue.splice(index, 1)[0] : this.#queue.shift()!; this.#hub.emit({ kind: "queue", count: this.#queue.length }); await this.#runTurn(item.text); } } finally { this.#draining = false; } }
   async #runTurn(input: string) {
@@ -196,30 +214,68 @@ class SessionConductorImpl implements SessionConductor {
   }
 
   selectModel(id: string) { const card = this.#matcher?.resolveCard(id); if (!card) { const fault = conductorFault("model", `no model matches "${id}"`); this.#dispatch({ type: "fault", fault }); this.#hub.emit({ kind: "fault", fault }); return; } this.#applyModel(card); }
-  cycleModel(id: string) { this.selectModel(id); }
+  cycleModel(id: string, direction: -1 | 1 = 1) {
+    if (id.trim()) { this.selectModel(id); return; }
+    const cards = this.availableModels();
+    if (!cards.length) return;
+    const at = cards.findIndex(card => card.id === this.#state.modelId);
+    const index = at < 0 ? 0 : (at + direction + cards.length) % cards.length;
+    this.selectModel(cards[index].id);
+  }
   #applyModel(card: CatalogCard) { const model = withGatewayBaseUrl(card.model, this.#gatewayBaseUrls); this.agent.setModel(model); this.#boundModel = model; this.#dispatch({ type: "model", modelId: card.id }); }
   updateGatewayBaseUrls(map: Record<string, string>) { this.#gatewayBaseUrls = map; this.selectModel(this.#state.modelId); }
   registerTools(tools: AgentTool[]) { this.agent.setTools([...this.#deckTools, ...tools]); }
 
-  async condense() { if (this.#busy) return "busy" as const; this.#busy = true; this.#condenseAbort = new AbortController(); try { const result = await this.#runCondense(true, this.#condenseAbort.signal); await this.#drainQueue(); return result; } finally { this.#busy = false; this.#condenseAbort = undefined; } }
+  async condense(instructions?: string) {
+    if (this.#busy) return "busy" as const;
+    this.#busy = true; this.#condenseAbort = new AbortController();
+    const work = (async () => {
+      try { const result = await this.#runCondense(true, this.#condenseAbort!.signal, instructions); await this.#drainQueue(); return result; }
+      finally { this.#busy = false; this.#condenseAbort = undefined; }
+    })();
+    this.#activeWork = work;
+    return work;
+  }
   cancelCondense() { this.#condenseAbort?.abort(); }
-  async #runCondense(force: boolean, signal?: AbortSignal) {
+  async #runCondense(force: boolean, signal?: AbortSignal, instructions?: string) {
     const before = [...this.agent.state.messages]; this.#dispatch({ type: "phase", phase: "condensing" });
-    try { const after = await (this.deps.condense ?? noopCondense)(before, { force, model: this.#boundModel, contextTokens: this.#state.contextTokens, signal }); if (signal?.aborted) return "cancelled" as const; if (after.length >= before.length) { this.#dispatch({ type: "settled" }); return "nothing" as const; } this.agent.replaceMessages(after); await this.store.reset(); for (let i = 0; i < after.length; i++) await this.store.append(after[i], i === 0 ? "condense" : undefined); this.#dispatch({ type: "head", head: this.store.head }); this.#hub.emit({ kind: "compacted", manual: force }); this.#dispatch({ type: "settled" }); return "condensed" as const; } catch (error) { const fault = conductorFault("overflow", "auto-condense failed", error); this.#dispatch({ type: "fault", fault }); this.#hub.emit({ kind: "fault", fault }); return "failed" as const; }
+    try { const after = await (this.deps.condense ?? noopCondense)(before, { force, model: this.#boundModel, contextTokens: this.#state.contextTokens, signal, instructions }); if (signal?.aborted) { this.#dispatch({type:"settled"}); this.#hub.emit({kind:"idle"}); return "cancelled" as const; } if (after.length >= before.length) { this.#dispatch({ type: "settled" }); return "nothing" as const; } this.agent.replaceMessages(after); await this.store.reset(); for (let i = 0; i < after.length; i++) await this.store.append(after[i], i === 0 ? "condense" : undefined); this.#dispatch({ type: "head", head: this.store.head }); this.#hub.emit({ kind: "compacted", manual: force }); this.#dispatch({ type: "settled" }); return "condensed" as const; } catch (error) { const fault = conductorFault("overflow", "auto-condense failed", error); this.#dispatch({ type: "fault", fault }); this.#hub.emit({ kind: "fault", fault }); return "failed" as const; }
   }
 
   async fork(id: string) { await this.#move(id, `cannot fork from "${id}"`); }
   async navigateTree(id: string) { await this.#move(id, `cannot navigate to "${id}"`); }
-  async #move(id: string, message: string) { try { await this.store.branchAt(id); this.agent.replaceMessages(this.store.messages()); this.#dispatch({ type: "head", head: this.store.head }); this.#dispatch({ type: "settled" }); this.#hub.emit({ kind: "idle" }); } catch (error) { const fault = conductorFault("persistence", message, error); this.#dispatch({ type: "fault", fault }); this.#hub.emit({ kind: "fault", fault }); } }
+  async #move(id: string, message: string) { try { await this.#stopWork(); await this.store.branchAt(id); this.agent.replaceMessages(this.store.messages()); this.#dispatch({ type: "head", head: this.store.head }); this.#dispatch({ type: "settled" }); this.#hub.emit({ kind: "reset" }); this.#hub.emit({ kind: "idle" }); } catch (error) { const fault = conductorFault("persistence", message, error); this.#dispatch({ type: "fault", fault }); this.#hub.emit({ kind: "fault", fault }); } }
   async restoreCode(id: string) { return this.options.checkpoint?.restore(id) ?? []; }
   async codeRestoreInfo(id: string) { return { canRestore: this.options.checkpoint?.hasSnapshot(id) ?? false }; }
-  async executeBash(command: string, opts: { excludeFromContext?: boolean } = {}) { const { spawn } = await import("node:child_process"); const outcome = await new Promise<{ output: string; exitCode: number }>((resolve) => { const child = spawn(command, { cwd: this.#workspace, shell: true }); let output = ""; child.stdout?.on("data", (chunk) => output += String(chunk)); child.stderr?.on("data", (chunk) => output += String(chunk)); child.on("error", (error) => resolve({ output: output + errorText(error), exitCode: 1 })); child.on("close", (code) => resolve({ output, exitCode: code ?? 1 })); }); if (!opts.excludeFromContext) await this.store.append({ role: "user", content: `$ ${command}\n${outcome.output}`.trimEnd(), timestamp: Date.now() } as AgentMessage, "note"); return outcome; }
+  async executeBash(command: string, opts: { excludeFromContext?: boolean; signal?: AbortSignal } = {}) {
+    if (this.#busy) throw new Error("A turn is running — stop it before running a shell command.");
+    this.#busy = true; this.#shellAbort = new AbortController();
+    const signal = opts.signal ? AbortSignal.any([opts.signal, this.#shellAbort.signal]) : this.#shellAbort.signal;
+    const work = (async () => {
+      try {
+        this.#dispatch({type:"phase",phase:"tooling"});
+        const outcome = await runShell(command, this.#workspace, signal);
+        if (!opts.excludeFromContext) {
+          const message: AgentMessage = {role:"user",content:`$ ${command}\n${outcome.output}`.trimEnd(),timestamp:Date.now()};
+          const entry = await this.store.append(message, "note");
+          this.agent.replaceMessages([...this.agent.state.messages, message]);
+          this.#dispatch({type:"head",head:this.store.head});
+          this.#hub.emit({kind:"persisted",entryId:entry.id});
+        }
+        this.#dispatch({type:"settled"}); this.#hub.emit({kind:"idle"});
+        await this.#drainQueue();
+        return outcome;
+      } finally { this.#busy = false; this.#shellAbort = undefined; }
+    })();
+    this.#activeWork = work;
+    return work;
+  }
 
   stats() { const messages = this.agent.state.messages; let userMessages = 0, assistantMessages = 0, toolCalls = 0, toolResults = 0; for (const message of messages) { if (message.role === "user") userMessages++; else if (message.role === "assistant") { assistantMessages++; for (const part of message.content ?? []) if (typeof part === "object" && part && part.type === "toolCall") toolCalls++; } else if (message.role === "toolResult") toolResults++; } const usage = this.#state.usage; return { sessionId: this.#state.head.sessionId, userMessages, assistantMessages, toolCalls, toolResults, totalMessages: messages.length, tokens: { input: usage.input, output: usage.output, cacheRead: usage.cacheRead, cacheWrite: usage.cacheWrite, total: usage.totalTokens }, cost: usage.cost.total }; }
   costReport() { const stats = this.stats(); return [`Total cost:            $${stats.cost.toFixed(4)}`, `Total tokens:          ${stats.tokens.total}`, `  Input:               ${stats.tokens.input}`, `  Output:              ${stats.tokens.output}`, `  Cache read:          ${stats.tokens.cacheRead}`, `  Cache write:         ${stats.tokens.cacheWrite}`].join("\n"); }
   thinkingLevel() { return this.#thinking; }
-  setThinkingLevel(level: ThinkingLevel) { this.#thinking = level; this.agent.setThinkingLevel?.(level); }
-  cycleThinkingLevel() { const next = THINKING_LADDER[(THINKING_LADDER.indexOf(this.#thinking) + 1) % THINKING_LADDER.length]; this.setThinkingLevel(next); return next; }
+  setThinkingLevel(level: CodingAgentThinkingLevel) { if (!isReasoningEffortSupported(this.#boundModel?.id, level)) return; this.#thinking = level; this.agent.setThinkingLevel?.(level as ThinkingLevel); }
+  cycleThinkingLevel() { const ladder = thinkingLadderForModel(this.#boundModel); const next = ladder[(ladder.indexOf(this.#thinking) + 1) % ladder.length]; this.setThinkingLevel(next); return next; }
   permissionMode() { return this.modeHolder.mode; }
   setPermissionMode(mode: PermissionMode) { this.modeHolder.mode = mode; }
   setApprovalResolver(resolver: ApprovalResolver | undefined) { this.approvalHolder.resolver = resolver; }
@@ -228,7 +284,11 @@ class SessionConductorImpl implements SessionConductor {
   cyclePermissionMode() { const current = this.modeHolder.mode === "bypassPermissions" ? "bypass" : this.modeHolder.mode; const next = PERMISSION_CYCLE[(PERMISSION_CYCLE.indexOf(current) + 1) % PERMISSION_CYCLE.length]; this.setPermissionMode(next); return next; }
   sessionName() { return this.#sessionName; }
   setSessionName(name: string) { this.#sessionName = name; }
-  async resume(id: string) { if (!await this.store.load(id)) { const fault = conductorFault("persistence", `no session "${id}" to resume`); this.#dispatch({ type: "fault", fault }); this.#hub.emit({ kind: "fault", fault }); return; } this.agent.replaceMessages(this.store.messages()); this.#state = { ...this.#state, head: this.store.head, usage: this.store.usage ?? createZeroUsage(), phase: "idle" }; this.#hub.emit({ kind: "idle" }); }
-  async newSession() { this.agent.abort(); this.agent.replaceMessages([]); this.store.startNewSession(newSessionId()); this.#queue.length = 0; this.#sessionName = undefined; this.#state = { phase: "idle", head: this.store.head, usage: createZeroUsage(), contextTokens: 0, modelId: this.#state.modelId }; this.#hub.emit({ kind: "idle" }); }
-  #dispatch(action: StateAction) { this.#state = reduceState(this.#state, action); }
+  async resume(id: string) { await this.#stopWork(); if (!await this.store.load(id)) { const fault = conductorFault("persistence", `no session "${id}" to resume`); this.#dispatch({ type: "fault", fault }); this.#hub.emit({ kind: "fault", fault }); return; } this.agent.replaceMessages(this.store.messages()); this.#state = { ...this.#state, head: this.store.head, usage: this.store.usage ?? createZeroUsage(), phase: "idle" }; this.#hub.emit({kind:"reset"}); this.#hub.emit({ kind: "idle" }); }
+  async newSession() { await this.#stopWork(); this.agent.replaceMessages([]); this.store.startNewSession(newSessionId()); this.#queue.length = 0; this.#sessionName = undefined; this.#state = { phase: "idle", head: this.store.head, usage: createZeroUsage(), contextTokens: 0, modelId: this.#state.modelId }; this.#hub.emit({kind:"reset"}); this.#hub.emit({ kind: "idle" }); }
+  #dispatch(action: StateAction) {
+    const phase = this.#state.phase;
+    this.#state = reduceState(this.#state, action);
+    if (phase !== this.#state.phase) this.#hub.emit({kind:"phase",phase:this.#state.phase});
+  }
 }

package/src/conductor/contract.ts

@@ -40,6 +40,7 @@ import type { AgentMessage, AgentTool, CanUseToolFn, ThinkingLevel } from "indus
 import type { KnownProvider, Model, Usage } from "indusagi/ai";
 import type { PermissionMode } from "../settings.js";
 import type { ApprovalResolver } from "./permissions.js";
+export type CodingAgentThinkingLevel = ThinkingLevel | "max";
 /** Re-exported framework vocabulary that conductor consumers routinely need. */
 export type { AgentMessage, AgentTool, CanUseToolFn, ThinkingLevel, Model, Usage, KnownProvider };
 /** Re-exported permission vocabulary, so conductor consumers get it in one import. */
@@ -118,7 +119,7 @@ export function conductorFault(kind: FaultKind, message: string, cause?: unknown
  *   - `queue`     — the pending-input queue changed; `count` is its new depth.
  *   - `idle`      — the conductor has no in-flight work and is ready for input.
  */
-export type SessionSignal = {
+export type SessionSignal = { readonly kind: "reset" } | { readonly kind: "phase"; readonly phase: ConductorPhase } | {
     readonly kind: "prompt";
     readonly text: string;
 } | {
@@ -369,6 +370,7 @@ export interface SessionStats {
 }
 /** Options for {@link SessionConductor.executeBash}. */
 export interface ExecuteBashOptions {
+    readonly signal?: AbortSignal;
     /**
      * When `true`, the command's output is *not* recorded as a transcript note,
      * so it never re-enters the agent's context. Defaults to `false`.
@@ -434,7 +436,7 @@ export interface SessionConductorOptions {
     /** Tools made available to the agent for this session. */
     readonly tools?: AgentTool[];
     /** Initial reasoning effort for models that support it. */
-    readonly thinking?: ThinkingLevel;
+    readonly thinking?: CodingAgentThinkingLevel;
     /**
      * Canonical id of a model to fall back to when the bound model is overloaded
      * (HTTP 529 / "overloaded") mid-turn (`--fallback-model`). When set, an
@@ -653,7 +655,7 @@ export interface SessionConductor {
      * While the condense runs, {@link submit} queues instead of racing it, and the
      * queue drains once the condense settles.
      */
-    condense(): Promise<CondenseOutcome>;
+    condense(instructions?: string): Promise<CondenseOutcome>;
     /**
      * Cancel an in-flight manual {@link condense} (the `/compact` Esc affordance).
      * The summarizer's result is discarded and the transcript stays untouched; a
@@ -718,19 +720,19 @@ export interface SessionConductor {
      */
     costReport(): string;
     /** The reasoning effort currently applied to the session. */
-    thinkingLevel(): ThinkingLevel;
+    thinkingLevel(): CodingAgentThinkingLevel;
     /**
      * Set the reasoning effort for subsequent turns. Applied to the agent when it
      * exposes a setter; otherwise stored and applied on the next model bind.
      *
      * @param level the reasoning effort to apply
      */
-    setThinkingLevel(level: ThinkingLevel): void;
+    setThinkingLevel(level: CodingAgentThinkingLevel): void;
     /**
      * Advance the reasoning effort to the next level in the cycle, applying it, and
      * return the newly-selected level.
      */
-    cycleThinkingLevel(): ThinkingLevel;
+    cycleThinkingLevel(): CodingAgentThinkingLevel;
     /**
      * The permission mode currently in effect. The live `canUseTool` gate reads
      * this on every tool call, so the value reflects the most recent
@@ -841,5 +843,5 @@ export interface SessionConductor {
      *
      * @param id canonical id of the model to switch to
      */
-    cycleModel?(id: string): void;
+    cycleModel?(id: string, direction?: -1 | 1): void;
 }

package/src/conductor/index.ts

@@ -16,7 +16,7 @@
  * land; consumers import the conductor surface from `src/conductor` rather than
  * reaching into individual modules.
  */
-export type { FaultKind, ConductorFault, SessionSignal, SignalKind, SignalOf, SignalHandler, TranscriptSchema, TranscriptRole, TranscriptEntry, SessionHead, ModelCardRef, MatchQuery, ConductorPhase, ConductorState, QueueMode, QueuedInput, SessionStats, ExecuteBashOptions, BashOutcome, SessionConductor, SessionConductorOptions, CondenseOutcome, AgentMessage, AgentTool, CanUseToolFn, ThinkingLevel, Model, Usage, KnownProvider, PermissionMode, } from "./contract.js";
+export type { FaultKind, ConductorFault, SessionSignal, SignalKind, SignalOf, SignalHandler, TranscriptSchema, TranscriptRole, TranscriptEntry, SessionHead, ModelCardRef, MatchQuery, ConductorPhase, ConductorState, QueueMode, QueuedInput, SessionStats, ExecuteBashOptions, BashOutcome, SessionConductor, SessionConductorOptions, CondenseOutcome, AgentMessage, AgentTool, CanUseToolFn, ThinkingLevel, CodingAgentThinkingLevel, Model, Usage, KnownProvider, PermissionMode, } from "./contract.js";
 export { conductorFault, TRANSCRIPT_SCHEMA } from "./contract.js";
 export { createSessionConductor, reduceState, noopCondense, withGatewayBaseUrl, type AgentLike, type ConductorDeps, type CondenseFn, type RetryPolicy, } from "./conductor.js";
 export { SignalHub, translateAgentEvent, type SignalHubOptions } from "./signal-hub/index.js";

package/src/conductor/transcript-store/store.ts

@@ -4,6 +4,7 @@ import type { Usage } from "indusagi/ai";
 import { TRANSCRIPT_SCHEMA } from "../contract.js";
 import type { SessionHead, TranscriptEntry, TranscriptRole } from "../contract.js";
 import { encodeEntry, encodeHead, parseSessionText, roleForMessage } from "./serialize.js";
+import { appendPrivateFileSync, atomicWritePrivateFileSync, readPrivateFileSync } from "../../security/private-state.js";
 
 export interface TranscriptBackend {
   locate(sessionId: string): string;
@@ -54,18 +55,13 @@ export function fsBackend(dir: string): TranscriptBackend {
   return {
     locate: (sessionId) => `${dir}/${sessionId}.ndjson`,
     read: async (sessionId) => {
-      const fs = await import("node:fs/promises");
-      try { return await fs.readFile(await fileOf(sessionId), "utf8"); } catch { return null; }
+      return readPrivateFileSync(await fileOf(sessionId));
     },
     append: async (sessionId, line) => {
-      const fs = await import("node:fs/promises");
-      await fs.mkdir(dir, { recursive: true });
-      await fs.appendFile(await fileOf(sessionId), `${line}\n`, "utf8");
+      appendPrivateFileSync(await fileOf(sessionId), `${line}\n`);
     },
     rewrite: async (sessionId, text) => {
-      const fs = await import("node:fs/promises");
-      await fs.mkdir(dir, { recursive: true });
-      await fs.writeFile(await fileOf(sessionId), text.length === 0 ? "" : `${text}\n`, "utf8");
+      atomicWritePrivateFileSync(await fileOf(sessionId), text.length === 0 ? "" : `${text}\n`);
     },
   };
 }

package/src/console/auth-status.ts

@@ -7,6 +7,7 @@
  * ready to use) both need the exact same answer, so it lives here once.
  */
 import { useEffect, useState } from "indusagi/react-host";
+import { getEnvApiKey } from "indusagi/ai";
 import { hasValidServerToken } from "../boot/server-token.js";
 import { serverTierProviders } from "../boot/runners/server-mode.js";
 import type { OverlayServices } from "./contract.js";
@@ -27,10 +28,14 @@ export function useAuthenticatedProviders(services: OverlayServices | undefined,
     void (async () => {
       const found = new Set<string>();
       try {
-        for (const provider of services.listLoginProviders()) {
+        const providers = new Set([
+          ...services.listLoginProviders().map(provider => provider.id),
+          ...services.conductor.availableModels().map(model => model.provider)
+        ]);
+        for (const provider of providers) {
           try {
-            if ((await services.vault.listAccounts(provider.id)).length > 0) {
-              found.add(provider.id);
+            if (getEnvApiKey(provider) || (await services.vault.listAccounts(provider)).length > 0) {
+              found.add(provider);
             }
           } catch {
             // ignore
@@ -51,6 +56,6 @@ export function useAuthenticatedProviders(services: OverlayServices | undefined,
     return () => {
       live = false;
     };
-  }, [refreshKey]);
+  }, [services, refreshKey]);
   return authed;
 }

package/src/console/components/AgentsView.ts

@@ -5,7 +5,7 @@ import { useState } from "indusagi/react-host";
 import { Box, Text, useInput } from "indusagi/react-host/ink";
 import { wrapSelectionIndex, type InkThemeAdapter } from "indusagi/react-ink";
 import { jsx, jsxs } from "indusagi/react-host/jsx-runtime";
-import type { AgentRun } from "./BackgroundAgents.js";
+import { useAgentClock, type AgentRun } from "./BackgroundAgents.js";
 
 function formatTokens(tokens: number): string {
   return tokens >= 1e3 ? `${(tokens / 1e3).toFixed(1)}k` : String(tokens);
@@ -66,7 +66,7 @@ export interface AgentsViewProps {
 }
 
 export function AgentsView({ theme, runs, activity, tokens, now, onExit }: AgentsViewProps) {
-  const clock = now ?? Date.now();
+  const clock = useAgentClock(runs.some(run => run.status === "running"), now);
   const [selectedIndex, setSelectedIndex] = useState(runs.length > 0 ? 1 : 0);
   const rowCount = runs.length + 1;
   const index = Math.min(selectedIndex, rowCount - 1);

package/src/console/components/BackgroundAgents.ts

@@ -2,6 +2,7 @@
  * BackgroundAgents — the live sub-agent panel pinned below the input.
  */
 import { Box, Text } from "indusagi/react-host/ink";
+import { useEffect, useState } from "indusagi/react-host";
 import { splitAssistantMessage, type InkThemeAdapter } from "indusagi/react-ink";
 import { jsx, jsxs } from "indusagi/react-host/jsx-runtime";
 import type { AgentMessage } from "indusagi/agent";
@@ -100,11 +101,23 @@ export interface BackgroundAgentsProps {
 /**
  * Render the background-agents panel, or nothing when no run is in flight.
  */
+export function useAgentClock(active: boolean, supplied?: number): number {
+  const [now, setNow] = useState(Date.now);
+  useEffect(() => {
+    if (!active || supplied !== undefined) return;
+    const timer = setInterval(() => setNow(Date.now()), 1000);
+    return () => clearInterval(timer);
+  }, [active, supplied]);
+  return supplied ?? now;
+}
+
 export function BackgroundAgents({ theme, runs, tokens, now }: BackgroundAgentsProps) {
-  const clock = now ?? Date.now();
+  const clock = useAgentClock(runs.some(run => run.status === "running"), now);
   const runningCount = runs.reduce((n, run) => (run.status === "running" ? n + 1 : n), 0);
   if (runningCount === 0) return null;
-  const visible = runs.slice(-MAX_VISIBLE_RUNS);
+  const running = runs.filter(run => run.status === "running");
+  const recentDone = runs.filter(run => run.status !== "running").slice(-Math.max(0, MAX_VISIBLE_RUNS - running.length));
+  const visible = [...running, ...recentDone].slice(0, MAX_VISIBLE_RUNS);
   return jsxs(Box, {
     flexDirection: "column",
     marginTop: 1,