@quantiya/codevibe-codex-plugin 2.0.64 → 2.0.66

package/node_modules/@quantiya/codevibe-core/dist/appsync/sync-source-cursor.d.ts

@@ -0,0 +1,529 @@
+import { z } from 'zod';
+import type { CreateDesktopSyncEventInput } from './sync-event-client';
+import type { DesktopSyncSessionScope, DesktopSyncSourceIdentity, DurableSyncResult } from './sync-operation-journal';
+export type DesktopSyncSourceStream = Pick<DesktopSyncSourceIdentity, 'provider' | 'streamSha256'>;
+export declare const MAX_SYNC_SOURCE_ANCHOR_BYTES: number;
+export interface DesktopSyncSourceAnchor {
+    startOffset: number;
+    endOffset: number;
+    sha256: string;
+}
+export interface DesktopSyncSourceFrame extends DesktopSyncSourceIdentity {
+    startOffset: number;
+    endOffset: number;
+    anchor?: DesktopSyncSourceAnchor;
+}
+export interface DesktopSyncSourcePosition {
+    byteOffset: number;
+    anchor: DesktopSyncSourceAnchor | null;
+    discardUntilNewline: boolean;
+}
+export interface DesktopSyncSourceGap {
+    startOffset: number;
+    endOffset: number;
+    anchor: DesktopSyncSourceAnchor;
+    reason: 'BACKLOG_LIMIT' | 'OVERSIZED_RECORD' | 'PARTIAL_RECORD' | 'MALFORMED_RECORD' | 'EMPTY_RECORD';
+    discardUntilNewline: boolean;
+}
+declare const schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"SOURCE_CURSOR">;
+    operationId: z.ZodString;
+    sessionId: z.ZodString;
+    sessionGenerationId: z.ZodString;
+    provider: z.ZodEnum<["codex", "claude", "agy"]>;
+    streamSha256: z.ZodString;
+    byteOffset: z.ZodNumber;
+    anchor: z.ZodNullable<z.ZodEffects<z.ZodObject<{
+        startOffset: z.ZodNumber;
+        endOffset: z.ZodNumber;
+        sha256: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        sha256: string;
+        startOffset: number;
+        endOffset: number;
+    }, {
+        sha256: string;
+        startOffset: number;
+        endOffset: number;
+    }>, {
+        sha256: string;
+        startOffset: number;
+        endOffset: number;
+    }, {
+        sha256: string;
+        startOffset: number;
+        endOffset: number;
+    }>>;
+    discardUntilNewline: z.ZodBoolean;
+    skippedBytes: z.ZodNumber;
+    lastGap: z.ZodNullable<z.ZodEffects<z.ZodObject<{
+        startOffset: z.ZodNumber;
+        endOffset: z.ZodNumber;
+        anchor: z.ZodEffects<z.ZodObject<{
+            startOffset: z.ZodNumber;
+            endOffset: z.ZodNumber;
+            sha256: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        }, {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        }>, {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        }, {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        }>;
+        reason: z.ZodEnum<["BACKLOG_LIMIT", "OVERSIZED_RECORD", "PARTIAL_RECORD", "MALFORMED_RECORD", "EMPTY_RECORD"]>;
+        discardUntilNewline: z.ZodBoolean;
+    }, "strict", z.ZodTypeAny, {
+        reason: "BACKLOG_LIMIT" | "OVERSIZED_RECORD" | "PARTIAL_RECORD" | "MALFORMED_RECORD" | "EMPTY_RECORD";
+        anchor: {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        };
+        startOffset: number;
+        endOffset: number;
+        discardUntilNewline: boolean;
+    }, {
+        reason: "BACKLOG_LIMIT" | "OVERSIZED_RECORD" | "PARTIAL_RECORD" | "MALFORMED_RECORD" | "EMPTY_RECORD";
+        anchor: {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        };
+        startOffset: number;
+        endOffset: number;
+        discardUntilNewline: boolean;
+    }>, {
+        reason: "BACKLOG_LIMIT" | "OVERSIZED_RECORD" | "PARTIAL_RECORD" | "MALFORMED_RECORD" | "EMPTY_RECORD";
+        anchor: {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        };
+        startOffset: number;
+        endOffset: number;
+        discardUntilNewline: boolean;
+    }, {
+        reason: "BACKLOG_LIMIT" | "OVERSIZED_RECORD" | "PARTIAL_RECORD" | "MALFORMED_RECORD" | "EMPTY_RECORD";
+        anchor: {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        };
+        startOffset: number;
+        endOffset: number;
+        discardUntilNewline: boolean;
+    }>>;
+    projection: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+    lastFrame: z.ZodNullable<z.ZodEffects<z.ZodObject<{
+        provider: z.ZodEnum<["codex", "claude", "agy"]>;
+        streamSha256: z.ZodString;
+        occurrence: z.ZodString;
+        sourceSha256: z.ZodString;
+    } & {
+        startOffset: z.ZodNumber;
+        endOffset: z.ZodNumber;
+        anchor: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+            startOffset: z.ZodNumber;
+            endOffset: z.ZodNumber;
+            sha256: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        }, {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        }>, {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        }, {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        }>>;
+    }, "strict", z.ZodTypeAny, {
+        provider: "agy" | "claude" | "codex";
+        streamSha256: string;
+        occurrence: string;
+        sourceSha256: string;
+        startOffset: number;
+        endOffset: number;
+        anchor?: {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        } | undefined;
+    }, {
+        provider: "agy" | "claude" | "codex";
+        streamSha256: string;
+        occurrence: string;
+        sourceSha256: string;
+        startOffset: number;
+        endOffset: number;
+        anchor?: {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        } | undefined;
+    }>, {
+        provider: "agy" | "claude" | "codex";
+        streamSha256: string;
+        occurrence: string;
+        sourceSha256: string;
+        startOffset: number;
+        endOffset: number;
+        anchor?: {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        } | undefined;
+    }, {
+        provider: "agy" | "claude" | "codex";
+        streamSha256: string;
+        occurrence: string;
+        sourceSha256: string;
+        startOffset: number;
+        endOffset: number;
+        anchor?: {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        } | undefined;
+    }>>;
+    entries: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        frame: z.ZodEffects<z.ZodObject<{
+            provider: z.ZodEnum<["codex", "claude", "agy"]>;
+            streamSha256: z.ZodString;
+            occurrence: z.ZodString;
+            sourceSha256: z.ZodString;
+        } & {
+            startOffset: z.ZodNumber;
+            endOffset: z.ZodNumber;
+            anchor: z.ZodOptional<z.ZodEffects<z.ZodObject<{
+                startOffset: z.ZodNumber;
+                endOffset: z.ZodNumber;
+                sha256: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            }, {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            }>, {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            }, {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            }>>;
+        }, "strict", z.ZodTypeAny, {
+            provider: "agy" | "claude" | "codex";
+            streamSha256: string;
+            occurrence: string;
+            sourceSha256: string;
+            startOffset: number;
+            endOffset: number;
+            anchor?: {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            } | undefined;
+        }, {
+            provider: "agy" | "claude" | "codex";
+            streamSha256: string;
+            occurrence: string;
+            sourceSha256: string;
+            startOffset: number;
+            endOffset: number;
+            anchor?: {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            } | undefined;
+        }>, {
+            provider: "agy" | "claude" | "codex";
+            streamSha256: string;
+            occurrence: string;
+            sourceSha256: string;
+            startOffset: number;
+            endOffset: number;
+            anchor?: {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            } | undefined;
+        }, {
+            provider: "agy" | "claude" | "codex";
+            streamSha256: string;
+            occurrence: string;
+            sourceSha256: string;
+            startOffset: number;
+            endOffset: number;
+            anchor?: {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            } | undefined;
+        }>;
+        operationId: z.ZodString;
+        state: z.ZodEnum<["PREPARING", "READY", "SETTLED"]>;
+        projectionAfter: z.ZodNullable<z.ZodEffects<z.ZodString, string, string>>;
+        outcome: z.ZodOptional<z.ZodEnum<["ACCEPTED", "OMITTED"]>>;
+    }, "strict", z.ZodTypeAny, {
+        state: "PREPARING" | "READY" | "SETTLED";
+        frame: {
+            provider: "agy" | "claude" | "codex";
+            streamSha256: string;
+            occurrence: string;
+            sourceSha256: string;
+            startOffset: number;
+            endOffset: number;
+            anchor?: {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            } | undefined;
+        };
+        operationId: string;
+        projectionAfter: string | null;
+        outcome?: "ACCEPTED" | "OMITTED" | undefined;
+    }, {
+        state: "PREPARING" | "READY" | "SETTLED";
+        frame: {
+            provider: "agy" | "claude" | "codex";
+            streamSha256: string;
+            occurrence: string;
+            sourceSha256: string;
+            startOffset: number;
+            endOffset: number;
+            anchor?: {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            } | undefined;
+        };
+        operationId: string;
+        projectionAfter: string | null;
+        outcome?: "ACCEPTED" | "OMITTED" | undefined;
+    }>, {
+        state: "PREPARING" | "READY" | "SETTLED";
+        frame: {
+            provider: "agy" | "claude" | "codex";
+            streamSha256: string;
+            occurrence: string;
+            sourceSha256: string;
+            startOffset: number;
+            endOffset: number;
+            anchor?: {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            } | undefined;
+        };
+        operationId: string;
+        projectionAfter: string | null;
+        outcome?: "ACCEPTED" | "OMITTED" | undefined;
+    }, {
+        state: "PREPARING" | "READY" | "SETTLED";
+        frame: {
+            provider: "agy" | "claude" | "codex";
+            streamSha256: string;
+            occurrence: string;
+            sourceSha256: string;
+            startOffset: number;
+            endOffset: number;
+            anchor?: {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            } | undefined;
+        };
+        operationId: string;
+        projectionAfter: string | null;
+        outcome?: "ACCEPTED" | "OMITTED" | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    anchor: {
+        sha256: string;
+        startOffset: number;
+        endOffset: number;
+    } | null;
+    kind: "SOURCE_CURSOR";
+    entries: {
+        state: "PREPARING" | "READY" | "SETTLED";
+        frame: {
+            provider: "agy" | "claude" | "codex";
+            streamSha256: string;
+            occurrence: string;
+            sourceSha256: string;
+            startOffset: number;
+            endOffset: number;
+            anchor?: {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            } | undefined;
+        };
+        operationId: string;
+        projectionAfter: string | null;
+        outcome?: "ACCEPTED" | "OMITTED" | undefined;
+    }[];
+    sessionId: string;
+    sessionGenerationId: string;
+    byteOffset: number;
+    schemaVersion: 1;
+    provider: "agy" | "claude" | "codex";
+    streamSha256: string;
+    discardUntilNewline: boolean;
+    operationId: string;
+    skippedBytes: number;
+    lastGap: {
+        reason: "BACKLOG_LIMIT" | "OVERSIZED_RECORD" | "PARTIAL_RECORD" | "MALFORMED_RECORD" | "EMPTY_RECORD";
+        anchor: {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        };
+        startOffset: number;
+        endOffset: number;
+        discardUntilNewline: boolean;
+    } | null;
+    projection: string | null;
+    lastFrame: {
+        provider: "agy" | "claude" | "codex";
+        streamSha256: string;
+        occurrence: string;
+        sourceSha256: string;
+        startOffset: number;
+        endOffset: number;
+        anchor?: {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        } | undefined;
+    } | null;
+}, {
+    anchor: {
+        sha256: string;
+        startOffset: number;
+        endOffset: number;
+    } | null;
+    kind: "SOURCE_CURSOR";
+    entries: {
+        state: "PREPARING" | "READY" | "SETTLED";
+        frame: {
+            provider: "agy" | "claude" | "codex";
+            streamSha256: string;
+            occurrence: string;
+            sourceSha256: string;
+            startOffset: number;
+            endOffset: number;
+            anchor?: {
+                sha256: string;
+                startOffset: number;
+                endOffset: number;
+            } | undefined;
+        };
+        operationId: string;
+        projectionAfter: string | null;
+        outcome?: "ACCEPTED" | "OMITTED" | undefined;
+    }[];
+    sessionId: string;
+    sessionGenerationId: string;
+    byteOffset: number;
+    schemaVersion: 1;
+    provider: "agy" | "claude" | "codex";
+    streamSha256: string;
+    discardUntilNewline: boolean;
+    operationId: string;
+    skippedBytes: number;
+    lastGap: {
+        reason: "BACKLOG_LIMIT" | "OVERSIZED_RECORD" | "PARTIAL_RECORD" | "MALFORMED_RECORD" | "EMPTY_RECORD";
+        anchor: {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        };
+        startOffset: number;
+        endOffset: number;
+        discardUntilNewline: boolean;
+    } | null;
+    projection: string | null;
+    lastFrame: {
+        provider: "agy" | "claude" | "codex";
+        streamSha256: string;
+        occurrence: string;
+        sourceSha256: string;
+        startOffset: number;
+        endOffset: number;
+        anchor?: {
+            sha256: string;
+            startOffset: number;
+            endOffset: number;
+        } | undefined;
+    } | null;
+}>;
+export type DesktopSyncSourceCursor = z.infer<typeof schema>;
+export type DesktopSyncSourceInventory = DesktopSyncSessionScope & DesktopSyncSourceStream & {
+    cursorId: string;
+    byteOffset: number;
+    pendingCount: number;
+};
+/** Internal decoder shared by direct opens and bounded restart inventory. */
+export declare function decodeSourceCursor(value: unknown, invalid: () => never): DesktopSyncSourceCursor;
+/** Validate the linked identities as well as the encrypted record's shape. */
+export declare function validateSourceCursor(value: unknown, options: {
+    id: string;
+    scope: Readonly<DesktopSyncSessionScope>;
+    stream: DesktopSyncSourceStream;
+    identify(source: DesktopSyncSourceIdentity): string;
+    invalid(): never;
+}): DesktopSyncSourceCursor;
+export interface DesktopSyncSourceJournal {
+    /** First admission chooses a descriptor-anchored baseline; existing state is never reset. */
+    open(initial: number | DesktopSyncSourcePosition): Promise<DesktopSyncSourceCursor>;
+    load(): Promise<DesktopSyncSourceCursor | null>;
+    /** Null means an explicitly ignored source frame, not quota/network failure. */
+    admit(frame: DesktopSyncSourceFrame, prepare: ((operationId: string) => Promise<CreateDesktopSyncEventInput>) | null, projectionAfter?: string | null): Promise<string | null>;
+    /** Persist an intentional reader safety gap, never a network/quota fallback. */
+    skip(gap: DesktopSyncSourceGap): Promise<void>;
+    /** Repairs interrupted preparation/settlement without source bytes or new encryption. */
+    recover(): Promise<void>;
+    /** Bounded cloud drain, separate from native source admission. */
+    drain(maximum?: number, signal?: AbortSignal): Promise<number>;
+}
+/** Internal persistence capabilities; only the owning encrypted journal constructs these. */
+export declare function createSourceJournal(options: {
+    id: string;
+    scope: Readonly<DesktopSyncSessionScope>;
+    stream: DesktopSyncSourceStream;
+    invalid(): never;
+    missing(): never;
+    locked<T>(fn: (assertOwnership: () => Promise<void>) => Promise<T>): Promise<T>;
+    drainLocked<T>(fn: () => Promise<T>): Promise<T>;
+    read(validate: (value: unknown) => DesktopSyncSourceCursor): Promise<DesktopSyncSourceCursor | null>;
+    write(value: DesktopSyncSourceCursor): Promise<void>;
+    prepare(source: DesktopSyncSourceIdentity, factory: (id: string) => Promise<CreateDesktopSyncEventInput>): Promise<string>;
+    identify(source: DesktopSyncSourceIdentity): string;
+    exists(id: string): Promise<boolean>;
+    retry(id: string, signal?: AbortSignal): Promise<DurableSyncResult>;
+    acknowledge(id: string): Promise<void>;
+}): DesktopSyncSourceJournal;
+export {};

package/node_modules/@quantiya/codevibe-core/dist/appsync/sync-source-file.d.ts

@@ -0,0 +1,33 @@
+import { type DesktopSyncSourceAnchor, type DesktopSyncSourcePosition, type DesktopSyncSourceGap } from './sync-source-cursor';
+export interface DesktopSyncFileIdentity {
+    filePath: string;
+    fileIdentity: Readonly<{
+        dev: number;
+        ino: number;
+    }>;
+}
+export interface DesktopSyncFileFrame extends DesktopSyncFileIdentity {
+    startOffset: number;
+    endOffset: number;
+    sha256: string;
+    anchor: DesktopSyncSourceAnchor;
+}
+export interface DesktopSyncFileAdmission<T> {
+    restore(source: Readonly<DesktopSyncFileIdentity>, initial: DesktopSyncSourcePosition): Promise<DesktopSyncSourcePosition | null>;
+    admit(event: T, source: Readonly<DesktopSyncFileFrame>): Promise<void>;
+    skip(gap: DesktopSyncSourceGap, source: Readonly<DesktopSyncFileIdentity>): Promise<void>;
+}
+/** Bounded descriptor-based reader. Admission/fsync, not cloud delivery, advances it. */
+export declare function readDesktopSyncFile<T>(options: {
+    filePath: string;
+    initialOffset: number;
+    admission: DesktopSyncFileAdmission<T>;
+    parse(line: string): T | null;
+    isCurrent(): boolean;
+    maxBacklogBytes?: number;
+    maxRecordBytes?: number;
+}): Promise<{
+    position: DesktopSyncSourcePosition;
+    size: number;
+    mtimeMs: number;
+} | null>;

package/node_modules/@quantiya/codevibe-core/dist/appsync/sync-source-pair.d.ts

@@ -0,0 +1,33 @@
+import type { CreateDesktopSyncEventInput } from './sync-event-client';
+import type { DesktopSyncSourceFrame, DesktopSyncSourceGap, DesktopSyncSourceJournal, DesktopSyncSourcePosition, DesktopSyncSourceStream } from './sync-source-cursor';
+type Prepare = ((operationId: string) => Promise<CreateDesktopSyncEventInput>) | null;
+export interface DesktopSyncSourcePair {
+    /** Restore the earliest unfinished lane, never the latest volatile reader offset. */
+    open(initial: number | DesktopSyncSourcePosition): Promise<DesktopSyncSourcePosition>;
+    /** Both slots are fixed for this source's lifetime; null explicitly ignores a slot. */
+    admit(frame: DesktopSyncSourceFrame, prepare: readonly [Prepare, Prepare]): Promise<readonly [string | null, string | null]>;
+    skip(gap: DesktopSyncSourceGap): Promise<void>;
+    recover(): Promise<void>;
+    /** The bound is per lane; two lanes cannot starve each other. */
+    drain(maximumPerLane?: number, signal?: AbortSignal): Promise<number>;
+}
+/**
+ * One native frame can carry two independently metered messages (Agy thinking
+ * and response). Each lane uses the existing encrypted cursor/operation WAL.
+ * The reader advances only after BOTH admissions; after a partial admission it
+ * resumes at the minimum cursor. The completed lane suppresses its replay even
+ * if its cloud operation was already settled and removed. There is deliberately
+ * no all-or-nothing cloud batch: each visible event has its own quota decision.
+ *
+ * Pair admission/open are serialized by the owning account's descriptor-checked
+ * lock. Cloud drain does not hold that lock. Lane identity/order is fixed here,
+ * not caller-configurable, so a mapper change cannot silently rename a cursor.
+ */
+export declare function createSourcePair(options: {
+    source: DesktopSyncSourceStream;
+    lanes: readonly [DesktopSyncSourceJournal, DesktopSyncSourceJournal];
+    laneStreams: readonly [string, string];
+    locked<T>(fn: () => Promise<T>): Promise<T>;
+    invalid(): never;
+}): DesktopSyncSourcePair;
+export {};

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

@@ -0,0 +1,51 @@
+type Meters = 'syncUnits' | 'mobileAttachmentCount' | 'mobileAttachmentBytes';
+type Usage = Record<`${Meters}${'Committed' | 'Reserved' | 'Limit' | 'PauseLimit'}`, string> & {
+    syncState: 'ACTIVE' | 'WARNING' | 'PAUSED';
+    usageRevision: string;
+    gapStartedAtEpochMs: string;
+};
+export declare const QUOTA_PAUSED_CONTENT = "Companion sync paused. Continue on desktop. Messages omitted while paused will not be backfilled.";
+export interface CompanionQuotaNotice {
+    schemaVersion: 1;
+    kind: 'QUOTA_PAUSED';
+    noticeId: string;
+    reasonCode: 'SYNC_QUOTA_EXHAUSTED';
+    localizationKey: 'codevibe.sync.quota_paused';
+    content: string;
+}
+export interface CompanionSyncState {
+    schemaVersion: 1;
+    environment: 'development' | 'production';
+    observedAtEpochMs: number;
+    validUntilEpochMs: number;
+    entitlementVersion: string;
+    tier: 'FREE' | 'PRO' | 'MAX';
+    mode: 'LEGACY' | 'SHADOW' | 'AUTHORITATIVE' | 'ROLLBACK_FREEZE';
+    /** Cloud-selected route. FROZEN never authorizes a legacy fallback. */
+    protocol: 'LEGACY' | 'SYNC_V2' | 'FROZEN';
+    controlGeneration: number;
+    accountingGeneration: string | null;
+    periodId: string | null;
+    resetAtEpochMs: number | null;
+    limits: Record<Meters, string>;
+    usage: Usage | null;
+    /** Present exactly when the authoritative usage is PAUSED; display only. */
+    quotaNotice?: CompanionQuotaNotice;
+}
+/** Display feed only. Callers must never use an observed snapshot as an
+ * admission cache; writes still perform the normal cloud-authorized request. */
+export interface CompanionSyncStateSource {
+    subscribeCompanionSyncState(userId: string, listener: (state: CompanionSyncState | null) => void): () => void;
+    getCompanionSyncState(signal?: AbortSignal): Promise<CompanionSyncState>;
+}
+/** Cloud authority tuple wins over response arrival time. An equal tuple may
+ * extend freshness, but cannot silently change the quota or route payload. */
+export declare function companionSyncStateMerge(next: CompanionSyncState, previous: CompanionSyncState): 'REPLACE' | 'RETAIN' | 'CONFLICT';
+export declare function companionSyncStateReplaces(next: CompanionSyncState, previous: CompanionSyncState): boolean;
+export declare function companionSyncBadge(state: CompanionSyncState | null, now?: number): string | null;
+/** Persistent usage details; wording and exact counters match the native
+ * subscription surfaces. Input is a validated, account-fenced observation. */
+export declare function companionSyncUsageLines(state: CompanionSyncState | null, now?: number): string[];
+/** Validate cloud state; never manufacture a tier, quota, route or empty usage. */
+export declare function parseCompanionSyncState(value: unknown, environment: string, now?: number): CompanionSyncState;
+export {};

package/node_modules/@quantiya/codevibe-core/dist/appsync/sync-usage-warning.d.ts

@@ -0,0 +1,33 @@
+import { type CompanionSyncState } from './sync-state';
+declare const METERS: readonly ["syncUnits", "mobileAttachmentCount", "mobileAttachmentBytes"];
+type Meter = typeof METERS[number];
+export interface CompanionSyncUsageWarning {
+    meter: Meter;
+    committed: string;
+    reserved: string;
+    limit: string;
+    periodId: string;
+    resetDate: string;
+}
+/** Same closed, committed-only 80% projection and copy as both mobile apps. */
+export declare function companionSyncUsageWarnings(state: CompanionSyncState | null, now?: number): CompanionSyncUsageWarning[];
+export declare function companionSyncUsageWarningMessage(warnings: readonly CompanionSyncUsageWarning[]): string | null;
+/** Installation-local advisory markers only; never admission authority. One
+ * <=4 KiB file per hashed account/environment, retaining at most three months.
+ * The existing portable lock serializes sibling TUI sessions. No OAuth path is
+ * used; ownerless/reclaim ambiguity fails only this advisory, not local work.
+ */
+export declare class CompanionSyncWarningStore {
+    private readonly options;
+    private readonly root;
+    private readonly pending;
+    private closed;
+    constructor(options?: {
+        root?: string;
+        now?: () => number;
+    });
+    present(state: CompanionSyncState, userId: string, isCurrent: () => boolean, presenter: (warnings: CompanionSyncUsageWarning[]) => boolean): Promise<CompanionSyncUsageWarning[]>;
+    close(): Promise<void>;
+    private run;
+}
+export {};