indusagi-coding-agent 0.2.2 → 0.2.4

package/dist/types/console/components/welcome.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Welcome-card content & per-session variation — the pure data behind the
+ * "IndusCode Saffron" startup card (the boxed masthead the {@link Banner} draws
+ * in its loud mode).
+ *
+ * This module holds *no* React or Ink: it is the render-agnostic source of the
+ * card's rotating mascot, the rotating "getting started" tip, the static
+ * "what's new" notes, the slash chips, and the small block-art robot mascot
+ * geometry. The banner reads these and paints them through the theme adapter;
+ * the geometry is returned as tone-tagged {@link MascotSegment}s so the banner
+ * maps a tone → a colour role without re-deriving the layout.
+ *
+ * Per-session freshness ("every new session the welcome looks a little
+ * different") is a *pure* selection: {@link pickWelcomeVariant} maps an integer
+ * seed onto one mascot + one tip deterministically, so a test pins an exact
+ * variant while the live surface seeds it once at mount from
+ * {@link randomWelcomeSeed}. Nothing here reads a clock or mutates state — same
+ * seed in, same variant out.
+ */
+/**
+ * One robot-mascot face: the two eye glyphs and the three-cell mouth.
+ *
+ * The face is drawn into a fixed nine-cell-wide rounded head (see
+ * {@link mascotRows}); only the eyes and mouth change between variants, so a
+ * face is just those glyphs plus a human-readable key for tests/logs. Each eye
+ * is exactly one display cell and the mouth exactly three so every face packs
+ * into the same head outline without shifting the columns.
+ */
+export interface MascotFace {
+    /** Stable identifier for the expression (for tests and selection logs). */
+    readonly key: string;
+    /** The left/right eye glyphs (one display cell each). */
+    readonly eyes: readonly [string, string];
+    /** The three-cell mouth glyph row. */
+    readonly mouth: string;
+}
+/**
+ * The rotating mascot expressions, in selection order.
+ *
+ * Each is the same rounded saffron head with dark eyes and a teal mouth — the
+ * expression is the only thing that changes session to session.
+ */
+export declare const MASCOTS: readonly MascotFace[];
+/** A drawn cell's colour intent, mapped to a theme role by the banner. */
+export type MascotTone = "head" | "eye" | "mouth" | "feet";
+/** One painted span of a mascot row: literal text plus its colour intent. */
+export interface MascotSegment {
+    /** The literal glyphs to draw. */
+    readonly text: string;
+    /** Which colour role the banner paints this span in. */
+    readonly tone: MascotTone;
+}
+/**
+ * Lay a {@link MascotFace} out into its drawable rows.
+ *
+ * Returns one array of {@link MascotSegment}s per terminal row of the mascot — a
+ * five-row rounded head (top, eyes, mouth, base, feet). The head outline is the
+ * `head` tone, the eyes the `eye` tone, the mouth the `mouth` tone, and the feet
+ * the `feet` tone; the banner resolves each tone to a concrete colour. Every row
+ * is the same nine-cell width (the feet row is centred under it), so the column
+ * stays rectangular whichever expression is chosen.
+ *
+ * @param face the expression to lay out
+ */
+export declare function mascotRows(face: MascotFace): readonly (readonly MascotSegment[])[];
+/**
+ * The rotating "Tips for getting started" lines.
+ *
+ * One is shown per session (chosen by {@link pickWelcomeVariant}); the pool is
+ * ordinary onboarding guidance so a returning user sees a different nudge each
+ * launch rather than the same line forever.
+ */
+export declare const TIPS: readonly string[];
+/**
+ * The static "What's new" notes shown in the card's right column.
+ *
+ * These are stable per release (the banner can override them from a live
+ * changelog); they describe the most recent user-facing changes.
+ */
+export declare const WHATS_NEW: readonly string[];
+/** The chosen per-session presentation: one mascot face and one tip line. */
+export interface WelcomeVariant {
+    /** The mascot expression to draw this session. */
+    readonly mascot: MascotFace;
+    /** The "getting started" tip to show this session. */
+    readonly tip: string;
+}
+/**
+ * Pick the welcome card's mascot + tip for a session seed.
+ *
+ * Pure and total: the same seed always yields the same variant, and any integer
+ * (including a negative one) lands on a valid mascot and tip. The mascot and the
+ * tip are advanced by different strides of the seed so they do not move in
+ * lock-step — two nearby seeds vary both independently.
+ *
+ * @param seed the per-session seed (e.g. from {@link randomWelcomeSeed})
+ */
+export declare function pickWelcomeVariant(seed: number): WelcomeVariant;
+/**
+ * The PINNED welcome-card variant seed. The card no longer rotates per session
+ * (one stable brand look): seeded with this, {@link pickWelcomeVariant} always
+ * resolves to the clean "focus" mascot (`MASCOTS[0]` — `●  ●` eyes, flat `───`
+ * mouth) + the Shift+Tab tip (`TIPS[2]`). (`12 % MASCOTS.length === 0` → focus;
+ * `Math.trunc(12 / MASCOTS.length) % TIPS.length === 2` → the Shift+Tab tip.) Swap
+ * the mount back to {@link randomWelcomeSeed} to restore per-session rotation.
+ */
+export declare const PINNED_WELCOME_SEED = 12;
+/**
+ * Mint a fresh seed for the current session.
+ *
+ * Impure by design (it reads the RNG), so the live surface calls it *once* at
+ * mount and threads the result into the otherwise-pure banner. Tests never call
+ * this — they pass a fixed seed to {@link pickWelcomeVariant} instead.
+ */
+export declare function randomWelcomeSeed(): number;

package/dist/types/console/components/welcome.test.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Welcome-card content & variation — pure behavioural tests.
+ *
+ * These exercise the render-agnostic data behind the saffron welcome card
+ * without mounting Ink: the per-session variant selection (deterministic,
+ * total, independent strides) and the mascot geometry (rectangular, tone-tagged,
+ * expression-driven).
+ */
+export {};

package/dist/types/console/contract.d.ts

@@ -60,13 +60,15 @@ export type { SessionConductor, SessionSignal, ConductorState };
  *
  * Named for the time-of-day they evoke rather than a bare light/dark axis, with
  * a daltonized (color-blind-friendly) variant of each:
+ *   - `saffron`     — the IndusCode brand scheme: a warm saffron-on-cream dark
+ *     terminal look with a cool teal accent. The shipped default.
  *   - `midnight`    — a low-luminance scheme for dark terminals.
  *   - `daylight`    — a high-luminance scheme for light terminals.
  *   - `midnight-cb` — the dark scheme re-derived so success vs failure separates
  *     off the red-green axis (success → blue), deuteran/protan-safe.
  *   - `daylight-cb` — the light scheme's color-blind-safe counterpart.
  */
-export type ThemeScheme = "midnight" | "daylight" | "midnight-cb" | "daylight-cb";
+export type ThemeScheme = "saffron" | "midnight" | "daylight" | "midnight-cb" | "daylight-cb";
 /** The default scheme applied before any user preference is loaded. */
 export declare const DEFAULT_SCHEME: ThemeScheme;
 /**
@@ -357,6 +359,12 @@ export type ConsoleEvent = {
 } | {
     readonly type: "buffer:insert";
     readonly text: string;
+}
+/** Swap the first occurrence of `find` for `replaceWith` (paste-marker growth). */
+ | {
+    readonly type: "buffer:replaceSpan";
+    readonly find: string;
+    readonly replaceWith: string;
 } | {
     readonly type: "buffer:erasePrev";
 } | {
@@ -546,6 +554,13 @@ export interface OverlayServices {
     readonly openLoginUrl: (url: string) => Promise<boolean>;
     /** The credential store sign-in / sign-out overlays read and write. */
     readonly vault: AuthVault;
+    /**
+     * Recompute the server-tier gateway routing map from current vault/token
+     * state and push it onto the live conductor, so a sign-in that happens
+     * mid-session (the "Indus Server" entry in `/login`) takes effect on the
+     * NEXT turn without needing a session restart.
+     */
+    readonly refreshGatewayRouting: () => Promise<void>;
 }
 /**
  * What the root `TerminalConsole` surface receives at mount.

package/dist/types/console/index.d.ts

@@ -26,6 +26,9 @@ export { TerminalConsole } from "./components/TerminalConsole";
 export { Composer, type ComposerProps } from "./components/Composer";
 export { StatusBar, type StatusBarProps } from "./components/StatusBar";
 export { Banner, type BannerProps } from "./components/Banner";
+export { BackgroundAgents, deriveAgentRuns, type BackgroundAgentsProps, type AgentRun, type AgentRunStatus, } from "./components/BackgroundAgents";
+export { AgentsView, type AgentsViewProps } from "./components/AgentsView";
+export { MASCOTS, TIPS, WHATS_NEW, mascotRows, pickWelcomeVariant, randomWelcomeSeed, type MascotFace, type MascotTone, type MascotSegment, type WelcomeVariant, } from "./components/welcome";
 export { gatherStartup, gatherChangelog } from "./startup";
 export type { StartupMap, StartupSection, StartupChangelog, StartupChangelogMode, StartupNotice, StartupNoticeKind, StartupInputs, } from "./startup";
 export { mountConsole, type MountConsoleOptions, type MountResult, } from "./mount";

package/dist/types/console/input/index.d.ts

@@ -18,7 +18,7 @@
 export type { KeyChord, ConsoleVerb, ConsoleIntent, ChordOutcome, ChordLatch, ChordStep, } from "./keymap";
 export { NO_INTENT, readKey, NO_CHORD, advanceChord } from "./keymap";
 export type { PasteThresholds, PasteVault, PasteCapture, } from "./paste";
-export { PASTE_THRESHOLDS, PASTE_BURST_GAP_MS, EMPTY_PASTE_VAULT, pasteMarker, classifyPaste, coalescePaste, expandMarkers, hasMarkers, } from "./paste";
+export { PASTE_THRESHOLDS, PASTE_BURST_GAP_MS, PASTE_CONTINUATION_MS, PASTE_MARKER_LINE_CAP, EMPTY_PASTE_VAULT, pasteMarker, classifyPaste, coalescePaste, appendToPaste, pasteLines, expandMarkers, hasMarkers, } from "./paste";
 export type { CompletionKind, Suggestion, TokenSpan, CompletionResult, DirEntry, DirReader, } from "./complete";
 export { completeAt, applySuggestion } from "./complete";
 export { createDirReader } from "./dir-reader";

package/dist/types/console/input/keymap.d.ts

@@ -82,7 +82,7 @@ export interface KeyChord {
  *     - `flow:cycleModel`  — rotate to the next model.
  *
  *   Model / reasoning
- *     - `model:cycleThinking` — advance the reasoning-effort ladder one step.
+ *     - `model:cycleThinking` — advance the reasoning-effort ladder one step (via /thinking command).
  *
  *   Permission mode
  *     - `mode:cyclePermission` — cycle through ALL permission modes (Shift+Tab),
@@ -115,7 +115,7 @@ export interface KeyChord {
  *   Inert
  *     - `none`             — the keystroke carries no console meaning.
  */
-export type ConsoleVerb = "text:type" | "text:newline" | "edit:erasePrev" | "edit:eraseNext" | "edit:clearLine" | "nav:left" | "nav:right" | "nav:home" | "nav:end" | "nav:up" | "nav:down" | "flow:submit" | "flow:dismiss" | "flow:accept" | "flow:interrupt" | "flow:suspend" | "flow:cycleModel" | "model:cycleThinking" | "mode:cyclePermission" | "mode:togglePlan" | "queue:dequeue" | "input:pasteImage" | "input:externalEditor" | "overlay:open" | "view:expandTools" | "view:toggleReasoning" | "none";
+export type ConsoleVerb = "text:type" | "text:newline" | "edit:erasePrev" | "edit:eraseNext" | "edit:clearLine" | "nav:left" | "nav:right" | "nav:home" | "nav:end" | "nav:up" | "nav:down" | "flow:submit" | "flow:dismiss" | "flow:accept" | "flow:interrupt" | "flow:suspend" | "flow:cycleModel" | "model:cycleThinking" | "mode:cyclePermission" | "mode:togglePlan" | "queue:dequeue" | "queue:steer" | "input:pasteImage" | "input:externalEditor" | "overlay:open" | "view:expandTools" | "view:toggleReasoning" | "none";
 /**
  * A classified keystroke: a {@link ConsoleVerb} plus the small payload a verb
  * may carry — the literal text for a `text:type` insert, or the target overlay

package/dist/types/console/input/paste.d.ts

@@ -24,8 +24,8 @@
  * the whole paste pipeline is unit-tested in isolation. The component owns only
  * the live vault value and the burst-coalescing timer; the decisions are here.
  *
- * The marker format is the console's own: `‹clip N · K lines›`, where `N` is the
- * 1-based mint order and `K` is the hidden line count. It is chosen to be
+ * The marker format is the console's own: `[Pasted text #N +K lines]`, where `N` is the
+ * 1-based mint order and `K` is the hidden line count. Matches induscode style:
  * visually distinct in the composer, unambiguous to match, and trivial to strip.
  */
 /**
@@ -41,7 +41,14 @@ export interface PasteThresholds {
     /** Minimum character count to treat a chunk as a large paste. */
     readonly chars: number;
 }
-/** The default cut-offs above which a paste is coalesced into a marker. */
+/**
+ * The default cut-offs above which a paste is coalesced into a marker.
+ *
+ * Matched to the reference agent: a paste of MORE than 10 lines (i.e. ≥10
+ * newlines) or more than 1000 characters hides behind a marker; anything
+ * smaller — including the common 8-line snippet — splices inline and renders
+ * as visible multi-line text in the composer.
+ */
 export declare const PASTE_THRESHOLDS: PasteThresholds;
 /**
  * The maximum gap, in milliseconds, between per-character events still treated
@@ -53,6 +60,30 @@ export declare const PASTE_THRESHOLDS: PasteThresholds;
  * it. Exposed as data so the coalescing timer and any test share one value.
  */
 export declare const PASTE_BURST_GAP_MS = 24;
+/**
+ * How long, after a coalesced flush, a paste stays "active" — a further
+ * multi-character chunk landing within this window APPENDS to the active
+ * marker instead of minting a new one.
+ *
+ * Terminals deliver a big paste as a series of ~1KB stdin reads whose gaps can
+ * exceed any reasonable per-chunk debounce, so timing alone shreds one paste
+ * into many markers (`[Pasted #11][Pasted #12]…`, issue #18's second form).
+ * Sized GENEROUSLY: a very long paste (the spec case is 1000 lines) must
+ * survive mid-stream read hiccups as ONE marker, and the failure mode of a
+ * too-long window is mild — two lightning-fast deliberate pastes merge into
+ * one marker whose expansion is still the correct concatenated text — while a
+ * too-short window re-creates the shredding this exists to fix. Two human
+ * paste chords are >300ms apart in practice; single characters (real typing)
+ * never extend the window.
+ */
+export declare const PASTE_CONTINUATION_MS = 250;
+/**
+ * Ceiling on the line count a single marker absorbs via continuation. One
+ * user paste stays ONE marker up to this many lines; a paste that keeps
+ * streaming past it rolls over into a fresh marker ("one more paste") so a
+ * runaway multi-megabyte paste can't grow a single unbounded vault body.
+ */
+export declare const PASTE_MARKER_LINE_CAP = 1000;
 /** The console's own placeholder format for a hidden paste body. */
 export declare function pasteMarker(ordinal: number, lineCount: number): string;
 /**
@@ -69,14 +100,14 @@ export declare function classifyPaste(chunk: string, thresholds?: PasteThreshold
 /**
  * The immutable marker → body store.
  *
- * `bodies` maps each minted marker token to the exact text it hides; `minted`
+ * `bodies` maps each ordinal number to the exact text it hides; `minted`
  * is the running count that drives the next ordinal. The store is replaced (not
  * mutated) on every coalesce, so the surface holds it as a plain value and React
  * reconciliation stays correct.
  */
 export interface PasteVault {
-    /** Marker token → the original pasted text it stands for. */
-    readonly bodies: ReadonlyMap<string, string>;
+    /** Ordinal number → the original pasted text it stands for. */
+    readonly bodies: ReadonlyMap<number, string>;
     /** How many markers have been minted so far (the next ordinal is this + 1). */
     readonly minted: number;
 }
@@ -106,6 +137,27 @@ export interface PasteCapture {
  * @param body  the full pasted text to hide
  */
 export declare function coalescePaste(body: string, vault?: PasteVault): PasteCapture;
+/**
+ * Grow an existing paste body with a follow-on chunk, reminting its marker.
+ *
+ * The continuation path for a paste the terminal split across reads: the extra
+ * text is appended to `ordinal`'s stored body and a fresh marker (same ordinal,
+ * updated line count) is returned so the surface can swap the token already
+ * spliced into the buffer. `minted` is unchanged — no new ordinal is consumed.
+ * An unknown ordinal starts from an empty body, so the call never throws.
+ *
+ * @param ordinal the marker ordinal to grow
+ * @param extra   the follow-on pasted text to append
+ * @param vault   the store holding the ordinal's current body
+ */
+export declare function appendToPaste(ordinal: number, extra: string, vault: PasteVault): PasteCapture;
+/**
+ * The line count of an ordinal's stored body — the surface consults this
+ * against {@link PASTE_MARKER_LINE_CAP} to decide whether a continuation chunk
+ * may still append or must roll over into a fresh marker. Zero for an unknown
+ * ordinal or an empty body.
+ */
+export declare function pasteLines(vault: PasteVault, ordinal: number): number;
 /**
  * Rewrite every paste marker in a buffer back to the text it stands for.
  *

package/dist/types/console/overlays/approval-queue.d.ts

@@ -15,7 +15,7 @@
  * abort/clear settles every outstanding entry with `"deny"` so a cancelled turn
  * never hangs on a pending prompt.
  */
-import type { ApprovalChoice } from "../../conductor";
+import type { ApprovalChoice, PermissionMode } from "../../conductor";
 import type { ApprovalRequest } from "./approval";
 /** One parked approval request awaiting the user's choice. */
 export interface ApprovalEntry {
@@ -69,3 +69,20 @@ export declare function approvalQueueReducer(state: ApprovalQueueState, event: A
  * @param state the queue state
  */
 export declare function activeApproval(state: ApprovalQueueState): ApprovalEntry | undefined;
+/**
+ * Whether switching INTO `mode` mid-prompt should release (auto-allow) every
+ * PARKED approval request.
+ *
+ * Only `bypass` qualifies: a parked entry already passed the deny-rule and
+ * catastrophic-blocklist scans before it reached `ask`, and under bypass the
+ * engine allows everything not denied — so settling the parked prompts with
+ * `allow-once` matches exactly what the mode now means, and the run resumes
+ * instead of idling behind a prompt the user just declared moot. Every other
+ * mode keeps the prompts parked: `default`/`acceptEdits` still want the answer,
+ * and `plan` must not auto-ALLOW a mutating call (the user can still deny).
+ *
+ * Pure; the component wires it to the actual settle.
+ *
+ * @param mode the permission mode just switched into
+ */
+export declare function modeReleasesApprovals(mode: PermissionMode): boolean;

package/dist/types/console/overlays/boards.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Saffron picker boards — the themed `/settings` and `/model` overlays styled to
+ * the "IndusCode Saffron · Settings · Config" design.
+ *
+ * The framework ships plain (un-themed) `SettingsDialog` / `ModelDialog`. These
+ * boards are the console's own theme-aware replacements for those two pickers: a
+ * saffron tab-pill header, a teal-bordered search box with a magnifier and a
+ * block caret, a two-column list whose values are tinted by kind (on/true →
+ * green, off/false → dim, everything else → teal), a windowed "↓ N more" hint,
+ * and a top-ruled footer of key hints. They reuse the framework's pure
+ * {@link matchesSearchQuery} / {@link wrapSelectionIndex} helpers (and the
+ * {@link SettingsDialogItem} shape) so only the *presentation* is re-authored,
+ * not the filter/navigation logic.
+ *
+ * All colour comes through the framework {@link InkThemeAdapter} the overlay
+ * group already holds, so the boards recolour with the active scheme; the one
+ * raw-hex touch is the chalk tab-pill (dark text on the accent fill), which has
+ * no theme role to resolve against.
+ */
+import { type InkThemeAdapter, type SettingsDialogItem } from "indusagi/react-ink";
+import type { Model } from "indusagi/ai";
+/** What the {@link SettingsBoard} renders. */
+export interface SettingsBoardProps {
+    /** The framework adapter that turns token roles into terminal colours. */
+    readonly theme: InkThemeAdapter;
+    /** The settings rows to present and cycle. */
+    readonly items: readonly SettingsDialogItem[];
+    /** Invoked when the board is dismissed. */
+    readonly onClose: () => void;
+}
+/**
+ * The saffron `/settings` board: a filterable, value-cycling settings list in the
+ * design's look. Up/Down move (wrapping), Left/Right or Enter cycle the value,
+ * typing filters, Ctrl+U clears, Esc closes.
+ */
+export declare function SettingsBoard({ theme, items, onClose }: SettingsBoardProps): JSX.Element;
+/** What the {@link ModelBoard} renders. */
+export interface ModelBoardProps {
+    /** The framework adapter that turns token roles into terminal colours. */
+    readonly theme: InkThemeAdapter;
+    /** The selectable models. */
+    readonly models: readonly Model<any>[];
+    /** Optional initial search query. */
+    readonly search?: string;
+    /** Invoked with the chosen model. */
+    readonly onSelect: (model: Model<any>) => void | Promise<void>;
+    /** Invoked when the board is dismissed. */
+    readonly onClose: () => void;
+}
+/**
+ * The saffron `/model` board: a filterable model list in the design's look.
+ * Up/Down move (wrapping), Enter selects, typing filters, Ctrl+U clears, Esc
+ * closes.
+ */
+export declare function ModelBoard({ theme, models, onClose, onSelect, search }: ModelBoardProps): JSX.Element;

package/dist/types/console/overlays/index.d.ts

@@ -12,4 +12,4 @@ export { PickerOverlays, type OverlayGroupProps } from "./pickers";
 export { SessionOverlays } from "./sessions";
 export { AuthOverlays } from "./auth";
 export { ApprovalOverlays, choiceFromId, readApprovalPayload, summarizeInput, APPROVAL_CHOICES, DISMISS_CHOICE, type ApprovalRequest, type ApprovalPayload, } from "./approval";
-export { approvalQueueReducer, activeApproval, EMPTY_APPROVAL_QUEUE, type ApprovalEntry, type ApprovalQueueState, type ApprovalQueueEvent, } from "./approval-queue";
+export { approvalQueueReducer, activeApproval, modeReleasesApprovals, EMPTY_APPROVAL_QUEUE, type ApprovalEntry, type ApprovalQueueState, type ApprovalQueueEvent, } from "./approval-queue";

package/dist/types/console/theme/adapter.d.ts

@@ -34,7 +34,7 @@ import type { InkThemeAdapter, ThemeTokens } from "../contract";
  *   accent          ← signal        (primary accent the components highlight in)
  *   borderMuted     ← quietFrame    (de-emphasised borders/separators)
  *   bashBorder      ← frame         (the bash-block border tone)
- *   userMessage     ← promptSurface (user-turn background tint)
+ *   userMessage     ← "" (no background, plain text)
  *   customMessage   ← cardAccent    (custom/plugin message background tint)
  *   success         ← affirm
  *   warning         ← caution

package/dist/types/console/theme/index.d.ts

@@ -12,7 +12,7 @@
  * Consumers import from `src/console/theme` and never reach into the individual
  * palette/tokens/adapter/resolve modules.
  */
-export { MIDNIGHT_PALETTE, DAYLIGHT_PALETTE, MIDNIGHT_CB_PALETTE, DAYLIGHT_CB_PALETTE, PALETTES, } from "./palette";
+export { SAFFRON_PALETTE, MIDNIGHT_PALETTE, DAYLIGHT_PALETTE, MIDNIGHT_CB_PALETTE, DAYLIGHT_CB_PALETTE, PALETTES, } from "./palette";
 export { deriveTokens } from "./tokens";
 export { themeAdapter, frameworkColors } from "./adapter";
 export { THEMES, THEME_SCHEMES, resolveTheme } from "./resolve";

package/dist/types/console/theme/palette.d.ts

@@ -33,6 +33,16 @@ export declare const MIDNIGHT_PALETTE: ThemePalette;
  * to a dark-on-light slate.
  */
 export declare const DAYLIGHT_PALETTE: ThemePalette;
+/**
+ * The "IndusCode Saffron" dark-terminal ramp — the brand scheme.
+ *
+ * The console's signature look: a warm saffron primary (borders, headings, the
+ * brand wordmark) against a cream neutral gradient, with a cool teal secondary
+ * for the interactive accents (the prompt caret, chips, bullets) — the two hues
+ * the IndusCode masthead is built from. The status hues stay warm-leaning so the
+ * whole scheme reads as one saffron identity rather than a recoloured midnight.
+ */
+export declare const SAFFRON_PALETTE: ThemePalette;
 /**
  * The dark-terminal color-blind-safe ramp.
  *

package/dist/types/launch/login.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Login command — `runLogin`.
+ *
+ * The top-level `login` / `logout` / `whoami` surface that authenticates the CLI
+ * against the indus-server so a user with **no local provider key** can still run
+ * model turns through the server gateway (the session token is vended as the
+ * provider key downstream — see `src/boot/runners/server-mode.ts`).
+ *
+ * `login` drives the OAuth 2.0 **device-authorization** flow (RFC 8628) against
+ * the server's better-auth endpoints under `${INDUS_SERVER_URL}/api/auth`:
+ *
+ *   1. POST `/api/auth/device/code` → a `user_code` + verification URL.
+ *   2. The user opens the URL in a browser and approves the device.
+ *   3. We poll POST `/api/auth/device/token` until it returns an `access_token`.
+ *   4. The token is persisted via {@link storeServerToken} (A1's token store).
+ *
+ * This is a **pre-pipeline router**, not a runner: a no-key user cannot build a
+ * session, so login must short-circuit before the stage pipeline. {@link runLogin}
+ * therefore mirrors `runCredential` in `boot.ts` — it owns the first positional
+ * token only and returns `undefined` (fall through to a normal launch) when that
+ * token is not one of its verbs.
+ *
+ * The app does not depend on `better-auth/client`, `open`, or a spinner library,
+ * so the device flow is implemented over raw `fetch` and the console is driven
+ * with `chalk` to match the rest of the launch surface. `--server-url` and
+ * `--client-id` are parsed from the argv tail here (the declarative flag table is
+ * for the launch invocation, not these auth-only verbs).
+ */
+import type { OAuthLoginCallbacks } from "indusagi/ai";
+import type { BootContext } from "../boot/contract";
+/**
+ * The sign-in directory id for the indus-server session (as opposed to a
+ * per-model-provider credential). Used by `src/launch/oauth.ts` to special-case
+ * this entry in `listLoginProviders` / `startOAuthLogin` so the interactive
+ * `/login` picker can drive the same device-authorization flow as the `indus
+ * login` CLI verb.
+ */
+export declare const SERVER_TIER_PROVIDER_ID = "indus-server";
+/**
+ * Drive the indus-server device-authorization flow through the framework's
+ * generic {@link OAuthLoginCallbacks} shape, so the interactive `/login` picker
+ * (`src/console/overlays/auth.tsx`'s `OAuthFlowDialog`) can establish a
+ * server-tier session the same way the `indus login` CLI verb does.
+ *
+ * Reuses the private {@link requestDeviceCode} / {@link pollForToken} helpers
+ * above rather than duplicating the request+poll sequence, and reports the
+ * verification URL / code through `callbacks.onAuth` exactly once, mirroring
+ * how `doLogin` renders them to the console. On success the token is persisted
+ * via {@link storeServerToken}; any thrown error (network failure, denial,
+ * expiry, timeout) propagates to the caller unchanged — `startOAuthLogin`'s
+ * caller (the dialog's try/catch) already renders a generic failure state.
+ *
+ * @param callbacks the framework's OAuth login callbacks (url + progress)
+ * @param serverUrl the indus-server base url (defaults to {@link INDUS_SERVER_URL})
+ * @param clientId  the device-flow client id (defaults to {@link INDUS_CLIENT_ID})
+ */
+export declare function runServerTierLogin(callbacks: OAuthLoginCallbacks, serverUrl?: string, clientId?: string): Promise<void>;
+/**
+ * Route a `login` / `logout` / `whoami` verb, if this invocation is one.
+ *
+ * Inspects `ctx.argv[0]`: returns a numeric exit code when it handled one of the
+ * auth verbs, or `undefined` when the leading token is something else so the
+ * caller falls through to a normal launch. Modeled on `runCredential` in
+ * `boot.ts`; `--server-url` / `--client-id` are parsed from the argv tail.
+ *
+ * @param ctx the seeded boot context (carries the raw argv)
+ */
+export declare function runLogin(ctx: BootContext): Promise<number | undefined>;

package/dist/types/launch/oauth.test.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `src/launch/oauth.ts` — unit tests for the indus-server bridge added to the
+ * merged sign-in directory and `startOAuthLogin`.
+ *
+ * Covers:
+ *   1. {@link listLoginProviders} includes the `indus-server` entry
+ *      (`SERVER_TIER_PROVIDER_ID`, `authKind: "oauth"`).
+ *   2. {@link startOAuthLogin} for `SERVER_TIER_PROVIDER_ID` drives the device
+ *      flow over a mocked `fetch`, reports `onAuth` exactly once with the right
+ *      shape, reports progress, never touches the vault, and resolves.
+ *   3. {@link startOAuthLogin} for an unregistered id still throws the
+ *      pre-existing "No browser sign-in is available" error (regression check).
+ *   4. A device/token failure (`access_denied`) propagates out of
+ *      `startOAuthLogin` unchanged rather than being swallowed.
+ *
+ * `storeServerToken` is mocked (partial mock of `../boot/server-token`) so the
+ * success-path test never touches the real `~/.indusagi/agent/server-token.json`
+ * file on the machine running the suite.
+ */
+export {};

package/dist/types/window-budget/summarize/condense.d.ts

@@ -38,6 +38,12 @@ export interface SummarizeDeps {
     readonly priorDigest?: string;
     /** Cancellation signal forwarded to the completer. */
     readonly signal?: AbortSignal;
+    /**
+     * Credential for the summarization model's provider, forwarded to the
+     * completer. Required in practice for sessions whose key is resolved
+     * per-call (server tier) rather than from an environment variable.
+     */
+    readonly apiKey?: string;
     /**
      * Optional cap on the digest size, in tokens, forwarded to the completer's
      * `maxTokens`. A modest ceiling keeps the summary itself from eating the