@quantiya/codevibe-core 2.0.1 → 2.0.3

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

@@ -9,11 +9,23 @@ interface InkExports {
     useApp: () => {
         exit: (err?: Error) => void;
     };
-    useInput: (handler: (input: string, key: any) => void) => 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 {
@@ -44,6 +56,14 @@ export declare function __setEsmLoaderForTest(loader: <T>(name: string) => Promi
  * 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.

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/non-tty-fallback.d.ts

@@ -16,6 +16,18 @@ export interface RunLineLogFallbackArgs {
     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
@@ -23,6 +35,15 @@ export interface RunLineLogFallbackArgs {
      */
     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.