@quantiya/codevibe-codex-plugin 2.0.10 → 2.0.13

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

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

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

@@ -43,4 +43,21 @@ export interface MigrateResult {
     fileDeviceId?: string | null;
     keychainDeviceId?: string | null;
 }
+interface ParsedIdentity {
+    deviceId: string;
+    publicKey: string;
+}
+/**
+ * Parse a stored device-identity blob into a VALIDATED identity: a canonical-UUID
+ * `deviceId`, a non-empty `publicKey`, AND a non-empty `privateKey`. Anything else
+ * (missing fields, non-UUID deviceId, keyless, unparseable) → null = "not a
+ * recognized identity". Returning null here makes the fork guard treat a
+ * parseable-but-invalid blob as a CONFLICT, not a match — so a file identity missing
+ * its private key can never `--force`-replace a good keyring identity with a keyless
+ * one. (Full ECDH derive-validation is deliberately NOT done: identities come from
+ * our own P-256 keygen, and the NO-CLOBBER invariant already protects the keyring's
+ * copy in the sameIdentity path — a non-empty privateKey field is a sufficient
+ * structural check.)
+ */
+export declare function parseIdentity(raw: string | null | undefined): ParsedIdentity | null;
 export declare function migrateKeychain(deps: MigrateDeps, opts: MigrateOptions): Promise<MigrateResult>;

package/node_modules/@quantiya/codevibe-core/dist/keychain/migrate-nudge.d.ts

@@ -0,0 +1,38 @@
+export interface FileStoreSnapshot {
+    kind: 'absent' | 'unreadable' | 'corrupt' | 'store';
+    /** Account count when kind === 'store'; 0 otherwise. */
+    accountCount: number;
+    /** True when kind === 'store' and the device-identity account parses as a valid identity. */
+    identityValid: boolean;
+    /**
+     * True when any account NAME or VALUE is not a non-empty string (Stage-2
+     * Codex r1+r2): migrate copies EVERY account via keytar.setPassword, whose
+     * checkRequired rejects empty accounts and empty passwords → verify_failed
+     * refusal (possibly after earlier accounts were written). Non-secret check —
+     * length/type only, never content.
+     */
+    hasEmptyAccountEntry: boolean;
+}
+export interface NudgeDeps {
+    /** CODEVIBE_ALLOW_FILE_KEYCHAIN === '1' — the user explicitly chose file storage. */
+    fileKeychainOptIn(): boolean;
+    /** Tri-state migration-tombstone probe (statSync-based). */
+    tombstoneStatus(): 'present' | 'absent' | 'error';
+    /** ONE discriminated read of the file store for the active service. */
+    fileStoreSnapshot(): FileStoreSnapshot;
+    /** Platform-structural "no keyring here" (e.g. headless Linux, no keytar module). */
+    keyringStructurallyAbsent(): boolean;
+    /**
+     * One live keytar read of the keyring's device-identity account. Resolves to
+     * the stored value or null; MAY THROW / reject (locked or denied keyring).
+     * The caller compares the result against null and nothing else (invariant 4).
+     */
+    keytarProbe(): Promise<unknown>;
+}
+/**
+ * True when `login`/`status` should print the keychain-migration suggestion.
+ * Never throws.
+ */
+export declare function shouldSuggestKeychainMigration(deps: NudgeDeps): Promise<boolean>;
+/** The advisory text, single-sourced so login/status/tests render identically. */
+export declare const MIGRATION_NUDGE_LINES: readonly string[];

package/node_modules/@quantiya/codevibe-core/dist/local-executor/__tests__/protocol-backlog-wiring.test.d.ts

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

package/node_modules/@quantiya/codevibe-core/dist/local-executor/__tests__/protocol-backlog.test.d.ts

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

package/node_modules/@quantiya/codevibe-core/dist/local-executor/__tests__/workspace-cleanup-audit.test.d.ts

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

package/node_modules/@quantiya/codevibe-core/dist/local-executor/anchored-fs.d.ts

@@ -22,6 +22,13 @@ export declare function listAnchoredPublicationAuthorityResidueForParents(parent
     ownerKey: string;
     label: string;
 }[]): Promise<AnchoredPublicationAuthorityResidue[]>;
+export declare class AnchoredFileRemovalDurabilityError extends Error {
+    readonly code = "EANCHOREDFILEREMOVALDURABILITY";
+    readonly removed = true;
+    readonly durabilityUncertain = true;
+    constructor(message: string);
+}
+export declare function isAnchoredFileRemovalDurabilityError(err: unknown): err is AnchoredFileRemovalDurabilityError;
 export interface AnchoredFsIdentity {
     dev: string;
     ino: string;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/bounded-directory.d.ts

@@ -10,6 +10,20 @@ export interface MetadataBudget {
     readonly maxUtf8PathBytes: number;
 }
 export declare function createMetadataBudget(maxEntries?: number, maxUtf8PathBytes?: number): MetadataBudget;
+/**
+ * Retry a complete read-only operation when a bounded directory keeps the same
+ * authenticated inode but gains or loses a child during one enumeration.
+ *
+ * The operation must create fresh metadata budgets on every invocation. Only
+ * same-inode content churn is retried: root replacement, identity loss,
+ * malformed authority, helper timeout, and every other failure remain
+ * immediate and fail closed.
+ */
+export declare function withTransientDirectoryEnumerationRetry<T>(operation: () => Promise<T>, opts?: {
+    maxAttempts?: number;
+    retryDelaysMs?: readonly number[];
+    sleep?: (ms: number) => Promise<void>;
+}): Promise<T>;
 /** Charge one path before retaining it or doing work derived from it. */
 export declare function consumeMetadataPath(budget: MetadataBudget, value: string, label: string): void;
 /** Validate an existing collection incrementally, without an intermediate map. */

package/node_modules/@quantiya/codevibe-core/dist/local-executor/process-identity.d.ts

@@ -7,10 +7,40 @@ export interface ProcessMetadata {
     identity: ProcessIdentity;
     processGroupId: number | null;
 }
+/**
+ * Share an in-flight Darwin boot-session probe, but persist only a verified
+ * kernel value. A transient sysctl failure or malformed reply must fail the
+ * current identity attempt closed without poisoning every later operation in
+ * the desktop process.
+ */
+export declare function createDarwinBootSessionProvider(runProbe: () => Promise<{
+    code: number | null;
+    stdout: string;
+} | null>): () => Promise<string | null>;
+/**
+ * Compare authenticated process incarnations across the Darwin identity
+ * migration from mutable `kern.boottime` microseconds to
+ * `kern.bootsessionuuid`.
+ *
+ * Exact equality remains authoritative on every platform. Darwin legacy
+ * records may additionally match when the native microsecond-resolution
+ * process creation time is identical and the clock-adjustable legacy boot
+ * second differs by at most the adjacent-second carry observed in the field.
+ * Two UUID-backed identities still require the same kernel boot UUID.
+ */
+export declare function processIncarnationIdsMatch(expected: string, actual: string): boolean;
 /** Same native identity reader embedded into fd-anchored helper processes. */
 export declare const PROCESS_IDENTITY_SYNC_HELPER_SOURCE: string;
 /** Read exact process metadata from one platform-owned source. */
 export declare function readProcessMetadata(pid: number): Promise<ProcessMetadata | null>;
 export declare function readProcessIdentity(pid: number): Promise<ProcessIdentity | null>;
+/**
+ * Memoize one process's authenticated native identity.
+ *
+ * A native probe may fail transiently under host load. Share concurrent work
+ * and retry once, but cache only a verified identity: a rejected probe must
+ * not permanently poison every later workspace operation in this process.
+ */
+export declare function createCurrentProcessIdentityProvider(resolveIdentity: () => Promise<ProcessIdentity | null>): () => Promise<ProcessIdentity>;
 export declare function currentProcessIdentity(): Promise<ProcessIdentity>;
 export declare function isProcessIdentityAlive(identity: ProcessIdentity): Promise<boolean>;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/process-tree.d.ts

@@ -94,7 +94,7 @@ export declare function captureProcessCleanupOwner(args: {
     /** @internal deterministic native-identity seam. */
     readProcessIncarnation?: ReadProcessIncarnation;
 }): Promise<ProcessCleanupOwner | undefined>;
-export declare function processTreeOwnership(substrateOwned: boolean, platform?: NodeJS.Platform): ProcessTreeOwnership;
+export declare function processTreeOwnership(substrateOwned: boolean, platform?: NodeJS.Platform, advertisedHostOwnership?: 'posix-host'): ProcessTreeOwnership;
 /**
  * Terminate a process tree CodeVibe owns. POSIX uses a detached process group;
  * Windows launches close their original Job Object host handle.

package/node_modules/@quantiya/codevibe-core/dist/local-executor/protocol-backlog.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Backlog-based flood guard for line-JSON helper protocols.
+ *
+ * WHY (2026-08-22, investigation of "anchored-fs helper exceeded its
+ * protocol-output limit"): the previous guards accumulated a LIFETIME byte
+ * counter (`protocolBytes += chunk.length`) that was never reset when lines
+ * were consumed, then killed the helper past 1 MiB. That conflates two very
+ * different things:
+ *
+ *   - a FLOOD: the helper emitting output nobody is consuming (backlog grows
+ *     without bound) — the thing the cap exists to stop; and
+ *   - a long-lived, perfectly healthy session whose request/response traffic
+ *     legitimately totals more than 1 MiB — e.g. an implementor task
+ *     materializing a workspace over a large non-git root (the CodeVibe
+ *     workspace root holds ~14 sibling repositories), where every per-file
+ *     exchange is consumed promptly but the cumulative counter still trips
+ *     and the round dies with "Implementor round 0 failed".
+ *
+ * The correct discriminator is the UNCONSUMED backlog: bytes sitting in the
+ * partial-line buffer plus bytes queued in lines nobody has read yet, and the
+ * count of queued lines. Consumed traffic must never count against the cap.
+ * A single overlong line is still caught because an unterminated line
+ * accumulates entirely in the partial buffer.
+ */
+/**
+ * UTF-8 byte length of a decoded protocol string.
+ *
+ * Stage-2 R1 (Codex, 2026-08-22): `String.length` counts UTF-16 CODE UNITS,
+ * not bytes. The caps below are documented — and were historically enforced —
+ * in BYTES (the pre-fix guards summed `chunk.length` on the raw Buffer). Using
+ * `.length` on the DECODED string would under-count every multi-byte
+ * character: 400k `€` occupy 1.2 MB of real backlog but measure as 400k,
+ * letting a non-ASCII flood sail past a cap that ASCII traffic respects. All
+ * helper protocol traffic is JSON, which may legitimately carry non-ASCII
+ * (paths, agent prose, refusal text), so this is reachable, not theoretical.
+ * Every queue/consume/partial measurement must route through this function so
+ * the accounting is symmetric AND byte-accurate.
+ */
+export declare function utf8Bytes(value: string): number;
+export interface ProtocolBacklogCaps {
+    /** Max unconsumed bytes (partial buffer + queued lines). */
+    maxBacklogBytes: number;
+    /** Max queued (unconsumed) lines. */
+    maxQueuedLines: number;
+}
+export declare const DEFAULT_PROTOCOL_BACKLOG_CAPS: ProtocolBacklogCaps;
+export declare class ProtocolBacklog {
+    private readonly caps;
+    private queuedBytes;
+    private queuedLines;
+    constructor(caps?: ProtocolBacklogCaps);
+    /**
+     * Check the caps against the CURRENT unconsumed state. Call after appending
+     * a chunk to the partial buffer (pass that buffer's length) and after any
+     * queue/consume transitions. Returns true while within caps.
+     */
+    withinCaps(partialBytes: number): boolean;
+    /** A complete line entered the unconsumed queue. */
+    onLineQueued(lineLength: number): void;
+    /** A previously queued line was consumed by a reader. */
+    onLineConsumed(lineLength: number): void;
+}

package/node_modules/@quantiya/codevibe-core/dist/local-executor/workspace-cleanup-audit.d.ts

@@ -0,0 +1,3 @@
+import { type ShadowCleanupResidue, type ShadowEnv } from './workspace-shadow';
+export { withTransientDirectoryEnumerationRetry } from './bounded-directory';
+export declare function listShadowCleanupResidueWithRetry(taskIds: ReadonlySet<string>, env?: ShadowEnv): Promise<ShadowCleanupResidue[]>;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/workspace-materializer.d.ts

@@ -1,10 +1,25 @@
 import { type WorkspaceRootAuthority } from './workspace-authority.js';
 export type MaterializationHangStage = 'realpath' | 'lstat' | 'open' | 'stat' | 'clone' | 'read' | 'close';
+export interface MaterializedFileMetadata {
+    sha256: string;
+    size: number;
+    mode: number;
+}
 export interface WorkspaceMaterializerSession {
-    copyFile(source: string, destination: string): Promise<void>;
-    copyRelativeSymlink(source: string, destination: string): Promise<void>;
+    copyFile(source: string, destination: string, maxLogicalBytes?: number): Promise<MaterializedFileMetadata>;
+    hashDestinationFile(destination: string, maxBytes: number): Promise<MaterializedFileMetadata>;
+    relocateDestinationRoot(authority: WorkspaceRootAuthority): Promise<void>;
+    close(): Promise<void>;
+}
+export interface WorkspaceFileHashSession {
+    hashFile(file: string): Promise<MaterializedFileMetadata>;
     close(): Promise<void>;
 }
+export interface WorkspaceFileHashOptions {
+    root: WorkspaceRootAuthority;
+    maxFileBytes: number;
+    helperTimeoutMs?: number;
+}
 export interface WorkspaceMaterializerOptions {
     sourceRoot: WorkspaceRootAuthority;
     destinationRoot: WorkspaceRootAuthority;
@@ -25,3 +40,9 @@ export interface WorkspaceMaterializerOptions {
  * physical fallback only after the helper reports the exact stable file size.
  */
 export declare function createWorkspaceMaterializerSession(opts: WorkspaceMaterializerOptions): WorkspaceMaterializerSession;
+/**
+ * Reuse one identity-bound helper for a full snapshot scan. This retains the
+ * same per-file path/inode/hash checks as `anchoredHashFileWithinRoot` without
+ * paying one operating-system process launch for every unchanged source file.
+ */
+export declare function createWorkspaceFileHashSession(opts: WorkspaceFileHashOptions): WorkspaceFileHashSession;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/workspace-shadow.d.ts

@@ -130,6 +130,8 @@ export interface ShadowEnv {
     failMarkerDirectorySync?: (filePath: string) => boolean;
     /** @internal inject a post-publication directory-sync failure for the quota registry. */
     failQuotaRegistryDirectorySync?: boolean;
+    /** @internal pause after quota-lock acquisition and before strict state enumeration. */
+    beforeQuotaFenceScan?: () => Promise<void>;
     /** @internal fail initial/retry shadow-root durability before acknowledgement. */
     failShadowRootDirectorySyncStage?: 'target-child' | 'target-parent';
     /** @internal fail initial/retry state-root durability before acknowledgement. */

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/__tests__/direct-file-delete.test.d.ts

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

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/__tests__/flag-command.test.d.ts

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

package/node_modules/@quantiya/codevibe-core/dist/orchestration-shell/__tests__/halt-message-wire-content.test.d.ts

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

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

@@ -27,6 +27,42 @@ export declare const WIRE_PUBLIC_PLAINTEXT_KINDS: ReadonlySet<string>;
 export declare const auditKindCopy: Readonly<Record<string, string>>;
 /** Humanize a wire kind via `auditKindCopy`; unknown/future → raw snake_case. */
 export declare function auditKindLabel(kind: string): string;
+/**
+ * The engine's `gate_resolved` payload stores `outcome` as the serde
+ * snake_case form of `GateOutcome` (`orchestration.rs` finalize emit). Pinned
+ * to the server's own validation constant
+ * (`record_execution_event.rs` `GATE_RESOLVED_OUTCOME_CONSENSUS_APPROVE`) —
+ * the `/flag` client-side subset check is defense-in-depth for the
+ * server-enforced check (design §3.1 items 1 + 4).
+ */
+export declare const GATE_RESOLVED_OUTCOME_CONSENSUS_APPROVE = "consensus_approve";
+/**
+ * The engine's `gate_resolved` payload stores `decision` as the
+ * internally-tagged serde form of `GateDecision` (`{"kind": "proceed"}` for
+ * the approve consensus). Pinned to
+ * `record_execution_event.rs` `GATE_RESOLVED_DECISION_PROCEED`.
+ */
+export declare const GATE_RESOLVED_DECISION_PROCEED = "proceed";
+/**
+ * The decrypted-outcome labels captured off a `gate_resolved` entry (O1 C1
+ * #652). Closed enum LABELS only — never free-form payload content. `null`
+ * fields fail closed (a missing key is never treated as an approval),
+ * mirroring the server's `flag_target_outcome_is_approve`.
+ */
+export interface AuditGateResolvedOutcome {
+    /** `payload.outcome` — snake_case `GateOutcome` label, or null. */
+    readonly outcome: string | null;
+    /** `payload.decision.kind` — internally-tagged `GateDecision` tag, or null. */
+    readonly decisionKind: string | null;
+}
+/**
+ * True iff the entry is a decrypted `gate_resolved` row whose resolution is
+ * the quorum's approve consensus — the ONLY flaggable target class (design
+ * §3.1 item 1; byte-mirrors the server predicate
+ * `flag_target_outcome_is_approve` in `record_execution_event.rs`). Missing
+ * keys fail closed.
+ */
+export declare function isFlaggableAuditEntry(entry: AuditEntryModel): boolean;
 /**
  * The minimal content-decrypt primitive the router needs — structurally
  * compatible with `cryptoService.decryptContent(ciphertextB64, sessionKeyB64)`.
@@ -63,6 +99,21 @@ export interface AuditEntryModel {
     readonly kind: string;
     /** RFC3339 timestamp (header line), or null when absent. */
     readonly timestamp: string | null;
+    /**
+     * O1 C1 (#652) — the row's zero-padded 16-digit audit-table sort key from
+     * the additive `AuditEntryWireRow.seqNum` projection (core-rs `types.rs`;
+     * D5 plaintext row coordinate). `null` for rows served by a backend that
+     * predates the projection — `/flag` then fails closed.
+     */
+    readonly seqNum: string | null;
+    /**
+     * O1 C1 (#652) — outcome LABELS captured off a DECRYPTED `gate_resolved`
+     * payload (`{outcome, decision.kind}` — closed enum labels only), else
+     * null. Feeds the `/flag` client-side approve-subset check
+     * ({@link isFlaggableAuditEntry}); the decrypted payload itself is never
+     * retained beyond the render.
+     */
+    readonly gateResolved: AuditGateResolvedOutcome | null;
     /** How the payload resolved. */
     readonly status: AuditEntryRouteStatus;
     /**
@@ -106,7 +157,9 @@ export interface AuditBrowserModel {
  * Build the full newest-first audit browser model from the server-ascending
  * `rows`. PURE — takes the rows + the session key + the injected decrypt fn.
  * Ordering (§2): the rows come back server-ascending; we reverse to newest-first
- * (using `timestamp`/`entryId` as keys — there is NO `seq_num` on the wire).
+ * (using `timestamp`/`entryId` as keys; the additive O1 C1 `seqNum` projection
+ * is a per-row COORDINATE for `/flag`, deliberately not re-litigating the
+ * shipped ordering).
  */
 export declare function buildAuditBrowserModel(rows: ReadonlyArray<Record<string, unknown>>, sessionKey: string | null, decrypt: DecryptContentFn): AuditBrowserModel;
 /** Render a single entry model as readable plaintext lines. */

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

@@ -395,6 +395,16 @@ export declare function buildQuorumLoopExecutor(args: {
      */
     classifyRunner?: LocalGemmaPlannerRunner | null;
 }): Promise<BuildQuorumLoopExecutorResult>;
+/**
+ * Single-task LE emit → wire shape. Exported for tests.
+ *
+ * 2026-08-22 (mobile halt-message loss): forwards `content` — previously
+ * dropped, so surfaceHalt's message ("Implementor round 0 failed…") rode only
+ * in encrypted metadata that no renderer shows, and mobile displayed a
+ * content-free NOTIFICATION as the bare word "notification". Content is
+ * E2E-encrypted on the wire like every other event.
+ */
+export declare function mapSingleTaskLeEventToShellEmit(e: Parameters<LEEmitShellEventFn>[0]): ShellEventEmit;
 export declare function mapTeamLeEventToShellEmit(e: Parameters<LEEmitShellEventFn>[0]): ShellEventEmit;
 /**
  * Construct the team-mode LocalExecutorImpl + the store-tap holder. Returns the