@quantiya/codevibe-claude-plugin 2.0.3 → 2.0.5

package/node_modules/@quantiya/codevibe-core/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/node_modules/@quantiya/codevibe-core/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/node_modules/@quantiya/codevibe-core/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/node_modules/@quantiya/codevibe-core/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/node_modules/@quantiya/codevibe-core/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/node_modules/@quantiya/codevibe-core/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/node_modules/@quantiya/codevibe-core/node_modules/@alcalzone/ansi-tokenize/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2026 AlCalzone
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@quantiya/codevibe-core/node_modules/@alcalzone/ansi-tokenize/README.md

@@ -0,0 +1,278 @@
+# @alcalzone/ansi-tokenize
+
+> Efficiently modify strings containing [ANSI escape codes](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors_and_Styles)
+
+If you find yourself modifying styled strings repeatedly, alternatives like [`slice-ansi`](https://github.com/chalk/slice-ansi/) may end up doing a lot of unnecessary work by re-parsing the string each time. This module provides a way to parse the string into an array of tokens (characters or ANSI codes), which can then be modified and re-serialized into a styled string.
+
+## Install
+
+```
+$ npm install @alcalzone/ansi-tokenize
+```
+
+## Usage
+
+### Tokenize a string
+
+```js
+import { tokenize } from "@alcalzone/ansi-tokenize";
+
+// red "foo", followed by unstyled "bar"
+const str = "\x1B[31mfoo\x1B[39mbar";
+const tokens = tokenize(str);
+
+// tokens will now look like this:
+[
+	{
+		type: "ansi",
+		code: "\x1B[31m",
+		endCode: "\x1B[39m",
+	},
+	{
+		type: "char",
+		value: "f",
+		fullWidth: false,
+	},
+	{
+		type: "char",
+		value: "o",
+		fullWidth: false,
+	},
+	{
+		type: "char",
+		value: "o",
+		fullWidth: false,
+	},
+	{
+		type: "ansi",
+		code: "\x1B[39m",
+		endCode: "\x1B[39m",
+	},
+	{
+		type: "char",
+		value: "b",
+		fullWidth: false,
+	},
+	{
+		type: "char",
+		value: "a",
+		fullWidth: false,
+	},
+	{
+		type: "char",
+		value: "r",
+		fullWidth: false,
+	},
+];
+```
+
+Each token is either a character
+
+```ts
+export interface Char {
+	type: "char";
+	value: string;
+	fullWidth: boolean;
+}
+```
+
+where
+
+-   `value` is the string representation of the character
+-   `fullWidth` is `true` if the character is full width (takes up 2 characters in monospace, like CJK characters)
+
+or an ANSI code
+
+```ts
+export interface AnsiCode {
+	type: "ansi";
+	code: string;
+	endCode: string;
+}
+```
+
+where
+
+-   `code` is the ANSI code that starts the style
+-   and `endCode` is the corresponding ANSI code that ends the style.
+
+An `AnsiCode` can also be an end code, in which case `code` and `endCode` will be the same.
+
+### Convert an array of tokens into an array of "styled" chars
+
+This representation is a 1:1 mapping of the original string, but not very useful for modifying the string. The `styledCharsFromTokens` function converts a token array to an array of characters, where each character has an all currently active styles associated with it:
+
+```ts
+export interface StyledChar {
+	type: "char";
+	value: string;
+	fullWidth: boolean;
+	styles: AnsiCode[];
+}
+```
+
+Using the above example:
+
+```js
+import { tokenize, styledCharsFromTokens } from "@alcalzone/ansi-tokenize";
+
+// red "foo", followed by unstyled "bar"
+const str = "\x1B[31mfoo\x1B[39mbar";
+const tokens = tokenize(str);
+
+const styledChars = styledCharsFromTokens(tokens);
+
+// styledChars will contain the following:
+[
+	{
+		type: "char",
+		value: "f",
+		fullWidth: false,
+		styles: [
+			{
+				type: "ansi",
+				code: "\x1B[31m",
+				endCode: "\x1B[39m",
+			},
+		],
+	},
+	{
+		type: "char",
+		value: "o",
+		fullWidth: false,
+		styles: [
+			{
+				type: "ansi",
+				code: "\x1B[31m",
+				endCode: "\x1B[39m",
+			},
+		],
+	},
+	{
+		type: "char",
+		value: "o",
+		fullWidth: false,
+		styles: [
+			{
+				type: "ansi",
+				code: "\x1B[31m",
+				endCode: "\x1B[39m",
+			},
+		],
+	},
+	{
+		type: "char",
+		value: "b",
+		fullWidth: false,
+		styles: [],
+	},
+	{
+		type: "char",
+		value: "a",
+		fullWidth: false,
+		styles: [],
+	},
+	{
+		type: "char",
+		value: "r",
+		fullWidth: false,
+		styles: [],
+	},
+];
+```
+
+### Modify an array of styled characters
+
+For modification simply edit the items in the array as necessary, as long as the following rules are followed:
+
+1. The `code` and `endCode` properties must match. You can use the `ansi-styles` module to do this.
+2. The `fullWidth` property must be correct. You can use the `is-fullwidth-code-point` module to do this, or if working with multiple strings, turn those into styled char arrays first.
+
+E.g. to make the first `o` blue and bold:
+
+```js
+import ansiStyles from "ansi-styles";
+
+// ... include the above code
+
+styledChars[1].styles = [
+	{
+		type: "ansi",
+		code: ansiStyles.blue.open,
+		endCode: ansiStyles.blue.close,
+	},
+	{
+		type: "ansi",
+		code: ansiStyles.bold.open,
+		endCode: ansiStyles.bold.close,
+	},
+];
+```
+
+### Serialize a styled character array back to a string
+
+The `styledCharsToString` function converts a styled character array back to a string:
+
+```js
+import { styledCharsToString } from "@alcalzone/ansi-tokenize";
+
+// ... include the above code
+
+const strOut = styledCharsToString(styledChars);
+
+// str will now be '\x1B[31mf\x1B[34m\x1B[1mo\x1B[22m\x1B[31mo\x1B[39mbar'
+```
+
+This automatically figures out the least amount of escape codes necessary to achieve the desired result, as long as the `styles` arrays contain no unnecessary styles, e.g. blue + red foreground.
+
+## Changelog
+
+<!--
+	Placeholder for next release:
+	### __WORK IN PROGRESS__
+-->
+### 0.3.0 (2026-02-20)
+
+-   Fix: preserve non-hyperlink OSC sequences when tokenizing (#54)
+-   Fix: support ST-terminated OSC hyperlinks (#53)
+
+### 0.2.5 (2026-02-11)
+
+-   Fix: preserve grapheme clusters when tokenizing (#51)
+
+### 0.2.4 (2026-01-29)
+
+-   Fix: Support hyperlinks with parameters (#45)
+
+### 0.2.3 (2026-01-02)
+
+-   Fix: Regression when rendering adjacent `dim` and `bold` styles (#43, #44)
+
+### 0.2.2 (2025-10-22)
+
+-   Fix: Support compound SGR sequences with multiple attributes (#39, #40)
+
+### 0.2.1 (2025-10-20)
+
+-   Fix: Prevent `dim` and `bold` modifiers from canceling each other (#37)
+
+### 0.2.0 (2025-04-24)
+
+-   Breaking: Require Node.js 18+
+-   Fix: Detect emojis as being full width
+
+### 0.1.3 (2023-09-07)
+
+-   Fix: Support links
+
+### 0.1.2 (2023-08-07)
+
+-   Fix: Reduce minimum Node.js version to `14.13.1`
+
+### 0.1.1 (2023-04-05)
+
+-   Fix: Active styles are now correctly reset at the end of the string
+
+### 0.1.0 (2023-03-20)
+
+Initial release

package/node_modules/@quantiya/codevibe-core/node_modules/@alcalzone/ansi-tokenize/build/ansiCodes.d.ts

@@ -0,0 +1,7 @@
+import type { AnsiCode } from "./tokenize.js";
+export declare const endCodesSet: Set<string>;
+export declare function getLinkStartCode(url: string, params?: Record<string, string>): string;
+export declare function getEndCode(code: string): string;
+export declare function ansiCodesToString(codes: AnsiCode[]): string;
+/** Check if a code is an intensity code (bold or dim) - these share endCode 22m but can coexist */
+export declare function isIntensityCode(code: AnsiCode): boolean;

package/node_modules/@quantiya/codevibe-core/node_modules/@alcalzone/ansi-tokenize/build/ansiCodes.js

@@ -0,0 +1,57 @@
+import ansiStyles from "ansi-styles";
+import { linkCodePrefix, linkCodeSuffix, linkEndCode, linkEndCodeC1ST, linkEndCodeST, } from "./consts.js";
+export const endCodesSet = new Set();
+const endCodesMap = new Map();
+for (const [start, end] of ansiStyles.codes) {
+    endCodesSet.add(ansiStyles.color.ansi(end));
+    endCodesMap.set(ansiStyles.color.ansi(start), ansiStyles.color.ansi(end));
+}
+export function getLinkStartCode(url, params) {
+    const paramsStr = params
+        ? Object.entries(params)
+            .map(([k, v]) => `${k}=${v}`)
+            .join(":")
+        : "";
+    return `${linkCodePrefix}${paramsStr};${url}${linkCodeSuffix}`;
+}
+export function getEndCode(code) {
+    if (endCodesSet.has(code))
+        return code;
+    if (endCodesMap.has(code))
+        return endCodesMap.get(code);
+    // We have a few special cases to handle here:
+    // Links:
+    if (code.startsWith(linkCodePrefix)) {
+        if (code.endsWith("\x1B\\"))
+            return linkEndCodeST;
+        if (code.endsWith("\x9C"))
+            return linkEndCodeC1ST;
+        return linkEndCode; // BEL (\x07)
+    }
+    code = code.slice(2);
+    // 8-bit/24-bit colors:
+    if (code.startsWith("38")) {
+        return ansiStyles.color.close;
+    }
+    else if (code.startsWith("48")) {
+        return ansiStyles.bgColor.close;
+    }
+    // Otherwise find the reset code in the ansi-styles map
+    const ret = ansiStyles.codes.get(parseInt(code, 10));
+    if (ret) {
+        return ansiStyles.color.ansi(ret);
+    }
+    else {
+        return ansiStyles.reset.open;
+    }
+}
+export function ansiCodesToString(codes) {
+    // Deduplicate ANSI code strings before joining
+    const deduplicated = new Set(codes.map((code) => code.code));
+    return [...deduplicated].join("");
+}
+/** Check if a code is an intensity code (bold or dim) - these share endCode 22m but can coexist */
+export function isIntensityCode(code) {
+    return code.code === ansiStyles.bold.open || code.code === ansiStyles.dim.open;
+}
+//# sourceMappingURL=ansiCodes.js.map

package/node_modules/@quantiya/codevibe-core/node_modules/@alcalzone/ansi-tokenize/build/ansiCodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ansiCodes.js","sourceRoot":"","sources":["../src/ansiCodes.ts"],"names":[],"mappings":"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"}