@quantiya/codevibe-claude-plugin 2.0.75 → 2.0.77

package/node_modules/@quantiya/codevibe-core/dist/session-resume/resume-create.d.ts

@@ -0,0 +1,121 @@
+/**
+ * P61 — create the successor S (SESSION-RESUME-DESIGN.md §12.2.2, §8.3, §10;
+ * Phase B implementation design §3, B-3, B-15, B-16).
+ *
+ * Order, under P's resume lock: mint S → prepare S's keys → write the
+ * carry-over to S's log and prove it by readback ending in the marker →
+ * seal the ledger → `createSession` → classify. Cleanup follows §12.2.4
+ * exactly. Every effect is injected, so each outcome class is testable.
+ */
+import type { ContextItem, ContextItemDraft, VerifiedContextItemsResult } from '../orchestration-shell/context-items';
+import type { CreateSessionInput, Session } from '../types/session';
+import type { EncryptedSessionKey } from '../types/encryption';
+import { type ResumeCreateOutcome } from './create-outcome';
+import { type CarryOverPlan } from './carry-over';
+import { type ResumeLedgerRecord } from './resume-ledger';
+export interface ResumeCreateDeps {
+    mintSessionId(): string;
+    /** `creationRequestId` for the idempotent create path. */
+    mintRequestId(): string;
+    prepareEncryption(sessionId: string): Promise<{
+        sessionKey: string;
+        encryptedKeys: EncryptedSessionKey[];
+    } | null>;
+    encryptContent(plaintext: string, sessionKey: string): string;
+    deviceId(): Promise<string>;
+    append(sessionId: string, draft: ContextItemDraft): Promise<ContextItem | null>;
+    flush(sessionId: string): Promise<void>;
+    readVerified(sessionId: string): Promise<VerifiedContextItemsResult>;
+    sealLedger(record: Omit<ResumeLedgerRecord, 'schema' | 'sealedAt'>): Promise<ResumeLedgerRecord>;
+    /** INV-5 rebuild: replace the existing ledger's marker, only while it is still this resume (P61B-S2-R1-F1). */
+    resealLedger(previous: ResumeLedgerRecord, marker: ResumeLedgerRecord['marker']): Promise<ResumeLedgerRecord>;
+    dropLedger(record: ResumeLedgerRecord): Promise<void>;
+    /**
+     * INV-6 on the `SessionIdRetired` path (P61B-S2-R1-F4): record S's publish obligation before its
+     * ledger is dropped, so it survives the drop and every later resume entry point retries it.
+     */
+    writeRetireNote(note: {
+        successorSessionId: string;
+        predecessorSessionId: string;
+        marker: {
+            seq: string;
+            itemSha256: string;
+        };
+    }): Promise<void>;
+    /** Remove S's prepared local directories by exact path (never P's). */
+    removeSuccessorDirectory(successorSessionId: string): Promise<void>;
+    createSession(input: CreateSessionInput): Promise<Session>;
+    /** Post-admission response check shared with the plain create path; throws on mismatch. */
+    checkAdmitted(session: Session, input: CreateSessionInput): 'exact' | 'resume';
+    /** End an S that must not run (B-15). Best effort. */
+    retireSession(sessionId: string): Promise<void>;
+    /**
+     * Write S's owner record (§12.5) before S's first context append — the
+     * carry-over — so this process is S's recorded single writer from the start.
+     */
+    claimSuccessorOwnership(successorSessionId: string): Promise<void>;
+}
+export type ResumeCreateResult = {
+    kind: 'admitted';
+    session: Session;
+    sessionKey: string;
+    marker: ContextItem;
+    ledger: ResumeLedgerRecord;
+} | {
+    kind: 'refused';
+    outcome: Exclude<ResumeCreateOutcome, {
+        kind: 'ambiguous';
+    }>;
+}
+/** Unknown outcome: S's directory and the ledger stay for replay at the next resume entry point. */
+ | {
+    kind: 'ambiguous';
+    outcome: Extract<ResumeCreateOutcome, {
+        kind: 'ambiguous';
+    }> | {
+        kind: 'ambiguous';
+        cause: 'response-mismatch';
+    };
+}
+/** The server did not resume P: a placeholder for a blocked caller (B-16), or a backend that ignored the predecessor (B-15). */
+ | {
+    kind: 'not-resumed';
+    cause: 'not-admitted' | 'predecessor-ignored' | 'ledger-pending';
+} | {
+    kind: 'encryption-unavailable';
+} | {
+    kind: 'carry-over-failed';
+}
+/**
+ * `/resume` parent (§5.3 step 1): S's carry-over is verified and the ledger
+ * sealed; the create is left to the relaunched child, which replays it.
+ */
+ | {
+    kind: 'prepared';
+    ledger: ResumeLedgerRecord;
+    marker: ContextItem;
+};
+export declare function createResumedSession(args: {
+    userId: string;
+    predecessorSessionId: string;
+    predecessorDirectory: string;
+    /** P's last activity, kept in the ledger for a replay's header (P61B-S1-E2). */
+    predecessorEndedAt?: string;
+    cwd: string;
+    plan: CarryOverPlan;
+    sourceComplete: boolean;
+    /** §8.4 step 2: the carry-over was rebuilt from P's own predecessor. */
+    rebuiltFrom?: string;
+    /** Stop after sealing the ledger (the `/resume` parent). */
+    prepareOnly?: boolean;
+    deps: ResumeCreateDeps;
+}): Promise<ResumeCreateResult>;
+/**
+ * Send (or replay, byte-for-byte) the sealed create and apply §12.2.4. Used
+ * for a new resume and for every interrupted one (§6.2 step 2).
+ */
+export declare function sendResumeCreate(args: {
+    ledger: ResumeLedgerRecord;
+    marker: ContextItem;
+    deps: Pick<ResumeCreateDeps, 'createSession' | 'checkAdmitted' | 'dropLedger' | 'removeSuccessorDirectory' | 'retireSession' | 'writeRetireNote'>;
+}): Promise<ResumeCreateResult>;

package/node_modules/@quantiya/codevibe-core/dist/session-resume/resume-entry.d.ts

@@ -0,0 +1,87 @@
+/**
+ * P61 resume entry points (`--continue`, `--resume [<id>]`, the `/resume`
+ * child): design §5.1, §6.2 steps 1–4, §12.2.3. Every effect is injected.
+ *
+ * 1. Read the lists and match the target (`collectResumeCandidates`).
+ * 2. Finish interrupted resumes on this computer: retry retire notes, replay
+ *    sealed ledgers. The targeted one starts S's shell; the others are
+ *    published and retired (INV-6). A definitive refusal of the targeted one
+ *    stops with its copy; it never falls through to another session. Each
+ *    replay first makes this process S's recorded owner (INV-1/INV-2) and
+ *    applies INV-5: S's verified local carry-over must end in its marker, or
+ *    it is rebuilt from P, or the replay fails closed.
+ * 3. Retire exactly the `willRetire` rows of the step-1 read.
+ * 4. Resolve the target (picker, non-TTY list, `--continue`, id) and resume it.
+ */
+import type { ContextItem, ReadOnlyContextLogResult } from '../orchestration-shell/context-items';
+import { type ResumeCandidateDeps } from './resume-candidates';
+import { type ResumeChosenDeps } from './resume-chosen';
+import type { ResumeCreateResult } from './resume-create';
+import type { ResumeLedgerRecord, ResumeRetireNote } from './resume-ledger';
+import { type UnlockedResumeRow } from './resume-rows';
+import { type ResumeEntryPoint } from './resume-target';
+import type { RetireCandidateRow } from './will-retire';
+import type { OwnerTakeover, ResumeLockHandle } from './local-records';
+import { type SuccessorLogFailure, type SuccessorRebuildResult } from './successor-carry-over';
+import type { Session } from '../types/session';
+export interface ResumeStart {
+    session: Session;
+    sessionKey: string;
+    predecessorSessionId: string;
+    predecessorDirectory: string | null;
+    predecessorEndedAtMs: number | null;
+    /** S's carried items, marker excluded, for `RESTORE_CONVERSATION`. */
+    restoredItems: ContextItem[];
+    markerSeq: string;
+    rulesRestored: number;
+    warnings: string[];
+    /** P's resume lock; released once S's shell has started. */
+    lock: ResumeLockHandle;
+}
+export type ResumeEntryResult = {
+    kind: 'start';
+    start: ResumeStart;
+} | {
+    kind: 'exit';
+    code: number;
+};
+export interface ResumeEntryDeps {
+    candidates: ResumeCandidateDeps;
+    chosen: ResumeChosenDeps;
+    /** §6.2 step 3 on the step-1 rows (`sweepOrphanSessionsFromRows`). */
+    retireRows(rows: RetireCandidateRow[], ids: ReadonlySet<string>): Promise<string[]>;
+    listRetireNotes(): Promise<ResumeRetireNote[]>;
+    /** Re-drain and retire one noted S (INV-6); true when it is now retired. */
+    retryRetireNote(note: ResumeRetireNote): Promise<boolean>;
+    /**
+     * Drop P's ledger when it still names the note's S (P61B-S2-R2-F1). True when no such ledger remains;
+     * false when one may (it cannot be read now).
+     */
+    settleNotedLedger(note: ResumeRetireNote): Promise<boolean>;
+    /** The `/resume` child's adopted predecessor (§12.6), whose lock step 2a must not take; null otherwise. */
+    handOffSessionId?: string | null;
+    /** Re-send one sealed create byte-for-byte, under P's lock (taken by the caller). */
+    replayLedger(record: ResumeLedgerRecord, marker: ContextItem): Promise<ResumeCreateResult>;
+    /** Publish then retire an admitted, non-targeted S. */
+    /** `carriedItems`: S's verified carry-over, for its picker preview (P61B-S1-L12). */
+    publishThenRetire(record: ResumeLedgerRecord, carriedItems: readonly ContextItem[]): Promise<'retired' | 'noted'>;
+    /** A read-only read of S's local log (B-8): never writes S's directory. */
+    readSuccessorLog(successorSessionId: string): Promise<ReadOnlyContextLogResult>;
+    /** Make this process S's recorded owner (`takeOverOwnerRecord`); P names the resume, for a `/resume` hand-off. */
+    takeOverSuccessorOwnership(successorSessionId: string, predecessorSessionId: string): Promise<OwnerTakeover>;
+    /** Mark S's owner record finished (`markOwnerFinished`) once this launch is done with a non-targeted S. */
+    markSuccessorFinished(successorSessionId: string): Promise<boolean>;
+    /** INV-5: set S's log aside and rebuild its carry-over from P (`rebuildSuccessorCarryOver`). */
+    rebuildSuccessor(args: {
+        record: ResumeLedgerRecord;
+        reason: SuccessorLogFailure;
+        interactive: boolean;
+    }): Promise<SuccessorRebuildResult>;
+    /** Picker (terminal only). Returns the chosen session ID, or null when cancelled. */
+    pick(rows: UnlockedResumeRow[]): Promise<string | null>;
+    print(text: string): void;
+    printError(text: string): void;
+}
+/** The plain-text list (no terminal): full IDs, directory, last prompt, then `tail`. */
+export declare function listText(rows: UnlockedResumeRow[], tail: string): string;
+export declare function runResumeEntryPoint(entry: ResumeEntryPoint, deps: ResumeEntryDeps): Promise<ResumeEntryResult>;

package/node_modules/@quantiya/codevibe-core/dist/session-resume/resume-header.d.ts

@@ -0,0 +1,25 @@
+/** Display cap for one restored reply (§5.4); the agents still get the full text. */
+export declare const RESTORED_REPLY_MAX_LINES = 40;
+export declare const RESTORED_REPLY_MAX_CHARS = 4000;
+export declare const RESTORED_REPLY_SHORTENED = "\u2026 (shortened here; the agents still have it)";
+export declare const NO_REPLY_RECORDED = "(no reply was recorded)";
+export declare function shortId(sessionId: string): string;
+export declare function endedAgo(endedAtMs: number, nowMs: number): string;
+export declare function displayPath(directory: string, home?: string): string;
+export declare function buildResumeHeader(args: {
+    predecessorSessionId: string;
+    successorSessionId: string;
+    endedAtMs: number | null;
+    nowMs: number;
+    recordedDirectory: string | null;
+    cwd: string;
+    rulesRestored: number;
+    warnings: readonly string[];
+    home?: string;
+}): {
+    top: string;
+    warnings: string[];
+    bottom: string;
+};
+/** §5.4 display shortening for a restored reply (display only). */
+export declare function shortenRestoredReply(text: string): string;

package/node_modules/@quantiya/codevibe-core/dist/session-resume/resume-io.d.ts

@@ -0,0 +1,34 @@
+import type { AppSyncClient } from '../appsync/appsync-client';
+import type { Logger } from '../logger';
+import { type CreateSessionInput, type Session } from '../types/session';
+import { type ResumeLockHandle } from './local-records';
+import { toPickerRows } from './picker-rows';
+import type { ResumeEntryDeps } from './resume-entry';
+import type { ContinueLabel } from './completeness-copy';
+/**
+ * A failed resume create is classified by `classifyResumeCreateFailure`; an unconfirmed one prints §10's
+ * "Couldn't confirm the resume" copy and keeps the ledger for replay, but nothing recorded WHY (E2E r18 and
+ * container-a-r3, both transient backend contention). Logs the failure's class and the server's short
+ * message (metadata only, no session content), then rethrows the same error, so classification is unchanged.
+ */
+export declare function logResumeCreateFailures(create: (input: CreateSessionInput) => Promise<Session>, logger: Pick<Logger, 'warn'>): (input: CreateSessionInput) => Promise<Session>;
+export declare function createResumeEntryDeps(args: {
+    client: AppSyncClient;
+    userId: string;
+    deviceId: string;
+    cwd: string;
+    isTTY: boolean;
+    logger: Logger;
+    ownSessionId?: string;
+    pick: (rows: ReturnType<typeof toPickerRows>) => Promise<string | null>;
+    choose: (prompt: string, continueLabel?: ContinueLabel) => Promise<boolean>;
+    print: (text: string) => void;
+    printError: (text: string) => void;
+    nowMs?: () => number;
+    /**
+     * `/resume` child (§12.6): P's lock adopted from the live parent. It serves
+     * the acquire for that P (the parent still holds it, waiting on this
+     * process), and lets S's owner record pass from the parent to this process.
+     */
+    adoptedLock?: ResumeLockHandle | null;
+}): ResumeEntryDeps;

package/node_modules/@quantiya/codevibe-core/dist/session-resume/resume-ledger.d.ts

@@ -0,0 +1,107 @@
+/**
+ * P61 session resume — the resume ledger and retire notes
+ * (SESSION-RESUME-DESIGN.md §12.2, INV-5/INV-6/INV-7/INV-10/INV-11; Phase B
+ * implementation design §3, §5).
+ *
+ * The ledger lives in its own directory, never under `pending-session-creates/`,
+ * so a plain launch can neither replay a resume nor be blocked by one (INV-10;
+ * code map finding 9). It is sealed with the device-bound at-rest key because
+ * it carries S's session key. A ledger sealed for another signed-in user is
+ * never read for replay, modified or deleted (INV-11).
+ */
+import type { CreateSessionInput } from '../types/session';
+declare const LEDGER_SCHEMA = "codevibe.resume_ledger.v1";
+declare const RETIRE_SCHEMA = "codevibe.resume_retire_note.v1";
+export declare function resumeLedgerDir(): string;
+export declare function resumeRetireDir(): string;
+export declare function resumeLedgerPath(predecessorSessionId: string): string;
+export interface ResumeLedgerRecord {
+    schema: typeof LEDGER_SCHEMA;
+    userId: string;
+    predecessorSessionId: string;
+    successorSessionId: string;
+    /** The exact create, replayed byte-for-byte (carries creationRequestId and resumedFromSessionId). */
+    createInput: CreateSessionInput;
+    /** S's session key (base64). */
+    sessionKey: string;
+    /** P's recorded directory, decrypted at resume time (the `--continue` match key). */
+    predecessorDirectory: string;
+    /** S's carry-over marker, which ends S's verified log. */
+    marker: {
+        seq: string;
+        itemSha256: string;
+    };
+    /**
+     * P's last activity when the resume began (`lastHeartbeatAt`, else `createdAt`), so a replay's header
+     * can say "ended <when>" as the fresh path does (§5.4; P61B-S1-E2). Absent on older ledgers.
+     */
+    predecessorEndedAt?: string;
+    sealedAt: string;
+}
+/** P already has a sealed ledger: an interrupted resume of P must be finished first (P61B-S1-L7). */
+export declare class ResumeLedgerExistsError extends Error {
+    constructor();
+}
+export declare class ResumeLedgerKeychainUnavailableError extends Error {
+    constructor();
+}
+/**
+ * Seal the ledger for one predecessor (design §12.2.2 step 3: after the
+ * carry-over is verified, before `createSession`). Throws when the record
+ * cannot be sealed: the resume then aborts with nothing claimed.
+ */
+export declare function sealResumeLedger(record: Omit<ResumeLedgerRecord, 'schema' | 'sealedAt'>): Promise<ResumeLedgerRecord>;
+/** The ledger on disk is no longer the resume being rebuilt: nothing was written (P61B-S2-R1-F1). */
+export declare class ResumeLedgerChangedError extends Error {
+    constructor();
+}
+/**
+ * Replace P's ledger after an INV-5 rebuild re-authored S's carry-over, which changes only the
+ * marker (P61B-S2-R1-F1: `sealResumeLedger` refuses every existing ledger, and an interrupted resume
+ * always has one). The ledger on disk must still be this exact resume — same user, P, S, key and
+ * create input, so the replay stays byte-for-byte — or nothing is written. The replacement is atomic
+ * and read back before it counts. The caller holds P's resume lock and is S's recorded owner.
+ */
+export declare function resealResumeLedger(previous: ResumeLedgerRecord, marker: ResumeLedgerRecord['marker'], signedInUserId: string): Promise<ResumeLedgerRecord>;
+export type ResumeLedgerRead = {
+    state: 'ok';
+    record: ResumeLedgerRecord;
+    file: string;
+} | {
+    state: 'foreign';
+    file: string;
+} | {
+    state: 'keychain-unavailable';
+    file: string;
+} | {
+    state: 'quarantined';
+    file: string;
+};
+/** Read one ledger file, fail-closed and INV-11-safe. */
+export declare function readResumeLedgerFile(file: string, signedInUserId: string): Promise<ResumeLedgerRead | null>;
+/** Every ledger on this computer (§6.2 step 1 target matching). */
+export declare function listResumeLedgers(signedInUserId: string): Promise<ResumeLedgerRead[]>;
+/**
+ * Drop a ledger after its outcome is definitive. Removes only the exact file
+ * whose content still names this successor for this user.
+ */
+export declare function dropResumeLedger(record: ResumeLedgerRecord, signedInUserId: string): Promise<void>;
+export interface ResumeRetireNote {
+    schema: typeof RETIRE_SCHEMA;
+    userId: string;
+    successorSessionId: string;
+    predecessorSessionId: string;
+    marker: {
+        seq: string;
+        itemSha256: string;
+    };
+    /** S's picker preview (P61B-S1-L12); absent on older notes. */
+    encryptedLastPrompt?: string;
+    notedAt: string;
+}
+export declare function resumeRetireNotePath(successorSessionId: string): string;
+/** Record an admitted S whose publish-then-retire failed; later entry points retry it. */
+export declare function writeResumeRetireNote(note: Omit<ResumeRetireNote, 'schema' | 'notedAt'>): Promise<void>;
+export declare function listResumeRetireNotes(signedInUserId: string): Promise<ResumeRetireNote[]>;
+export declare function clearResumeRetireNote(note: Pick<ResumeRetireNote, 'userId' | 'successorSessionId'>, signedInUserId: string): Promise<void>;
+export {};

package/node_modules/@quantiya/codevibe-core/dist/session-resume/resume-messages.d.ts

@@ -0,0 +1,68 @@
+/**
+ * P61 §10 — the exact refusal and failure copy. Pure: callers pass what they
+ * already know (the `getResumeDetails` row, the create result).
+ */
+import type { ResumeDetails } from '../types/session';
+import type { ResumeCreateResult } from './resume-create';
+export declare const OLD_BACKEND_MESSAGE = "Resume isn't available on this CodeVibe server yet.";
+/**
+ * P61B-S1-L13: a backend without Phase A has no resume queries, so step 1's read fails GraphQL
+ * validation before anything runs, and the §10 old-backend copy applies. AppSync's answer, observed
+ * against Development on 2026-10-15 (`tools/probe_undefined_query_field.js`, Phase B assumption
+ * PB-13): "Validation error of type FieldUndefined: Field '<query>' in type 'Query' is undefined".
+ */
+export declare function isResumeUnavailableOnServer(error: unknown): boolean;
+/** The text for a resume that threw instead of returning a §10 refusal. */
+export declare function resumeErrorMessage(error: unknown, prefix: string): string;
+/** The plain create path's session-cap copy (`cli.ts` `classifyOrchestrationSessionBootstrapError`); §10: a resume's
+ * cap refusal uses "the existing create-path messages". One constant, so the two paths cannot drift. */
+export declare const SESSION_LIMIT_MESSAGE = "Your active-session limit is reached. Close an active session in the CodeVibe mobile app or exit another desktop agent, then try again.";
+export declare const ACCOUNT_DELETION_MESSAGE = "Your CodeVibe account is being deleted, so sessions can't be resumed.";
+export declare function noMatchMessage(id: string): string;
+export declare function companionMessage(id: string, agentType: string): string;
+export declare function alreadyResumedMessage(id: string, successorSessionId: string, successorResumable: boolean): string;
+export declare function windowClosedMessage(id: string): string;
+/**
+ * DD-1 (amended 2026-10-15, Hendry: "Fix copy + mobile follow-up"). A computer
+ * signed in when the session started always holds its key. The phone apps
+ * derive keys for the sessions they list only while ACTIVE and keep them in
+ * memory, so the dependable way for a phone to share an ENDED session's key is
+ * an app that has stayed open since the session was running (E2E-7 r4). It is
+ * not the only way: the iOS app also caches the key of a session it opens from
+ * a notification, in any status (DD-1, A-5; P61B-S1-L4, P61B-S2-R1-L2).
+ */
+export declare function noKeyMessage(id: string): string;
+/**
+ * P61B-S1-L5: the rebuild of an interrupted resume (INV-5). This computer held P's key when it
+ * prepared S, so a missing key now means its device identity changed since (`codevibe reset-device`
+ * deletes it; the next launch mints a new one). The way forward is the same as `noKeyMessage`.
+ */
+export declare function resetIdentityNoKeyMessage(id: string): string;
+/**
+ * The refusal for a chosen session decided from its `getResumeDetails` row,
+ * before anything is prepared. `still-active` defers to the §6.2 owner-record
+ * table; `null` means resumable.
+ */
+export declare function refusalFromDetails(id: string, details: ResumeDetails | null, successorResumable?: boolean): {
+    kind: 'message';
+    text: string;
+} | {
+    kind: 'still-active';
+} | null;
+/** §10 copy for a create result; null for an admitted S. */
+export declare function createResultMessage(predecessorSessionId: string, result: ResumeCreateResult): string | null;
+/** §10, `SessionIdRetired` on a ledger replay. */
+export declare function admittedThenRetiredMessage(predecessorSessionId: string, successorSessionId: string): string;
+/**
+ * §6.2 "When P is chosen but is still ACTIVE", by P's owner record here and
+ * `willRetire`. `retire-and-continue` means retire P now (as the sweep does),
+ * then resume; `continue` means step 3 already retired it.
+ */
+export declare function stillActiveDecision(id: string, ownerState: 'finished' | 'dead' | 'live' | 'absent' | 'unreadable', retiring: boolean): {
+    kind: 'refuse';
+    text: string;
+} | {
+    kind: 'retire-and-continue';
+} | {
+    kind: 'continue';
+};

package/node_modules/@quantiya/codevibe-core/dist/session-resume/resume-rows.d.ts

@@ -0,0 +1,24 @@
+import type { ResumeDetails } from '../types/session';
+import type { TargetSession } from './resume-target';
+export type UnlockFailure = 'no-envelope-for-this-computer' | 'keychain-unavailable';
+export interface UnlockedResumeRow {
+    details: ResumeDetails;
+    sessionKey: string | null;
+    /** Why the row could not be unlocked here (null when unlocked). */
+    failure: UnlockFailure | null;
+    directory: string | null;
+    lastPrompt: string | null;
+    /** §5.2 / amendment A-1 ordering: `max(lastHeartbeatAt, createdAt)` in ms, or null. */
+    activityMs: number | null;
+}
+export declare function resumeRowActivityMs(details: Pick<ResumeDetails, 'lastHeartbeatAt' | 'createdAt'>): number | null;
+export declare function unlockResumeRow(details: ResumeDetails): Promise<UnlockedResumeRow>;
+/** The target-matching view of an unlocked row (§12.2.3). */
+export declare function toTargetSession(row: UnlockedResumeRow, retiring?: boolean): TargetSession;
+/** Picker order: most recent activity first; undatable rows last, by ID. */
+export declare function sortByActivity<T extends {
+    activityMs: number | null;
+    details: {
+        sessionId: string;
+    };
+}>(rows: readonly T[]): T[];

package/node_modules/@quantiya/codevibe-core/dist/session-resume/resume-target.d.ts

@@ -0,0 +1,65 @@
+/**
+ * P61 target matching (SESSION-RESUME-DESIGN.md §5.1, §6.2 step 1, §12.2.3).
+ * Pure: the caller has already read `listResumableSessions` to the end, the
+ * account's `listSessions`, and this computer's resume ledgers, and has
+ * decrypted each recorded directory it can.
+ */
+/** §5.1 — the shortest session ID prefix `--resume <id>` accepts. */
+export declare const RESUME_ID_PREFIX_MIN_CHARS = 8;
+export type ResumeEntryPoint = {
+    kind: 'continue';
+    cwd: string;
+} | {
+    kind: 'resume-id';
+    id: string;
+} | {
+    kind: 'resume-pick';
+}
+/** The `/resume` child: its exact P, nothing else. */
+ | {
+    kind: 'child';
+    predecessorSessionId: string;
+};
+export interface TargetSession {
+    sessionId: string;
+    /** Decrypted recorded directory; null when this computer cannot unlock the row. */
+    directory: string | null;
+    /** `max(lastHeartbeatAt, createdAt, updatedAt)` in ms; null when none parses. */
+    activityMs: number | null;
+    /** True for an ACTIVE row this launch retires (`willRetire`), resumable once retired. */
+    retiring?: true;
+}
+export interface TargetLedger {
+    predecessorSessionId: string;
+    /** P's recorded directory, sealed in the ledger at resume time. */
+    predecessorDirectory: string;
+    sealedAtMs: number;
+}
+export type ResumeTarget = 
+/** Finish this interrupted resume as the targeted one (its S's shell starts). */
+{
+    kind: 'ledger';
+    predecessorSessionId: string;
+}
+/** Resume this session (retire it first when `retiring`). */
+ | {
+    kind: 'session';
+    sessionId: string;
+    retiring: boolean;
+}
+/** Ask the user; `sessionIds` limits the picker (all resumable sessions when absent). */
+ | {
+    kind: 'pick';
+    sessionIds?: string[];
+}
+/** `--continue` found nothing in this directory. */
+ | {
+    kind: 'nothing-to-continue';
+}
+/** No resumable session or interrupted resume matches; the caller asks `getResumeDetails` for the exact §10 refusal of a full ID. */
+ | {
+    kind: 'no-match';
+    id: string;
+};
+export declare function isFullSessionId(id: string): boolean;
+export declare function resolveResumeTarget(entry: ResumeEntryPoint, sessions: readonly TargetSession[], ledgers: readonly TargetLedger[]): ResumeTarget;

package/node_modules/@quantiya/codevibe-core/dist/session-resume/shell-resume-io.d.ts

@@ -0,0 +1,25 @@
+/**
+ * P61 `/resume` inside the shell — production bindings (design §5.3). The
+ * picker and the §8.4 choice open as in-shell modals; prints become shell
+ * advisories. The rules live in `shell-resume.ts`.
+ */
+import type { AppSyncClient } from '../appsync/appsync-client';
+import type { Logger } from '../logger';
+import type { OrchestrationAction, OrchestrationState, Tier } from '../orchestration-shell/types';
+import { type ShellResumeOutcome } from './shell-resume';
+/** Running work as `/status` shows it: a running task, or a team that has not resolved or halted. */
+export declare function shellHasRunningWork(state: Pick<OrchestrationState, 'runningTasks' | 'team'>): boolean;
+export declare function runShellResumeInShell(opts: {
+    client: AppSyncClient;
+    store: {
+        dispatch(action: OrchestrationAction): void;
+        getState(): OrchestrationState;
+    };
+    ownSessionId: string;
+    tier: Tier;
+    isTTY: boolean;
+    origin: 'keyboard' | 'mobile';
+    id: string | null;
+    cwd: string;
+    logger: Logger;
+}): Promise<ShellResumeOutcome>;

package/node_modules/@quantiya/codevibe-core/dist/session-resume/shell-resume.d.ts

@@ -0,0 +1,34 @@
+import type { RelaunchRequest } from './relaunch';
+import { type ResumeEntryDeps } from './resume-entry';
+export declare const RESUME_DESKTOP_ONLY = "/resume works on the desktop only.";
+export declare const RESUME_RUNNING_WORK = "Finish or cancel the running work first \u2014 /status shows it.";
+export declare const RESUME_NEEDS_PAID_TIER = "Resuming a session needs CodeVibe Pro or Max.";
+export declare const RESUME_CANCELLED = "Resume cancelled. This session continues.";
+export type ShellResumeOutcome = 
+/** Print and keep this session running (an empty text prints nothing). */
+{
+    kind: 'message';
+    text: string;
+}
+/** End this session through `/exit`, then relaunch as the resume of P. */
+ | {
+    kind: 'switch';
+    request: RelaunchRequest;
+};
+/** Step 1's first checks, before anything is read (a phone, Free, running work). */
+export declare function shellResumePreCheck(args: {
+    origin: 'keyboard' | 'mobile';
+    paidTier: boolean;
+    hasRunningWork(): boolean;
+}): string | null;
+export declare function runShellResume(args: {
+    /** `/resume <id>`; null opens the picker (or lists without a terminal). */
+    id: string | null;
+    origin: 'keyboard' | 'mobile';
+    /** Pro or Max. */
+    paidTier: boolean;
+    hasRunningWork(): boolean;
+    ownSessionId: string;
+    /** Entry-point deps built for this shell (`ownSessionId` set; in-shell picker and choice). */
+    deps: ResumeEntryDeps;
+}): Promise<ShellResumeOutcome>;

package/node_modules/@quantiya/codevibe-core/dist/session-resume/source-choice.d.ts

@@ -0,0 +1,37 @@
+/**
+ * P61 §8.1 — which copy of P's context a resume reads, and whether this
+ * process may write P's directory. Pure over what the caller has already
+ * established: the resume lock, P's owner record here, a read-only read of
+ * P's local log, and whether P ran on this computer.
+ */
+import type { ContextItem, ReadOnlyContextLogResult } from '../orchestration-shell/context-items';
+import type { OwnerRecordState } from './local-records';
+/** Why a resume on the computer where P ran uses the hosted copy (the §8.1 fallback-reason table). */
+export type HostedFallbackReason = 'keychain-unavailable' | 'local-log-absent' | 'unreadable-local-log';
+export type ResumeSourceChoice = {
+    source: 'local';
+    items: ContextItem[];
+    tail: {
+        seq: string;
+        itemSha256: string;
+    } | null;
+    /** P's owner is finished or dead: this resumer is P's sole post-mortem writer and drains P's outbox (best effort). */
+    postMortemWriter: boolean;
+} | {
+    source: 'hosted';
+    /** Null when P ran on another computer. */
+    fallbackReason: HostedFallbackReason | null;
+}
+/** Every local line unsealed but the chain did not verify: refused, no fallback. */
+ | {
+    source: 'refuse-integrity';
+}
+/** P's own process is still closing here (§8.1 copy). */
+ | {
+    source: 'still-closing';
+};
+export declare function chooseResumeSource(args: {
+    ownerState: OwnerRecordState;
+    ranHere: boolean;
+    local: ReadOnlyContextLogResult;
+}): ResumeSourceChoice;