indusagi-coding-agent 0.2.13 → 0.2.14

package/src/conductor/conductor.ts

@@ -3,6 +3,7 @@ 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, CodingAgentThinkingLevel, ConductorFault, ConductorPhase, ConductorState, PermissionMode, SessionConductor, SessionConductorOptions, SessionHead } from "./contract.js";
 import { ModelCatalog, ModelMatcher } from "./catalog/index.js";
@@ -28,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 }
@@ -134,6 +135,8 @@ 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>;
@@ -164,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) {
@@ -201,24 +214,62 @@ 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"); }
@@ -233,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

@@ -119,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;
 } | {
@@ -370,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`.
@@ -654,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
@@ -842,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/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,

package/src/console/components/Banner.ts

@@ -9,7 +9,9 @@ import { basename } from "node:path";
 import type { InkThemeAdapter } from "indusagi/react-ink";
 import type { StartupChangelog, StartupMap, StartupNotice } from "../startup.js";
 import { MASCOTS, WHATS_NEW, pickWelcomeVariant, mascotRows, type MascotFace } from "./welcome.js";
-import { welcomeLine } from "./banner-sweep.js";
+import { welcomeLine, rowGradient } from "./banner-sweep.js";
+import chalk from "chalk";
+import { useTerminalSize } from "./ScrollViewport.js";
 
 const BRAND = "IndusCode";
 const COMPACT_EMBLEM = "▛▜▙▟";
@@ -23,6 +25,11 @@ const WORDMARK_ROWS: readonly string[] = [
   "╚═╝╚═╝  ╚═══╝╚═════╝  ╚═════╝ ╚══════╝     ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝"
 ];
 
+function StartupSummary({theme, startup}: {theme: InkThemeAdapter; startup?: StartupMap}) {
+  if (!startup?.sections.length) return null;
+  return jsx(Text, {wrap:"truncate-end", children:theme.muted(startup.sections.map(section => `${section.title}: ${section.count}`).join(" · "))});
+}
+
 function StartupNotices({ theme, notices }: { theme: InkThemeAdapter; notices: readonly StartupNotice[] }) {
   if (notices.length === 0) return null;
   return jsx(Box, {
@@ -98,10 +105,10 @@ function ShellLine({ theme, workspace, branch }: { theme: InkThemeAdapter; works
   });
 }
 
-function Wordmark({ theme }: { theme: InkThemeAdapter }) {
+function Wordmark({ theme, sweep }: { theme: InkThemeAdapter; sweep?: boolean }) {
   return jsx(Box, {
     flexDirection: "column",
-    children: WORDMARK_ROWS.map((line, index) => jsx(Text, { children: theme.color("accent", line) }, index))
+    children: WORDMARK_ROWS.map((line, index) => jsx(Text, { children: sweep ? chalk.hex(rowGradient(index, WORDMARK_ROWS.length, theme.colors.accent, theme.colors.customMessage))(line) : theme.color("accent", line) }, index))
   });
 }
 
@@ -127,7 +134,7 @@ function paintMascot(theme: InkThemeAdapter, tone: string, text: string) {
   }
 }
 
-function Mascot({ theme, face }: { theme: InkThemeAdapter; face: MascotFace }) {
+function Mascot({ theme, face, sweep }: { theme: InkThemeAdapter; face: MascotFace; sweep?: boolean }) {
   return jsx(Box, {
     flexDirection: "column",
     alignItems: "center",
@@ -137,7 +144,7 @@ function Mascot({ theme, face }: { theme: InkThemeAdapter; face: MascotFace }) {
         Box,
         {
           children: row.map((seg, segIndex) =>
-            jsx(Text, { children: paintMascot(theme, seg.tone, seg.text) }, segIndex)
+            jsx(Text, { children: sweep && seg.tone === "head" ? chalk.hex(rowGradient(rowIndex, 5, theme.colors.accent, theme.colors.customMessage))(seg.text) : paintMascot(theme, seg.tone, seg.text) }, segIndex)
           )
         },
         rowIndex
@@ -174,6 +181,7 @@ export interface BannerProps {
 }
 
 export function Banner(props: BannerProps) {
+  const { columns } = useTerminalSize();
   const {
     theme,
     modelId,
@@ -187,15 +195,16 @@ export function Banner(props: BannerProps) {
     variantSeed,
     whatsNew,
     notices,
-    changelog
+    changelog, sweep, startup
   } = props;
   const noticeList = notices ?? [];
-  if (quiet || compact) {
+  if (quiet || compact || columns < 76) {
     return jsxs(Box, {
       flexDirection: "column",
       marginBottom: 1,
       children: [
         jsx(StartupNotices, { theme, notices: noticeList }),
+        jsx(StartupSummary, {theme, startup}),
         jsxs(Box, {
           children: [
             compact
@@ -225,8 +234,9 @@ export function Banner(props: BannerProps) {
       marginBottom: 1,
       children: [
         jsx(StartupNotices, { theme, notices: noticeList }),
+        jsx(StartupSummary, {theme, startup}),
         jsx(ShellLine, { theme, workspace, branch }),
-        jsx(Box, { marginTop: 1, children: jsx(Wordmark, { theme }) }),
+        jsx(Box, { marginTop: 1, children: jsx(Wordmark, { theme, sweep }) }),
         jsxs(Box, {
           marginTop: 1,
           flexDirection: "column",
@@ -266,6 +276,7 @@ export function Banner(props: BannerProps) {
     marginBottom: 1,
     children: [
       jsx(StartupNotices, { theme, notices: noticeList }),
+        jsx(StartupSummary, {theme, startup}),
       jsxs(Box, {
         flexDirection: "column",
         borderStyle: "round",
@@ -292,7 +303,7 @@ export function Banner(props: BannerProps) {
                 marginRight: 2,
                 children: [
                   jsx(Text, { bold: true, children: theme.color("text", greeting) }),
-                  jsx(Mascot, { theme, face: variant.mascot }),
+                  jsx(Mascot, { theme, face: variant.mascot, sweep }),
                   jsx(Text, { children: theme.dim(metaLine) }),
                   jsx(Text, { children: theme.dim(shortenWorkspace(workspace)) })
                 ]

package/src/console/components/Composer.ts

@@ -1,29 +1,31 @@
-/**
- * Composer — the prompt-input surface.
- */
-import { Box, Text } from "indusagi/react-host/ink";
-import { jsx, jsxs } from "indusagi/react-host/jsx-runtime";
-import type { InkThemeAdapter } from "indusagi/react-ink";
-import type { Suggestion } from "../input/index.js";
+/** Bounded, grapheme-aware editor and selection-following completion menu. */
+import { Box, Text } from 'indusagi/react-host/ink';
+import { jsx, jsxs } from 'indusagi/react-host/jsx-runtime';
+import stringWidth from 'string-width';
+import type { InkThemeAdapter } from 'indusagi/react-ink';
+import type { Suggestion } from '../input/index.js';
+import { snapGrapheme } from '../input/graphemes.js';
+import { useTerminalSize } from './ScrollViewport.js';
 
-const PROMPT_GLYPH = "› ";
-const SUGGESTION_WINDOW = 8;
-const NAME_COLUMN_CAP = 24;
-const NAME_COLUMN_FLOOR = 8;
-
-function clampName(label: string, width: number): string {
-  if (label.length <= width) return label;
-  if (width <= 1) return label.slice(0, width);
-  return `${label.slice(0, width - 1)}…`;
-}
-
-function bufferWithCaret(buffer: string, caret: number) {
-  const before = buffer.slice(0, caret);
-  const under = caret < buffer.length ? buffer[caret] : " ";
-  const after = caret < buffer.length ? buffer.slice(caret + 1) : "";
-  return jsxs(Text, {
-    children: [before, jsx(Text, { inverse: true, children: under }), after]
-  });
+const segmenter = new Intl.Segmenter(undefined, {granularity:'grapheme'});
+interface Cell { text: string; caret: boolean }
+function editorLines(buffer: string, caret: number, width: number) {
+  const lines: Cell[][] = [[]];
+  let column = 0;
+  caret = snapGrapheme(buffer, caret);
+  for (const {segment, index} of segmenter.segment(buffer + ' ')) {
+    const cursor = index === caret;
+    if (segment === '\n') {
+      if (cursor) lines.at(-1)!.push({text:' ', caret:true});
+      lines.push([]); column=0; continue;
+    }
+    const text = segment === '\t' ? '  ' : segment.replace(/[\x00-\x1f\x7f]/g,'');
+    const cells = stringWidth(text);
+    if (column + cells > width && column > 0) {lines.push([]);column=0;}
+    lines.at(-1)!.push({text:cells > width ? '?' : text,caret:cursor});
+    column += Math.min(width,cells);
+  }
+  return lines;
 }
 
 export interface ComposerProps {
@@ -33,62 +35,35 @@ export interface ComposerProps {
   readonly busy: boolean;
   readonly suggestions: readonly Suggestion[];
   readonly highlight: number;
+  readonly paddingX?: number;
 }
 
-export function Composer({ theme, buffer, caret, busy, suggestions, highlight }: ComposerProps) {
-  const shown = suggestions.slice(0, SUGGESTION_WINDOW);
-  const borderColor = theme.colors.borderMuted ?? theme.colors.accent ?? "gray";
-  const nameWidth = shown.length > 0
-    ? Math.max(NAME_COLUMN_FLOOR, Math.min(NAME_COLUMN_CAP, Math.max(...shown.map((s) => s.label.length))))
-    : 0;
-  return jsxs(Box, {
-    flexDirection: "column",
-    children: [
-      jsxs(Box, {
-        borderStyle: "round",
-        borderColor,
-        paddingX: 1,
-        children: [
-          jsxs(Box, {
-            flexGrow: 1,
-            children: [
-              jsx(Text, { children: theme.color("customMessage", PROMPT_GLYPH) }),
-              bufferWithCaret(buffer, caret)
-            ]
-          }),
-          jsx(Text, { children: theme.dim("↵ send") })
-        ]
-      }),
-      shown.length > 0
-        ? jsx(Box, {
-            flexDirection: "column",
-            marginTop: 1,
-            children: shown.map((suggestion, index) => {
-              const active = index === highlight;
-              const name = clampName(suggestion.label, nameWidth);
-              return jsxs(
-                Box,
-                {
-                  children: [
-                    jsx(Box, {
-                      width: 2,
-                      flexShrink: 0,
-                      children: jsx(Text, { children: active ? theme.color("accent", "▸") : " " })
-                    }),
-                    jsx(Box, {
-                      width: nameWidth,
-                      flexShrink: 0,
-                      children: jsx(Text, { bold: active, children: theme.color("customMessage", name) })
-                    }),
-                    jsx(Text, { children: "  " }),
-                    jsx(Text, { children: theme.muted(suggestion.detail) })
-                  ]
-                },
-                suggestion.value
-              );
-            })
-          })
-        : null
-    ]
-  });
-}
+export function Composer({theme,buffer,caret,suggestions,highlight,paddingX=1}: ComposerProps) {
+  const {columns,rows} = useTerminalSize();
+  const padding = Math.max(0, Math.min(3, Math.floor(paddingX), Math.floor((columns-8)/2)));
+  const sendWidth = columns >= 32 ? 7 : 0;
+  const width = Math.max(1,columns - 2 - padding*2 - 2 - sendWidth);
+  const allLines = editorLines(buffer,caret,width);
+  const caretRow = Math.max(0,allLines.findIndex(line=>line.some(cell=>cell.caret)));
+  const editorBudget = Math.max(1,Math.min(6,Math.floor(rows/4)));
+  const top = Math.max(0,Math.min(caretRow-editorBudget+1,allLines.length-editorBudget));
+  const lines = allLines.slice(top,top+editorBudget);
+  const budget = Math.max(1,Math.min(8,rows-lines.length-12));
+  const start = Math.max(0,Math.min(highlight-budget+1,suggestions.length-budget));
+  const shown = suggestions.slice(start,start+budget);
+  const nameWidth = Math.max(1,Math.min(24,Math.floor(columns/3)));
+  return jsxs(Box,{flexDirection:'column',flexShrink:0,children:[
+    jsx(Box,{borderStyle:'round',borderColor:theme.colors.borderMuted??'gray',paddingX:padding,flexDirection:'column',children:
+      lines.map((line,index)=>jsxs(Box,{height:1,flexShrink:0,children:[
+        jsx(Box,{width:2,flexShrink:0,children:jsx(Text,{children:theme.color('customMessage',index+top===0?'› ':'· ')})}),
+        jsx(Box,{width,flexShrink:0,children:jsx(Text,{wrap:'truncate-end',children:line.map((cell,i)=>jsx(Text,{inverse:cell.caret,children:cell.text},i))})}),
+        sendWidth ? jsx(Box,{width:sendWidth,flexShrink:0,children:jsx(Text,{children:index===0?theme.dim(' ↵ send'):''})}) : null
+      ]},index))
+    }),
+    shown.length ? jsx(Box,{flexDirection:'column',marginTop:1,children:shown.map((suggestion,index)=>jsxs(Box,{height:1,children:[
+      jsx(Box,{width:2,flexShrink:0,children:jsx(Text,{children:start+index===highlight?theme.color('accent','▸'):' '})}),
+      jsx(Box,{width:nameWidth,flexShrink:0,children:jsx(Text,{wrap:'truncate-end',bold:start+index===highlight,children:theme.color('customMessage',suggestion.label)})}),
+      jsx(Box,{width:Math.max(1,columns-nameWidth-2),children:jsx(Text,{wrap:'truncate-end',children:theme.muted('  '+suggestion.detail)})})
+    ]},suggestion.value))}) : null
+  ]});
+}

package/src/console/components/ScrollViewport.ts

@@ -0,0 +1,46 @@
+import React, { useEffect, useState } from 'indusagi/react-host';
+import { Box, useInput } from 'indusagi/react-host/ink';
+import { measureElement, useStdout, type DOMElement } from 'ink';
+import { jsx } from 'indusagi/react-host/jsx-runtime';
+import type { ReactNode } from 'react';
+
+export function useTerminalSize() {
+  const { stdout } = useStdout();
+  const read = () => ({ columns: Math.max(1, stdout.columns || 80), rows: Math.max(1, stdout.rows || 24) });
+  const [size, setSize] = useState(read);
+  useEffect(() => {
+    const resize = () => setSize(read());
+    stdout.on('resize', resize);
+    return () => { stdout.off('resize', resize); };
+  }, [stdout]);
+  return size;
+}
+
+/** Row-bounded Ink viewport. Page keys scroll; new output follows only at the bottom. */
+export function ScrollViewport({ children, active = true, follow = true }: { children: ReactNode; active?: boolean; follow?: boolean }) {
+  const outer = React.useRef<DOMElement>(null);
+  const inner = React.useRef<DOMElement>(null);
+  const [metrics, setMetrics] = useState({ height: 1, content: 1 });
+  const [offset, setOffset] = useState(0);
+  useEffect(() => {
+    if (!outer.current || !inner.current) return;
+    const height = measureElement(outer.current).height;
+    const content = measureElement(inner.current).height;
+    if (metrics.height !== height || metrics.content !== content) {
+      const oldMax = Math.max(0, metrics.content - metrics.height);
+      const newMax = Math.max(0, content - height);
+      if (follow) setOffset(n => n === 0 ? 0 : Math.max(0, Math.min(newMax, n + newMax - oldMax)));
+      setMetrics({height, content});
+    }
+  });
+  const max = Math.max(0, metrics.content - metrics.height);
+  const scroll = Math.min(max, offset);
+  useInput((_input, key) => {
+    const step = Math.max(1, metrics.height - 2);
+    if (key.pageUp) setOffset(n => Math.min(max, n + (follow ? step : -step)));
+    if (key.pageDown) setOffset(n => Math.max(0, Math.min(max, n + (follow ? -step : step))));
+  }, {isActive: active});
+  const top = follow ? Math.max(0, max - scroll) : Math.max(0, scroll);
+  return jsx(Box, {ref: outer, flexDirection:'column', flexGrow:1, flexBasis:0, minHeight:1, overflow:'hidden',
+    children:jsx(Box, {ref:inner, flexDirection:'column', flexShrink:0, marginTop:-top, children})});
+}