@quantiya/codevibe-core 2.0.0 → 2.0.2

package/dist/orchestration-shell/ink-runtime.d.ts

@@ -0,0 +1,84 @@
+interface InkExports {
+    Box: any;
+    Text: any;
+    Static: any;
+    render: (tree: any) => {
+        waitUntilExit(): Promise<void>;
+        unmount(): void;
+    };
+    useApp: () => {
+        exit: (err?: Error) => void;
+    };
+    useInput: (handler: (input: string, key: any) => void, options?: {
+        isActive?: boolean;
+    }) => void;
+    useStdin: () => {
+        stdin: any;
+        setRawMode: (raw: boolean) => void;
+        isRawModeSupported: boolean;
+        internal_eventEmitter?: import('node:events').EventEmitter;
+    };
+    useStdout: () => {
+        stdout: {
+            columns?: number;
+            rows?: number;
+            isTTY?: boolean;
+            writable?: boolean;
+            write?: (s: string) => unknown;
+        };
+    };
+}
+interface InkTextInputExports {
+    default: any;
+}
+interface InkSpinnerExports {
+    default: any;
+}
+interface InkSelectInputExports {
+    default: any;
+}
+interface GradientStringExports {
+    default: (colors: string[] | string) => (s: string) => string;
+}
+interface InkRuntime {
+    ink: InkExports;
+    inkTextInput: InkTextInputExports;
+    inkSpinner: InkSpinnerExports;
+    inkSelectInput: InkSelectInputExports;
+    gradientString: GradientStringExports;
+}
+/**
+ * Test seam — replace the ESM loader (e.g., for Vitest, which gets
+ * the dynamic-import error via the VM).
+ */
+export declare function __setEsmLoaderForTest(loader: <T>(name: string) => Promise<T>): void;
+/**
+ * Resets the ESM loader to the production default.
+ */
+export declare function __resetEsmLoaderForTest(): void;
+/**
+ * Generic ESM-only module loader, routed through the same test seam as the ink
+ * runtime so a single audited site bypasses TS's `module: commonjs` import→require
+ * rewrite (see the trampoline comment above). Exported so other CJS modules that need
+ * an ESM-only dependency (e.g. `parse5` in `web/extract.ts`) load it the same way and
+ * honor `__setEsmLoaderForTest`/`__resetEsmLoaderForTest`.
+ */
+export declare function loadEsm<T>(name: string): Promise<T>;
+/**
+ * Loads the ESM-only ink packages. Idempotent — second call returns
+ * the cached runtime. Throws if any package fails to load.
+ */
+export declare function initInkRuntime(): Promise<InkRuntime>;
+/**
+ * Synchronous accessor. Components call this AFTER the entrypoint
+ * `await initInkRuntime()` succeeds. Throws if ink isn't loaded — that
+ * indicates a programming error in the entrypoint sequencing.
+ */
+export declare function getInkRuntime(): InkRuntime;
+/**
+ * Test seam — lets the unit tests inject a fake runtime so component
+ * tests can render without launching real terminals. Production code
+ * never calls this.
+ */
+export declare function __setInkRuntimeForTest(rt: InkRuntime | null): void;
+export {};

package/dist/orchestration-shell/live-region-cap.d.ts

@@ -0,0 +1,70 @@
+import { ConversationEntry } from './types';
+/**
+ * DEFAULT rows reserved below the live `<ConversationPane>` for the rest of the
+ * chrome: the spinner line (1) + the input bar (~2) + the status bar (1) + the
+ * multi-track status node (~3) + a margin. Conservative on purpose — better to
+ * keep the live region a row or two shorter than the terminal than to risk the
+ * `outputHeight >= rows` reprint path.
+ *
+ * This is the FALLBACK for callers that don't pass a precise reserve.
+ * `<OrchestrationApp>` passes an EXACT reserve via `capLiveEntries(…, reserved)`,
+ * growing it by the bordered `MultiTrackStatusNode`'s real footprint when a team
+ * is mounted (Stage-1 r1 LOW: a 2-track bordered node is ~6 rows, exceeding the
+ * static ~3 budgeted here) — see `OrchestrationApp.tsx`.
+ */
+export declare const RESERVED_ROWS = 8;
+/** Floor on the live-region budget so a very short terminal still shows
+ * something (and the active gate control is never starved). */
+export declare const MIN_LIVE_ROWS = 6;
+/**
+ * Conservative per-entry rendered-line estimate. Over-estimating is safe (keeps
+ * the live region shorter); under-estimating risks the reprint path, so these
+ * lean high.
+ *   - `gate-prompt`         → [#469 gate-pin] the bordered PINNED gate card.
+ *                             `GatePromptEntry` truncates each option's server
+ *                             description to the render width, so every option
+ *                             renders on EXACTLY one row — this is therefore an
+ *                             EXACT height, not a heuristic: round border (2) +
+ *                             header (1) + status (1) + one row per option while
+ *                             unresolved + a queue row (if buffered) + the
+ *                             reply-hint row while awaiting a number. Resolved:
+ *                             options + hint drop (the record migrates to
+ *                             <Static>) → border(2) + header + status = 4 (+ a
+ *                             queue row if buffered). NB header/status/hint are
+ *                             short fixed-vocab strings (the header's variable
+ *                             halt-reason is itself truncated to fit) → 1 row on
+ *                             any terminal ≳ ~50 cols; on a narrower terminal the
+ *                             gate is still force-kept (the documented overflow
+ *                             exception — #469's "can't guarantee width" stance).
+ *   - `reviewer-status-node`→ 2 + one row per seat
+ *   - `gate-status-node`    → 3
+ *   - `gate-panel`          → never appears here (it is final → <Static>)
+ *   - default               → 2
+ */
+export declare function estimateEntryLines(entry: ConversationEntry): number;
+export interface CapLiveEntriesResult {
+    /** The kept entries, in their ORIGINAL order. */
+    rendered: ConversationEntry[];
+    /** How many entries were dropped off the head (oldest) to fit the budget. */
+    hiddenCount: number;
+}
+/**
+ * Cap the live entries so the live `<ConversationPane>` never makes Ink's
+ * dynamic `outputHeight >= terminalRows`.
+ *
+ * Algorithm:
+ *   budget = max(terminalRows - reservedRows, MIN_LIVE_ROWS)
+ *   Walk from the TAIL, summing `estimateEntryLines`; keep an entry while the
+ *   running sum ≤ budget; stop at the first entry that would exceed it. Return
+ *   the kept entries in original order + the dropped count.
+ *
+ * `reservedRows` defaults to {@link RESERVED_ROWS}; the caller SHOULD pass the
+ * exact below-pane chrome height (the precise reserve grows with the mounted
+ * MultiTrackStatusNode when a team is active — see `OrchestrationApp.tsx`).
+ *
+ * INVARIANT: the tail-most `kind:'gate-prompt'` entry (the active control) is
+ * ALWAYS kept, even if it alone exceeds the budget — it is the user's only way
+ * to resolve the gate. If it sits below the tail-budget cut, it is force-kept
+ * and counted as kept (NOT hidden).
+ */
+export declare function capLiveEntries(entries: ConversationEntry[], terminalRows: number, reservedRows?: number): CapLiveEntriesResult;

package/dist/orchestration-shell/live-static-order.d.ts

@@ -0,0 +1,22 @@
+import { ConversationEntry } from './types';
+/**
+ * Append-only accumulator of finalized static items, in finalization order.
+ * `ids` is the membership guard; `items` is the append-only, never-shrinking
+ * array handed (after the logo) to `<Static>`. Generic over the rendered item
+ * type so this module stays React-free.
+ */
+export interface StaticOrderAccum<T> {
+    readonly ids: Set<string>;
+    readonly items: T[];
+}
+/** Fresh empty accumulator (call once; persist across renders via a ref). */
+export declare function makeStaticOrderAccum<T>(): StaticOrderAccum<T>;
+/**
+ * For each entry that is `final` and not yet recorded, BUILD its item ONCE (the
+ * entry is guaranteed present THIS call) and append it — in conversation order
+ * among the new ones, which equals finalization order. Idempotent: an id already
+ * recorded is skipped, so repeat calls never duplicate, reorder, or shrink
+ * `items`. `items` is owned here and is independent of any later trimming of
+ * `conversation`.
+ */
+export declare function appendNewlyFinal<T>(accum: StaticOrderAccum<T>, conversation: ReadonlyArray<ConversationEntry>, build: (entry: ConversationEntry) => T): void;

package/dist/orchestration-shell/mode-selection.d.ts

@@ -0,0 +1,46 @@
+import { Mode, Tier } from './types';
+/**
+ * Thrown when a Free-tier user explicitly requests `--mode orchestration`.
+ * Per §2 + §16 LOCK #1: Orchestration Mode is Pro/Max-gated; Free-tier
+ * users hit this error with the upgrade URL.
+ */
+export declare class TierError extends Error {
+    constructor(message: string);
+}
+/**
+ * Parsed arguments the entrypoint hands to `pickMode`. Either flag is
+ * optional; a value of `undefined` means "not specified".
+ */
+export interface ParsedModeArgs {
+    /** `--mode companion` | `--mode orchestration` | undefined */
+    mode?: Mode;
+}
+/**
+ * Test seam — lets the unit tests inject a deterministic prompt
+ * callback instead of opening a real TTY.
+ */
+export interface ModeSelectionDeps {
+    readStickyPreference: (tier: Tier) => Promise<Mode | null>;
+    writeStickyPreference: (args: {
+        mode: Mode;
+        pickedByTier: 'PRO' | 'MAX';
+    }) => Promise<void>;
+    promptUserForMode: (tier: 'PRO' | 'MAX') => Promise<Mode>;
+}
+/**
+ * §2 LOCK lines 80-99. Pure decision function — only filesystem I/O is
+ * the sticky-preference read via `deps.readStickyPreference`.
+ *
+ * Rules:
+ *   1. Free-tier + `--mode orchestration` → `TierError` with upgrade URL.
+ *   2. Explicit `--mode` flag → honor it.
+ *   3. Free-tier (no flag) → 'companion'.
+ *   4. Pro/Max (no flag) + sticky present → sticky mode.
+ *   5. Pro/Max (no flag) + no sticky → prompt user; write sticky after pick.
+ */
+export declare function pickMode(args: ParsedModeArgs, tier: Tier, deps?: ModeSelectionDeps): Promise<Mode>;
+/**
+ * Default deps wiring — production callers can omit `deps` from
+ * `pickMode()` and get this. Tests override via the optional 3rd arg.
+ */
+export declare function defaultDeps(): ModeSelectionDeps;

package/dist/orchestration-shell/non-tty-fallback.d.ts

@@ -0,0 +1,67 @@
+import { OrchestrationStore } from './store';
+import { ConversationEntry } from './types';
+export interface RunLineLogFallbackArgs {
+    store: OrchestrationStore;
+    /** CP-1.b PlannerAdapter; CP-1.a passes a stub or `undefined`. */
+    plannerClient?: unknown;
+    /** CP-1.b cache layer; CP-1.a passes a stub or `undefined`. */
+    cacheLayer?: unknown;
+    /** CP-1.b health machine; CP-1.a passes a stub or `undefined`. */
+    healthMachine?: unknown;
+    /** CP-1.c executor; CP-1.a passes a stub or `undefined`. */
+    executor?: unknown;
+    /** Optional override for input — defaults to `process.stdin`. */
+    input?: NodeJS.ReadableStream;
+    /** Optional override for output — defaults to `process.stdout`. */
+    output?: NodeJS.WritableStream;
+    /** Optional onUserInput handler (host wires this to the slash router / planner classifier). */
+    onUserInput?: (text: string) => Promise<void> | void;
+    /**
+     * Audited-path fix (Fix 8) — gate-resolution interceptor. When an unresolved
+     * gate-prompt is active, a typed line that resolves it MUST go through the
+     * SAME decision-submit path the TTY uses, NOT the planner. The host wires this
+     * to `routeGatePromptInput` (the shared module). It is called BEFORE
+     * `onUserInput`; when it returns `{ handled: true }` the line was consumed by
+     * gate resolution and is NOT forwarded to the planner. ABSENT (CP-1.a callers /
+     * non-loop sessions) → every line goes to `onUserInput` (legacy behavior).
+     */
+    resolveGateInput?: (text: string) => Promise<{
+        handled: boolean;
+    }>;
+    /**
+     * CP-1.b IMPL r4 H-3 — Optional abort signal so the surrounding
+     * shell can break the readline loop on SIGINT/SIGTERM. Aborting
+     * triggers a clean rl.close() so the awaiting promise resolves.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Whether the internal planner-classification entry (`[planner] <action>:
+ * <rationale>` / the TTY "Planner classified …" node) is shown to the user.
+ * OFF by default — it's internal mechanics that duplicate the actual response /
+ * clarification the user already sees, and leaks taxonomy jargon ("classify").
+ * Opt in with `CODEVIBE_PLANNER_DEBUG=1` when debugging the planner. The entry is
+ * ALWAYS kept in conversation state (audit / logic / tests) — only the VIEW is gated.
+ */
+export declare function plannerDecisionRenderEnabled(env?: NodeJS.ProcessEnv): boolean;
+/**
+ * Renders a single `ConversationEntry` as a line-prefixed text string.
+ * Strict text only — no ANSI escapes, no colors, no `\r` rewrites.
+ */
+export declare function renderEntryAsLine(entry: ConversationEntry): string;
+/**
+ * Subscribes to the store and prints new conversation entries as
+ * line-prefixed text. Returns a promise that resolves on `EXIT` action
+ * (currently inferred by the store-state being a re-emission of the
+ * same state object after `EXIT` dispatch — the runner uses an
+ * `exitRequested` flag toggled by an external dispatch wrapper).
+ *
+ * CP-1.a ships the basic line-log + stdin readline loop; CP-1.b/c
+ * additional knobs (plannerClient, cacheLayer, executor) are accepted
+ * as optional args but ignored. The runner exits on:
+ *   - The host's onUserInput throwing (propagated).
+ *   - stdin closing (EOF).
+ *   - `/quit` slash command (the host detects via the SLASH_OUTPUT
+ *     action's sideEffect — the host wires `exitRequested` here).
+ */
+export declare function runLineLogFallback(args: RunLineLogFallbackArgs): Promise<void>;

package/dist/orchestration-shell/process-markers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The three baseline markers every subprocess inherits. `CODEVIBE_PROCESS_ROLE`
+ * defaults to `'implementor'`; per-subprocess role overrides via
+ * `withRoleMarker()`.
+ */
+export declare function processMarkers(): Record<string, string>;
+/**
+ * Returns `base` with `CODEVIBE_PROCESS_ROLE` overridden to `role`.
+ * CP-1.c will call this per-spawn (e.g., reviewer spawns set role to
+ * `'reviewer'`; planner-health probes to `'health_probe'`).
+ */
+export declare function withRoleMarker(base: Record<string, string>, role: 'implementor' | 'reviewer' | 'health_probe' | 'auth_probe' | 'model_probe'): Record<string, string>;