@quantiya/codevibe-codex-plugin 2.0.51 → 2.0.53

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/components/OrchestrationApp.d.ts

@@ -36,6 +36,7 @@ export interface OrchestrationAppProps {
      */
     plannerRuntimeKind?: PlannerRuntimeKind;
     plannerLabel?: string;
+    plannerAdapter?: unknown;
     /**
      * TUI redesign (2026-06-29) — the PLAINTEXT cwd for the status bar, threaded
      * from the shell entry (process.cwd()). Sourced here rather than from

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/doctor-cli.d.ts

@@ -1,3 +1,4 @@
+import { type ShadowEnv } from '../local-executor/shadow-protocol';
 interface RegisteredRoot {
     path: string;
     dev?: string;
@@ -21,6 +22,72 @@ export interface RootDiagnosis {
     markers: string[];
     verdict: 'healthy' | 'reconcilable' | 'bytes-may-exist' | 'unknown';
 }
+export interface AgentCliStatus {
+    agent: 'CLAUDE' | 'CODEX' | 'ANTIGRAVITY';
+    command: string;
+    name: string;
+    installed: boolean;
+    version?: string;
+    binPath?: string;
+    error?: string;
+}
+export interface AuthPreflightStatus {
+    authenticated: boolean;
+    email?: string;
+    userId?: string;
+    expiresAt?: string;
+    tokenExpired: boolean;
+    deviceIdentityPresent: boolean;
+    deviceIdentityId?: string;
+    deviceIdentityError?: string;
+    vendorKeys: {
+        anthropic: boolean;
+        openai: boolean;
+        custodyBackend?: string;
+    };
+    error?: string;
+}
+export interface ConnectivityPreflightStatus {
+    appsyncReachable: boolean;
+    appsyncUrl: string;
+    latencyMs?: number;
+    error?: string;
+}
+export interface OrphanPreflightStatus {
+    deadProcessOwnersCount: number;
+    orphanedShadowCount: number;
+    retainedStateDiagnostics?: string[];
+    error?: string;
+}
+export interface DoctorCliOpts {
+    stateRoot?: string;
+    ownerRoot?: string;
+    skipPreflight?: boolean;
+    detectAgentsFn?: () => Promise<AgentCliStatus[]> | AgentCliStatus[];
+    authStatusFn?: () => Promise<AuthPreflightStatus>;
+    connectivityFn?: (url: string) => Promise<ConnectivityPreflightStatus>;
+    orphanProbeFn?: (stateRoot: string) => Promise<OrphanPreflightStatus>;
+    reapShadowsFn?: (keepTaskIds?: ReadonlySet<string>, env?: ShadowEnv) => Promise<{
+        reaped: string[];
+        retained: string[];
+    }>;
+    reapProcessOwnersFn?: () => Promise<{
+        reaped: number;
+        retained: number;
+    }>;
+    refreshTokenFn?: () => Promise<boolean>;
+}
+export declare function probeAgentClis(env?: NodeJS.ProcessEnv): AgentCliStatus[];
+export declare function probeAuthPreflight(): Promise<AuthPreflightStatus>;
+export declare function probeBackendConnectivity(appsyncUrl: string): Promise<ConnectivityPreflightStatus>;
+/**
+ * Derives the process-owner registry root without string surgery on stateRoot (N10).
+ * Uses opts.ownerRoot if given; falls back to parent of opts.stateRoot only when an explicit
+ * stateRoot was passed; otherwise uses canonical product accessor processOwnerRoot().
+ */
+export declare function resolveOwnerRoot(opts?: DoctorCliOpts, stateRoot?: string): string;
+export declare function probeOrphanStatus(stateRoot: string, ownerRootOverride?: string, shadowRootOverride?: string): Promise<OrphanPreflightStatus>;
+export declare function renderPreflight(agents: AgentCliStatus[], auth: AuthPreflightStatus, connectivity: ConnectivityPreflightStatus, orphans: OrphanPreflightStatus): void;
 /** The product's own state root — never a second spelling of it (Stage 1 F7). */
 export declare function shadowStateRoot(): string;
 /** Read the registry. A missing or unreadable registry is reported, never repaired. */
@@ -38,7 +105,16 @@ export declare function collectMarkers(stateRoot: string): Map<string, string[]>
  */
 export declare function inodeSurvivesInParent(root: RegisteredRoot): boolean | undefined;
 export declare function diagnose(stateRoot: string, roots: RegisteredRoot[]): RootDiagnosis[];
-export declare function runDoctorCli(argv: string[], opts?: {
-    stateRoot?: string;
-}): Promise<number>;
+export interface RepairOutcome {
+    pruneAttempted: boolean;
+    pruneSuccess: boolean;
+    pruneCount: number;
+    pruneError?: string;
+    refreshAttempted: boolean;
+    refreshSuccess: boolean;
+    refreshError?: string;
+}
+export declare function renderRepairPlan(orphans: OrphanPreflightStatus, auth: AuthPreflightStatus): boolean;
+export declare function performOrphanAndAuthRepairs(opts: DoctorCliOpts, stateRoot: string, orphans: OrphanPreflightStatus, auth: AuthPreflightStatus): Promise<RepairOutcome>;
+export declare function runDoctorCli(argv: string[], opts?: DoctorCliOpts): Promise<number>;
 export {};

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/emit-shell-event.d.ts

@@ -33,6 +33,8 @@ export interface ShellEventEmit {
     timestamp?: string;
     /** Pre-minted nonce when encrypted metadata must bind the response nonce. */
     writerEventNonce?: string;
+    /** Idempotency key for receiving boundary deduplication in DynamoDB (R5-F2). */
+    clientEventId?: string;
     /** P16/P20 encrypted terminal-result authority. All four fields are atomic. */
     writerEventKind?: 'WORKSPACE_OUTCOME';
     writerSessionGenerationId?: string;

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/index.d.ts

@@ -144,7 +144,8 @@ export interface RunOrchestrationShellArgs {
      * planner semantics. `local_gemma_qat` means natural-language decisions came
      * from the local runtime and need shell-owned M1 safety/milestone gates.
      * `local_unavailable` means the user opted into local-model orchestration but
-     * the verified runtime is not usable; no hosted fallback is allowed.
+     * the verified runtime is not usable; for Pro/Max sessions it falls back to
+     * hosted Bedrock planner, while Free tier operates in Companion Mode.
      */
     plannerRuntimeKind?: 'hosted' | 'local_gemma_qat' | 'local_unavailable';
     /**
@@ -330,7 +331,7 @@ export type { Mode, Tier, PlannerDecision, AgentKind, PlannerHealthState, Runnin
 export { formatElapsed, isSpinnerPhase, renderProgressLine, type TaskProgressEvent, type OnProgress, } from './task-progress';
 export { createTaskProgressRelay, formatMobileProgressMessage, MAX_MOBILE_PROGRESS_MESSAGE_LENGTH, type TaskProgressRelay, type TaskProgressRelayDeps, } from './task-progress-relay';
 export { runDeclaredTestSurfaces, DECLARED_TEST_TIMEOUT_MS, type DeclaredTestResult, type DeclaredTestReason, type RunDeclaredTestSurfacesArgs, } from './declared-test-runner';
-export { QuorumLoop, type QuorumLoopDeps } from './quorum-loop';
+export { QuorumLoop, type QuorumLoopDeps, claimOutageNotificationOnDisk, isOutageNotificationDeliveredOnDisk, markOutageNotificationDeliveredOnDisk, releaseOutageNotificationClaimOnDisk, tryAcquireRecoveryLock, releaseRecoveryLock, cleanArbiterSafely, type RecoveryLockHandle, type RecoveryLockDeps, defaultOutageNotificationRoot, } from './quorum-loop';
 /**
  * [A1g] Round-5 (Codex round-4 MEDIUM) — INVOCATION-OWNED conversation deltas.
  *
@@ -1131,6 +1132,7 @@ export declare function serializeShellSubmissions(handler: (text: string, images
  * slash route then reports "unavailable").
  */
 export declare function buildContinuationActionDeps(args: RunOrchestrationShellArgs, store: OrchestrationStore): Partial<ContinuationCliDeps>;
+export declare function shouldSuppressStructuralContextRefresh(args: RunOrchestrationShellArgs): boolean;
 /**
  * Tokenize a command line string respecting single/double quotes and backslash escapes.
  * Returns tokens array or error if unclosed quote / trailing escape.

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/quorum-loop.d.ts

@@ -1,3 +1,4 @@
+import * as fsSync from 'node:fs';
 import type { AppSyncClient, TeamTrackRecoveryRow } from '../appsync/appsync-client';
 import type { Session } from '../types';
 import type { LocalExecutor } from '../local-executor';
@@ -80,10 +81,103 @@ export declare function classifyImplementorRoundFailure(err: unknown): string;
  *     An UNMATCHED quota error degrades FAIL-SAFE to the existing born-halt
  *     `surfaceHalt` (the user just doesn't get auto-continuation; identical to
  *     today) — NOT fail-open.
- *
- * Exported for the L1 fixture test (I5).
+ */
+export type ProviderFailureClassifier = 'rate_limit_429' | 'overloaded_529' | 'quota_exhausted' | 'model_error';
+export interface ProviderFailureClassification {
+    isOutage: boolean;
+    classifier: ProviderFailureClassifier | null;
+    verbatimLine: string;
+    humaneMessage: string;
+    actionAdvice: string;
+}
+/**
+ * HB-60 — Provider rate limit, quota exhaustion, and server overload classifier.
+ * Categorizes failure text into a structured, wire-safe classification label with
+ * a humane explanation and recommended recovery advice for desktop and mobile surfacing.
+ * Anchored to HTTP error tokens and provider phrases to prevent false positives on
+ * compiler line numbers, durations, or token counts.
+ */
+export declare function classifyProviderFailure(text: string): ProviderFailureClassification;
+/**
+ * Scans provider stdout (e.g. from `codex exec --json` or `claude --json`)
+ * for structured failure events (`{"type":"error"}` or `{"type":"turn.failed"}`)
+ * and extracts all failure error messages for provider outage classification.
+ */
+export declare function extractFailureMessagesFromStdout(stdout: string): string[];
+export declare function extractFailureMessageFromStdout(stdout: string): string | null;
+/**
+ * Format a clear, humane TUI banner for desktop rendering when a provider outage or quota occurs.
+ */
+export declare function formatProviderOutageBanner(agent: string, classification: ProviderFailureClassification): string;
+/**
+ * Exported for the L1 fixture test (I5) and provider rate-limit classification (HB-60).
  */
 export declare function classifyImplementorQuotaFailure(exitCode: number | undefined, text: string): boolean;
+/**
+ * Root directory for persisting provider outage notification delivery markers.
+ * Configurable via CODEVIBE_OUTAGE_NOTIFICATION_ROOT for hermetic test isolation.
+ */
+export declare function defaultOutageNotificationRoot(): string;
+export interface OutageNotificationMarker {
+    status: 'claimed' | 'delivered';
+    disposition?: 'dispatched' | 'acknowledged' | 'retained';
+    deliveryId: string;
+    sessionId?: string;
+    taskId?: string;
+    agent?: string;
+    classifier?: string;
+    claimedAtMs?: number;
+    deliveredAt?: string;
+    pid?: number;
+    ambiguousOutcome?: boolean;
+    reason?: string;
+    error?: string;
+}
+export interface RecoveryLockHandle {
+    lockDir: string;
+    token: string;
+}
+export interface RecoveryLockDeps {
+    fs?: {
+        readdirSync?: typeof fsSync.readdirSync;
+        readFileSync?: typeof fsSync.readFileSync;
+        writeFileSync?: typeof fsSync.writeFileSync;
+        renameSync?: typeof fsSync.renameSync;
+        unlinkSync?: typeof fsSync.unlinkSync;
+        rmdirSync?: typeof fsSync.rmdirSync;
+        existsSync?: typeof fsSync.existsSync;
+        mkdirSync?: typeof fsSync.mkdirSync;
+    };
+}
+export declare function cleanArbiterSafely(arbiterDir: string, expectedToken: string, deps?: RecoveryLockDeps): void;
+export declare function tryAcquireRecoveryLock(lockDir: string, deps?: RecoveryLockDeps): RecoveryLockHandle | null;
+export declare function releaseRecoveryLock(handle: RecoveryLockHandle | null | undefined, deps?: RecoveryLockDeps): void;
+/**
+ * Atomically claims an outage notification delivery on disk before emission begins (R4-F2, R5-F3, R6-F3, R7-F3, R7-F4).
+ * Uses atomic temporary file publication via linkSync, exclusive recovery locking with tombstone rename,
+ * and fail-closed crash deduplication so lost acknowledgements never produce duplicate mobile pushes on restart.
+ */
+export declare function claimOutageNotificationOnDisk(deliveryId: string, payload: Record<string, unknown>): {
+    claimed: boolean;
+    alreadyDelivered: boolean;
+};
+/**
+ * Releases a transient claim on disk if emission aborted cleanly without reaching the backend.
+ * Ownership-checked: only unlinks if the file is currently claimed by claimantPid (R5-F3).
+ */
+export declare function releaseOutageNotificationClaimOnDisk(deliveryId: string, claimantPid?: number): void;
+/**
+ * Determines whether an emit error definitively proves the mutation was not committed (R5-F2).
+ */
+export declare function isDefinitiveNonDelivery(reason?: string): boolean;
+/**
+ * Checks whether an outage notification has already been successfully delivered and persisted on disk.
+ */
+export declare function isOutageNotificationDeliveredOnDisk(deliveryId: string): boolean;
+/**
+ * Persists an outage notification delivery marker to disk atomically so deduplication survives process restart.
+ */
+export declare function markOutageNotificationDeliveredOnDisk(deliveryId: string, payload: Record<string, unknown>): void;
 /**
  * Audited-path fix (Fix 1) — build the SAFE, no-plaintext desktop advisory text
  * for a hosted-side PolicyRejection. Uses ONLY the closed `category` classifier
@@ -1007,6 +1101,18 @@ export declare class QuorumLoop {
      * manual prompt (fail-closed; the Max user is prompted instead of auto-resumed).
      */
     private readonly quotaContinuationOffers;
+    /**
+     * HB-60 — deduplicated provider outages / rate limits announced to the user
+     * and mobile companion. Keyed by `${sessionId}:${taskId}:${classifier}` so
+     * one notification is dispatched per failure event and a resumed session does
+     * not re-announce it.
+     */
+    private static readonly globalAnnouncedOutages;
+    private static readonly inFlightOutageEmissions;
+    private readonly announcedDesktopOutages;
+    private readonly announcedProviderOutages;
+    /** @internal reset process-wide announced provider outages for unit tests (memory-only) */
+    static resetGlobalAnnouncedOutages(): void;
     /** REVISE_FEEDBACK ids already consumed (deterministic dedup). */
     private readonly seenReviseFeedbackIds;
     /**
@@ -2711,6 +2817,13 @@ export declare class QuorumLoop {
      */
     private resolveForcedImplementorAgent;
     private resolveQuotaClassificationText;
+    /**
+     * HB-60 / Must-Have 2: Gracefully surface provider rate limit / 429 / 529 / quota
+     * errors via a humane TUI banner and mobile AppSync NOTIFICATION alert.
+     * Wire-safety invariant: zero raw agent prompt/diff/output on the wire;
+     * only closed humane message and structured classification metadata cross into AppSync.
+     */
+    announceProviderOutageIfNew(taskId: string, agent: AgentKind, textOrClassification: string | ProviderFailureClassification): Promise<boolean>;
     /**
      * #585 §3.5 / §3.6 — the `quota_exhausted` fork. The implementor halted on a
      * quota error (born-halt or, defensively, a throw). Bound-check the

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/status-format.d.ts

@@ -30,7 +30,7 @@ export declare function prettyModelLabel(model: string | null | undefined): stri
  *   - `local_gemma_qat`  → dim `<label> · local`   (no color → caller renders dim)
  *   - `local_unavailable`→ yellow degraded warning  (the ONE state worth surfacing —
  *     NL routing is off; only deterministic slash commands work)
- *   - `hosted`           → null (hosted planner retired → no badge)
+ *   - `hosted`           → dim `Gemma · hosted` (hosted Bedrock Gemma planner active)
  *
  * The badge is a boot-time FACT, not a live health light — copy avoids implying
  * liveness (see design doc "Architecture grounding").

package/node_modules/@quantiya/codevibe-core/dist/planner/client.d.ts

@@ -67,6 +67,9 @@ export declare class PlannerBudgetExceededError extends Error {
 export declare class PlannerTierGateRejectedError extends Error {
     constructor(msg: string);
 }
+export declare class PlannerMalformedRequestError extends Error {
+    constructor(msg: string);
+}
 export declare class BackendPlannerClient implements PlannerAdapter {
     private transport;
     private cache;

package/node_modules/@quantiya/codevibe-core/dist/planner/composite-adapter.d.ts

@@ -0,0 +1,39 @@
+import type { Tier } from '../orchestration-shell/types';
+import type { PlannerAdapter, PlannerDecision, PlannerInput, PlannerProbeResult } from './adapter';
+import type { PlannerHealthMachine } from './health-state';
+export interface CompositePlannerAdapterOptions {
+    localAdapter?: PlannerAdapter | null;
+    hostedAdapter: PlannerAdapter;
+    tier: Tier;
+    localRuntimeKind?: 'hosted' | 'local_gemma_qat' | 'local_unavailable';
+    localRuntimeLabel?: string;
+    hostedHealth?: PlannerHealthMachine | null;
+    recoveryProbeIntervalMs?: number;
+    onNotice?: (message: string) => void;
+    onBeforeHostedFallback?: (input: PlannerInput) => Promise<PlannerInput>;
+}
+export declare class CompositePlannerAdapter implements PlannerAdapter {
+    private readonly opts;
+    private activeSessionId;
+    private currentSource;
+    private recoveryTimer;
+    private readonly sourceChangeListeners;
+    private readonly recoveryIntervalMs;
+    private beforeHostedFallbackHook;
+    constructor(opts: CompositePlannerAdapterOptions);
+    setBeforeHostedFallback(hook: (input: PlannerInput) => Promise<PlannerInput>): void;
+    get activeSource(): 'local' | 'hosted';
+    get runtimeKind(): 'local_gemma_qat' | 'local_unavailable' | 'hosted';
+    get runtimeLabel(): string;
+    get suppressStructuralContextRefresh(): boolean;
+    onSourceChange(listener: (source: 'local' | 'hosted') => void): () => void;
+    private notifySourceChange;
+    private transitionToHosted;
+    private transitionToLocal;
+    private startRecoveryProbe;
+    private stopRecoveryProbe;
+    setActiveSession(sessionId: string | null): void;
+    classify(input: PlannerInput): Promise<PlannerDecision>;
+    probe(): Promise<PlannerProbeResult>;
+    dispose(): void;
+}

package/node_modules/@quantiya/codevibe-core/dist/planner/index.d.ts

@@ -5,3 +5,4 @@ export { PlannerHealthMachine } from './health-state';
 export { BackendPlannerClient, PlannerBudgetExceededError, PlannerTierGateRejectedError, type PlannerAppSyncTransport, type PlannerCryptoBridge, type SessionKeyResolver, type ShellEventEmit, type EmitShellEventFn, } from './client';
 export { LocalGemmaPlannerAdapter, parseLocalGemmaPlannerDecision, PlannerOutputUnparseableError, renderLocalGemmaPlannerPrompt, type LocalGemmaPlannerRunner, } from './local-gemma';
 export { parseLocalGemmaAdvisorySummary, renderLocalGemmaFamiliarizePrompt, renderLocalGemmaMultiBrowsePrompt, renderLocalGemmaBrowsePrompt, MAX_BROWSE_CONTENT_CHARS, MAX_MULTI_BROWSE_TOTAL_CONTENT_CHARS, MAX_MULTI_BROWSE_RENDERED_PROMPT_CHARS, type LocalGemmaAdvisoryRunner, } from './local-advisory';
+export { CompositePlannerAdapter, type CompositePlannerAdapterOptions, } from './composite-adapter';

package/node_modules/@quantiya/codevibe-core/dist/substrate-launch/index.d.ts

@@ -6,7 +6,7 @@ export { buildSanitizedBaseEnv, assertNoAmbientCreds, SAFE_ENV_ALLOWLIST, SANDBO
 export type { SanitizedEnvInput } from "./sanitized-env";
 export { ApiKeyBootstrap, SANDBOX_BOOTSTRAP_DIR, HELPER_SCRIPT_NAME, TOKEN_FILE_NAME, CODEX_PROVIDER_ID, } from "./apikey-bootstrap";
 export type { ApiKeyBootstrapInput } from "./apikey-bootstrap";
-export { assertReviewerVendorCredential, reviewerProviderFor, withReviewerCredentialPreflight, ReviewerCredentialMissingError, REVIEWER_CREDENTIAL_MISSING, } from "./reviewer-credential-preflight";
+export { assertReviewerVendorCredential, reviewerProviderFor, withReviewerCredentialPreflight, ReviewerCredentialMissingError, REVIEWER_CREDENTIAL_MISSING, assertImplementorVendorCredential, implementorProviderFor, withImplementorCredentialPreflight, ImplementorCredentialMissingError, IMPLEMENTOR_CREDENTIAL_MISSING, } from "./reviewer-credential-preflight";
 export type { ReviewerCredentialStore } from "./reviewer-credential-preflight";
 export { scrubLeEnvOrReexec, buildScrubbedLeEnv, findCredShapedKeys, isCredShapedEnvKey, LE_ENV_SCRUBBED_MARKER, } from "./le-env-scrub";
 export type { LeEnvScrubDeps } from "./le-env-scrub";

package/node_modules/@quantiya/codevibe-core/dist/substrate-launch/reviewer-credential-preflight.d.ts

@@ -9,6 +9,10 @@ export declare const REVIEWER_CREDENTIAL_MISSING = "ReviewerCredentialMissingErr
 export declare class ReviewerCredentialMissingError extends Error {
     name: string;
 }
+export declare const IMPLEMENTOR_CREDENTIAL_MISSING = "ImplementorCredentialMissingError";
+export declare class ImplementorCredentialMissingError extends Error {
+    name: string;
+}
 /**
  * The minimal store surface the preflight needs (structurally satisfied by
  * `KeychainVendorKeyStore`); narrow so tests can stub it without keychain IO.
@@ -24,6 +28,10 @@ export interface ReviewerCredentialStore {
  * them (the loop pre-routes them to legacy+badge before engaging anyway).
  */
 export declare function reviewerProviderFor(agent: string): VendorProvider | null;
+/**
+ * Map an implementor agent kind to its broker vendor provider.
+ */
+export declare function implementorProviderFor(agentKind: string): VendorProvider | null;
 /**
  * Throw (fail-closed) when a Trusted reviewer is about to substrate-engage but
  * no vendor credential exists for its provider. The message is the user-facing
@@ -48,3 +56,21 @@ export declare function withReviewerCredentialPreflight<I extends {
     mode: string;
     teardown: () => Promise<void>;
 }>(engage: (input: I) => Promise<R>, store: ReviewerCredentialStore): (input: I) => Promise<R>;
+/**
+ * Throw (fail-closed) when a Trusted implementor is about to substrate-engage
+ * but no vendor credential exists for its provider.
+ */
+export declare function assertImplementorVendorCredential(agentKind: string, store: ReviewerCredentialStore): Promise<void>;
+/**
+ * Wrap an implementor substrate engager with the credential preflight, ordered
+ * AFTER tier selection: the underlying engage runs first, and the credential check
+ * applies ONLY when the ladder actually chose `substrate` (broker) mode. On
+ * substrate + missing credential the engaged substrate is torn down and the
+ * actionable `ImplementorCredentialMissingError` propagates (fail-closed).
+ */
+export declare function withImplementorCredentialPreflight<I extends {
+    agentKind: string;
+}, R extends {
+    mode: string;
+    teardown: () => Promise<void>;
+}>(engage: (input: I) => Promise<R>, store: ReviewerCredentialStore): (input: I) => Promise<R>;

package/node_modules/@quantiya/codevibe-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "2.0.44",
+  "version": "2.0.46",
   "description": "Core library for CodeVibe plugins - shared keychain, crypto, AppSync, and auth functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,7 +18,7 @@
     "typecheck": "tsc --noEmit",
     "emit-types": "tsc -p tsconfig.types.json --emitDeclarationOnly",
     "build": "rm -rf dist && npm run emit-types && esbuild src/index.ts --bundle --platform=node --target=node18 --minify --packages=external --define:__CODEVIBE_TEST_BUILD__=false --outfile=dist/index.js && esbuild src/orchestration-shell/cli.ts --bundle --platform=node --target=node18 --minify-syntax --packages=external --define:__CODEVIBE_TEST_BUILD__=false --outfile=dist/orchestration-shell/cli.js --banner:js=\"#!/usr/bin/env node\" && esbuild src/orchestration-shell/web/web-extract-worker.ts --bundle --platform=node --target=node18 --minify --packages=external --outfile=dist/orchestration-shell/web-extract-worker.js && npm run verify-no-test-hooks && npm run verify-no-test-types",
-    "verify-no-test-hooks": "if grep -ERl 'CODEVIBE_TEST_FORCE_QUOTA_FAIL|CODEVIBE_TEST_FORCE_IMPLEMENTOR_AGENT|CODEVIBE_ANCHORED_PUBLICATION_AUTHORITY_ROOT|codevibe-anchored-publications-|cv-publication-authority-vitest-|codevibe\\.test\\.publication-authority-|setPublicationAuthorityRootForTestBuild|__CODEVIBE_TEST_BUILD__|_onBeforeLinkForTesting|_onBeforeSummariesLockForTesting|__codevibe_test_on_before_link|__codevibe_test_on_before_summaries_lock' dist; then echo 'ERROR: a test-only hook leaked into a published artifact (prod-unreachability invariant)'; exit 1; fi; echo 'OK \u2014 no test-only hooks in published artifacts'",
+    "verify-no-test-hooks": "if grep -ERl 'CODEVIBE_TEST_FORCE_QUOTA_FAIL|CODEVIBE_TEST_FORCE_IMPLEMENTOR_AGENT|CODEVIBE_ANCHORED_PUBLICATION_AUTHORITY_ROOT|codevibe-anchored-publications-|cv-publication-authority-vitest-|codevibe\\.test\\.publication-authority-|setPublicationAuthorityRootForTestBuild|__CODEVIBE_TEST_BUILD__|_onBeforeLinkForTesting|_onBeforeSummariesLockForTesting|__codevibe_test_on_before_link|__codevibe_test_on_before_summaries_lock|simulatePostPublicationError' dist; then echo 'ERROR: a test-only hook leaked into a published artifact (prod-unreachability invariant)'; exit 1; fi; echo 'OK — no test-only hooks in published artifacts'",
     "verify-no-test-types": "if find dist -type f \\( -path '*/__tests__/*' -o -name '*.test.d.ts' -o -name 'test-publication-authority-setup.d.ts' \\) | grep -q .; then echo 'verify-no-test-types: test declarations present in dist (tsconfig.types.json must exclude test sources)' >&2; exit 1; fi",
     "clean": "rm -rf dist",
     "prepublishOnly": "npm run build",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@quantiya/codevibe-codex-plugin",
-  "version": "2.0.51",
-  "description": "Control OpenAI Codex CLI from your iPhone and Android \u2014 real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
+  "version": "2.0.53",
+  "description": "Control OpenAI Codex CLI from your iPhone and Android — real-time sync, approve file edits, send prompts by voice. Part of CodeVibe.",
   "main": "dist/server.js",
   "codevibe": {
     "companionLauncher": "./libexec/companion-launcher"
@@ -47,7 +47,7 @@
     "node": ">=22.0.0"
   },
   "dependencies": {
-    "@quantiya/codevibe-core": "^2.0.44",
+    "@quantiya/codevibe-core": "^2.0.46",
     "@quantiya/quorum-core": "^1.0.1",
     "chokidar": "^4.0.0",
     "dotenv": "^16.6.1",