vibe-usage-cli 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mustafa Çağrı Güven
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,276 @@
-# Temporary Holding Version
+<div align="center">
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**English** · [Türkçe](docs/readme/README.tr.md) · [Deutsch](docs/readme/README.de.md) · [Español](docs/readme/README.es.md) · [Français](docs/readme/README.fr.md) · [Italiano](docs/readme/README.it.md) · [Português](docs/readme/README.pt.md) · [Nederlands](docs/readme/README.nl.md) · [Polski](docs/readme/README.pl.md) · [日本語](docs/readme/README.ja.md) · [한국어](docs/readme/README.ko.md) · [简体中文](docs/readme/README.zh.md) · [Русский](docs/readme/README.ru.md)
+
+<img src="assets/icon.png" width="96" alt="" />
+
+# Vibe Usage
+
+**Every AI coding subscription you pay for, in one menu-bar window.**
+
+See how much quota Claude Code, Codex, Cursor and Antigravity have left, and keep working when a limit runs out:
+your session continues on another account or tool, without re-explaining the task.
+
+Windows tray · macOS menu bar · 13 languages · no passwords, no tokens stored
+
+**[Download for Windows and macOS](https://github.com/mustafacagri/vibe-usage/releases/latest)** · Terminal: `npm install -g vibe-usage-cli`
+
+<img src="docs/media/demo.gif" width="400" alt="Vibe Usage walkthrough: switching accounts, every account side by side, the compact view, Smart Launch and Handover" />
+
+<sub>[Watch in full resolution (MP4)](docs/media/demo.mp4)</sub>
+
+</div>
+
+## Why
+
+If you code with several AI tools, you hit the same wall over and over: the 5-hour limit runs out mid-task, you open
+another tool, and you start explaining the task from scratch. Each provider shows its usage somewhere different, if at
+all.
+
+Vibe Usage reads the sessions already signed in on your machine and shows every limit side by side: how much is left
+and when it resets. When one tool is running low, it starts the next one with verified quota in your project folder,
+and writes a briefing of the current session so the new tool can continue where the old one stopped.
+
+## Features
+
+<table>
+<tr>
+<td width="50%" valign="top">
+
+### Quota at a glance
+
+Every limit of every account: 5-hour and weekly windows, per-model scopes, spend pools. Countdowns show when each one
+resets, and a limit that will run out before it resets says when, at the current pace. The last 7 days are one click
+away as a chart. If a refresh fails, the last reading stays visible and is clearly marked as stale. Unknown numbers are
+never shown as a full quota. The tray icon is a ring that fills with what your first tool has left; hover it for every
+tool. Show each tool's accounts side by side, order the tools as you like, and switch to a compact view with one line
+per account.
+
+</td>
+<td width="50%" valign="top">
+
+<img src="docs/media/main.png" width="100%" alt="Quota cards for Claude, Codex, Cursor and Antigravity, with each tool’s accounts side by side" />
+
+<img src="docs/media/compact.png" width="100%" alt="The compact view: one line per account" />
+
+</td>
+</tr>
+<tr>
+<td valign="top">
+
+### Keep working when a limit runs out
+
+When Claude Code or Codex stops because its account hit the usage limit, the session continues where there is room:
+on the same tool's account with the most quota left, then, if you allow it, on the next tool in your fallback order.
+Opt in and it happens on its own; otherwise it is one click. The trigger is the tool's own "usage limit reached"
+record, never a percentage, so two agents never work on the same folder at once. A Claude Code session moves to your
+other Claude account **whole** and goes on by itself; other tools get a handover brief (kept out of `git status`).
+An account running low offers the same move early, and warns if its session is still running. When the first account
+has quota again, bringing the work back is one click.
+
+If the computer goes down (a restart, a crash, a power cut) while Claude Code sessions are open, they open again where
+they left off, on the account they belong to, and a turn that was cut off goes on. Suggested by default, or on its own
+if you choose. Sessions you closed yourself stay closed.
+
+### Smart Launch
+
+Picks the first tool in your priority order whose quota is **verified** to have room, then opens it in a new terminal
+in the project folder you choose. If no tool can be verified, it says so instead of guessing.
+
+</td>
+<td valign="top">
+
+<img src="docs/media/smart-launch.png" width="100%" alt="Smart Launch recommending Codex because Claude's 5-hour limit is nearly spent" />
+
+</td>
+</tr>
+<tr>
+<td valign="top">
+
+### Handover
+
+Choose a session from Claude Code, Codex, Cursor Agent or Antigravity. Vibe Usage summarizes it into
+`VIBE_HANDOVER.md` in the project folder: the goal, the latest request, the recent conversation, the files touched and
+the git status. **Preview brief** shows it before anything is written or started; recognizable secrets are redacted and
+the brief is marked as unverified context. Handing over then uses exactly the previewed session and starts the target
+tool with a prompt to read the brief. Only sessions started in the chosen folder are listed, and a file of your own
+named `VIBE_HANDOVER.md` is never overwritten.
+
+</td>
+<td valign="top">
+
+<img src="docs/media/handover.png" width="100%" alt="Handover dialog moving a Claude session to Codex" />
+
+</td>
+</tr>
+<tr>
+<td valign="top">
+
+### Multiple accounts
+
+Claude and Codex keep one sign-in per profile folder. **Add account** creates a new folder and opens the tool's sign-in
+there; `~/.claude-*` and `~/.codex-*` folders you made yourself are found automatically. Each account is shown by the
+e-mail it is signed in with, and every signed-in Antigravity account is tracked separately too. Pick the primary
+account, launch Claude Code with a specific account, and set the fallback order and the preferred model per tool.
+A sign-in not finished within ten minutes takes the account off again, and the next account reuses its folder.
+
+</td>
+<td valign="top">
+
+<img src="docs/media/settings.png" width="100%" alt="Settings: connected accounts, two each for Claude and Codex" />
+
+</td>
+</tr>
+</table>
+
+### Per-project choices, history and diagnostics
+
+- **Project preferences** (Settings): give a folder its own tool, model, account and automatic continuation. They narrow
+  what Smart Launch and continuation pick, never replace the verified-quota check, and a project set to *off* stays off
+  even when continuation is on globally.
+- **Notifications**: choose the low-quota line and quiet hours (they may cross midnight). Quiet hours skip notifications
+  (they are not sent later); quota is still read, work still continues and suggestions wait in the window.
+- **Handover history** lists each continuation with its project, route and outcome. A failed one can be tried again,
+  checked against current quota first.
+- **Diagnostics** shows, per tool, whether it is installed, each account's state and freshness, and the next step.
+  **Copy report** gives a version without names, e-mail addresses or folders, ready for an issue.
+- **Backup and restore**: export, import or reset the settings. Every save keeps the previous good copy; a damaged
+  settings file is restored from it (and kept aside), and a file written by a newer version is never overwritten.
+
+## Supported tools
+
+| Tool        | Where the quota comes from                                              | Sessions for handover                   | Launch                                 |
+| ----------- | ----------------------------------------------------------------------- | --------------------------------------- | -------------------------------------- |
+| Claude Code | The profile's OAuth usage endpoint (Keychain on macOS)                  | `~/.claude/projects`                    | `claude` CLI with the chosen profile   |
+| Codex       | The installed CLI's app-server rate-limit methods                       | `~/.codex/sessions`                     | `codex` CLI                            |
+| Cursor      | The signed-in session's usage summary                                   | Cursor Agent CLI chats (`~/.cursor/chats`) | `cursor-agent`, otherwise the app      |
+| Antigravity | The running app's local service (process and port ownership verified)   | `~/.gemini/antigravity-ide`             | Antigravity app                        |
+
+Model lists come from each tool's own data: Claude Code aliases and the models you used, the Codex model cache, and
+`cursor-agent --list-models` (cached for 24 hours).
+
+## Privacy and safety
+
+- **Your sign-ins stay as they are.** It uses the sessions that already exist. It never asks for a password, never
+  reads or stores a refresh token, never signs you out, and never touches running work. When work may move between
+  accounts on its own, an expired Claude Code sign-in is renewed by Claude Code itself: one minimal Haiku request (one
+  word, no tools, nothing saved), at most every 30 minutes per account. Continuing a Claude Code session on
+  another account copies its transcript into that account's profile folder; the original is left as it is.
+- **Few endpoints.** Quota requests go only to the Anthropic and Cursor usage endpoints, with TLS verification on
+  (and the renewal above goes through Claude Code).
+  Codex and Antigravity are read locally. Once a day the app asks GitHub for its latest release (Settings → General
+  turns this off). An update is downloaded only when you click **Download**, only from this repository's releases, and
+  checked against the release's SHA-512 checksums before **Restart to update** installs it.
+- **Nothing secret on disk.** Settings live in `%APPDATA%\Vibe Usage\settings.json` (Windows) or
+  `~/Library/Application Support/Vibe Usage/settings.json` (macOS), with `settings.json.bak` (the previous good copy)
+  and, if the file was ever damaged, `settings.json.damaged-<time>`. Next to them, `history.json` keeps a week of quota
+  percentages for the chart and the forecast (numbers only), `measurements.json` each account's last good reading (its
+  limits, percentages, reset times and plan, shown as stale after a restart until a fresh read), and `continuity.json`
+  the handover history: project folders, tool and account ids, session ids and outcomes, never conversation text,
+  tokens or e-mails.
+- **A locked-down app.** The window is sandboxed with a strict CSP, cannot navigate or open other windows, and only
+  answers its own page. Electron fuses disable `runAsNode`, `NODE_OPTIONS` and the inspector, and enforce ASAR
+  integrity.
+
+Found a security issue? Please report it privately as described in [SECURITY.md](SECURITY.md).
+
+## Install
+
+### Windows
+
+Download `Vibe-Usage-<version>-win-setup.exe` from the [latest release](https://github.com/mustafacagri/vibe-usage/releases/latest) and
+run it: it installs for your user only (no administrator rights), and once releases are signed it updates itself from
+inside the app. Or take the
+portable `Vibe-Usage-<version>-win-x64.zip` (or `-arm64`), unzip it and run `Vibe Usage.exe`; a portable copy
+links to the release page when there is a new version. Either way it lives in the system tray.
+
+Unless a release says it is signed, the app is not code-signed, so on first launch Windows SmartScreen may say **Windows protected your PC**. Click **More info**, then **Run anyway**.
+
+### macOS
+
+Download `Vibe-Usage-<version>-mac-arm64.dmg` (Apple silicon) from the
+[latest release](https://github.com/mustafacagri/vibe-usage/releases/latest), open it and drag **Vibe Usage** to
+Applications. The app is not signed with an Apple Developer ID yet, so Gatekeeper blocks the first launch: open
+**System Settings › Privacy & Security** and click **Open Anyway**, or run:
+
+```sh
+xattr -dr com.apple.quarantine "/Applications/Vibe Usage.app"
+```
+
+On an Intel Mac, or to skip that step, build it yourself. You only need Node.js 24:
+
+```sh
+git clone https://github.com/mustafacagri/vibe-usage.git && cd vibe-usage
+npm ci
+npm run build:mac
+cp -R "release/mac-arm64/Vibe Usage.app" /Applications/
+```
+
+On an Intel Mac the folder is `release/mac`. An app you build yourself is not quarantined and opens directly.
+
+macOS lets only a signed app replace itself, so until releases are signed a new version is installed the same way
+(the app links to it when one is out).
+
+## Command line
+
+The same data is available in the terminal on Windows and macOS, with or without the desktop app. It needs Node.js 24
+or later and reads the same signed-in sessions as the app; when both are installed they share settings and language.
+
+```sh
+npm install -g vibe-usage-cli
+vibe-usage status
+```
+
+<img src="docs/media/cli.png" width="640" alt="vibe-usage status in a terminal: every window of two Claude, two Codex, one Cursor and two Antigravity accounts" />
+
+```sh
+vibe-usage status [--json]   # every account's quota once; --json for scripts
+vibe-usage watch             # the same, refreshed until Ctrl+C
+vibe-usage run <claude|codex|cursor> [--account ID] [--cwd PATH] [--model MODEL] [--dry-run]
+vibe-usage handover [--from TOOL] [--to TOOL] [--session ID] [--cwd PATH]
+vibe-usage help
+```
+
+To try it without installing, run `npx vibe-usage-cli status`.
+
+`run` starts the tool in this terminal with an account whose quota is verified; otherwise name one with `--account`
+(the IDs are in `status --json`). `--dry-run` prints the account and the command without starting anything.
+`handover` writes `VIBE_HANDOVER.md` for the folder's latest session (or `--session`) and opens the target tool with
+it.
+
+## Development
+
+TypeScript in strict mode on Node.js 24 (the version Electron 44 embeds). Tests, the CLI and scripts run straight from
+the `.ts` sources; the app is compiled to `build/`.
+
+```sh
+npm ci
+npm start              # build and run the app
+npm test               # unit and integration tests
+npm run test:coverage  # the same, with the coverage gates CI enforces
+npm run lint           # ESLint with type information
+npm run format         # Prettier
+npm run ui-check       # renders the built UI in all 13 languages and checks that every text fits
+npm run media          # regenerates the screenshots and the walkthrough in docs/media (needs ffmpeg)
+npm run build:win      # or build:mac
+```
+
+| Folder                                                | Runs in       | Contains                                               |
+| ----------------------------------------------------- | ------------- | ------------------------------------------------------ |
+| `src/shared`                                          | anywhere      | provider catalog, data types, IPC contract, i18n       |
+| `src/ui`                                              | the window    | the interface                                          |
+| `src/core`, `src/providers`, `src/main`, `src/cli.ts` | Node/Electron | service, provider adapters, main process, CLI          |
+| `test`, `scripts`                                     | Node          | type-checked only, never compiled                      |
+
+`VIBE_DATA_DIR` moves the settings folder. `VIBE_CLAUDE_BINARY`, `VIBE_CODEX_BINARY` and `VIBE_CURSOR_AGENT_BINARY`
+point at specific CLI binaries. Tests never start a real tool or read real accounts.
+
+## Limitations
+
+- The macOS build is not notarized (see [macOS](#macos)).
+- Antigravity's session model comes from an undocumented local record; if it cannot be read, the model is left blank.
+- Cursor IDE (Composer) chats cannot be handed over; only Cursor Agent CLI sessions are read.
+
+## License
+
+[MIT](LICENSE)

package/build/cli.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+// Terminal front end: quota status, a live watch, running a provider CLI with verified quota,
+// and handing a task over. Uses the desktop app's settings and language.
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { applyEnvironment, environmentChanges } from "./core/environment.js";
+import { AppError } from "./core/errors.js";
+import { executeHandover, parseProviderChoice } from "./core/handover.js";
+import { launchPlan, launchWarnings, projectDirectory } from "./core/launch.js";
+import { selectAccount } from "./core/selection.js";
+import { createService } from "./core/service.js";
+import { appDataDir, settingsPath } from "./core/settings.js";
+import { AUTO, isProviderId, providerById } from "./shared/catalog.js";
+import { describeCode, describeWindow, formatAccountName, formatFreshness, LAUNCH_MESSAGES, toolLabel } from "./shared/format.js";
+import { DEFAULT_LANGUAGE, translator } from "./shared/i18n/index.js";
+const CLEAR_SCREEN = '\x1b[2J\x1b[H';
+const EXIT_FAILURE = 1;
+const EXIT_INTERRUPTED = 130;
+// Strict: an unknown flag or a missing value is an error, never ignored.
+function parseFlags(args, options) {
+    try {
+        return parseArgs({ args, options, strict: true, allowPositionals: false }).values;
+    }
+    catch (error) {
+        throw new AppError('invalid_argument', {}, { cause: error });
+    }
+}
+export function renderSnapshot(snapshot, context) {
+    const { t } = context;
+    const lines = [];
+    for (const provider of snapshot.providers) {
+        lines.push(providerById(provider.id).name.toUpperCase());
+        for (const account of provider.accounts) {
+            const name = `${account.primary ? '★ ' : ''}${formatAccountName(account, t)}`;
+            const freshness = formatFreshness(account.fetchedAt, account.status, context);
+            lines.push(`  ${[name, account.plan, freshness].filter(Boolean).join(' · ')}`);
+            for (const window of account.windows) {
+                const view = describeWindow(window, context);
+                const scope = window.scope ? ` / ${window.scope}` : '';
+                lines.push(`    ${view.label}${scope}: ${[view.value, view.reset, view.detail].filter(Boolean).join(' · ')}`);
+            }
+            if (account.messageCode)
+                lines.push(`    ${describeCode(account.messageCode, t)}`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n').trimEnd();
+}
+function watch({ service, print }, t, locale) {
+    const draw = (snapshot) => {
+        // Only the live view says how to leave it.
+        print(`${process.stdout.isTTY ? CLEAR_SCREEN : ''}${renderSnapshot(snapshot, { t, locale })}\n\n${t('cliWatchFooter')}`);
+    };
+    draw(service.snapshot());
+    return service.refresh().then(snapshot => {
+        draw(snapshot);
+        let busy = false;
+        const timer = setInterval(() => {
+            if (busy)
+                return;
+            busy = true;
+            void service
+                .refresh()
+                .then(draw, () => undefined)
+                .finally(() => {
+                busy = false;
+            });
+        }, service.snapshot().settings.intervalSeconds * 1000);
+        // Runs until interrupted.
+        return new Promise(resolve => {
+            process.once('SIGINT', () => {
+                clearInterval(timer);
+                resolve(0);
+            });
+        });
+    });
+}
+// Runs a provider CLI in this terminal for the chosen (or best eligible) account.
+async function run(context, [providerId, ...args], t) {
+    if (!isProviderId(providerId))
+        throw new AppError('invalid_provider');
+    const flags = parseFlags(args, {
+        account: { type: 'string' },
+        cwd: { type: 'string' },
+        model: { type: 'string' },
+        'dry-run': { type: 'boolean' }
+    });
+    const snapshot = await context.service.refresh(providerId);
+    // Without an explicit --account, only an account with verified quota is used.
+    const chosen = selectAccount(snapshot, providerId, { accountId: flags.account, model: flags.model });
+    if (!chosen)
+        throw new AppError('no_verified_quota');
+    const cwd = await projectDirectory(path.resolve(context.cwd, flags.cwd ?? '.'));
+    const plan = await launchPlan(providerId, { account: chosen, model: flags.model });
+    if (!plan)
+        throw new AppError('no_cli', { tool: providerById(providerId).name });
+    const warnings = await launchWarnings(snapshot, chosen, { projectDir: cwd, model: flags.model });
+    const messages = warnings.map(w => t(w.key, w.params));
+    if (flags['dry-run']) {
+        const command = [plan.binary, ...plan.args];
+        context.print(JSON.stringify({ provider: providerId, accountId: chosen.id, projectDir: cwd, command, warnings: messages }, null, 2));
+        return 0;
+    }
+    for (const message of messages)
+        context.print(message);
+    return context.runAttached(plan.binary, plan.args, { cwd, env: applyEnvironment(environmentChanges(plan.env)) });
+}
+async function handover(context, args, t) {
+    const flags = parseFlags(args, {
+        from: { type: 'string' },
+        to: { type: 'string' },
+        cwd: { type: 'string' },
+        session: { type: 'string' }
+    });
+    const result = await executeHandover({
+        projectDir: path.resolve(context.cwd, flags.cwd ?? '.'),
+        fromProvider: parseProviderChoice(flags.from ?? AUTO),
+        toProvider: parseProviderChoice(flags.to ?? AUTO),
+        sessionId: flags.session ?? AUTO
+    }, await context.service.refresh(), { dataDir: context.dataDir, ...context.launch });
+    context.print(t(LAUNCH_MESSAGES[result.mode], { tool: toolLabel(result.to, result.model) }));
+    return 0;
+}
+// Runs one command and resolves with the process exit code. Failures are printed in the
+// user's language; nothing else reaches the terminal.
+export async function runCli([command = 'status', ...args], context) {
+    const { language } = context.service.snapshot().settings;
+    const t = translator(language);
+    try {
+        switch (command) {
+            case 'help':
+            case '--help':
+                context.print(t('cliHelp'));
+                return 0;
+            case 'status': {
+                const { json } = parseFlags(args, { json: { type: 'boolean' } });
+                const snapshot = await context.service.refresh();
+                context.print(json ? JSON.stringify(snapshot, null, 2) : renderSnapshot(snapshot, { t, locale: language }));
+                return 0;
+            }
+            case 'watch':
+                return await watch(context, t, language);
+            case 'run':
+                return await run(context, args, t);
+            case 'handover':
+                return await handover(context, args, t);
+            default:
+                throw new AppError('unknown_command');
+        }
+    }
+    catch (error) {
+        const { code, params } = error instanceof AppError ? error : new AppError('unexpected');
+        context.printError(describeCode(code, t, params));
+        return EXIT_FAILURE;
+    }
+}
+// The tool shares this terminal: Ctrl+C reaches it as well, and it decides what to do with it.
+// This process waits for it rather than exiting under it and leaving it attached.
+function runAttached(binary, args, options) {
+    const ignore = () => undefined;
+    process.on('SIGINT', ignore);
+    return new Promise(resolve => {
+        const child = spawn(binary, args, { ...options, shell: false, stdio: 'inherit' });
+        child.once('error', () => {
+            resolve(EXIT_FAILURE);
+        });
+        child.once('close', (code, signal) => {
+            resolve(code ?? (signal === 'SIGINT' ? EXIT_INTERRUPTED : EXIT_FAILURE));
+        });
+    }).finally(() => {
+        process.off('SIGINT', ignore);
+    });
+}
+// Runs only as a program; importing the module (tests) has no side effects.
+if (import.meta.main) {
+    const dataDir = appDataDir();
+    createService({ settingsPath: settingsPath(dataDir) })
+        .then(service => runCli(process.argv.slice(2), {
+        service,
+        dataDir,
+        cwd: process.cwd(),
+        print: text => {
+            console.log(text);
+        },
+        printError: text => {
+            console.error(text);
+        },
+        runAttached
+    }))
+        .then(code => {
+        process.exitCode = code;
+    }, (error) => {
+        console.error(describeCode(error instanceof AppError ? error.code : 'unexpected', translator(DEFAULT_LANGUAGE)));
+        process.exitCode = EXIT_FAILURE;
+    });
+}

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

@@ -0,0 +1,51 @@
+export declare const CLAUDE_SESSION_STATUSES: readonly ["busy", "idle", "shell", "waiting"];
+export type ClaudeSessionStatus = (typeof CLAUDE_SESSION_STATUSES)[number];
+export interface LiveClaudeSession {
+    pid: number;
+    sessionId: string;
+    listed: boolean;
+    status: ClaudeSessionStatus | null;
+    statusSince: number;
+    startedAt: number;
+    procStart: string | null;
+}
+export interface ProcessStart {
+    at: number;
+    ticks: string | null;
+}
+export interface SystemProcess extends ProcessStart {
+    pid: number;
+    command: string;
+}
+export type ProcessLookup = {
+    kind: 'found';
+    process: LiveClaudeSession;
+} | {
+    kind: 'none';
+} | {
+    kind: 'unknown';
+    reason: string;
+};
+export type ProcessEnd = 'ended' | 'gone' | 'other' | 'unknown';
+export interface ProcessControl {
+    isAlive: (pid: number) => boolean;
+    started: (pid: number) => Promise<ProcessStart | null>;
+    end: (pid: number) => void;
+    list?: () => Promise<SystemProcess[]>;
+}
+export declare function parseWindowsStart(stdout: string): ProcessStart | null;
+export declare function parseWindowsProcesses(stdout: string): SystemProcess[];
+export declare function parsePsProcesses(stdout: string): {
+    pid: number;
+    command: string;
+}[];
+export declare function processStarted(pid: number): Promise<ProcessStart | null>;
+export declare function resumingProcess(processes: readonly SystemProcess[], sessionId: string): SystemProcess | null;
+export declare const systemProcesses: ProcessControl;
+export interface OpenClaudeSession extends LiveClaudeSession {
+    cwd: string;
+}
+export declare function openSessionsReader(processes?: Pick<ProcessControl, 'isAlive' | 'started'>): (configDir: string) => Promise<OpenClaudeSession[]>;
+export declare function findClaudeProcess(configDir: string, sessionId: string, processes?: Pick<ProcessControl, 'isAlive' | 'list'>): Promise<ProcessLookup>;
+export declare function isSameProcess(live: LiveClaudeSession, started: ProcessStart): boolean;
+export declare function endClaudeSession(live: LiveClaudeSession, processes?: ProcessControl): Promise<ProcessEnd>;