@quantiya/codevibe-codex-plugin 2.0.9 → 2.0.11

package/hooks/common.sh

@@ -5,13 +5,12 @@
 
 # ─── Reviewer-subprocess short-circuit ───────────────────────────────
 #
-# When $QUORUM_REVIEWER_SUBPROCESS is set, the current `codex`
-# invocation is a reviewer subprocess spawned by Quorum 2.0's
-# `CodexReviewerProvider` (codevibe-core-rs/crates/codevibe-reviewer/
-# src/providers/codex.rs). Reviewer subprocesses use
-# `codex exec --sandbox read-only --ephemeral` and have their own
-# ephemeral session id that MUST NOT interact with the user's
-# primary Codex session state.
+# When $QUORUM_REVIEWER_SUBPROCESS is set, the current `codex` invocation is an
+# internal CodeVibe subprocess and MUST NOT interact with the user's primary
+# Codex session state. This isolation marker is dominant: an inherited
+# $CODEVIBE_CODEX_PRIMARY_COMPANION value must never bypass it. The private
+# launcher removes QUORUM only at the exact primary Codex handoff; reviewers and
+# implementors add/inherit QUORUM again and therefore always stop here.
 #
 # Without this guard, every reviewer spawn would fire SessionStart →
 # the plugin's resume/create logic creates a ghost backend session →
@@ -23,16 +22,14 @@
 # prevents the same bug class for Codex.
 #
 # `common.sh` is sourced by every hook script (session-start.sh,
-# user-prompt.sh, pre-tool-use.sh, post-tool-use.sh, stop.sh), so
-# `exit 0` here propagates to the hook script — Codex CLI sees a
-# clean hook success and continues normally. Zero-impact for normal
-# user sessions (the env var is never set in the 1.0 code path).
+# user-prompt.sh, pre-tool-use.sh, post-tool-use.sh, stop.sh), so `exit 0` here
+# propagates to the hook script and Codex sees a clean hook success.
 #
 # This change belongs on 1.0 main because it protects the 1.0
 # primary-session-isolation invariant. The env var name is the same
 # `QUORUM_*` scope used by the Claude and Gemini plugins' matching
 # guards.
-if [ -n "$QUORUM_REVIEWER_SUBPROCESS" ]; then
+if [ -n "${QUORUM_REVIEWER_SUBPROCESS:-}" ]; then
     exit 0
 fi
 
@@ -56,7 +53,7 @@ fi
 #
 # The right behavior for an unsupported environment is a silent no-op.
 # `exit 0` propagates a clean hook success to Codex.
-if [ -z "$CODEVIBE_CODEX_TMUX_SESSION" ]; then
+if [ -z "${CODEVIBE_CODEX_TMUX_SESSION:-}" ]; then
     exit 0
 fi
 

package/libexec/companion-launcher

@@ -139,7 +139,7 @@ case "${1:-}" in
             echo "Install Codex CLI with: npm install -g @openai/codex" >&2
             exit 127
         fi
-        exec codex "$@"
+        exec env -u QUORUM_REVIEWER_SUBPROCESS codex "$@"
         ;;
 esac
 
@@ -379,7 +379,7 @@ if [ -n "$TMUX" ]; then
     # leaves _CV_RC at its 0 default. printf's `|| true` keeps a
     # disk-full failure from clobbering diagnostics.
     _CV_RC=0
-    codex "$@" || _CV_RC=$?
+    env -u QUORUM_REVIEWER_SUBPROCESS codex "$@" || _CV_RC=$?
     printf '%s' "$_CV_RC" > "$_CV_CODEX_EXIT_FILE" 2>/dev/null || true
     exit "$_CV_RC"
 fi
@@ -390,7 +390,7 @@ if [ ! -t 0 ] || [ ! -t 1 ]; then
     _CV_AGENT_INVOKED="true"
     _CV_AGENT_STARTED_AT="$(date +%s)"
     _CV_RC=0
-    codex "$@" || _CV_RC=$?
+    env -u QUORUM_REVIEWER_SUBPROCESS codex "$@" || _CV_RC=$?
     printf '%s' "$_CV_RC" > "$_CV_CODEX_EXIT_FILE" 2>/dev/null || true
     exit "$_CV_RC"
 fi
@@ -399,6 +399,7 @@ fi
 log "Starting session log watcher server..."
 export CODEX_WORKING_DIRECTORY="$WORKING_DIR"
 export CODEVIBE_CODEX_TMUX_SESSION="$SESSION_NAME"
+export CODEVIBE_CODEX_PRIMARY_COMPANION=1
 export CODEVIBE_CODEX_PLUGIN_DIR="$PLUGIN_DIR"
 
 # Install hooks.json for Codex CLI with absolute paths (idempotent)
@@ -523,11 +524,12 @@ _CV_HOOKS_REASON=""
 #
 # Design notes:
 #
-#  - "already installed" detection: a structured walk of the JSON
-#    looking for our specific hook-script filenames at expected event
-#    keys. Replaces the prior `grep -q "codevibe-codex"` substring
-#    check, which false-positived on unrelated user paths containing
-#    that string.
+#  - "already installed" detection: a structured comparison of the exact
+#    current hook commands at every expected event key. An older install path
+#    is owned but stale, so it is replaced instead of silently pinning hooks to
+#    a prior checkout/package version. This also replaces the former
+#    `grep -q "codevibe-codex"` substring test, which false-positived on
+#    unrelated user paths containing that string.
 #
 #  - Merge dedupe: filters our previously-installed entries out of
 #    each event key's array, then appends the fresh template entries.
@@ -586,12 +588,13 @@ if INSTALLER_OUTPUT=$(CV_EXISTING="$CODEX_HOOKS_FILE" \
     if (filtered.length === 0) return null;
     return { ...entry, hooks: filtered };
   };
-  // Does this matcher entry contain at least one of our hooks anywhere
-  // in its inner hooks[]? Used by the "already installed" walk only —
-  // it does NOT decide whether the entry survives a strip.
-  const entryContainsOurs = (entry) =>
-    entry && typeof entry === "object" && Array.isArray(entry.hooks) &&
-    entry.hooks.some((h) => h && isOurCommand(h.command));
+  const ownedCommands = (entries) => entries
+    .flatMap((entry) => entry && typeof entry === "object" && Array.isArray(entry.hooks)
+      ? entry.hooks
+      : [])
+    .map((hook) => hook && hook.command)
+    .filter(isOurCommand)
+    .sort();
 
   let existingObj = null;
   let existed = false;
@@ -618,8 +621,9 @@ if INSTALLER_OUTPUT=$(CV_EXISTING="$CODEX_HOOKS_FILE" \
     nextObj.hooks && typeof nextObj.hooks === "object") ? nextObj.hooks : {};
   let allPresent = existed;
   for (const k of Object.keys(nextHooks)) {
-    const arr = Array.isArray(existingHooks[k]) ? existingHooks[k] : [];
-    if (!arr.some(entryContainsOurs)) {
+    const existingArr = Array.isArray(existingHooks[k]) ? existingHooks[k] : [];
+    const nextArr = Array.isArray(nextHooks[k]) ? nextHooks[k] : [];
+    if (JSON.stringify(ownedCommands(existingArr)) !== JSON.stringify(ownedCommands(nextArr))) {
       allPresent = false;
       break;
     }
@@ -752,7 +756,7 @@ done
 # wrapper's cleanup trap can report it via `wrapper_exited` telemetry —
 # tmux's own attach exit code is independent of the inner process exit.
 tmux new-session -d -s "$SESSION_NAME" -x "$(tput cols)" -y "$(tput lines)" \
-    "export CODEVIBE_CODEX_TMUX_SESSION='$SESSION_NAME'; export ENVIRONMENT='$ENVIRONMENT'; $CODEX_CMD; printf '%s' \"\$?\" > '$_CV_CODEX_EXIT_FILE'; exit"
+    "unset QUORUM_REVIEWER_SUBPROCESS; export CODEVIBE_CODEX_TMUX_SESSION='$SESSION_NAME'; export CODEVIBE_CODEX_PRIMARY_COMPANION=1; export ENVIRONMENT='$ENVIRONMENT'; $CODEX_CMD; printf '%s' \"\$?\" > '$_CV_CODEX_EXIT_FILE'; exit"
 _CV_TMUX_STARTED="true"
 _CV_AGENT_INVOKED="true"
 _CV_AGENT_STARTED_AT="$(date +%s)"

package/libexec/pane-mirror-writer.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+'use strict';
+
+// tmux pipe-pane must execute a command string in the tmux server. Keep the
+// file-open security and hard byte bound in this tiny helper, independently of
+// the observer's tmux control path. The observer owns both files and passes
+// their expected identities; this process refuses path substitution, reports
+// ready/done through the verified state descriptor, and never grows pane.log
+// past maxBytes even if `tmux pipe-pane -t` later fails.
+const fs = require('fs');
+
+const [
+  , ,
+  filePath,
+  expectedDevText,
+  expectedInoText,
+  statePath,
+  expectedStateDevText,
+  expectedStateInoText,
+  token,
+  maxBytesText,
+] = process.argv;
+const expectedDev = Number(expectedDevText);
+const expectedIno = Number(expectedInoText);
+const expectedStateDev = Number(expectedStateDevText);
+const expectedStateIno = Number(expectedStateInoText);
+const maxBytes = Number(maxBytesText);
+
+if (
+  !filePath
+  || !statePath
+  || !/^[a-f0-9]{32}$/.test(token || '')
+  || !Number.isSafeInteger(expectedDev)
+  || !Number.isSafeInteger(expectedIno)
+  || !Number.isSafeInteger(expectedStateDev)
+  || !Number.isSafeInteger(expectedStateIno)
+  || !Number.isSafeInteger(maxBytes)
+  || maxBytes <= 0
+) {
+  process.exit(64);
+}
+
+const openVerified = (target, flags, expectedDevice, expectedInode) => {
+  const fd = fs.openSync(target, flags | (fs.constants.O_NOFOLLOW || 0));
+  const stat = fs.fstatSync(fd);
+  if (!stat.isFile() || stat.dev !== expectedDevice || stat.ino !== expectedInode) {
+    fs.closeSync(fd);
+    throw new Error('identity mismatch');
+  }
+  return fd;
+};
+
+let paneFd;
+let stateFd;
+try {
+  paneFd = openVerified(
+    filePath,
+    fs.constants.O_WRONLY | fs.constants.O_APPEND,
+    expectedDev,
+    expectedIno,
+  );
+  stateFd = openVerified(
+    statePath,
+    fs.constants.O_WRONLY,
+    expectedStateDev,
+    expectedStateIno,
+  );
+} catch {
+  if (paneFd !== undefined) try { fs.closeSync(paneFd); } catch { /* ignore */ }
+  if (stateFd !== undefined) try { fs.closeSync(stateFd); } catch { /* ignore */ }
+  process.exit(66);
+}
+
+const writeState = (state, code = '') => {
+  const value = Buffer.from(`${state} ${token} ${process.pid}${code === '' ? '' : ` ${code}`}\n`, 'utf8');
+  fs.ftruncateSync(stateFd, 0);
+  let written = 0;
+  while (written < value.length) {
+    const count = fs.writeSync(stateFd, value, written, value.length - written, written);
+    if (count <= 0) throw new Error('short writer-state write');
+    written += count;
+  }
+  fs.fsyncSync(stateFd);
+};
+
+let finished = false;
+const finish = (code) => {
+  if (finished) return;
+  finished = true;
+  process.stdin.pause();
+  try { fs.closeSync(paneFd); } catch { /* ignore */ }
+  try { writeState('done', code); } catch { /* observer will retain the bounded mirror */ }
+  try { fs.closeSync(stateFd); } catch { /* ignore */ }
+  process.exit(code);
+};
+
+try {
+  writeState('ready');
+  if (fs.fstatSync(paneFd).size >= maxBytes) finish(0);
+} catch {
+  finish(67);
+}
+
+process.stdin.on('data', (chunk) => {
+  if (finished) return;
+  try {
+    const size = fs.fstatSync(paneFd).size;
+    const remaining = Math.max(0, maxBytes - size);
+    const input = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    const length = Math.min(remaining, input.length);
+    let written = 0;
+    while (written < length) {
+      const count = fs.writeSync(paneFd, input, written, length - written);
+      if (count <= 0) throw new Error('short pane-mirror write');
+      written += count;
+    }
+    if (length < input.length || size + written >= maxBytes) finish(0);
+  } catch {
+    finish(67);
+  }
+});
+process.stdin.on('end', () => finish(0));
+process.stdin.on('close', () => finish(0));
+process.stdin.on('error', () => finish(68));
+process.on('SIGHUP', () => finish(0));
+process.on('SIGINT', () => finish(0));
+process.on('SIGTERM', () => finish(0));

package/node_modules/@quantiya/codevibe-core/dist/appsync/__tests__/appsync-client-flag-locator.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@quantiya/codevibe-core/dist/appsync/__tests__/dispose-watcher-socket.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,8 +1,30 @@
+import WebSocket from 'ws';
 import { CreateEventInput, CreateSessionInput, UpdateSessionInput, UpdateEventStatusInput, Event, Session, EventSource, DeviceKey, GrantSessionKeyInput, UpdateReviewerPolicyInput, UserReviewerPolicySnapshot } from '../types';
 import type { PostDecisionAction } from '../orchestration-shell/types';
+import type { InvocationUsageSnapshot } from '../reviewer/token-usage';
 import type { CreateTaskGroupInput, CreateTaskGroupResult, SubmitMergeGateVerdictInput, SubmitMergeGateVerdictResult, SubmitTrackVerificationOutcomeInput, SubmitTrackVerificationOutcomeResult, ClaimGroupDecisionInput, ClaimGroupDecisionResult } from '../local-executor/task-group-types';
 import type { ReviewerVerdict, ReviewerRole, AgentKind as ReviewerAgentKind } from '../reviewer/types';
 import type { PlannerDecision } from '../planner/types';
+/**
+ * Dispose a watcher/subscription WebSocket without crashing the process
+ * (#657 D-1 fix-forward — the clean-quit session/admission leak).
+ *
+ * `ws.close()` on a still-CONNECTING socket aborts the handshake and emits an
+ * ASYNC 'error' ("WebSocket was closed before the connection was established")
+ * on a LATER tick. Every prior disposal site paired `close(1000)` with
+ * `removeAllListeners()` — in either order — so that late emission always
+ * found a listener-less socket and crashed Node with an unhandled 'error'
+ * mid-teardown, BEFORE `retireHostedSession` could land the session INACTIVE
+ * mutation. Net effect: every clean `/quit` whose Class B watcher (or any
+ * other watcher) was mid-(re)connect leaked an ACTIVE session row AND an
+ * `activeSessionAdmissionCount` slot (#101 class), hard-capping the
+ * 19-scenario GA baseline after exactly the free headroom.
+ *
+ * Order is load-bearing: strip stale handlers FIRST, re-arm a swallow-all
+ * 'error' handler, THEN close. Exported for the regression test only — not
+ * part of the public SDK surface.
+ */
+export declare function disposeWatcherSocket(ws: WebSocket, subscriptionId?: string): void;
 /**
  * One assigned reviewer seat returned by `getInReviewAssignments`. Mirrors the
  * engine `InReviewAssignment` serde (camelCase) in
@@ -101,6 +123,24 @@ export interface RecordExecutionEventInput {
     /** Free-form JSON; encrypted before crossing AppSync. */
     payload: unknown;
     dedupKeyHex: string;
+    /**
+     * O1 C1 (#652) §3.1 item 3 — the plaintext flag-target locator, REQUIRED
+     * when `kind = 'FLAG_BAD_APPROVAL'` and absent otherwise (non-flag events
+     * stay byte-identical to the pre-O1-C1 wire). Row COORDINATES only — zero
+     * content. Field names mirror the Rust handler DTO
+     * (`RecordExecutionEventInput` in core-rs `types.rs`, camelCase serde) —
+     * the wire-shape source of truth. The server rejects a request whose
+     * `taskId` ≠ `flaggedTaskId` (the per-task dedup-partition pin).
+     */
+    flaggedTaskId?: string;
+    /**
+     * The flagged row's audit-table sort key — the zero-padded 16-digit
+     * `seqNum` string exactly as surfaced by `queryAudit`'s additive
+     * `AuditEntryWireRow.seqNum` projection.
+     */
+    flaggedSeqNum?: string;
+    /** The flagged entry's `entry_id` (also the dedup-key derivation input). */
+    flaggedEntryId?: string;
 }
 /**
  * PHASE-CP-1-F.1 Part A (LOCK L2) — tolerant `AWSJSON!` object read.
@@ -180,8 +220,29 @@ export interface TaskReviewSummaryDurations {
 }
 export interface TaskReviewSummaryTokenUsage {
     knownTotal?: number;
+    knownInput?: number;
+    knownOutput?: number;
+    knownCachedInput?: number;
     availability: string;
     unavailableRoles: string[];
+    invocations?: TaskReviewSummaryTokenInvocation[];
+}
+export interface TaskReviewSummaryTokenInvocation {
+    role: string;
+    agent: string;
+    taskId?: string;
+    trackIndex?: number;
+    round?: number;
+    gateId?: string;
+    seatId?: number;
+    reviewerRole?: string;
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedInputTokens?: number;
+    totalTokens?: number;
+    elapsedMs?: number;
+    availability: string;
+    unavailableReason?: string;
 }
 /** One round in the per-round summary (decrypted). */
 export interface TaskReviewSummaryRound {
@@ -862,6 +923,7 @@ export declare class AppSyncClient {
         sessionId: string;
         roundNumber: number;
         rawOutput: string;
+        usage?: InvocationUsageSnapshot;
     }, sessionKeyBase64: string): Promise<{
         gateId: string;
         workflowState: string;

package/node_modules/@quantiya/codevibe-core/dist/auth/__tests__/keychain-cli-nudge.test.d.ts

@@ -0,0 +1 @@
+export {};

package/node_modules/@quantiya/codevibe-core/dist/auth/keychain-cli.d.ts

@@ -4,3 +4,11 @@
  * the raw process argv (node, script, "keychain", subcommand, flags…).
  */
 export declare function runKeychainCli(argv: string[]): Promise<number>;
+/**
+ * Advisory nudge for `codevibe login` / `codevibe status` (GA follow-up to #642):
+ * when this machine still holds file-backed credentials, has NOT migrated, and the
+ * OS keyring is actually usable, print the `keychain migrate` suggestion. Purely
+ * additive output — never throws, never mutates state, silent on any ambiguity
+ * (see migrate-nudge.ts invariants).
+ */
+export declare function maybePrintKeychainMigrationNudge(print?: (line: string) => void): Promise<void>;