@quantiya/codevibe-codex-plugin 2.0.6 → 2.0.8

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

@@ -0,0 +1,64 @@
+import type { Dirent } from 'node:fs';
+import type { WorkspaceRootAuthority } from './workspace-authority.js';
+/** Shared metadata ceilings for every CodeVibe-owned filesystem traversal. */
+export declare const MAX_METADATA_ENTRY_COUNT = 100000;
+export declare const MAX_METADATA_PATH_BYTES: number;
+export interface MetadataBudget {
+    entries: number;
+    utf8PathBytes: number;
+    readonly maxEntries: number;
+    readonly maxUtf8PathBytes: number;
+}
+export declare function createMetadataBudget(maxEntries?: number, maxUtf8PathBytes?: number): MetadataBudget;
+/** 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. */
+export declare function assertMetadataPathCollection(values: Iterable<string>, label: string, budget?: MetadataBudget): void;
+/** Validate object-backed path collections without allocating `items.map(...)`. */
+export declare function assertMetadataItemPathCollection<T>(items: Iterable<T>, pathOf: (item: T) => string, label: string, budget?: MetadataBudget): void;
+export interface BoundedDirectoryStat {
+    dev: string;
+    ino: string;
+    birthtimeNs: string;
+    canonicalPath: string;
+    size: bigint;
+    mtimeMs: number;
+    mtimeNs: string;
+    ctimeNs: string;
+    nlink: string;
+}
+/** Metadata captured in the same isolated enumeration request, when requested. */
+export declare function boundedDirectoryStat(entry: Dirent): BoundedDirectoryStat | undefined;
+/**
+ * Enumerate a directory in an isolated process group. The helper's absolute
+ * deadline is armed before its first target-filesystem access, so a blocked
+ * FUSE/network open, read, or close cannot retain a desktop lifecycle lock.
+ * Entries are streamed and charged in the desktop before being retained.
+ */
+export declare function readDirectoryBounded(dirPath: string, budget: MetadataBudget, label: string, relativePrefix?: string, opts?: {
+    /** @internal lower deterministic helper deadline for tests. */
+    helperTimeoutMs?: number;
+    /** @internal deterministic target-filesystem stall seam. */
+    testHangStage?: 'open' | 'read' | 'stat' | 'close';
+    /** Capture lstat metadata inside the same deadline-bound worker request. */
+    includeStats?: boolean;
+    /** @internal deterministic seam after a missing component, before acknowledgement. */
+    beforeMissing?: () => Promise<void> | void;
+    /** @internal deterministic seam before final public-chain authentication. */
+    beforeCompletion?: () => Promise<void> | void;
+    /** Exact directory inode that must own the enumeration. */
+    expectedDirectory?: {
+        dev: string;
+        ino: string;
+        birthtimeNs?: string;
+        canonicalPath?: string;
+        size?: bigint;
+        mtimeNs?: string;
+        ctimeNs?: string;
+        nlink?: string;
+    };
+    /** Persisted root authority used to enter the complete relative chain. */
+    rootAuthority?: WorkspaceRootAuthority;
+    /** Directory path relative to `rootAuthority` (empty means the root). */
+    relativeDirectory?: string;
+}): Promise<Dirent[]>;

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

@@ -0,0 +1,22 @@
+import { type ChildProcess, type SpawnOptions } from 'node:child_process';
+/** Production ceiling for one helper protocol wait or helper subtree. */
+export declare const DEFAULT_HELPER_TIMEOUT_MS: number;
+export declare const MAX_HELPER_TIMEOUT_MS: number;
+/** Cleanup is itself bounded; callers must never wait forever for `close`. */
+export declare const DEFAULT_HELPER_TERMINATION_TIMEOUT_MS = 5000;
+/** Absolute deadline inherited by recursive helper descendants. */
+export declare const HELPER_DEADLINE_ENV = "CODEVIBE_HELPER_DEADLINE_AT_MS";
+export declare const HELPER_TIMEOUT_ENV = "CODEVIBE_HELPER_TIMEOUT_MS";
+export declare function resolveHelperTimeout(value: number | undefined): number;
+export declare function helperDeadlineEnv(timeoutMs: number): Record<string, string>;
+/** Spawn every top-level helper in its own POSIX process group. */
+export declare function spawnIsolatedHelper(command: string, args: readonly string[], options: SpawnOptions): ChildProcess;
+export declare function observeChildClose(child: ChildProcess): Promise<number | null>;
+export declare function withHelperDeadline<T>(work: Promise<T>, timeoutMs: number, label: string): Promise<T>;
+/**
+ * Best-effort full-tree termination with a hard upper bound on cleanup wait.
+ * POSIX helpers are isolated process-group leaders. Windows uses taskkill's
+ * `/T` tree semantics and then a direct-kill fallback; neither path is awaited
+ * without a deadline.
+ */
+export declare function terminateHelperTree(child: ChildProcess | undefined, closed: Promise<unknown> | undefined, timeoutMs?: number): Promise<void>;

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

@@ -0,0 +1,11 @@
+/** Maximum retained bytes per stdout/stderr stream; pipes are still fully drained. */
+export declare const MAX_RETAINED_PROCESS_OUTPUT_BYTES: number;
+export declare class BoundedOutputBuffer {
+    private readonly limit;
+    private chunks;
+    private bytes;
+    constructor(limit?: number);
+    push(value: Buffer | string): void;
+    toBuffer(): Buffer;
+    toString(): string;
+}

package/node_modules/@quantiya/codevibe-core/dist/local-executor/class-a-emit.d.ts

@@ -2,7 +2,7 @@ import type { AdapterProgressEnvelope } from '../adapter/progress';
 import { AuthorityRefusal, AuthorityRefusalCategory } from './authority';
 import { type DeviceSigningKey } from './class-a-sign';
 import { AgentKind, FailureClass, ProcessRole } from './types';
-export type ExecutionEventKind = 'PROCESS_SPAWNED' | 'TOOL_USE' | 'FILE_CHANGE' | 'VERIFICATION_RUN' | 'PROCESS_EXITED';
+export type ExecutionEventKind = 'PROCESS_SPAWNED' | 'TOOL_USE' | 'FILE_CHANGE' | 'VERIFICATION_RUN' | 'PROCESS_EXITED' | 'TRACK_PROGRESS';
 export type ClassAMessageType = 'EXECUTION_EVENT' | 'EXECUTOR_REFUSAL' | 'VERIFICATION_RESULT' | 'ADAPTER_PROGRESS';
 export interface ClassAEnvelope {
     messageVersion: 1;
@@ -51,6 +51,15 @@ export interface ProcessExitedPayload {
     exitCode: number;
     failureClass: FailureClass;
 }
+/** Team-child liveness fact; its hosted audit append renews the exact lease. */
+export interface TrackProgressPayload {
+    kind: 'TRACK_PROGRESS';
+    taskGroupId: string;
+    trackIndex: number;
+    dispatchGeneration: number;
+    phase: 'track_spawned' | 'lease_heartbeat';
+    sequence: number;
+}
 export interface ExecutorRefusalPayload {
     refusedMessageId: string;
     refusalCategory: AuthorityRefusalCategory;
@@ -124,6 +133,9 @@ export declare class ClassAEmitter {
         failureClass: FailureClass;
         occurredAt?: string;
     }): Promise<void>;
+    emitTrackProgress(ctx: ClassAEmitterContext, args: Omit<TrackProgressPayload, 'kind'> & {
+        occurredAt?: string;
+    }): Promise<void>;
     emitExecutorRefusal(ctx: ClassAEmitterContext, args: {
         refusal: AuthorityRefusal;
         refusedMessageId: string;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/class-a-sign.d.ts

@@ -23,6 +23,21 @@ export interface DeviceSigningKey {
  * exact canonical string and catch future json-freeze JCS drift.
  */
 export declare function canonicalJsonForSigning(obj: Record<string, unknown>, signatureFieldName: string): string;
+/**
+ * Sign `canonical` (the JCS string) with the device's P-256 key under
+ * ECDSA-P-256-with-SHA-256, returning the STANDARD-base64 of the raw 64-byte
+ * r‖s (IEEE P-1363) signature. Matches the Rust verifier's
+ * `Signature::from_slice(&B64.decode(sig))` decode path (signing.rs:203-218).
+ */
+export declare function signCanonical(canonical: string, keys: DeviceSigningKey): string;
+/**
+ * Generic writer-attestation signing primitive. Unlike Class A envelopes,
+ * every field in this closed object is in the signing domain; the signature
+ * is carried in the adjacent GraphQL input rather than embedded in `payload`.
+ */
+export declare function signWriterEventPayload(payload: Record<string, unknown>, keys: DeviceSigningKey): string;
+export declare const WRITER_EVENT_ATTESTATION_SCHEMA: "codevibe.encrypted_desktop_event.writer.v1";
+export declare function signWriterEventEnvelope(envelope: Record<string, unknown>, keys: DeviceSigningKey): string;
 /**
  * Sign a Class A envelope object. The canonical bytes are the JCS of the
  * envelope with `signature` removed (matching Rust

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

@@ -0,0 +1,25 @@
+export interface DurableDirectoryIdentity {
+    canonicalPath: string;
+    dev: string;
+    ino: string;
+    birthtimeNs: string;
+    mtimeMs: number;
+    created: boolean;
+}
+/**
+ * Create/validate a directory tree and seal every acknowledged target with
+ * child-then-parent fsync inside a killable, deadline-bound helper.
+ */
+export declare function ensureDurableDirectoryTree(target: string, opts?: {
+    /** Existing durable ancestor; every controlled descendant is resealed on every retry. */
+    anchorPath?: string;
+    mode?: number;
+    enforceTargetMode?: boolean;
+    helperTimeoutMs?: number;
+    /** @internal deterministic durability failure seam. */
+    failDirectorySyncStage?: 'created-child' | 'created-parent' | 'target-child' | 'target-parent';
+    /** @internal deterministic target-filesystem stall seam. */
+    testHangStage?: 'anchor-open' | 'component-open' | 'mkdir' | 'created-child' | 'created-parent' | 'target-child' | 'target-parent';
+    /** @internal replace the live anchor after binding; proves cwd anchoring and final rejection. */
+    testSwapAnchorTo?: string;
+}): Promise<DurableDirectoryIdentity>;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/durable-store.d.ts

@@ -1,11 +1,37 @@
-import type { ShadowChangeKind, ShadowDiffFile } from './workspace-shadow';
+import { type ReviewedShadowDiffFile, type ShadowChangeKind, type ShadowDiffFile } from './workspace-shadow';
+import { type SnapshotBundlesView, type SnapshotTrackBundle } from './snapshot-merge';
 import type { ImageAttachment } from '../orchestration-shell/types';
+import { type WorkspaceRootAuthority } from './workspace-authority';
+export declare const MAX_STORE_JSON_BYTES: number;
+export declare const MAX_PREIMAGE_BYTES: number;
+export declare const MAX_PREIMAGE_AGGREGATE_BYTES: number;
 /** The current manifest schema version (append-only; bump on a breaking shape change). */
 export declare const REVERT_MANIFEST_VERSION: 1;
 /** Marker stored in `preImageRef` for a file that did NOT exist pre-promote (a created file). */
 export declare const ABSENT_PREIMAGE: "ABSENT";
 /** Default TTL for a true-orphan manifest GC fallback (~48h, LOCK #589-I). */
 export declare const ORPHAN_TTL_MS: number;
+type StoreHelperRequest = ({
+    operation: 'stat-child';
+    name: string;
+} | {
+    operation: 'mkdir';
+    name: string;
+    mode: number;
+} | {
+    operation: 'remove-file';
+    name: string;
+    childDev: string;
+    childIno: string;
+    childBirthtimeNs: string;
+    childCanonicalPath: string;
+}) & {
+    /** @internal deterministic durability-failure seam. */
+    failDirectorySyncStage?: 'mkdir-child' | 'mkdir-parent' | 'remove-parent';
+    /** @internal deterministic blocked-helper seam. */
+    testHangBeforeReady?: boolean;
+};
+type StoreOperation = StoreHelperRequest['operation'] | 'write' | 'remove-tree';
 /**
  * The lifecycle of a group's revert record — the GC-predicate key (LOCK #589-I).
  * A group is GC-eligible ONLY in a terminal lifecycle (`accepted` /
@@ -15,6 +41,8 @@ export declare const ORPHAN_TTL_MS: number;
 export type RevertLifecycle = 'in_flight' | 'accepted' | 'reject_revert_in_progress' | 'reject_revert_complete';
 /** One applied-file entry in the durable revert manifest. */
 export interface RevertManifestEntry {
+    /** Exact user-root instance on which this reverse authority may operate. */
+    workspaceRootAuthority: WorkspaceRootAuthority;
     /** The track that applied this path. */
     trackIndex: number;
     /** Monotonic apply order ACROSS the whole group (reverse order drives reverse-apply). */
@@ -30,8 +58,12 @@ export interface RevertManifestEntry {
     preImageRef: string;
     /** SHA-256 of the pre-image content; `null` for an absent (created) file. */
     preImageHash: string | null;
+    /** POSIX permission bits of the pre-image; `null` when absent. */
+    preImageMode: number | null;
     /** SHA-256 of the applied content; `null` for a `deleted` file. */
     postPromoteHash: string | null;
+    /** POSIX permission bits of the applied image; `null` when deleted. */
+    postPromoteMode: number | null;
 }
 /** The revert-manifest record-type-1 slot. */
 export interface RevertManifestSlot {
@@ -57,6 +89,18 @@ export interface PendingGroupDecision {
     claimToken: string;
     notes?: string;
 }
+export interface SnapshotPromotionJournalV1 {
+    version: 1;
+    workspaceRootAuthority: WorkspaceRootAuthority;
+    /** Hash of the exact bundle set + integration gate specification. */
+    operationHash: string;
+    state: 'prepared' | 'applied' | 'acknowledged' | 'reverted' | 'rejected';
+    /** Reviewed final bytes and exact pre-images needed for crash reconciliation. */
+    files: ReviewedShadowDiffFile[];
+    /** Content address over `files`; corruption fails closed before replay. */
+    filesHash: string;
+    updatedAtMs: number;
+}
 /**
  * Record-type-3 slot (PHASE-589/469 W3.2 RESIDUAL 1) — the retained `/team`
  * launch input a `REJECT_RESTART` re-dispatches from. `workItems` is the wire
@@ -109,6 +153,8 @@ export interface RevertRecordV1 {
      * Append-only field — a pre-HIGH-1 record decodes via the `?? null` reads.
      */
     pendingDecision?: PendingGroupDecision | null;
+    /** Record type 5 — group promotion prepare/apply/acknowledge journal. */
+    snapshotPromotion?: SnapshotPromotionJournalV1 | null;
 }
 /**
  * Stable cursor key for ONE manifest entry (W3-H1). The crash-resume cursor MUST
@@ -120,9 +166,11 @@ export interface RevertRecordV1 {
  * dirty (stuck at B instead of the oldest baseline). The separator is a single
  * space; `promoteOrder` is a non-negative integer (no spaces), so the leading
  * maximal digit-run before the first space uniquely decomposes `(promoteOrder,
- * path)` — the key is collision-free. Keys are only string-compared (Set
- * membership), never parsed back. (Exported so the revert-runner reads/writes the
- * SAME key.)
+ * path)` — the key is collision-free. Live journal validation parses the key
+ * back into this canonical form, rejects duplicates, and the revert runner binds
+ * it to an actual manifest entry. The cursor is an audit/checkpoint hint only;
+ * recovery idempotently replays the manifest instead of trusting cursor presence
+ * as proof of completed filesystem mutation.
  */
 export declare function revertEntryKey(promoteOrder: number, relPath: string): string;
 /** The write-ahead revert journal — crash-resume cursor (LOCK #589-I). */
@@ -139,16 +187,16 @@ export interface RevertJournalV1 {
     revertedPaths: string[];
     /**
      * W3-H1 — the PER-ENTRY resume cursor: `revertEntryKey(promoteOrder, path)` for
-     * each manifest entry reverted in THIS pass. Resume skips by ENTRY identity (not
-     * path), so a same-path multi-promote reverts EVERY remaining step in reverse
-     * order after a mid-revert crash. Append-only field — a pre-W3-H1 journal decodes
-     * via the `?? []` reads (its in-flight steps re-run, which is idempotent: the
-     * 3-hash check in revertOne no-ops an already-reverted entry).
+     * each manifest entry reverted in THIS pass. Recovery authenticates membership
+     * but never treats cursor presence as filesystem proof: every non-final path is
+     * replayed idempotently in reverse order. Append-only field — a pre-W3-H1
+     * journal decodes via the `?? []` reads.
      */
     revertedEntryKeys?: string[];
 }
 /** Manifest entries a promote contributes, BEFORE the content is spilled to blobs. */
 export interface PromoteManifestInput {
+    workspaceRootAuthority: WorkspaceRootAuthority;
     trackIndex: number;
     promoteOrder: number;
     path: string;
@@ -157,8 +205,10 @@ export interface PromoteManifestInput {
     preImageContent: string | null;
     /** SHA-256 of `preImageContent`; `null` when absent. */
     preImageHash: string | null;
+    preImageMode: number | null;
     /** SHA-256 of the applied content; `null` for a deleted file. */
     postPromoteHash: string | null;
+    postPromoteMode: number | null;
 }
 /**
  * CP-14 Wave A — one committed track tip (a merge-train input). Written at the
@@ -186,6 +236,28 @@ export interface TrackTipsView {
  */
 export declare class RevertManifestStore {
     private readonly rootDir;
+    private readonly maxStoreJsonBytes;
+    private readonly maxPreImageAggregateBytes;
+    private readonly maxMetadataEntries;
+    private readonly maxMetadataPathBytes;
+    private readonly beforePreImageOpen?;
+    private readonly afterPreImageStat?;
+    private readonly afterAnchoredParentValidation?;
+    private readonly beforeStoreFileRetirement?;
+    private readonly afterTreeTombstoneRename?;
+    private readonly failAnchoredWriteAt;
+    private readonly failDirectorySyncAt;
+    private readonly failMkdirDirectorySyncStage;
+    private readonly failRootDirectorySyncStage;
+    private readonly helperTimeoutMs;
+    private readonly testHangStoreHelperBeforeReady;
+    private readonly testHangPreImageEnumerationStat;
+    private readonly testHangPreImageReadStage;
+    private readonly afterAnchoredWriteValidation?;
+    private readonly afterJsonAuthorityRead?;
+    private readonly afterPreImageAbsentRead?;
+    private readonly beforeMergeFenceAcquire?;
+    private anchoredWriteCount;
     /**
      * CP-14 Wave A (Codex r2 MED) — per-group serialization for the track-tips
      * read-modify-write. Two tracks of the SAME group authorize concurrently (the
@@ -195,11 +267,62 @@ export declare class RevertManifestStore {
      * only source of truth). A per-group promise chain serializes the RMW.
      */
     private readonly trackTipChains;
+    /** Groups for which this store instance authored session-owned resources. */
+    private readonly sessionOwnedGroups;
+    private readonly ownerLeasePromises;
+    private readonly ownerLeaseNonce;
+    /** A successful seal is reusable; every later helper still authenticates this exact inode. */
+    private rootDirectoryPromise?;
     constructor(opts?: {
         rootDir?: string;
+        /** @internal lower deterministic limit for serialized-authority boundary tests. */
+        maxStoreJsonBytes?: number;
+        /** @internal lower deterministic aggregate pre-image quota for tests. */
+        maxPreImageAggregateBytes?: number;
+        /** @internal lower deterministic shared metadata ceilings for tests. */
+        maxMetadataEntries?: number;
+        maxMetadataPathBytes?: number;
+        /** @internal deterministic read-race seam. */
+        beforePreImageOpen?: (blobPath: string) => Promise<void> | void;
+        /** @internal deterministic same-inode growth seam. */
+        afterPreImageStat?: (blobPath: string) => Promise<void> | void;
+        /** @internal deterministic parent-swap seam, after final path validation. */
+        afterAnchoredParentValidation?: (operation: StoreOperation, parent: string, name: string) => Promise<void> | void;
+        /** @internal exact syscall seam after source validation, before retirement. */
+        beforeStoreFileRetirement?: (filePath: string) => Promise<void> | void;
+        /** @internal deterministic post-rename tree-substitution seam. */
+        afterTreeTombstoneRename?: (tombstonePath: string, taskGroupId: string) => Promise<void> | void;
+        /** @internal deterministic failed-write cleanup seam. */
+        failAnchoredWriteAfterTemp?: boolean;
+        /** @internal fail the Nth anchored write after its temp is durable. */
+        failAnchoredWriteAt?: number;
+        /** @internal fail the Nth anchored write at its post-publication directory sync. */
+        failDirectorySyncAt?: number;
+        /** @internal fail durable child creation before acknowledgement. */
+        failMkdirDirectorySyncStage?: 'mkdir-child' | 'mkdir-parent';
+        /** @internal fail root resealing before acknowledgement. */
+        failRootDirectorySyncStage?: 'target-child' | 'target-parent';
+        /** @internal lower deterministic helper deadline for tests. */
+        helperTimeoutMs?: number;
+        /** @internal deterministic blocked store-helper seam. */
+        testHangStoreHelperBeforeReady?: boolean;
+        /** @internal deterministic bounded pre-image enumeration/read seams. */
+        testHangPreImageEnumerationStat?: boolean;
+        testHangPreImageReadStage?: 'open' | 'read' | 'close';
+        /** @internal deterministic prepared-inode replacement seam. */
+        afterAnchoredWriteValidation?: (filePath: string) => Promise<void> | void;
+        /** @internal deterministic independent-store RMW seam. */
+        afterJsonAuthorityRead?: (filePath: string) => Promise<void> | void;
+        /** @internal deterministic content-addressed create race seam. */
+        afterPreImageAbsentRead?: (blobPath: string) => Promise<void> | void;
+        /** @internal causal cross-process fence test seam. */
+        beforeMergeFenceAcquire?: (taskGroupId: string) => Promise<void> | void;
     });
     /** Serialize `fn` against other track-tip RMW for the same group (Codex r2 MED). */
     private withTrackTipLock;
+    private ownSessionGroup;
+    private ensureOwnerLease;
+    listSessionOwnedGroups(): string[];
     /** The per-group directory `<root>/<taskGroupId>/`. */
     private groupDir;
     /**
@@ -213,19 +336,25 @@ export declare class RevertManifestStore {
      * `recursive: true` honors `mode` for the components it creates.
      */
     private mkdirSecure;
-    /**
-     * Refuse to operate under a path whose any in-`rootDir` component is a symlink
-     * (LOCK #589-G "no symlink following"). lstat each component from `rootDir`
-     * down; a symlinked component throws. Missing components are fine (not yet
-     * created). The `rootDir` itself is lstat-checked too.
-     */
-    private assertNoSymlinkComponents;
+    private runStoreHelper;
     /**
      * Atomic write: write `<final>.tmp.<pid>.<rand>` (`0600`) → fsync → rename →
      * fsync(dir). Refuses symlinked components first. NEVER logs CONTENT.
      */
     private atomicWrite;
+    /**
+     * Capture one group directory by an opened, no-follow handle. Callers carry
+     * this identity from the authority read through destructive cleanup, so a
+     * pathname replacement can never make GC remove a different directory.
+     */
+    private captureGroupIdentity;
+    private captureChildDirectoryIdentity;
+    private assertGroupIdentity;
+    private readJsonSnapshot;
     private readJson;
+    private readRecordSnapshot;
+    private readJournalSnapshot;
+    private assertSnapshotParent;
     /**
      * Append a track's promote entries to the group manifest, BEFORE the tree
      * mutates (LOCK #589-I). Spills pre-image content to `preimages/<sha>.blob`.
@@ -256,8 +385,43 @@ export declare class RevertManifestStore {
      * tip is missing.
      */
     readTrackTips(taskGroupId: string): Promise<TrackTipsView>;
-    /** Read a pre-image blob's content by its manifest `preImageRef`. */
-    readPreImage(taskGroupId: string, preImageRef: string): Promise<string>;
+    /**
+     * Persist one track's reviewed bytes and per-file pre-image hashes. The
+     * record is idempotent on `trackIndex`, serialized against sibling tracks,
+     * atomic, and removed with the group lifecycle.
+     */
+    appendTrackBundle(taskGroupId: string, bundle: SnapshotTrackBundle): Promise<void>;
+    readTrackBundles(taskGroupId: string): Promise<SnapshotBundlesView>;
+    /**
+     * Serialize the complete merge-gate body (including hosted verdict submit)
+     * across every dispatch generation and every desktop executor process that
+     * shares this durable group root. The callback process owns the lock through
+     * an OS-incarnation identity; helper death cannot split the fence and PID
+     * reuse cannot inherit it.
+     */
+    withSnapshotMergeGateFence<T>(taskGroupId: string, operation: () => Promise<T>, signal?: AbortSignal): Promise<T>;
+    private withSnapshotMergeGateFenceTimeout;
+    /** Cross-process RMW fence for aggregate quotas and manifest append. */
+    private withGroupWriterFence;
+    clearTrackBundles(taskGroupId: string): Promise<void>;
+    readSnapshotPromotion(taskGroupId: string): Promise<SnapshotPromotionJournalV1 | null>;
+    /** Durable PREPARE; must complete before the first user-tree mutation. */
+    prepareSnapshotPromotion(taskGroupId: string, operationHash: string, files: readonly ReviewedShadowDiffFile[], workspaceRootAuthority: WorkspaceRootAuthority): Promise<void>;
+    markSnapshotPromotionApplied(taskGroupId: string, operationHash: string): Promise<void>;
+    acknowledgeSnapshotPromotion(taskGroupId: string, operationHash: string): Promise<void>;
+    /**
+     * Terminal reject disposition. `reverted` means every final pre-image was
+     * reverified; `rejected` means user-owned conflicts were explicitly retained.
+     * Either state retires forward-promotion authority and permits terminal GC.
+     */
+    dispositionSnapshotPromotionRejected(taskGroupId: string, operationHash: string, verifiedReverted: boolean): Promise<void>;
+    private setSnapshotPromotionState;
+    /**
+     * Read and authenticate a pre-image through stable no-follow handles. The
+     * manifest hash and the content-addressed filename must agree before any
+     * reverse CAS is allowed to consume these bytes.
+     */
+    readPreImage(taskGroupId: string, preImageRef: string, expectedHash: string): Promise<string>;
     private setLifecycle;
     /** Group accepted/kept → terminal lifecycle `accepted` (GC-eligible). */
     markAccepted(taskGroupId: string): Promise<void>;
@@ -301,8 +465,8 @@ export declare class RevertManifestStore {
     clearPendingDecision(taskGroupId: string): Promise<void>;
     /**
      * Begin a revert journal (or read the existing one to RESUME). If a
-     * `reverting` journal already exists, return it (the caller resumes,
-     * skipping `revertedPaths`); otherwise start a fresh one.
+     * `reverting` journal already exists, return it so the caller can authenticate
+     * its checkpoints and replay idempotently; otherwise start a fresh one.
      */
     beginRevert(taskGroupId: string): Promise<RevertJournalV1>;
     /** Read the current journal (or `null`). */
@@ -311,16 +475,17 @@ export declare class RevertManifestStore {
     /**
      * Record ONE reverted manifest ENTRY (append-only resume cursor). W3-H1: the
      * cursor is keyed on the entry IDENTITY `(promoteOrder, path)` — NOT path alone —
-     * so a same-path multi-promote records EACH step independently and a crash-resume
-     * reverts every remaining step. The path is ALSO appended (legacy/diagnostics
-     * compat). Idempotent on the entry key (a redelivered record is a no-op);
-     * atomic + append-only per LOCK #589-G.
+     * so a same-path multi-promote records EACH step independently. The path is
+     * ALSO appended (legacy/diagnostics compat). The runner authenticates these
+     * checkpoints but replays non-final paths idempotently, so a forged checkpoint
+     * cannot skip a reverse CAS. Idempotent on the entry key; atomic + append-only.
      */
     recordReverted(taskGroupId: string, relPath: string, promoteOrder: number): Promise<void>;
     /** Mark the journal complete (the revert finished this pass). */
     endRevert(taskGroupId: string): Promise<void>;
     /** List every group id with a durable record under `<root>/`. */
     listManifests(): Promise<string[]>;
+    private hasLiveOwnerLease;
     /**
      * GC predicate (LOCK #589-I): delete a group's `<taskGroupId>/` ONLY when its
      * LOCAL lifecycle is terminal (`accepted` / `reject_revert_complete`) OR it is
@@ -328,7 +493,34 @@ export declare class RevertManifestStore {
      * "engine terminal alone" is INSUFFICIENT (the caller reconciles BEFORE GC).
      * Returns the ids it removed.
      */
-    gc(now?: number, ttlMs?: number): Promise<string[]>;
+    gc(now?: number, ttlMs?: number, protectedTaskGroupIds?: ReadonlySet<string>): Promise<string[]>;
+    private gcOneGroup;
+    /**
+     * Same-session terminal reclamation for one group. This is intentionally
+     * stricter than TTL GC: the lifecycle must be terminal, the pending-decision
+     * crash token must be gone, and snapshot promotion must already be terminal.
+     */
+    gcTerminalGroup(taskGroupId: string): Promise<boolean>;
+    /**
+     * Terminal collection for the completion callback that already owns the
+     * stable-root merge fence. Never call this from an independent decision path.
+     */
+    gcTerminalGroupAlreadyFenced(taskGroupId: string): Promise<boolean>;
+    /**
+     * Normal-session retirement for every group authored by this store instance.
+     * Ordinary reviewed bundles/specs/journals are removed immediately. Durable
+     * state is retained only when exact workspace proof says a mutation may still
+     * need replay/revert authority.
+     */
+    disposeSessionOwnedGroups(opts: {
+        verifyPreparedBases: (journal: SnapshotPromotionJournalV1) => Promise<boolean>;
+        verifyManifestBases: (entries: readonly RevertManifestEntry[]) => Promise<boolean>;
+    }): Promise<{
+        removed: string[];
+        retained: string[];
+    }>;
+    private removeGroupDirectory;
 }
 /** SHA-256 hex of UTF-8 content (exported for the promote-site manifest capture). */
 export declare function hashManifestContent(content: string): string;
+export {};

package/node_modules/@quantiya/codevibe-core/dist/local-executor/group-decision-outcome.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Map a group-escalation decision label to its authoritative
+ * `TEAM_GROUP_RESOLVED.outcome` const. Both accept-family decisions resolve the
+ * group `complete`; each reject-family decision has its OWN distinct terminal so
+ * mobile can tell abort / restart / plain-reject apart (the closed-enum promise).
+ *
+ * A label outside the closed 5-option set (only reachable from a corrupt persisted
+ * marker — the SDK re-validates live labels) maps to the safest `group_user_rejected`
+ * so a recovered decision still resolves the group rather than stranding it.
+ */
+export declare function decisionToGroupOutcome(decision: string): string;

package/node_modules/@quantiya/codevibe-core/dist/local-executor/hosted-class-a-sink.d.ts

@@ -0,0 +1,27 @@
+import type { ClassAEnvelope, ClassASink } from './class-a-emit';
+export interface HostedClassARecordTransport {
+    recordExecutionEvent(input: {
+        taskId: string;
+        sessionId: string;
+        kind: 'PROGRESS_EVENT' | 'TOOL_USE';
+        payload: unknown;
+        dedupKeyHex: string;
+    }, sessionKeyBase64: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
+}
+/** A heartbeat must fail quickly enough that a later interval can retry. */
+export declare const HOSTED_CLASS_A_EMIT_TIMEOUT_MS = 10000;
+/**
+ * Class A → existing `recordExecutionEvent` transport.
+ *
+ * The complete signed envelope is the encrypted audit payload. The outer
+ * mutation fields remain the server-readable routing/dedup surface required by
+ * the existing handler; team child tasks receive its targeted lease renewal.
+ */
+export declare class HostedClassASink implements ClassASink {
+    private readonly transport;
+    private readonly sessionKeyBase64;
+    constructor(transport: HostedClassARecordTransport, sessionKeyBase64: string);
+    emit(envelope: ClassAEnvelope): Promise<void>;
+}