@quantiya/codevibe-core 2.0.4 → 2.0.6

package/dist/orchestration-shell/components/InputBar.d.ts

@@ -7,6 +7,73 @@ import type { SlashCommandInfo } from '../slash-router';
  * dropdown can be open (Stage-2 — keeps the dropdown from re-triggering #469).
  */
 export declare const DROPDOWN_MAX_ROWS: number;
+/**
+ * Single-width visible marker shown IN THE DISPLAY ONLY in place of a real
+ * newline. The value renders on ONE physical line (readline-style), so the real
+ * terminal cursor's row/column math is trivially single-line. The ACTUAL value
+ * keeps its real `\n` and is submitted verbatim — only the on-screen rendering
+ * single-lines. It is ONE code unit wide (like the chip `[`), so a cursor offset
+ * in the value maps 1:1 to a column in the display string (no caret drift).
+ *
+ * INTENTIONAL UX CHANGE (Hendry-approved, ink7 real-cursor fix): a multi-line
+ * (e.g. `\n`-bearing history-recall) value now shows inline on one row with the
+ * `⏎` marker + horizontal scroll, instead of wrapping to multiple rows. This is
+ * what makes the REAL terminal cursor land correctly in every terminal (the
+ * caret can no longer be on a wrapped/second row). Normal single-line typing —
+ * and the submitted value (newlines, chips) — are UNCHANGED.
+ */
+export declare const NEWLINE_MARKER = "\u23CE";
+/**
+ * Display form of a value: chip sentinels → `[` (displayChips) AND real newlines
+ * → the width-1 `NEWLINE_MARKER`. Both are 1:1 char substitutions, so
+ * `displayValue(v).length === v.length` and a cursor offset into the value indexes
+ * the same column in the display string.
+ */
+export declare function displayValue(v: string): string;
+/** Left border + left padding + prompt "❯ " width — the caret's x offset base. */
+export declare const CARET_X_BASE = 4;
+/** Top border row — the caret's y offset from the row Box's own top. */
+export declare const CARET_Y_BASE = 1;
+/**
+ * Pure caret-cell computation (unit-tested). `rowLeft`/`rowTop` are the input row
+ * Box's absolute top-left in Ink's dynamic output; `visibleCol` is the caret's
+ * ON-SCREEN column within the (single, horizontally-scrolled) value window
+ * (`caretDisplayCol − scroll`; see `computeInputWindow`). Returns the 0-based
+ * `{ x, y }` for `useCursor().setCursorPosition`. `y` is always one row (the
+ * value is one physical line).
+ */
+export declare function caretPosition(rowLeft: number, rowTop: number, visibleCol: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Result of windowing the single-line display string so the caret stays on-screen.
+ * `text` is the ≤`valueWidth`-wide slice to render (`…` overwrites any clipped
+ * edge); `visibleCol` is the caret's column WITHIN that slice (feeds
+ * `caretPosition`); `scroll` is the chosen left offset (kept in a ref for sticky
+ * readline-style scrolling).
+ */
+export interface InputWindow {
+    text: string;
+    visibleCol: number;
+    scroll: number;
+}
+/**
+ * Pure horizontal-scroll window for the single physical input line (unit-tested).
+ * `display` is the full display string (chips + newline-marker already applied, so
+ * its `.length` IS the display width, 1:1). `caretCol` is the logical caret column
+ * in `display` coords. `valueWidth` is the number of columns available for the
+ * value (= innerW − 2, where innerW = columns − border 2 − padX 2, and the `❯ `
+ * prompt takes the leading 2). `prevScroll` is the previous window offset (sticky).
+ *
+ * If everything fits (`display.length ≤ valueWidth`) the whole string shows with no
+ * scroll. Otherwise a `valueWidth`-wide window is slid over `display` so the caret
+ * is always visible — the previous scroll is only nudged when the caret crosses an
+ * edge (readline-style; the view does not jump). A `…` marks each clipped edge (a
+ * width-preserving overwrite of the boundary char — purely cosmetic; the real
+ * terminal cursor draws on top).
+ */
+export declare function computeInputWindow(display: string, caretCol: number, valueWidth: number, prevScroll: number): InputWindow;
 /**
  * Gate-prompt-aware input modes per PHASE-CP-8-MIN-DESIGN.md §7
  * + #C8M-5. `maxOption: number` (NOT a `2 | 5` literal union) per

package/dist/orchestration-shell/emit-shell-event.d.ts

@@ -4,7 +4,7 @@ import { AppSyncClient } from '../appsync';
  * the Stage A contract. CP-1.a ships the union; CP-1.b/c/d add call
  * sites for each emit type.
  */
-export type NewEventTypeKind = 'MODE_SELECTED' | 'PLANNER_DECISION' | 'PLANNER_CACHE_HIT' | 'PLANNER_DEGRADED' | 'PLANNER_OUTAGE' | 'PLANNER_RECOVERED' | 'SLASH_COMMAND_INVOKED' | 'STRUCTURAL_SUMMARY_GENERATED' | 'LOCAL_AUTHORITY_REFUSAL' | 'NOTIFICATION' | 'ASSISTANT_RESPONSE';
+export type NewEventTypeKind = 'MODE_SELECTED' | 'PLANNER_DECISION' | 'PLANNER_CACHE_HIT' | 'PLANNER_DEGRADED' | 'PLANNER_OUTAGE' | 'PLANNER_RECOVERED' | 'SLASH_COMMAND_INVOKED' | 'STRUCTURAL_SUMMARY_GENERATED' | 'LOCAL_AUTHORITY_REFUSAL' | 'NOTIFICATION' | 'ASSISTANT_RESPONSE' | 'USER_PROMPT';
 /**
  * §3 LOCK lines 160-170. ShellEventEmit contract.
  *

package/dist/orchestration-shell/index.d.ts

@@ -10,7 +10,7 @@ import { type RunAuditBrowserResult } from './audit-runner';
 import { Tier } from './types';
 import type { PendingClarification } from './types';
 import { type GatePromptEnvelope, type DecryptedReviewSummaryInput } from './gate-prompts';
-import type { Event } from '../types/events';
+import type { Event, UpdateEventStatusInput } from '../types/events';
 import { type StructuralSummaryGenerator } from '../structural-summary';
 import type { PlannerAdapter } from '../planner/adapter';
 import type { PlannerCacheLayer } from '../planner/cache';
@@ -272,6 +272,61 @@ export declare const TASK_REVIEW_SUMMARY_FETCH_TIMEOUT_MS = 5000;
  */
 export type ReviewSummaryFetcher = (taskId: string, gateId: string, sessionId: string) => Promise<DecryptedReviewSummaryInput | null>;
 export declare function handleSubscribedEvent(event: Event, store: OrchestrationStore, sessionKeyResolver?: (sessionId: string) => Promise<string | null>, reviewSummaryFetcher?: ReviewSummaryFetcher, maybeAutoContinue?: (envelope: GatePromptEnvelope) => boolean): void;
+/**
+ * Route a `USER_PROMPT` sent from the paired MOBILE companion into the shell's
+ * SERIALIZED submission pipeline so the planner processes it EXACTLY like a typed
+ * prompt (classify → decision → reply), and its reply mirrors back to the phone via
+ * `emitOrchestrationTurnMirror` (which suppresses the duplicate DESKTOP `USER_PROMPT`
+ * for a mobile-origin turn — see `skipUserPromptMirror`).
+ *
+ * Before this fix the shell subscribed to events but `handleSubscribedEvent` opened
+ * with a cheap `if (event.type !== 'INTERACTIVE_PROMPT') return;` pre-check, so a
+ * MOBILE `USER_PROMPT` ("Good morning") was delivered and silently DROPPED — the
+ * planner never saw it, the phone got no reply. This is the missing RETURN path
+ * (desktop→mobile mirroring already works via `emitOrchestrationTurnMirror`).
+ *
+ * CALLER CONTRACT — must pre-filter to `event.source === 'MOBILE' && event.type ===
+ * 'USER_PROMPT'`. The subscription runs with `receiveDesktopEvents:true`, so the
+ * shell's OWN Bug-A mirror emissions (DESKTOP `USER_PROMPT` / `ASSISTANT_RESPONSE`)
+ * are re-delivered here; feeding a DESKTOP echo back into `submit` would INFINITE-LOOP.
+ * Filtering to source===MOBILE (and only USER_PROMPT) is the anti-loop guard.
+ *
+ * The mobile `USER_PROMPT` content is E2E-encrypted (`isEncrypted:true`); decrypt it
+ * with the session key (the SAME resolver the non-gate prompt path uses) before
+ * submitting. Fail-soft: a missing resolver/key, a decrypt failure, or empty text logs
+ * and DROPS (never crashes the shell, never submits ciphertext). Async — the sync
+ * subscription callback fires-and-forgets via `void`; every throw is caught here.
+ */
+export declare function routeMobileUserPrompt(event: Event, sessionKeyResolver: ((sessionId: string) => Promise<string | null>) | undefined, submit: (text: string, images?: string[], options?: ShellSubmitOptions) => Promise<void>, updateEventStatus?: (input: UpdateEventStatusInput) => Promise<unknown>): Promise<void>;
+/**
+ * Build the single `(event) => void` callback the AppSync events subscription
+ * invokes. Routes each delivered event to exactly ONE handler:
+ *
+ *   - MOBILE-source `USER_PROMPT` → `routeMobileUserPrompt` (the mobile→desktop RETURN
+ *     path: decrypt + feed into the serialized submission pipeline). STRICT filter —
+ *     see the anti-loop note below.
+ *   - Everything else → `handleSubscribedEvent` (gate escalation / final-approval /
+ *     continuation-handoff INTERACTIVE_PROMPTs + the agent's own AskUserQuestion).
+ *
+ * ANTI-LOOP (CRITICAL): the subscription runs with `receiveDesktopEvents:true`, so the
+ * shell's OWN Bug-A turn-mirror rows (DESKTOP `USER_PROMPT` + `ASSISTANT_RESPONSE`) are
+ * re-delivered here. The mobile branch fires ONLY for `source === 'MOBILE' && type ===
+ * 'USER_PROMPT'`, so a DESKTOP echo NEVER re-enters `submit` (which would infinite-loop);
+ * it falls through to `handleSubscribedEvent`, whose `type !== 'INTERACTIVE_PROMPT'`
+ * pre-check drops it (and `ASSISTANT_RESPONSE`/`MODE_SELECTED`/`NOTIFICATION`) unchanged.
+ *
+ * Extracted (vs an inline closure) so the routing decision is unit-testable in isolation.
+ * `submit` is passed as a thunk by the caller so the forward reference to the
+ * later-declared `handleUserInput` is only read at event time, never at setup.
+ */
+export declare function createSubscribedEventDispatcher(deps: {
+    store: OrchestrationStore;
+    submit: (text: string, images?: string[], options?: ShellSubmitOptions) => Promise<void>;
+    sessionKeyResolver?: (sessionId: string) => Promise<string | null>;
+    reviewSummaryFetcher?: ReviewSummaryFetcher;
+    maybeAutoContinue?: (envelope: GatePromptEnvelope) => boolean;
+    updateEventStatus?: (input: UpdateEventStatusInput) => Promise<unknown>;
+}): (event: Event) => void;
 /**
  * Route ONE team-mode LE shell event into the store's minimal `team` state.
  * The W2.b `emitTrackProgress` emits a NOTIFICATION carrying
@@ -631,7 +686,21 @@ export interface HandleShellUserInputDeps extends StructuralSummaryRunDeps {
  * real result/rejection), while the internal queue swallows rejections so one
  * failed turn can't break serialization for later submissions.
  */
-export declare function serializeShellSubmissions(handler: (text: string, images?: string[]) => Promise<void>): (text: string, images?: string[]) => Promise<void>;
+/**
+ * Options threaded through a shell submission so the turn handler + the companion
+ * mirror can distinguish a mobile-origin turn from a keyboard turn.
+ */
+export interface ShellSubmitOptions {
+    /**
+     * The submission originated from the paired MOBILE companion (the mobile→desktop
+     * RETURN path). The turn mirror (`emitOrchestrationTurnMirror`) must NOT re-emit a
+     * DESKTOP `USER_PROMPT` for this turn — the phone already displays its own sent
+     * message — but MUST still mirror the `ASSISTANT_RESPONSE`. Absent/false ⇒ a normal
+     * keyboard turn (both `USER_PROMPT` + `ASSISTANT_RESPONSE` mirror as today).
+     */
+    fromMobile?: boolean;
+}
+export declare function serializeShellSubmissions(handler: (text: string, images?: string[], options?: ShellSubmitOptions) => Promise<void>): (text: string, images?: string[], options?: ShellSubmitOptions) => Promise<void>;
 /**
  * Process one shell submission (slash command or natural-language → planner).
  *
@@ -668,6 +737,54 @@ export declare function buildContinuationActionDeps(args: RunOrchestrationShellA
  */
 export declare function detectBrowseFastPath(text: string, pending: PendingClarification | null): string[] | null;
 export declare function handleShellUserInput(deps: HandleShellUserInputDeps): Promise<void>;
+/**
+ * COMPANION-MIRROR (dogfood 2026-07-05) — mirror ONE just-completed conversational
+ * (natural-language) turn to the backend so the paired mobile companion can SEE the
+ * orchestration chat.
+ *
+ * The orchestration shell previously emitted only MODE_SELECTED (+ NOTIFICATION
+ * audits + the team-result ASSISTANT_RESPONSE) to the backend — a plain `"hi"` →
+ * planner-greeting turn produced NO `USER_PROMPT` / `ASSISTANT_RESPONSE`, so the phone
+ * showed nothing for conversational turns. This mirrors, per turn, via the SAME
+ * cohort-gated + E2E-encrypted `emitShellEvent` chokepoint MODE_SELECTED uses:
+ *   - USER_PROMPT        — the user's submitted text (this turn's `user-message` entry)
+ *   - ASSISTANT_RESPONSE — the planner/shell conversational reply rendered this turn
+ *
+ * Scope = CONVERSATIONAL (NON-team) turns:
+ *   - No `user-message` appended this turn (slash command / empty input) ⇒ nothing to
+ *     mirror (return early — slash commands already emit their own SLASH_COMMAND_INVOKED).
+ *   - This turn was a `start_task` / `team_decompose` decision ⇒ the reply is OWNED by
+ *     the team-result path (`emitGroupConvergence` → `leEmitShellEvent`, which emits its
+ *     OWN ASSISTANT_RESPONSE when the team converges — cli.ts `mapTeamLeEventToShellEmit`).
+ *     We emit ONLY the USER_PROMPT and leave the reply to that path — NO double-emit.
+ *     The reducer ALWAYS appends a (TUI-hidden) `planner-decision` entry, so the delta
+ *     carries the action even though the team launch's TASK_LIFECYCLE may land async.
+ *
+ * Ordering: USER_PROMPT carries the turn-start timestamp and ASSISTANT_RESPONSE a
+ * later `new Date()` (classify took real time), so the companion's (timestamp,id) sort
+ * renders prompt-before-reply.
+ *
+ * Fail-soft: an emit throw is logged, never fatal to the shell — matching the sibling
+ * MODE_SELECTED emit. The stub-session refusal + cohort gate + no-session-key
+ * fail-closed all live INSIDE `emitShellEvent`; we route through it (never bypass it)
+ * and pass PLAINTEXT `content` (the chokepoint encrypts under the session key).
+ */
+export declare function emitOrchestrationTurnMirror(deps: {
+    store: OrchestrationStore;
+    sessionId: string;
+    emitShellEventBound: ReturnType<typeof createShellEventEmitter>;
+    /** Conversation length captured BEFORE this turn ran (the delta baseline). */
+    convLenBefore: number;
+    /** RFC3339 timestamp captured at turn start — the USER_PROMPT event time. */
+    userTurnTimestamp: string;
+    /**
+     * MOBILE→DESKTOP RETURN PATH — this turn originated from the paired MOBILE companion,
+     * so the phone ALREADY displays its own sent message. Skip the DESKTOP `USER_PROMPT`
+     * mirror (it would duplicate on the phone) but STILL emit the `ASSISTANT_RESPONSE` so
+     * the planner's reply reaches mobile. Absent/false ⇒ a keyboard turn (mirror both).
+     */
+    skipUserPromptMirror?: boolean;
+}): Promise<void>;
 /**
  * CP-4 §4.2 (Codex r1 M1 — the double-walk unify) — the SINGLE structural-
  * summary refresh entry point. Drives the context store via

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

@@ -2,7 +2,11 @@ interface InkExports {
     Box: any;
     Text: any;
     Static: any;
-    render: (tree: any) => {
+    render: (tree: any, options?: {
+        stdout?: any;
+        stdin?: any;
+        stderr?: any;
+    }) => {
         waitUntilExit(): Promise<void>;
         unmount(): void;
     };
@@ -12,6 +16,12 @@ interface InkExports {
     useInput: (handler: (input: string, key: any) => void, options?: {
         isActive?: boolean;
     }) => void;
+    useCursor: () => {
+        setCursorPosition: (position: {
+            x: number;
+            y: number;
+        } | undefined) => void;
+    };
     useStdin: () => {
         stdin: any;
         setRawMode: (raw: boolean) => void;

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

@@ -20,23 +20,19 @@ export interface ParsedModeArgs {
  * 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`.
+ * §2 LOCK lines 80-99. Decision function — Pro/Max always resolve via an
+ * interactive prompt (`deps.promptUserForMode`); no sticky preference is
+ * read or written here.
  *
  * 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.
+ *   4. Pro/Max (no flag) → always prompt the user (sticky preference is
+ *      never consulted; the answer is not persisted).
  */
 export declare function pickMode(args: ParsedModeArgs, tier: Tier, deps?: ModeSelectionDeps): Promise<Mode>;
 /**

package/dist/types/session.d.ts

@@ -13,7 +13,8 @@ export declare enum SessionStatus {
 export declare enum AgentType {
     CLAUDE = "CLAUDE",
     GEMINI = "GEMINI",
-    CODEX = "CODEX"
+    CODEX = "CODEX",
+    CODEVIBE = "CODEVIBE"
 }
 /**
  * Session type

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "Core library for CodeVibe plugins - shared keychain, crypto, AppSync, and auth functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,13 +28,14 @@
     "@iarna/toml": "^2.2.5",
     "@npmcli/package-json": "^5.2.1",
     "gradient-string": "^3.0.0",
-    "ink": "5.2.1",
+    "ink": "7.1.0",
     "ink-select-input": "^6.2.0",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
     "json-freeze": "^1.0.0",
     "parse5": "^7.3.0",
-    "react": "^18.3.1",
+    "react": "^19.2.0",
+    "react-devtools-core": "^6.1.2",
     "ulid": "^3.0.0",
     "uuid": "^9.0.0",
     "ws": "^8.14.0",
@@ -47,7 +48,7 @@
   "devDependencies": {
     "@types/gradient-string": "^1.1.6",
     "@types/node": "^20.0.0",
-    "@types/react": "^18.3.0",
+    "@types/react": "^19.2.0",
     "@types/uuid": "^9.0.0",
     "@types/ws": "^8.5.0",
     "esbuild": "^0.28.0",
@@ -56,7 +57,7 @@
     "vitest": "^1.6.1"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.0.0"
   },
   "author": "Quantiya",
   "license": "MIT",