@quantiya/codevibe-core 2.0.5 → 2.0.7

package/dist/tool-activity/socket-rollout-lock.d.ts

@@ -0,0 +1,57 @@
+import type { Logger } from '../logger';
+import type { RolloutLock, RolloutOwnership } from './session-map';
+export interface SocketRolloutLockOptions {
+    agent: string;
+    logger: Logger;
+    /** Override the filesystem-socket directory (tests) — default os.tmpdir(). */
+    socketDir?: string;
+    /** Base retry backoff while a LIVE owner holds `R` (default 25ms, capped ×~40). */
+    backoffMs?: number;
+    /** Max total wait before {@link acquireOwnership} throws (default 60000ms). */
+    maxWaitMs?: number;
+    /** Injectable clock (default Date.now). */
+    now?: () => number;
+    /** Injectable delay (default setTimeout) — tests pass a controllable fake. */
+    delay?: (ms: number) => Promise<void>;
+    /** Connect-probe timeout deciding live-vs-stale on filesystem sockets (default 500ms). */
+    probeTimeoutMs?: number;
+}
+export declare class SocketRolloutLock implements RolloutLock {
+    private readonly agent;
+    private readonly logger;
+    private readonly socketDir;
+    private readonly backoffMs;
+    private readonly maxWaitMs;
+    private readonly now;
+    private readonly delayFn;
+    private readonly probeTimeoutMs;
+    constructor(opts: SocketRolloutLockOptions);
+    /** A short per-user, per-R address key (sun_path is length-bounded). */
+    private key;
+    /** Abstract name (Linux) or filesystem path (else) for a rollout's lock socket. */
+    private address;
+    /**
+     * The on-disk lock-socket path for a rollout, or `null` on Linux (abstract
+     * sockets have no filesystem presence). Diagnostic / test use only.
+     */
+    socketPathFor(rollout: string): string | null;
+    /**
+     * Block until this process exclusively holds `rollout` (like `flock(LOCK_EX)`),
+     * then return an ownership handle. Throws if it cannot acquire within maxWaitMs
+     * (the caller's per-call barrier then throws — a RETRYABLE re-observe, never a
+     * skip, §4.5 invariant ①).
+     */
+    acquireOwnership(rollout: string): Promise<RolloutOwnership>;
+    /** Attempt one bind. Returns the listening server, or null on EADDRINUSE. */
+    private tryBind;
+    /**
+     * On a filesystem socket, decide whether EADDRINUSE is a live owner or a stale
+     * file from a crashed one. Connect-probe: connect OK → live (false); refused /
+     * absent → stale → unlink → true. Linux abstract sockets vanish on death, so
+     * EADDRINUSE is always live → never stale.
+     */
+    private breakStaleFilesystemSocket;
+    /** True if a listener currently accepts a connection at `address`. */
+    private probeConnect;
+    private closeServer;
+}

package/dist/tool-activity/types.d.ts

@@ -0,0 +1,368 @@
+import { z } from 'zod';
+/**
+ * One occurrence of a tool invocation inside a window (§4.1). `id` is the
+ * REPRODUCIBLE native invocation id (claude `toolu_…`, codex `call_id`) — it is
+ * the MOBILE render-dedup key (design-lock ①), so it must re-derive
+ * byte-identically on any transcript rescan. `ts` is the best-available
+ * occurrence time (display fidelity only; not required re-derivable, §4.5).
+ */
+export declare const ToolActivityOccurrenceSchema: z.ZodObject<{
+    ts: z.ZodString;
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    ts: string;
+}, {
+    id: string;
+    ts: string;
+}>;
+export type ToolActivityOccurrence = z.infer<typeof ToolActivityOccurrenceSchema>;
+/**
+ * Per-occurrence display detail (§4.1 manifest JSON `detail[]`) — lives OUTSIDE
+ * `occurrences[]` (which stays the minimal `{ts,id}` dedup shape). `i` indexes into
+ * the group's `occurrences[]`; `digest` is `digestOf(toolInput)` (§0), a one-way
+ * `sha256:`-prefixed hash carried ENCRYPTED (G4-safe). Present only for occurrences
+ * whose observer supplied a tool input.
+ */
+export declare const ToolActivityDetailSchema: z.ZodObject<{
+    i: z.ZodNumber;
+    digest: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    digest: string;
+    i: number;
+}, {
+    digest: string;
+    i: number;
+}>;
+export type ToolActivityDetail = z.infer<typeof ToolActivityDetailSchema>;
+/**
+ * One `{tool, target}` group within a window (§4.1) — Hendry's
+ * `grep file1 ×2 @ t1,t2` shape. `count === occurrences.length` (lossless).
+ */
+export declare const ToolActivityGroupSchema: z.ZodObject<{
+    tool: z.ZodString;
+    /** The normalized grouping target (§4.1 manifest JSON key `target`; file path / command word). */
+    target: z.ZodOptional<z.ZodString>;
+    count: z.ZodNumber;
+    occurrences: z.ZodArray<z.ZodObject<{
+        ts: z.ZodString;
+        id: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        ts: string;
+    }, {
+        id: string;
+        ts: string;
+    }>, "many">;
+    detail: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        i: z.ZodNumber;
+        digest: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        digest: string;
+        i: number;
+    }, {
+        digest: string;
+        i: number;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    count: number;
+    occurrences: {
+        id: string;
+        ts: string;
+    }[];
+    tool: string;
+    target?: string | undefined;
+    detail?: {
+        digest: string;
+        i: number;
+    }[] | undefined;
+}, {
+    count: number;
+    occurrences: {
+        id: string;
+        ts: string;
+    }[];
+    tool: string;
+    target?: string | undefined;
+    detail?: {
+        digest: string;
+        i: number;
+    }[] | undefined;
+}>;
+export type ToolActivityGroup = z.infer<typeof ToolActivityGroupSchema>;
+/**
+ * The consolidated manifest carried (E2E-encrypted at send) as the content of a
+ * `TOOL_ACTIVITY` event (§4.1 manifest JSON). `continues` marks an overflow-chained
+ * segment (§4.4 — never truncate, never degrade). The window-level fields
+ * (`windowStart`/`windowEnd`/`totalInvocations`/`trackId`) are OPTIONAL in the schema
+ * (a bare `{groups}` still validates) but the consolidator ALWAYS populates them;
+ * `trackId` is `null` on the companion path (2.0 team attribution only).
+ */
+export declare const ToolActivityManifestSchema: z.ZodObject<{
+    windowStart: z.ZodOptional<z.ZodString>;
+    windowEnd: z.ZodOptional<z.ZodString>;
+    totalInvocations: z.ZodOptional<z.ZodNumber>;
+    trackId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    groups: z.ZodArray<z.ZodObject<{
+        tool: z.ZodString;
+        /** The normalized grouping target (§4.1 manifest JSON key `target`; file path / command word). */
+        target: z.ZodOptional<z.ZodString>;
+        count: z.ZodNumber;
+        occurrences: z.ZodArray<z.ZodObject<{
+            ts: z.ZodString;
+            id: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            id: string;
+            ts: string;
+        }, {
+            id: string;
+            ts: string;
+        }>, "many">;
+        detail: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            i: z.ZodNumber;
+            digest: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            digest: string;
+            i: number;
+        }, {
+            digest: string;
+            i: number;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        count: number;
+        occurrences: {
+            id: string;
+            ts: string;
+        }[];
+        tool: string;
+        target?: string | undefined;
+        detail?: {
+            digest: string;
+            i: number;
+        }[] | undefined;
+    }, {
+        count: number;
+        occurrences: {
+            id: string;
+            ts: string;
+        }[];
+        tool: string;
+        target?: string | undefined;
+        detail?: {
+            digest: string;
+            i: number;
+        }[] | undefined;
+    }>, "many">;
+    continues: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    groups: {
+        count: number;
+        occurrences: {
+            id: string;
+            ts: string;
+        }[];
+        tool: string;
+        target?: string | undefined;
+        detail?: {
+            digest: string;
+            i: number;
+        }[] | undefined;
+    }[];
+    trackId?: string | null | undefined;
+    windowStart?: string | undefined;
+    windowEnd?: string | undefined;
+    totalInvocations?: number | undefined;
+    continues?: boolean | undefined;
+}, {
+    groups: {
+        count: number;
+        occurrences: {
+            id: string;
+            ts: string;
+        }[];
+        tool: string;
+        target?: string | undefined;
+        detail?: {
+            digest: string;
+            i: number;
+        }[] | undefined;
+    }[];
+    trackId?: string | null | undefined;
+    windowStart?: string | undefined;
+    windowEnd?: string | undefined;
+    totalInvocations?: number | undefined;
+    continues?: boolean | undefined;
+}>;
+export type ToolActivityManifest = z.infer<typeof ToolActivityManifestSchema>;
+/**
+ * The durable outbox entry, stored PLAINTEXT at rest inside an explicit envelope
+ * (§4.5 — Stage-2 Codex H3 + agy F2: the envelope flag is unconditional so the
+ * send loop never double-encrypts or leaks a stale-key ciphertext). The manifest
+ * is encrypted ONLY at SEND, under the session's CURRENT key; `expectedSessionKeyGen`
+ * is therefore a SEND-TIME value (read from the live session), NOT stored here.
+ *
+ * `backendSessionId` is bound into the entry (X2a/W4) so a durably-outboxed
+ * occurrence is ROUTED by reading the entry and never depends on the separate
+ * `(R, call_id) → backend` session-map surviving.
+ */
+export declare const ToolActivityOutboxEnvelopeSchema: z.ZodObject<{
+    /** ALWAYS false — the entry never contains ciphertext (encrypt-at-send). */
+    isEncrypted: z.ZodLiteral<false>;
+    /** Random 128-bit id: the idempotency key (§4.9) AND the entry's filename stem. */
+    clientEventId: z.ZodString;
+    /** The plugin's backend session id this window belongs to (routing, X2a). */
+    backendSessionId: z.ZodString;
+    /** ISO-8601 ms — the event row sort key `(sessionId, windowStart)` (§4.9). */
+    windowStart: z.ZodString;
+    /** The plaintext manifest (encrypted only at send). */
+    manifest: z.ZodObject<{
+        windowStart: z.ZodOptional<z.ZodString>;
+        windowEnd: z.ZodOptional<z.ZodString>;
+        totalInvocations: z.ZodOptional<z.ZodNumber>;
+        trackId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        groups: z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+            /** The normalized grouping target (§4.1 manifest JSON key `target`; file path / command word). */
+            target: z.ZodOptional<z.ZodString>;
+            count: z.ZodNumber;
+            occurrences: z.ZodArray<z.ZodObject<{
+                ts: z.ZodString;
+                id: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                id: string;
+                ts: string;
+            }, {
+                id: string;
+                ts: string;
+            }>, "many">;
+            detail: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                i: z.ZodNumber;
+                digest: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                digest: string;
+                i: number;
+            }, {
+                digest: string;
+                i: number;
+            }>, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            count: number;
+            occurrences: {
+                id: string;
+                ts: string;
+            }[];
+            tool: string;
+            target?: string | undefined;
+            detail?: {
+                digest: string;
+                i: number;
+            }[] | undefined;
+        }, {
+            count: number;
+            occurrences: {
+                id: string;
+                ts: string;
+            }[];
+            tool: string;
+            target?: string | undefined;
+            detail?: {
+                digest: string;
+                i: number;
+            }[] | undefined;
+        }>, "many">;
+        continues: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        groups: {
+            count: number;
+            occurrences: {
+                id: string;
+                ts: string;
+            }[];
+            tool: string;
+            target?: string | undefined;
+            detail?: {
+                digest: string;
+                i: number;
+            }[] | undefined;
+        }[];
+        trackId?: string | null | undefined;
+        windowStart?: string | undefined;
+        windowEnd?: string | undefined;
+        totalInvocations?: number | undefined;
+        continues?: boolean | undefined;
+    }, {
+        groups: {
+            count: number;
+            occurrences: {
+                id: string;
+                ts: string;
+            }[];
+            tool: string;
+            target?: string | undefined;
+            detail?: {
+                digest: string;
+                i: number;
+            }[] | undefined;
+        }[];
+        trackId?: string | null | undefined;
+        windowStart?: string | undefined;
+        windowEnd?: string | undefined;
+        totalInvocations?: number | undefined;
+        continues?: boolean | undefined;
+    }>;
+    /** Native invocation ids in this window (ledger reconciliation + render dedup). */
+    invocationIds: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    isEncrypted: false;
+    manifest: {
+        groups: {
+            count: number;
+            occurrences: {
+                id: string;
+                ts: string;
+            }[];
+            tool: string;
+            target?: string | undefined;
+            detail?: {
+                digest: string;
+                i: number;
+            }[] | undefined;
+        }[];
+        trackId?: string | null | undefined;
+        windowStart?: string | undefined;
+        windowEnd?: string | undefined;
+        totalInvocations?: number | undefined;
+        continues?: boolean | undefined;
+    };
+    windowStart: string;
+    clientEventId: string;
+    backendSessionId: string;
+    invocationIds: string[];
+}, {
+    isEncrypted: false;
+    manifest: {
+        groups: {
+            count: number;
+            occurrences: {
+                id: string;
+                ts: string;
+            }[];
+            tool: string;
+            target?: string | undefined;
+            detail?: {
+                digest: string;
+                i: number;
+            }[] | undefined;
+        }[];
+        trackId?: string | null | undefined;
+        windowStart?: string | undefined;
+        windowEnd?: string | undefined;
+        totalInvocations?: number | undefined;
+        continues?: boolean | undefined;
+    };
+    windowStart: string;
+    clientEventId: string;
+    backendSessionId: string;
+    invocationIds: string[];
+}>;
+export type ToolActivityOutboxEnvelope = z.infer<typeof ToolActivityOutboxEnvelopeSchema>;

package/dist/types/encryption.d.ts

@@ -5,6 +5,8 @@ export interface EncryptedSessionKey {
     deviceId: string;
     encryptedKey: string;
     ephemeralPublicKey: string;
+    /** SHA-256 of the exact registered public-key string used for wrapping. */
+    recipientPublicKeySha256?: string;
 }
 /**
  * Device key stored with backend
@@ -51,4 +53,6 @@ export interface GrantSessionKeyInput {
     deviceId: string;
     encryptedKey: string;
     ephemeralPublicKey: string;
+    /** SHA-256 of the exact registered public-key string used to wrap the key. */
+    recipientPublicKeySha256: string;
 }

package/dist/types/events.d.ts

@@ -3,9 +3,10 @@
  *
  * 1.x values come first. CP-1 adds 9 new values per
  * `codevibe-backend/docs/2.0/PHASE-CP-1-DESIGN.md` §3 lines 138-148 +
- * §16 Stage A LOCK. Emission of CP-1 values is gated by the
- * `new-event-types-enabled` cohort flag (default OFF — Phase 4 flips
- * per-user once mobile decoders ship).
+ * §16 Stage A LOCK. CP-1 values emit unconditionally — the earlier
+ * `new-event-types-enabled` cohort gate was removed (2026-07-09 descope)
+ * now that the mobile forward-compat decoder ships (unknown types render
+ * as an "Unsupported Event" placeholder, no crash).
  */
 export declare enum EventType {
     USER_PROMPT = "USER_PROMPT",
@@ -25,7 +26,12 @@ export declare enum EventType {
     STRUCTURAL_SUMMARY_GENERATED = "STRUCTURAL_SUMMARY_GENERATED",
     LOCAL_AUTHORITY_REFUSAL = "LOCAL_AUTHORITY_REFUSAL",
     CONTINUATION_PACKET_WRITTEN = "CONTINUATION_PACKET_WRITTEN",
-    CONTINUATION_PACKET_FAILED = "CONTINUATION_PACKET_FAILED"
+    CONTINUATION_PACKET_FAILED = "CONTINUATION_PACKET_FAILED",
+    TEAM_DECOMPOSED = "TEAM_DECOMPOSED",
+    TEAM_TRACK_STATUS = "TEAM_TRACK_STATUS",
+    TEAM_GROUP_RESOLVED = "TEAM_GROUP_RESOLVED",
+    ADAPTER_PROGRESS = "ADAPTER_PROGRESS",
+    TOOL_ACTIVITY = "TOOL_ACTIVITY"
 }
 export declare enum EventSource {
     DESKTOP = "DESKTOP",
@@ -66,6 +72,16 @@ export interface Event {
     deliveredAt?: string;
     executedAt?: string;
     isEncrypted?: boolean;
+    encryptionVersion?: number;
+    writerAuthenticated?: boolean | null;
+    writerEventNonce?: string | null;
+}
+export interface WriterEventAttestationInput {
+    schema: 'codevibe.encrypted_desktop_event.writer.v1';
+    writerEventNonce: string;
+    contentCiphertextSha256: string;
+    metadataCiphertextSha256: string;
+    signatureB64: string;
 }
 /**
  * GraphQL input for creating events
@@ -79,6 +95,10 @@ export interface CreateEventInput {
     promptId?: string;
     timestamp?: string;
     isEncrypted?: boolean;
+    clientEventId?: string;
+    expectedSessionKeyGen?: string;
+    encryptionVersion?: number;
+    writerAttestation?: WriterEventAttestationInput;
 }
 /**
  * GraphQL input for updating event status

package/dist/types/session.d.ts

@@ -1,4 +1,18 @@
 import { EncryptedSessionKey } from './encryption';
+/**
+ * Tool-event consolidation (codevibe-backend/docs/2.0/TOOL-EVENT-CONSOLIDATION-DESIGN.md
+ * §4.9). Distinguished sentinel a client stamps as `expectedSessionKeyGen` when it
+ * observes a session whose `sessionKeyGen` attribute is ABSENT (a LEGACY session
+ * created before sessionKeyGen shipped). The backend resolver maps this sentinel to
+ * the absence-aware, TTL-delete-safe ConditionCheck
+ * `attribute_exists(sessionId) AND attribute_not_exists(sessionKeyGen)` (never a
+ * literal `sessionKeyGen = :0`, which would wedge every legacy session).
+ *
+ * MUST stay byte-identical to the backend Lambda literal
+ * (codevibe-backend/lambda/event-management/index.ts `SESSION_KEY_GEN_ABSENT_SENTINEL`).
+ * The chosen value can never collide with a real server-minted nonce (a UUID).
+ */
+export declare const SESSION_KEY_GEN_ABSENT_SENTINEL = "__CODEVIBE_SESSION_KEY_GEN_ABSENT__";
 /**
  * Session status enum
  */
@@ -14,6 +28,7 @@ export declare enum AgentType {
     CLAUDE = "CLAUDE",
     GEMINI = "GEMINI",
     CODEX = "CODEX",
+    ANTIGRAVITY = "ANTIGRAVITY",
     CODEVIBE = "CODEVIBE"
 }
 /**
@@ -33,18 +48,33 @@ export interface Session {
     creatorDeviceId?: string;
     encryptionVersion?: number;
     lastHeartbeatAt?: string;
+    /** True only for the immutable registered desktop creator key snapshot. */
+    writerAttestationEligible?: boolean | null;
+    /** SHA-256 of the raw 64-byte creator signing public key. */
+    creatorSigningKeySha256?: string | null;
     /**
      * Quorum 2.0 opt-in flag (2f.0.a.3). True routes the session to the
      * 2.0 orchestration flow once 2f.3 Lambda is live; null/false keeps
      * the 1.0 companion flow.
      */
     orchestrationEnabled?: boolean | null;
+    /**
+     * Tool-event consolidation (TOOL-EVENT-CONSOLIDATION-DESIGN.md §4.9).
+     * Server-minted random nonce written by createSession; advances ONLY on a
+     * genuine createSession (never updateSession/resume/grantSessionKey). The
+     * client reads it to stamp/refresh `expectedSessionKeyGen` on TOOL_ACTIVITY
+     * sends. OPTIONAL — a LEGACY session created before this shipped lacks it, in
+     * which case the client stamps SESSION_KEY_GEN_ABSENT_SENTINEL.
+     */
+    sessionKeyGen?: string;
 }
 /**
  * GraphQL input for creating sessions
  */
 export interface CreateSessionInput {
     sessionId?: string;
+    /** Stable UUIDv4 used to retry one sealed create request byte-for-byte. */
+    creationRequestId?: string;
     userId: string;
     agentType?: AgentType;
     projectPath: string;
@@ -69,8 +99,8 @@ export interface UpdateSessionInput {
     metadata?: Record<string, any>;
     lastHeartbeatAt?: string;
     /**
-     * Quorum 2.0 (2f.0.a.3). Per-session override for the orchestration
-     * opt-in. Plugin CLI --orchestration/--no-orchestration sets this.
+     * Legacy Quorum 2.0 compatibility field. Public per-session override flags
+     * were retired by A6; current clients do not set this from the CLI.
      */
     orchestrationEnabled?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quantiya/codevibe-core",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "Core library for CodeVibe plugins - shared keychain, crypto, AppSync, and auth functionality",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -37,13 +37,14 @@
     "react": "^19.2.0",
     "react-devtools-core": "^6.1.2",
     "ulid": "^3.0.0",
-    "uuid": "^9.0.0",
+    "uuid": "^11.1.1",
     "ws": "^8.14.0",
     "yaml": "^2.9.0",
     "zod": "^3.23.0"
   },
   "optionalDependencies": {
-    "keytar": "^7.9.0"
+    "keytar": "^7.9.0",
+    "fs-ext": "^2.0.0"
   },
   "devDependencies": {
     "@types/gradient-string": "^1.1.6",
@@ -57,7 +58,7 @@
     "vitest": "^1.6.1"
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=22.0.0"
   },
   "author": "Quantiya",
   "license": "MIT",
@@ -70,7 +71,7 @@
     "quantiya",
     "claude",
     "codex",
-    "gemini",
+    "antigravity",
     "ai",
     "coding",
     "encryption"

package/dist/orchestration/orchestration-cli.d.ts

@@ -1,12 +0,0 @@
-/**
- * Dispatch for the `orchestration` subcommand. Called by runAuthCli
- * when it sees `argv[2] === 'orchestration'`. Supports five sub-actions:
- *   enable    — set orchestrationEnabledDefault = true
- *   disable   — set orchestrationEnabledDefault = false
- *   status    — print current policy snapshot + installed agents
- *   configure — interactive wizard (toggle + panel customization)
- *   setup     — Phase 3.a (#190) 3-step locked setup wizard with Test
- *               My Agents (locked role taxonomy: architecture /
- *               correctness / security)
- */
-export declare function runOrchestrationCli(argv: string[]): Promise<void>;