@quantiya/codevibe-codex-plugin 2.0.6 → 2.0.8

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

@@ -26,33 +26,37 @@ export interface InReviewAssignment {
  * recovery-row type — NOT an extension of the live `TrackAssignedPayload` (so the
  * live Class B contract stays unpolluted). Mirrors the engine handler's camelCase
  * `TeamTrackRecoveryRow` serde:
- *   - ALWAYS present: `taskGroupId`, `trackIndex`, `relaunch`, and `encryptedBrief?`
+ *   - ALWAYS present: `taskGroupId`, `trackIndex`, `taskId`,
+ *     `dispatchGeneration`, `relaunch`, and `encryptedBrief?`
  *     (omitted when the track had no description → recovery treats it as an empty
- *     brief). `taskGroupId` is on EVERY row (seed-only too) so the desktop keys its
- *     recovered brief + corrupt-brief tombstone by `(taskGroupId, trackIndex)` —
- *     B.2 aggregates across groups, so a bare `trackIndex` key could cross-blend
- *     two groups (#593 Stage-2 r2 Codex MEDIUM).
+ *     brief). The four identity fields bind recovered brief and tombstone
+ *     authority to `(taskGroupId, trackIndex, taskId, dispatchGeneration)`;
+ *     reused group/index slots cannot cross-contaminate generations.
  *   - ONLY when `relaunch === true` (flattened at top level): the full live
- *     `TrackAssigned` wire-field set (`taskId`, `implementorAgent`,
- *     `ownershipScope`, `isSharedTestOwner`, `stateDir`, `dispatchId`,
- *     `dispatchGeneration`, `conflictContext`) PLUS recovery metadata (`gateRunId`,
+ *     `TrackAssigned` wire-field set (the always-present identity fields plus
+ *     `implementorAgent`, `ownershipScope`, `isSharedTestOwner`, `stateDir`,
+ *     `dispatchId`, `conflictContext`) and recovery metadata (`gateRunId`,
  *     `gateType`). These camelCase keys are byte-identical to the live
  *     `TrackAssigned` Class B packet, so `normalizeTrackAssignedWire(row)` accepts
  *     a relaunch row directly (it picks the expected keys and ignores the extras).
  *
  * Typed loosely (`unknown` payload past the always-present fields) because the
- * relaunch keys are present-or-absent; the recovery loop runs the shared
- * `normalizeTrackAssignedWire` + `isValidTrackAssignedPayload` validators on the
- * raw row (never a divergent second validator), so the SDK does not re-type them.
+ * relaunch keys are present-or-absent. Recovery first validates complete row
+ * shape/correlation, then runs the shared `normalizeTrackAssignedWire` +
+ * `isValidTrackAssignedPayload` live validators.
  */
 export interface TeamTrackRecoveryRow {
     /**
      * The owning task group's id — present on EVERY row (seed-only + relaunch) so
-     * recovered briefs + tombstones key by `(taskGroupId, trackIndex)` and B.2's
-     * cross-group aggregation can't collide on a shared `trackIndex` (#593 r2).
+     * recovered rows carry complete authority, so B.2's cross-group aggregation
+     * cannot collide on a shared `trackIndex`.
      */
     taskGroupId: string;
     trackIndex: number;
+    /** Child task identity; present on seed-only and relaunch rows. */
+    taskId: string;
+    /** Current u32 dispatch generation; present on every recovery row. */
+    dispatchGeneration: number;
     /** Bare base64 ciphertext; absent when the track had no description. */
     encryptedBrief?: string;
     relaunch: boolean;
@@ -76,6 +80,28 @@ export interface TaskGroupStatusResult {
     status: string;
     haltReason?: string;
 }
+/**
+ * A1e hosted blind-hold upload input. These are the ONLY client-supplied
+ * plaintext fields permitted by the shared-context ZK boundary. `expiresAt`
+ * is intentionally absent: AppSync derives it from the authoritative Session
+ * row so a stale/offline desktop cannot extend retention.
+ */
+export interface PutContextItemInput {
+    sessionId: string;
+    seq: string;
+    taskId?: string;
+    trackId?: string;
+    ciphertext: string;
+}
+/** Host-emittable audit surface used by the signed Class A transport. */
+export interface RecordExecutionEventInput {
+    taskId: string;
+    sessionId: string;
+    kind: 'TASK_CREATED' | 'TASK_TERMINATED' | 'PROGRESS_EVENT' | 'TOOL_USE' | 'DESTRUCTIVE_ACTION_ESCALATED' | 'FLAG_BAD_APPROVAL';
+    /** Free-form JSON; encrypted before crossing AppSync. */
+    payload: unknown;
+    dedupKeyHex: string;
+}
 /**
  * PHASE-CP-1-F.1 Part A (LOCK L2) — tolerant `AWSJSON!` object read.
  *
@@ -120,6 +146,42 @@ export interface TaskReviewSummaryReviewer {
     reasoning: string;
     /** ReviewerVerdict.suggested_changes (may be empty). */
     suggestedChanges: string[];
+    /** Non-blocking observations that did not request another revision. */
+    residualObservations?: string[];
+}
+export interface TaskReviewSummaryRequirements {
+    problem: string;
+    expectedOutputs: string[];
+}
+export interface TaskReviewSummaryImplementor {
+    agent: string;
+    trackIndex?: number;
+    taskId: string;
+}
+export interface TaskReviewSummaryQuorumSeat {
+    seatId: number;
+    role: string;
+    agent: string;
+}
+export interface TaskReviewSummaryQuorum {
+    seats: TaskReviewSummaryQuorumSeat[];
+    roundCount: number;
+    revisionCount: number;
+}
+export interface TaskReviewSummaryMergeGate {
+    applicable: boolean;
+    outcome: string;
+    resolution?: string;
+}
+export interface TaskReviewSummaryDurations {
+    taskElapsedMs?: number;
+    reviewerElapsedMs?: number;
+    availability: string;
+}
+export interface TaskReviewSummaryTokenUsage {
+    knownTotal?: number;
+    availability: string;
+    unavailableRoles: string[];
 }
 /** One round in the per-round summary (decrypted). */
 export interface TaskReviewSummaryRound {
@@ -140,6 +202,15 @@ export interface TaskReviewSummaryRound {
  * projection; `truncatedForSize`/`omittedRounds` flag the size-cap degrade.
  */
 export interface TaskReviewSummary {
+    /** Present on the additive P15 terminal-report shape; absent on legacy v1. */
+    schemaVersion?: number;
+    requirements?: TaskReviewSummaryRequirements;
+    implementors?: TaskReviewSummaryImplementor[];
+    reviewQuorum?: TaskReviewSummaryQuorum;
+    mergeGate?: TaskReviewSummaryMergeGate;
+    durations?: TaskReviewSummaryDurations;
+    tokenUsage?: TaskReviewSummaryTokenUsage;
+    residualRisks?: string[];
     rounds: TaskReviewSummaryRound[];
     /** The resolution that produced the final-approval prompt (normally proceed). */
     finalOutcome: string;
@@ -186,6 +257,12 @@ export declare class AppSyncGraphQLError extends Error {
         path?: unknown;
     });
 }
+export type AppSyncAuthenticationFailureKind = 'refresh_auth_rejected' | 'refresh_network';
+/** A foreground GraphQL 401 that token refresh could not recover. */
+export declare class AppSyncAuthenticationError extends Error {
+    readonly kind: AppSyncAuthenticationFailureKind;
+    constructor(kind: AppSyncAuthenticationFailureKind);
+}
 /**
  * PHASE-CP-10-MIN (#585) §2.3 — the parsed cross-device applyUserDecision
  * echo. Mirrors the quorum-core SDK's `UserDecisionAppliedEvent`
@@ -225,19 +302,16 @@ export declare function shouldDeliverSubscribedEvent(event: Pick<Event, 'source'
  * Discriminator for the most recent `authenticateWithStoredTokens()`
  * failure. Lets callers distinguish a genuine "no tokens / refresh
  * rejected" outcome from a transient network failure during the
- * Cognito refresh-token POST.
+ * Cognito refresh-token POST, or a credential-store failure that prevented
+ * the token read from completing.
  *
  * Stage 2 round-1 Codex M1: the production refresh path returns
  * `false` on every error (including network blow-ups inside
- * `callCognitoRefresh`'s catch block), so the wizard's auth-vs-network
- * heuristic — which only ran on caught throws — never fired in
- * production. Recording the kind on every false-return path lets
- * `setup-bootstrap.ts:defaultClientFactory()` route network-shaped
- * refresh failures to `subscription_status_network` (per §6 row
- * "transient 5xx during refresh") instead of misleading the user with
- * a "not signed in" abort.
+ * `callCognitoRefresh`'s catch block). Recording the kind on every
+ * false-return path lets CLI callers distinguish a transient network
+ * failure from a genuine sign-in rejection.
  */
-export type AuthFailureKind = 'no_tokens' | 'refresh_auth_rejected' | 'refresh_network';
+export type AuthFailureKind = 'no_tokens' | 'refresh_auth_rejected' | 'refresh_network' | 'credential_storage_unavailable';
 /**
  * AppSync GraphQL client with WebSocket subscriptions
  */
@@ -250,8 +324,7 @@ export declare class AppSyncClient {
     private activeSubscriptions;
     /**
      * Set by `authenticateWithStoredTokens()` on every false-return path
-     * (and reset to `null` on success). Read by callers (e.g., the
-     * wizard's `defaultClientFactory`) to discriminate auth-rejection
+     * (and reset to `null` on success). Read by callers to discriminate auth-rejection
      * vs network-failure without re-running the auth call. Stage 2
      * round-1 Codex M1.
      */
@@ -267,8 +340,31 @@ export declare class AppSyncClient {
      */
     private lastRefreshNetworkError;
     private pendingRefresh;
+    private pendingRefreshCredential;
+    /**
+     * All five WebSocket watcher families reconcile the same process-wide token
+     * cache. Collapse concurrent reconnects onto one bounded durable read /
+     * refresh operation so a keyring stall cannot multiply native calls.
+     */
+    private pendingReconnectReconciliation;
+    /**
+     * A stopped watcher cancels only its wait on the shared reconciliation. The
+     * flight remains live for other watcher families and owns its own deadline.
+     */
+    private reconnectReconciliationWaiters;
+    /**
+     * Every in-process credential replacement advances this generation. Async
+     * refresh/reconciliation work captures it before starting and may mutate the
+     * token cache only while that captured generation is still current.
+     */
+    private tokenStateGeneration;
     private lastRefreshFailureAt;
+    private lastRefreshFailureCredential;
     private static readonly REFRESH_BACKOFF_MS;
+    /** Bounds the shared Cognito flight even when a transport ignores abort. */
+    private static readonly COGNITO_REFRESH_TIMEOUT_MS;
+    /** Bounds the durable read and any refresh as one reconnect operation. */
+    private static readonly RECONNECT_RECONCILIATION_TIMEOUT_MS;
     private deviceKeyWatcher;
     private sessionUpdateWatchers;
     private applyUserDecisionWatchers;
@@ -288,23 +384,16 @@ export declare class AppSyncClient {
      * `authenticateWithStoredTokens()` failure, or `null` if the call
      * succeeded (or has never been called).
      *
-     * Stage 2 round-1 Codex M1. Callers (today: `setup-bootstrap.ts
-     * :defaultClientFactory`) use this to distinguish network blow-ups
+     * Stage 2 round-1 Codex M1. Callers use this to distinguish network blow-ups
      * during the Cognito refresh-token POST from genuine auth
-     * rejections. The wizard maps `'refresh_network'` to
-     * `subscription_status_network` (don't tell a signed-in user to
-     * re-login when their tokens are valid and the network is broken)
-     * and the other two kinds to `not_signed_in` (preserves
-     * pre-Codex-M1 behavior).
+     * Credential-storage failure remains distinct because re-authentication
+     * cannot repair a locked or unavailable keyring.
      */
     getLastAuthFailureKind(): AuthFailureKind | null;
     /**
      * Heuristic — does the error message look like a transient network
-     * failure rather than an auth-token rejection? Mirrors
-     * `setup-bootstrap.ts:isNetworkLikeError` byte-for-byte so the same
-     * classifier runs both inside the client (for refresh-path
-     * discrimination) and at the bootstrap boundary (for caught-throw
-     * routing). Stage 2 round-1 Codex M1.
+     * failure rather than an auth-token rejection? Used for refresh-path
+     * discrimination. Stage 2 round-1 Codex M1.
      */
     private static isNetworkLikeMessage;
     /**
@@ -314,6 +403,23 @@ export declare class AppSyncClient {
     /**
      * Refresh expired tokens
      */
+    private static abortReason;
+    private static throwIfAborted;
+    /**
+     * Bound one stage by its owning operation's absolute deadline. Every stage
+     * receives the same `deadlineAtMs`; a storage-backed retry therefore consumes
+     * the first attempt's elapsed time instead of acquiring another full timeout.
+     * `onTimeout` is used by network stages to abort their transport, while the
+     * explicit race remains authoritative when it ignores that signal.
+     */
+    private static awaitWithinAbsoluteDeadline;
+    /**
+     * Cancel only this caller's wait. The shared operation remains live for
+     * concurrent callers and its owner clears the single-flight slot only when
+     * the operation itself settles.
+     */
+    private static awaitSharedFlightForCaller;
+    private replaceTokens;
     private refreshTokens;
     /**
      * Do the work of refreshing tokens. Tries the caller-supplied tokens
@@ -337,25 +443,35 @@ export declare class AppSyncClient {
      */
     private callCognitoRefresh;
     /**
-     * Apply a successful refresh response: update in-memory cache first,
-     * clear the backoff sentinel, then persist to storage. Success here
-     * is defined as "the process has usable fresh tokens in memory" —
-     * storage persistence is degraded-success, not a failure mode.
+     * Apply a successful refresh response to this process's in-memory cache.
+     * Cognito's refresh response does not rotate the durable refresh token, so
+     * the already-stored credentials remain sufficient to refresh again after a
+     * restart.
      *
-     * Ordering matters. The API call to Cognito already succeeded, which
-     * means we hold valid access/id tokens right now. If we delayed the
-     * in-memory update until after persistence and the keychain write
-     * threw (keychain locked, disk full, file-backend permission error),
-     * we'd be stuck with stale-and-known-dead tokens in memory while
-     * holding valid fresh tokens in local scope that vanish at the end
-     * of this function. That would re-break both guarantees this hotfix
-     * makes: no-restart recovery becomes "restart required to escape
-     * the keychain-lock window," and backoff stays unarmed so the
-     * caller hot-loops against a working Cognito endpoint — R1's MEDIUM
-     * on round 1 of this review. Persistence-failure is loud-logged
-     * so operators can see degraded durability without losing availability.
+     * Do not rewrite durable login credentials from this background refresh.
+     * Native keychain writes are not cancellable: once a deadline wins, a late
+     * write could otherwise overwrite a newer out-of-band login or resurrect
+     * credentials deleted by a concurrent logout process. Login/logout remain
+     * the sole durable credential writers; refresh remains one bounded,
+     * memory-only operation.
      */
     private applyRefreshedTokens;
+    /**
+     * Reconcile durable login credentials with this process's token cache before
+     * reconnecting a WebSocket watcher.
+     *
+     * Background refresh deliberately leaves the durable refresh credential
+     * unchanged. When storage still contains the older access/id pair for that
+     * same refresh token, a newer non-expired in-memory pair must therefore win;
+     * otherwise every reconnect would issue a redundant Cognito refresh. A
+     * different stored refresh token is an out-of-band login and remains
+     * authoritative.
+     */
+    private reconcileTokensBeforeReconnect;
+    private performReconnectTokenReconciliation;
+    private beginReconnectReconciliationWait;
+    private finishReconnectReconciliationWait;
+    private cancelReconnectReconciliationWait;
     /**
      * Check if authenticated
      */
@@ -372,6 +488,21 @@ export declare class AppSyncClient {
      * Create a session
      */
     createSession(input: CreateSessionInput): Promise<Session>;
+    /**
+     * Blind-hold one canonical ContextItem. The mutation is idempotent only for
+     * an exact ciphertext+routing replay; a conflicting rewrite is rejected by
+     * the backend and therefore throws here, leaving the local durable outbox
+     * available for retry/diagnosis.
+     */
+    putContextItem(input: PutContextItemInput): Promise<void>;
+    /**
+     * Persist one host-authenticated execution fact. The payload is encrypted
+     * under the task's session key; for team child tasks the backend performs the
+     * same conditional write as the audit append to renew that exact track lease.
+     */
+    recordExecutionEvent(input: RecordExecutionEventInput, sessionKeyBase64: string, options?: {
+        signal?: AbortSignal;
+    }): Promise<void>;
     /**
      * Update a session
      */
@@ -385,6 +516,16 @@ export declare class AppSyncClient {
      * Create an event
      */
     createEvent(input: CreateEventInput): Promise<Event>;
+    /**
+     * E1 (§3.1) — liveness TTL co-refresh for the caller's still-open prompt rows
+     * (+ their deep-linked Events). Plugins call this heartbeat-driven for their
+     * durable open-prompt ledger so a >7-day-open prompt's row is NOT TTL-deleted
+     * (under-nag). The backend is scoped to `$ctx.identity.sub` + `attribute_exists`
+     * per promptId, so it works post-retirement too. Returns the promptIds whose
+     * row/Event had already aged out — the caller re-raises those (§6a-4
+     * return-driven re-raise). No-ops on an empty list (no network call).
+     */
+    refreshOpenPromptTtl(promptIds: string[]): Promise<string[]>;
     /**
      * Update event status
      */
@@ -402,6 +543,8 @@ export declare class AppSyncClient {
         agentType: string;
         status: string;
         lastHeartbeatAt: string | null;
+        createdAt: string | null;
+        updatedAt: string | null;
     }>>;
     /**
      * Mark stale ACTIVE sessions of a given agentType INACTIVE so they
@@ -409,19 +552,20 @@ export declare class AppSyncClient {
      * startup to clean up after daemons that died without running their
      * graceful shutdown (crash, auth-loop death, force-kill, power loss).
      *
-     * Staleness rule: lastHeartbeatAt is older than `staleThresholdMs`
-     * (default 15 min — a conservative ~7.5× the 2-min heartbeat
-     * interval, giving legitimately-active daemons on other machines
-     * ample margin before we consider their session abandoned).
+     * Staleness rule: the newest usable timestamp among lastHeartbeatAt,
+     * createdAt, and updatedAt is older than `staleThresholdMs` (default
+     * 15 min — a conservative ~7.5× the 2-min heartbeat interval, giving
+     * legitimately-active daemons on other machines ample margin before
+     * we consider their session abandoned). createdAt/updatedAt cover a
+     * creator that dies before its first heartbeat.
      *
      * Safety:
      *   - Only sessions with status === 'ACTIVE' are candidates.
      *   - Sessions explicitly listed in `excludeSessionIds` are skipped
      *     (caller can pass the session the daemon is about to attach to
      *     if the ID is known before the sweep).
-     *   - Absent `lastHeartbeatAt` (never-heartbeated sessions — should
-     *     only happen for rows created within the last few seconds)
-     *     treats the session as fresh and skips.
+     *   - A row with no parseable heartbeat/create/update timestamp is
+     *     skipped fail-safe; the sweeper never guesses its age.
      *   - updateSession failures are logged as warnings and don't abort
      *     the sweep — best-effort cleanup.
      *
@@ -648,7 +792,9 @@ export declare class AppSyncClient {
      * real classification; the signing helper is `signMergeClassification` in
      * `local-executor/class-a-sign.ts`). W2.a ships the SDK surface only.
      */
-    submitMergeGateVerdict(input: SubmitMergeGateVerdictInput): Promise<SubmitMergeGateVerdictResult>;
+    submitMergeGateVerdict(input: SubmitMergeGateVerdictInput, opts?: {
+        signal?: AbortSignal;
+    }): Promise<SubmitMergeGateVerdictResult>;
     /**
      * PHASE-589/469 W1 (LOCK #589-F) — report that ONE team track HARD-FAILED
      * its own local gate (a declared-test failure or an out-of-scope write). The
@@ -700,6 +846,7 @@ export declare class AppSyncClient {
         sessionId: string;
         decision: PlannerDecision;
         availableAgents?: string[];
+        implementorAgent?: string;
     }): Promise<{
         workflowState: string;
     }>;
@@ -922,6 +1069,8 @@ export declare class AppSyncClient {
      */
     subscribeToEvents(sessionId: string, onEvent: (event: Event) => void, onError?: (error: Error) => void, options?: {
         receiveDesktopEvents?: boolean;
+        onSubscribed?: (isReconnect: boolean) => void;
+        onSessionRetired?: () => Promise<void> | void;
     }): () => void;
     /**
      * Build WebSocket URL
@@ -950,6 +1099,7 @@ export declare class AppSyncClient {
      * Create WebSocket subscription
      */
     private createSubscription;
+    private handleSubscriptionStartAck;
     /**
      * Send subscription start message
      */
@@ -1059,19 +1209,37 @@ export declare class AppSyncClient {
     private handleApplyUserDecisionWatcherError;
     private cleanupApplyUserDecisionWatcherState;
     private heartbeatTimers;
+    /** Identity tokens invalidate in-flight pulses when a session is stopped. */
+    private heartbeatTokens;
+    /** Shared initial confirmation makes duplicate start calls idempotent. */
+    private heartbeatInitialPulses;
+    private heartbeatInitialOutcomes;
+    /** Every pulse that may still persist a timestamp, including periodic pulses. */
+    private heartbeatInFlight;
     /**
      * Start periodic heartbeat for a session.
      * Updates lastHeartbeatAt on the session every intervalMs (default 2 minutes).
      */
-    startHeartbeat(sessionId: string, intervalMs?: number): void;
+    startHeartbeat(sessionId: string, intervalMs?: number): Promise<boolean>;
+    private startHeartbeatOutcome;
     /**
      * Stop heartbeat for a session.
      */
     stopHeartbeat(sessionId: string): void;
+    /**
+     * Fence every heartbeat generation, wait for already-issued timestamp writes,
+     * then persist an expired timestamp so mobile immediately renders the desktop
+     * disconnected. The ordering is load-bearing: writing the tombstone before an
+     * in-flight pulse settles would let that older pulse make the row look live
+     * again after this method returned.
+     */
+    invalidateHeartbeat(sessionId: string): Promise<boolean>;
+    private trackHeartbeatPulse;
     /**
      * Send a single heartbeat update.
      */
     private sendHeartbeat;
+    private notifyRetiredSession;
     /**
      * Tear down the mobile-event subscription for a SINGLE session.
      *

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

@@ -1,3 +1,4 @@
+import type { Event } from '../types/events';
 /** Exposed for the single log line in createEvent. */
 export declare const CLIENT_THROTTLE_EVENTS_PER_WINDOW: number;
 interface RateWindow {
@@ -21,6 +22,38 @@ export declare function shouldSuppressEvent(sessionId: string, type: string, now
 export declare function consumeThrottleLogOnce(sessionId: string): RateWindow | undefined;
 /** Test-only: clears the per-process rate map. */
 export declare function resetThrottleState(): void;
+/**
+ * True iff a `createEvent` result is PROVEN durably persisted by the backend (a real
+ * stored Events row), as opposed to a NON-persisted synthetic acknowledgement that
+ * EITHER throttle layer returns over-cap:
+ *   - the CLIENT throttle above (`createEvent` short-circuit) → `eventId` prefixed
+ *     `local-throttled-`, no `writerAuthenticated`;
+ *   - the BACKEND Lambda's per-SESSION guardrail → fresh `generateId()`, no
+ *     `writerAuthenticated`;
+ *   - the BACKEND per-ACCOUNT guardrail → fresh `generateId()`, no
+ *     `writerAuthenticated` (its `rateLimitNotice` marker is not even in the
+ *     `createEvent` selection set, so it never reaches the client);
+ * none of which stored a row.
+ *
+ * The single reliable POSITIVE persistence signal is `writerAuthenticated`: the
+ * backend stamps it (a boolean — `false` for a non-writer emit, `true` for a writer-
+ * attested one) on EVERY persisted Event and returns it in the `createEvent`
+ * selection set (queries.ts). No synthetic populates it — the client synthetic omits
+ * it (→ `undefined`) and every backend synthetic omits it (→ `null` through GraphQL).
+ * `emittedBy` (the other persist-only attribute) is `EventAuthor!` (non-null) in the
+ * schema, so it CANNOT be selected on a mutation whose resolver may return a
+ * synthetic — a non-null field resolving to null would error the whole response —
+ * which is exactly why `writerAuthenticated` (nullable) is the only persist marker
+ * safely in the selection set. The `local-throttled-` guard is belt-and-suspenders.
+ *
+ * Deliberately CONSERVATIVE: returns true ONLY on positive proof, so any
+ * unrecognized / partial shape is treated as NOT-persisted. Callers use this to
+ * decide whether to record a legacy `TOOL_USE` id as "legacy-owned" (§4.8) — being
+ * wrong toward "not persisted" only forgoes a dedup (a cosmetic duplicate render),
+ * whereas being wrong toward "persisted" on a synthetic would suppress the
+ * consolidator re-derive and permanently SKIP the tool (G2). Never the latter.
+ */
+export declare function isPersistedEventResult(event: Pick<Event, 'eventId' | 'writerAuthenticated'> | null | undefined): boolean;
 /** Test-only: current size of the per-process rate map (eviction-bound check). */
 export declare function throttleMapSize(): number;
 /** Test-only: whether a session is currently tracked (eviction assertions). */

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

@@ -1,5 +1,6 @@
-export { AppSyncClient, AppSyncGraphQLError, DownloadUrlResponse } from './appsync-client';
+export { AppSyncClient, AppSyncAuthenticationError, AppSyncGraphQLError, DownloadUrlResponse, } from './appsync-client';
 export { coerceAwsJsonObject } from './appsync-client';
 export type { ClassBPacketEnvelopeMeta } from './appsync-client';
-export type { TaskReviewSummary, TaskReviewSummaryRound, TaskReviewSummaryReviewer, TaskGroupStatusResult, } from './appsync-client';
+export type { TaskReviewSummary, TaskReviewSummaryRound, TaskReviewSummaryReviewer, TaskGroupStatusResult, PutContextItemInput, } from './appsync-client';
 export { queries, mutations, subscriptions } from './queries';
+export { isPersistedEventResult } from './event-throttle';

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

@@ -7,8 +7,9 @@ export declare const queries: {
      * Minimal session listing used by the orphan-sweep path. Only the
      * fields needed to decide whether a session row is stale — sessionId
      * for the INACTIVE mutation, agentType for the per-plugin filter,
-     * status to skip non-ACTIVE rows, and lastHeartbeatAt for the age
-     * check.
+     * status to skip non-ACTIVE rows, lastHeartbeatAt for the usual age
+     * check, and createdAt/updatedAt as the startup-age fallback for rows
+     * whose creator died before its first heartbeat.
      */
     listSessions: string;
     getSubscriptionStatus: string;
@@ -23,9 +24,12 @@ export declare const queries: {
     getTaskReviewSummary: string;
 };
 export declare const mutations: {
+    recordExecutionEvent: string;
+    putContextItem: string;
     createSession: string;
     updateSession: string;
     createEvent: string;
+    refreshOpenPromptTtl: string;
     updateEventStatus: string;
     registerDeviceKey: string;
     grantSessionKey: string;

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

@@ -23,6 +23,31 @@ export type AuthFailureReason = 'port_in_use' | 'port_range_exhausted' | 'server
  * not user AFK).
  */
 export type AuthStage = 'server_start' | 'browser_open' | 'awaiting_callback' | 'exchanging_code' | 'storing_tokens' | 'unknown';
+/**
+ * Preserve the retired shell wrappers' exact activation-funnel identity.
+ * POSIX `echo` added a trailing newline before hashing, so omitting `\n` here
+ * would split the same machine across two GA4 client IDs after the A6 cutover.
+ */
+declare function getLegacyWrapperClientId(): string;
+/**
+ * Agent label used by the long-lived `wrapper_launched` activation-funnel
+ * event. Keep these values aligned with the historical public-wrapper event so
+ * the 2.x unified CLI continues the same GA4 series.
+ */
+export type CompanionActivationAgent = 'claude' | 'codex' | 'antigravity';
+declare function legacyWrapperBaseParams(): Record<string, string>;
+/**
+ * Preserve the final activation-funnel event after A6 retires the public
+ * `codevibe-*` wrappers. The unified Companion route calls this exactly once
+ * after resolving the selected agent and before handing off to its private
+ * launcher. The caller awaits the bounded best-effort transport before its
+ * synchronous child handoff blocks the event loop.
+ */
+export declare function fireWrapperLaunchedBeacon(agent: CompanionActivationAgent): Promise<void>;
+export declare const __testing: {
+    getLegacyWrapperClientId: typeof getLegacyWrapperClientId;
+    legacyWrapperBaseParams: typeof legacyWrapperBaseParams;
+};
 /**
  * Fire the `auth_completed` success beacon. Replaces the inline POST
  * previously duplicated in `auth-cli.ts`. Includes `user_id` so the
@@ -165,3 +190,4 @@ export declare function fireSessionEncryptionSelfRekeyTimeoutBeacon(params: {
     session_hash: string;
     attempt_count: number;
 }): Promise<void>;
+export {};

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

@@ -0,0 +1,6 @@
+/**
+ * Run the `keychain` subcommand group. Returns the process exit code (does NOT
+ * call `process.exit` — the caller does, keeping this unit-testable). `argv` is
+ * the raw process argv (node, script, "keychain", subcommand, flags…).
+ */
+export declare function runKeychainCli(argv: string[]): Promise<number>;

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

@@ -0,0 +1,49 @@
+import { type OAuthAccountLock } from "../credential-broker/oauth-account-lock";
+import type { VendorKeyStore, VendorOAuthBundle } from "../credential-broker/types";
+/** Injectable IO seam so the subcommands are unit-testable without a TTY. */
+export interface VendorKeyCliIO {
+    print(line: string): void;
+    printErr(line: string): void;
+    /** Read a secret with NO echo (hidden). Never appears in argv/logs. */
+    readSecret(prompt: string): Promise<string>;
+    /** Read a visible yes/no consent answer. */
+    confirm(prompt: string): Promise<boolean>;
+}
+/** Injectable dependencies (production defaults wire the real store/keychain/lock). */
+export interface VendorKeyCliDeps {
+    store: VendorKeyStore;
+    io: VendorKeyCliIO;
+    /** The §5 cross-process OAuth-account lock for C4 mutations. */
+    oauthLock: OAuthAccountLock;
+    /**
+     * Resolve (WITHOUT reading) the Codex auth file path — displayed in the consent
+     * prompt BEFORE any read (§4/§7: the prompt must authorize the read it names).
+     */
+    codexAuthPath: () => string;
+    /** Read `~/.codex/auth.json` raw contents (or null if missing) — ONLY AFTER consent. */
+    readCodexAuth: (authPath: string) => Promise<string | null>;
+    /**
+     * Content-BLIND existence check for the Codex auth file — used by the setup
+     * wizard for flow control WITHOUT reading token material before consent
+     * (§4/§7). Never opens/parses the file; existence only.
+     */
+    codexAuthExists: (authPath: string) => Promise<boolean>;
+    /** True iff the OS-native keychain is the active custody backend. */
+    custodyAvailable: () => boolean;
+    now: () => Date;
+    /**
+     * Run `claude setup-token` interactively with INHERITED stdio (the token is
+     * displayed by the claude CLI itself and pasted by the user — never captured
+     * from the subprocess). Resolves the exit code, or null when the `claude`
+     * binary is not on PATH.
+     */
+    runClaudeSetupToken: () => Promise<number | null>;
+}
+/** Parse a Codex `auth.json` into the C4 bundle. Never logs token material. */
+export declare function parseCodexAuth(raw: string): VendorOAuthBundle | null;
+/**
+ * Run the `vendor-key` subcommand group. Returns the process exit code (does NOT
+ * call `process.exit` — the caller does, keeping this unit-testable). `argv` is
+ * the full process argv (node, script, `vendor-key`, sub, …).
+ */
+export declare function runVendorKeyCli(argv: string[], depsOverride?: Partial<VendorKeyCliDeps>): Promise<number>;