vibe-usage-cli 0.0.0-stage → 0.1.1

package/build/core/claude-processes.js

@@ -0,0 +1,288 @@
+// Evidence about the Claude Code process running a session, from what Claude Code and the
+// system keep about it.
+//
+// A Claude Code process that saves its session lists itself in <profile>/sessions/<pid>.json,
+// with its session id, what it is doing and when it started, from startup on. A process begun
+// as a child session (the markers in CLAUDE_SESSION_ENV_KEYS) lists nothing and saves nothing:
+// it leaves only <profile>/sessions/<pid>.<hash>.key, the key of its messaging socket, which
+// every process writes. That key is what ties a process to a profile.
+//
+// A process not listed is looked for among the system's processes, by the `--resume <session>`
+// it was started with, among the pids the profile holds a key for. The list file can outlive
+// its process and a pid can be reused, so a process is ended only after its start time matches
+// the one recorded: exactly, where Claude Code recorded the system's own (`procStart`, Windows
+// file-time ticks), else to within a second or two.
+//
+// Asking the system can fail (a timeout under load, say). That is not the same as "no such
+// process": a caller gets `unknown` and acts on nothing until it can tell.
+import { execFile } from 'node:child_process';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+import { CLAUDE_FILES } from "../providers/claude.js";
+import { windowsPowerShell } from "../providers/common.js";
+import { systemErrorCode } from "./errors.js";
+import { isOneOf } from "../shared/catalog.js";
+import { isObject, readJson } from "./files.js";
+const execFileAsync = promisify(execFile);
+const QUERY_TIMEOUT_MS = 10_000;
+// Windows records process start times in 100 ns ticks since 1601.
+const TICKS_PER_MS = 10_000;
+const UNIX_EPOCH_TICKS = 116444736000000000n;
+// Without `procStart`: how far the recorded start may be from the process's own, for the two
+// to be one process.
+const SAME_START_MS = 2_000;
+const LIST_ENTRY = /^(\d+)\.json$/;
+const KEY_ENTRY = /^(\d+)\.[0-9a-f]+\.key$/;
+// A pid or Windows file-time ticks, as the system prints them and Claude Code records a start.
+const DIGITS = /^\d+$/;
+// What a listed Claude Code process says it is doing (pinned by the corpus contract). `waiting`
+// is a session Claude Code holds at the usage limit until the reset (2.1.302, seen 2026-10-18);
+// such a session counts as stopped by its transcript, not by this.
+export const CLAUDE_SESSION_STATUSES = ['busy', 'idle', 'shell', 'waiting'];
+function isAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return systemErrorCode(error) === 'EPERM';
+    }
+}
+const ticksToMs = (ticks) => Number((BigInt(ticks) - UNIX_EPOCH_TICKS) / BigInt(TICKS_PER_MS));
+async function powershell(script) {
+    const { stdout } = await execFileAsync(windowsPowerShell(), ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', script], {
+        encoding: 'utf8',
+        timeout: QUERY_TIMEOUT_MS,
+        windowsHide: true
+    });
+    return stdout;
+}
+// A process start as `Get-Process` prints it (`StartTime.ToFileTimeUtc()`), null for none.
+export function parseWindowsStart(stdout) {
+    const ticks = stdout.trim();
+    return DIGITS.test(ticks) ? { at: ticksToMs(ticks), ticks } : null;
+}
+// Processes as the Windows query prints them: `pid|ticks|command line` per line.
+export function parseWindowsProcesses(stdout) {
+    return stdout.split(/\r?\n/).flatMap(line => {
+        const [pid, ticks, ...command] = line.split('|');
+        if (!pid || !ticks || !DIGITS.test(pid) || !DIGITS.test(ticks))
+            return [];
+        return [{ pid: Number(pid), at: ticksToMs(ticks), ticks, command: command.join('|') }];
+    });
+}
+// Claude Code processes as `ps -eo pid=,args=` prints them, without their start (looked up
+// one by one).
+export function parsePsProcesses(stdout) {
+    return stdout.split('\n').flatMap(line => {
+        const match = /^\s*(\d+)\s+(.*)$/.exec(line);
+        if (!match?.[1] || !match[2] || !/(^|[\\/\s])claude(\s|$)/.test(match[2]))
+            return [];
+        return [{ pid: Number(match[1]), command: match[2] }];
+    });
+}
+// When the process started, as the system reports it: null for a process that is gone. A
+// system that cannot answer throws.
+export async function processStarted(pid) {
+    if (process.platform === 'win32') {
+        const script = `$p = Get-Process -Id ${pid} -ErrorAction SilentlyContinue; if ($p) { $p.StartTime.ToFileTimeUtc() } else { 'gone' }`;
+        const stdout = await powershell(script);
+        if (stdout.trim() === 'gone')
+            return null;
+        const started = parseWindowsStart(stdout);
+        if (!started)
+            throw new Error(`unexpected process start: ${stdout.trim().slice(0, 40)}`);
+        return started;
+    }
+    let stdout;
+    try {
+        ({ stdout } = await execFileAsync('ps', ['-o', 'lstart=', '-p', String(pid)], { encoding: 'utf8', timeout: QUERY_TIMEOUT_MS }));
+    }
+    catch (error) {
+        // `ps` exits 1 for a pid it does not know.
+        if (systemErrorCode(error) === 1)
+            return null;
+        throw error;
+    }
+    if (!stdout.trim())
+        return null;
+    const at = Date.parse(stdout.trim());
+    if (!Number.isFinite(at))
+        throw new Error('unexpected process start');
+    return { at, ticks: null };
+}
+// The running Claude Code processes and their command lines. The start time comes from the
+// same source as `processStarted`, so the two compare exactly (CIM's creation date is coarser).
+async function claudeProcesses() {
+    if (process.platform === 'win32') {
+        const script = "Get-CimInstance Win32_Process -Filter \"Name='claude.exe'\" | ForEach-Object { $started = (Get-Process -Id $_.ProcessId -ErrorAction SilentlyContinue).StartTime; if ($started) { '{0}|{1}|{2}' -f $_.ProcessId, $started.ToFileTimeUtc(), $_.CommandLine } }";
+        return parseWindowsProcesses(await powershell(script));
+    }
+    const { stdout } = await execFileAsync('ps', ['-eo', 'pid=,args='], { encoding: 'utf8', timeout: QUERY_TIMEOUT_MS });
+    const found = [];
+    for (const { pid, command } of parsePsProcesses(stdout)) {
+        const started = await processStarted(pid);
+        if (started)
+            found.push({ pid, ...started, command });
+    }
+    return found;
+}
+// The newest process started to resume `sessionId`.
+export function resumingProcess(processes, sessionId) {
+    const resume = new RegExp(`(^|\\s)(--resume|-r)\\s+"?${RegExp.escape(sessionId)}"?(\\s|$)`);
+    return [...processes].filter(p => resume.test(p.command)).sort((a, b) => b.at - a.at)[0] ?? null;
+}
+export const systemProcesses = {
+    isAlive,
+    started: processStarted,
+    list: claudeProcesses,
+    end: pid => {
+        try {
+            process.kill(pid);
+        }
+        catch (error) {
+            // Gone already is fine; a refusal (another user's process, an elevated one) is not.
+            if (systemErrorCode(error) !== 'ESRCH')
+                throw error;
+        }
+    }
+};
+// How long a process gets to go after being told to.
+const END_WAIT_MS = 2_000;
+const END_POLL_MS = 100;
+const number = (value) => (typeof value === 'number' && Number.isFinite(value) ? value : 0);
+// The pids the profile's processes list under, and the pids it holds a key for.
+async function profilePids(configDir) {
+    const dir = path.join(configDir, CLAUDE_FILES.sessions);
+    const names = await fsp.readdir(dir).catch(() => []);
+    const listed = new Map();
+    const keyed = new Set();
+    for (const name of names) {
+        const entry = LIST_ENTRY.exec(name);
+        if (entry?.[1])
+            listed.set(Number(entry[1]), path.join(dir, name));
+        const key = KEY_ENTRY.exec(name);
+        if (key?.[1])
+            keyed.add(Number(key[1]));
+    }
+    return { listed, keyed };
+}
+// A process as its entry in the profile's session list describes it.
+function listedSession(pid, sessionId, entry) {
+    return {
+        pid,
+        sessionId,
+        listed: true,
+        status: isOneOf(CLAUDE_SESSION_STATUSES, entry.status) ? entry.status : null,
+        statusSince: number(entry.statusUpdatedAt) || number(entry.updatedAt),
+        startedAt: number(entry.startedAt),
+        procStart: typeof entry.procStart === 'string' && DIGITS.test(entry.procStart) ? entry.procStart : null
+    };
+}
+// Reads the interactive sessions a profile's processes run now, as they list themselves. Child
+// sessions (unlisted, unsaved) and runs started by a program are left out: neither can be
+// reopened. A list entry outlives a process that ended with the system, and its pid can belong
+// to another process by now, so each process's start is checked against the system's, once
+// (a system that cannot say throws, and is asked again next time).
+export function openSessionsReader(processes = systemProcesses) {
+    const checked = new Map();
+    return async (configDir) => {
+        const { listed } = await profilePids(configDir);
+        const open = [];
+        for (const [pid, file] of listed) {
+            const entry = await readJson(file);
+            if (!isObject(entry) || entry.kind !== 'interactive' || typeof entry.sessionId !== 'string' || typeof entry.cwd !== 'string')
+                continue;
+            if (!processes.isAlive(pid))
+                continue;
+            const session = { ...listedSession(pid, entry.sessionId, entry), cwd: entry.cwd };
+            const id = `${pid}:${session.startedAt}:${session.procStart ?? ''}`;
+            let same = checked.get(id);
+            if (same === undefined) {
+                const started = await processes.started(pid);
+                same = started !== null && isSameProcess(session, started);
+                checked.set(id, same);
+            }
+            if (same)
+                open.push(session);
+        }
+        return open;
+    };
+}
+// The running process of `sessionId` in the profile: the newest listed one, else the newest
+// started to resume it among the processes the profile holds a key for.
+export async function findClaudeProcess(configDir, sessionId, processes = systemProcesses) {
+    const { listed, keyed } = await profilePids(configDir);
+    const live = [];
+    for (const [pid, file] of listed) {
+        const entry = await readJson(file);
+        if (!isObject(entry) || entry.sessionId !== sessionId || !processes.isAlive(pid))
+            continue;
+        live.push(listedSession(pid, sessionId, entry));
+    }
+    const newest = live.sort((a, b) => b.startedAt - a.startedAt)[0];
+    if (newest)
+        return { kind: 'found', process: newest };
+    // A key without a list entry is a child session's: unlisted, unsaved, but this profile's.
+    const unlisted = [...keyed].filter(pid => !listed.has(pid) && processes.isAlive(pid));
+    if (!unlisted.length || !processes.list)
+        return { kind: 'none' };
+    let all;
+    try {
+        all = await processes.list();
+    }
+    catch (error) {
+        return { kind: 'unknown', reason: error instanceof Error ? error.message : String(error) };
+    }
+    const resuming = resumingProcess(all.filter(p => unlisted.includes(p.pid)), sessionId);
+    return resuming
+        ? {
+            kind: 'found',
+            process: {
+                pid: resuming.pid,
+                sessionId,
+                listed: false,
+                status: null,
+                statusSince: 0,
+                startedAt: resuming.at,
+                procStart: resuming.ticks
+            }
+        }
+        : { kind: 'none' };
+}
+// Whether the system's process is the one Claude Code recorded. Recorded ticks are compared
+// exactly: a mismatch is another process, never a near miss.
+export function isSameProcess(live, started) {
+    if (live.procStart !== null && started.ticks !== null)
+        return live.procStart === started.ticks;
+    return Math.abs(started.at - live.startedAt) <= SAME_START_MS;
+}
+// Ends the session's process: `gone` when no process has its pid any more, `other` when the pid
+// now belongs to another process, `unknown` when the system could not say, or would not do it,
+// or the process did not go. Only `ended` means the process is no more.
+export async function endClaudeSession(live, processes = systemProcesses) {
+    let started;
+    try {
+        started = await processes.started(live.pid);
+    }
+    catch {
+        return 'unknown';
+    }
+    if (!started)
+        return 'gone';
+    if (!isSameProcess(live, started))
+        return 'other';
+    try {
+        processes.end(live.pid);
+    }
+    catch {
+        return 'unknown';
+    }
+    for (const deadline = Date.now() + END_WAIT_MS; processes.isAlive(live.pid);) {
+        if (Date.now() >= deadline)
+            return 'unknown';
+        await new Promise(resolve => setTimeout(resolve, END_POLL_MS));
+    }
+    return 'ended';
+}

package/build/core/claude-profile.d.ts

@@ -0,0 +1,2 @@
+import type { Account } from '../shared/types.ts';
+export declare function prepareClaudeProfile(account: Account, accounts: readonly Account[], dir: string, home?: string): Promise<void>;

package/build/core/claude-profile.js

@@ -0,0 +1,146 @@
+// Getting a Claude Code profile ready for a session the app starts in it.
+//
+// Some answers Claude Code asks for belong to the user, not to the signed-in account: whether
+// a folder is trusted, the first-run setup (theme, onboarding) and the notices already seen.
+// Each profile keeps its own copy, so a profile used only to sign in would stop a moved
+// session at the first-run setup. At launch, what another of the user's profiles already
+// answered is carried into the profile being started, so the session goes on by itself.
+//
+// This happens at launch, for the one folder being opened, rather than by copying between
+// profiles in the background: only a launch knows what the profile is about to need, and the
+// state file is written under Claude Code's own lock, so a running session's changes are kept.
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { CLAUDE_FILES, claudeStateFile } from "../providers/claude.js";
+import { systemErrorCode } from "./errors.js";
+import { isObject, readJson, writeFileAtomic } from "./files.js";
+// What Claude Code writes for a folder it has not opened before.
+const NEW_PROJECT = {
+    allowedTools: [],
+    mcpContextUris: [],
+    mcpServers: {},
+    enabledMcpjsonServers: [],
+    disabledMcpjsonServers: [],
+    hasClaudeMdExternalIncludesApproved: false,
+    hasClaudeMdExternalIncludesWarningShown: false
+};
+// The user's own answers in the state file: first-run setups done (Claude Code's own and those of
+// later features, such as Claude in Chrome) and notices seen. Account facts (subscription,
+// usage, caches) are not among them, nor is what a feature was set to: a choice that opens a
+// browser or changes what Claude Code may do is made in each profile, not copied.
+const CHOICES = new Set(['lastOnboardingVersion', 'lastReleaseNotesSeen']);
+const isAcknowledgment = (key) => CHOICES.has(key) || /^hasCompleted([A-Z]\w*)?Onboarding$/.test(key) || /^hasSeen[A-Z]/.test(key);
+// Questions Claude Code asks at a start unless a choice is recorded, answered the quiet way: a
+// session the app starts may run unattended, and the user turns the feature on where they want it.
+const QUIET_CHOICES = { claudeInChromeDefaultEnabled: false };
+// What a project entry records about its CLAUDE.md includes; asked again where neither is set.
+const INCLUDE_ANSWERS = ['hasClaudeMdExternalIncludesApproved', 'hasClaudeMdExternalIncludesWarningShown'];
+// Claude Code's lock on its state file is a folder next to it, refreshed while held; one left
+// behind longer than this is stale.
+const LOCK_STALE_MS = 10_000;
+const LOCK_WAIT_MS = 5_000;
+const LOCK_RETRY_MS = 100;
+// Claude Code keys projects by absolute path with forward slashes.
+const projectKey = (dir) => path.resolve(dir).replaceAll('\\', '/');
+const projectsOf = (state) => (isObject(state) && isObject(state.projects) ? state.projects : {});
+// The entry that trusts `dir`: its own, or the nearest folder's above it, as Claude Code reads it.
+function trustingEntry(state, dir) {
+    const projects = projectsOf(state);
+    for (let current = path.resolve(dir);; current = path.dirname(current)) {
+        const project = projects[projectKey(current)];
+        if (isObject(project) && project.hasTrustDialogAccepted === true)
+            return project;
+        if (path.dirname(current) === current)
+            return null;
+    }
+}
+const isTrusted = (state, dir) => trustingEntry(state, dir) !== null;
+async function withStateLock(file, task) {
+    const lock = `${file}.lock`;
+    for (const deadline = Date.now() + LOCK_WAIT_MS;;) {
+        try {
+            await fsp.mkdir(lock);
+            break;
+        }
+        catch (error) {
+            if (systemErrorCode(error) !== 'EEXIST')
+                throw error;
+            const held = await fsp.stat(lock).catch(() => null);
+            if (held && Date.now() - held.mtimeMs > LOCK_STALE_MS)
+                await fsp.rm(lock, { recursive: true, force: true });
+            else if (Date.now() > deadline)
+                throw new Error('state file is locked', { cause: error });
+            else
+                await new Promise(resolve => setTimeout(resolve, LOCK_RETRY_MS));
+        }
+    }
+    try {
+        await task();
+    }
+    finally {
+        await fsp.rm(lock, { recursive: true, force: true });
+    }
+}
+// What `state` lacks that the other profiles' states answer for `dir`.
+function missingAnswers(state, others, dir) {
+    const answers = {};
+    // A question asked again only where it was not answered yet, also in a profile set up before
+    // the question existed; what a profile answered itself stays.
+    for (const other of others)
+        if (isObject(other))
+            for (const [key, value] of Object.entries(other))
+                if (isAcknowledgment(key) && state[key] === undefined && answers[key] === undefined)
+                    answers[key] = value;
+    for (const [key, value] of Object.entries(QUIET_CHOICES))
+        if (state[key] === undefined)
+            answers[key] = value;
+    if (!isTrusted(state, dir) && others.some(other => isTrusted(other, dir))) {
+        const projects = projectsOf(state);
+        const key = projectKey(dir);
+        const entry = isObject(projects[key]) ? projects[key] : NEW_PROJECT;
+        // The includes question is about this folder's own CLAUDE.md: only an answer given for this
+        // very folder comes along, never a parent's (trust is inherited from above; consent is not).
+        const own = others.map(other => projectsOf(other)[key]).find(isObject);
+        const includes = own
+            ? Object.fromEntries(INCLUDE_ANSWERS.filter(name => typeof own[name] === 'boolean').map(name => [name, own[name]]))
+            : {};
+        answers.projects = { ...projects, [key]: { ...entry, ...includes, hasTrustDialogAccepted: true } };
+    }
+    return answers;
+}
+// The theme lives in the profile's settings; it is set only where none was chosen.
+async function carryTheme(account, others) {
+    if (!account.configDir)
+        return;
+    const file = path.join(account.configDir, CLAUDE_FILES.settings);
+    const settings = await readJson(file);
+    if (isObject(settings) && settings.theme !== undefined)
+        return;
+    for (const other of others) {
+        const theirs = other.configDir ? await readJson(path.join(other.configDir, CLAUDE_FILES.settings)) : null;
+        if (!isObject(theirs) || typeof theirs.theme !== 'string')
+            continue;
+        await writeFileAtomic(file, `${JSON.stringify({ ...(isObject(settings) ? settings : {}), theme: theirs.theme }, null, 2)}\n`);
+        return;
+    }
+}
+// Carries the user's answers from their other Claude Code profiles into `account`'s, for a
+// session about to start in `dir`. A profile that was never signed in is left alone.
+export async function prepareClaudeProfile(account, accounts, dir, home = os.homedir()) {
+    const file = claudeStateFile(account, home);
+    if (!isObject(await readJson(file)))
+        return;
+    const others = accounts.filter(a => a.providerId === 'claude' && a.enabled && a.id !== account.id);
+    const states = await Promise.all(others.map(other => readJson(claudeStateFile(other, home))));
+    await carryTheme(account, others);
+    await withStateLock(file, async () => {
+        // Read under the lock, so nothing Claude Code wrote meanwhile is lost.
+        const state = await readJson(file);
+        if (!isObject(state))
+            return;
+        const answers = missingAnswers(state, states, dir);
+        if (Object.keys(answers).length)
+            await writeFileAtomic(file, JSON.stringify({ ...state, ...answers }, null, 2));
+    });
+}

package/build/core/claude-renew.d.ts

@@ -0,0 +1,12 @@
+import { type ExecFileOptions } from 'node:child_process';
+import type { Account } from '../shared/types.ts';
+export declare const RENEW_ARGS: readonly ["-p", "Reply with the single word ok.", "--model", string, "--tools", "", "--strict-mcp-config", "--no-session-persistence", "--max-turns", "1"];
+export type RunProcess = (binary: string, args: readonly string[], options: ExecFileOptions) => Promise<void>;
+export interface RenewOptions {
+    dataDir: string;
+    home?: string;
+    clock?: () => number;
+    runProcess?: RunProcess;
+    readCredentials?: (account: Account) => Promise<unknown>;
+}
+export declare function renewClaudeSignIn(account: Account, { dataDir, home, clock, runProcess, readCredentials }: RenewOptions): Promise<boolean>;

package/build/core/claude-renew.js

@@ -0,0 +1,79 @@
+// Renewing a Claude Code profile's sign-in once its access token has expired.
+//
+// Claude Code renews its token only while it runs, so a profile left idle for some hours holds an
+// expired one: its quota cannot be read, and it cannot take over work when another account runs
+// out. The app never uses the refresh token itself: it is Claude Code's own sign-in, and a second
+// refresher could invalidate the token a running Claude Code holds. Claude Code renews it, with
+// the smallest request it makes: one word from the smallest model, no tools, no MCP servers,
+// nothing saved as a session.
+import { execFile } from 'node:child_process';
+import fsp from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { claudeOAuthSection, readClaudeCredentials } from "../providers/claude.js";
+import { findBinary } from "../providers/common.js";
+import { applyEnvironment, environmentChanges } from "./environment.js";
+import { profileEnvironment } from "./launch.js";
+import { claudeAlias } from "./model-families.js";
+const RENEW_DIR = 'renew';
+const RENEW_TIMEOUT_MS = 90_000;
+// Written for Claude Code, so it is deliberately not localized.
+const RENEW_PROMPT = 'Reply with the single word ok.';
+export const RENEW_ARGS = [
+    '-p',
+    RENEW_PROMPT,
+    '--model',
+    claudeAlias('fast'),
+    '--tools',
+    '',
+    '--strict-mcp-config',
+    '--no-session-persistence',
+    '--max-turns',
+    '1'
+];
+const run = (binary, args, options) => new Promise(resolve => {
+    execFile(binary, [...args], options, () => {
+        resolve();
+    });
+});
+// Whether Claude Code can renew the sign-in: it holds a refresh token, and that token has not
+// itself expired. Claude Code writes the refresh token's own expiry (refreshTokenExpiresAt, some
+// weeks out) on every refresh; once it has passed only signing in again helps, so starting Claude
+// Code would cost a launch for nothing. Credentials without it (older files) are taken as renewable.
+function canRenew(oauth, now) {
+    if (typeof oauth.refreshToken !== 'string' || oauth.refreshToken.length === 0)
+        return false;
+    if (oauth.refreshTokenExpiresAt === undefined || oauth.refreshTokenExpiresAt === null)
+        return true;
+    const refreshExpiresAt = Number(oauth.refreshTokenExpiresAt);
+    return !Number.isFinite(refreshExpiresAt) || refreshExpiresAt > now;
+}
+// The saved sign-in's expiry, and whether Claude Code can renew it.
+async function signIn(account, read, now) {
+    const credentials = await read(account).catch(() => null);
+    const oauth = claudeOAuthSection(credentials);
+    if (!oauth)
+        return null;
+    const expiresAt = Number(oauth.expiresAt);
+    return {
+        expiresAt: Number.isFinite(expiresAt) ? expiresAt : 0,
+        renewable: canRenew(oauth, now)
+    };
+}
+// True when the profile's sign-in was renewed (its expiry moved on, into the future).
+export async function renewClaudeSignIn(account, { dataDir, home = os.homedir(), clock = Date.now, runProcess = run, readCredentials }) {
+    const read = readCredentials ?? ((target) => readClaudeCredentials(target, { home }));
+    const before = await signIn(account, read, clock());
+    if (!before?.renewable)
+        return false;
+    const cwd = path.join(dataDir, RENEW_DIR);
+    await fsp.mkdir(cwd, { recursive: true });
+    await runProcess(await findBinary('claude'), RENEW_ARGS, {
+        cwd,
+        env: applyEnvironment(environmentChanges(profileEnvironment(account))),
+        timeout: RENEW_TIMEOUT_MS,
+        windowsHide: true
+    });
+    const after = await signIn(account, read, clock());
+    return Boolean(after && after.expiresAt > before.expiresAt && after.expiresAt > clock());
+}

package/build/core/continuity.d.ts

@@ -0,0 +1,90 @@
+import { type ProviderId } from '../shared/catalog.ts';
+import type { LaunchMode } from '../shared/ipc.ts';
+import type { Account, ErrorCode, MeasuredAccount, Snapshot, Suggestion, TransitionRecord } from '../shared/types.ts';
+import { type LiveClaudeSession, type OpenClaudeSession, type ProcessControl, type ProcessLookup } from './claude-processes.ts';
+import type { QuotaAlert } from './glance.ts';
+import { type LaunchContext } from './handover.ts';
+import { type Successor } from './selection.ts';
+import { type BackgroundTask, type RecentSession, type SessionIdentity, type StoppedSession } from './sessions.ts';
+export declare const RETURN_TASK_WAIT_MS: number;
+export declare const RESUME_PROMPT = "Your previous turn was cut off by a usage limit on another account. Continue the task exactly where it stopped; run `git status` first to see what is already done.";
+export declare const RETURN_PROMPT = "This session moved back to its main account.";
+export declare const RESTART_PROMPT = "The computer went down while this session was open, and your last turn did not finish. Background commands and subagents started before did not survive it. Continue the task exactly where it stopped; run `git status` first to see what is already done.";
+export declare function findRecentSession(account: Account, homeDir: string, identity?: SessionIdentity): Promise<RecentSession | null>;
+export declare function findStoppedSessions(account: Account, homeDir: string, now?: number): Promise<StoppedSession[]>;
+export declare function findStoppedSession(account: Account, homeDir: string, now?: number): Promise<StoppedSession | null>;
+export declare function carryClaudeSession(session: RecentSession, configDir: string): Promise<void>;
+export interface ContinueResult {
+    to: ProviderId;
+    accountId: string | null;
+    resumed: boolean;
+    mode: LaunchMode;
+    tab?: string | null;
+}
+export interface MoveOptions {
+    prompt?: string | undefined;
+    running?: LiveClaudeSession | null | undefined;
+    tab?: string | null | undefined;
+    processes?: ProcessControl | undefined;
+}
+export declare function holdsUnsavedConversation(running: LiveClaudeSession, file: string): boolean;
+export declare function continueSession(session: RecentSession, to: Successor, state: Snapshot, context: LaunchContext, options?: MoveOptions): Promise<ContinueResult>;
+declare const ATTEMPTS: readonly ["return", "reopen"];
+export type Attempt = (typeof ATTEMPTS)[number];
+export type Notice = {
+    kind: 'suggested';
+    suggestion: Suggestion;
+} | {
+    kind: 'continued';
+    from: MeasuredAccount;
+    to: Successor;
+    result: ContinueResult;
+    projectDir: string;
+} | {
+    kind: 'returned';
+    from: MeasuredAccount;
+    to: Successor;
+    result: ContinueResult;
+    projectDir: string;
+} | {
+    kind: 'reopened';
+    from: MeasuredAccount;
+    to: Successor;
+    result: ContinueResult;
+    projectDir: string;
+} | {
+    kind: 'stranded';
+    from: MeasuredAccount;
+} | {
+    kind: 'failed';
+    from: MeasuredAccount;
+    code: ErrorCode;
+    attempt?: Attempt;
+};
+export interface Continuity {
+    observe(snapshot: Snapshot, alerts: {
+        low: readonly QuotaAlert[];
+    }): Promise<Notice[]>;
+    suggestions(): Suggestion[];
+    isRunning(id: string, snapshot?: Snapshot): Promise<boolean>;
+    accept(id: string, snapshot: Snapshot): Promise<ContinueResult>;
+    dismiss(id: string): void;
+    transitions(): TransitionRecord[];
+    retry(id: string, snapshot: Snapshot): Promise<ContinueResult>;
+    quit(): void;
+}
+export interface ContinuityOptions {
+    homeDir: string;
+    dataDir: string;
+    launch: LaunchContext;
+    findSession?: (account: Account, identity?: SessionIdentity) => Promise<RecentSession | null>;
+    findStopped?: (account: Account) => Promise<StoppedSession[]>;
+    findRunning?: (account: Account, sessionId: string) => Promise<ProcessLookup>;
+    findTasks?: (file: string) => Promise<BackgroundTask[]>;
+    findOpen?: (account: Account) => Promise<OpenClaudeSession[]>;
+    start?: typeof continueSession;
+    clock?: () => number;
+    historyCap?: number;
+}
+export declare function createContinuity({ homeDir, dataDir, launch, findSession, findStopped, findRunning, findTasks, findOpen, start, clock, historyCap }: ContinuityOptions): Promise<Continuity>;
+export {};