@bridge4dev/runner 0.11.0

package/dist/adapters/claude.js

@@ -0,0 +1,631 @@
+import { query, } from '@anthropic-ai/claude-agent-sdk';
+import { AsyncQueue } from '../async-queue.js';
+import { log } from '../log.js';
+import { evaluateToolUse, maskSecrets, maskString } from '../policy.js';
+import { AGENT_MODES, } from './types.js';
+// Claude adapter over the Agent SDK. Three live-verified gotchas (plan §2):
+//  1. Bare tool names in `allowedTools` auto-approve BEFORE canUseTool — we
+//     never populate allowedTools with gated tools (we don't set it at all).
+//  2. Sandbox-safe commands run without a canUseTool callback — audit relies
+//     on tool events, not on permission requests.
+//  3. The bundled CLI inherits host env/settings (IS_SANDBOX=1 silently
+//     disabled permissions on our own dev host) — env is scrubbed and
+//     settingSources is empty.
+const TEXT_LIMIT = 16_000; // events are capped at 128KB server-side; stay far below
+export function truncate(text, limit = TEXT_LIMIT) {
+    return text.length > limit
+        ? `${text.slice(0, limit)}\n…[truncated ${text.length - limit} chars]`
+        : text;
+}
+// Allowlist, not denylist (QA-96 F12): whatever secrets live in the daemon's
+// environment (CI creds, DATABASE_URL, …) must not reach the agent process.
+// Notably absent by design: ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN (silently
+// override subscription auth) and IS_SANDBOX (kills permission prompts).
+const ENV_ALLOWLIST = [
+    'PATH',
+    'HOME',
+    'USER',
+    'LOGNAME',
+    'SHELL',
+    'LANG',
+    'LANGUAGE',
+    'LC_ALL',
+    'LC_CTYPE',
+    'TERM',
+    'TMPDIR',
+    'TZ',
+    'COLORTERM',
+    'XDG_RUNTIME_DIR',
+    'XDG_DATA_HOME',
+    'XDG_CONFIG_HOME',
+    'XDG_CACHE_HOME',
+    'HTTP_PROXY',
+    'HTTPS_PROXY',
+    'NO_PROXY',
+    'http_proxy',
+    'https_proxy',
+    'no_proxy',
+    'SSL_CERT_FILE',
+    'SSL_CERT_DIR',
+    'NODE_EXTRA_CA_CERTS',
+    // Subscription token — legitimate agent auth when the user configured it.
+    'CLAUDE_CODE_OAUTH_TOKEN',
+];
+function scrubbedEnv() {
+    const env = {};
+    for (const key of ENV_ALLOWLIST) {
+        const value = process.env[key];
+        if (value !== undefined)
+            env[key] = value;
+    }
+    return env;
+}
+// Normalized mode → Claude permission mode (session-5 plan §2). `full` is the
+// owner's explicit call (2026-07-24): "same as Claude works now, we don't
+// restrict anything" — in that mode the SDK stops calling canUseTool at all,
+// so the layer-1 policy cannot gate tools either; the dashboard says so.
+const MODE_TO_PERMISSION = {
+    ask: 'default',
+    plan: 'plan',
+    auto: 'acceptEdits',
+    full: 'bypassPermissions',
+};
+const SYSTEM_APPEND = [
+    'You are running inside a DevBridge dev session, controlled from the DevBridge dashboard.',
+    'Rules:',
+    '- Work ONLY inside the current working directory (a dedicated git worktree on a session branch).',
+    '- Commit your work in the current branch with clear messages. NEVER push to main/master and never force-push.',
+    '- If DevBridge MCP tools (mcp__devbridge__*) are available and the task mentions tickets: fetch the ticket first, set its status to IN_PROGRESS when you start and READY_FOR_REVIEW when your implementation is complete, and leave a short summary comment.',
+    '- The user is not in a terminal: if you need a decision or information, ask the question in plain text and end your turn — the answer arrives as the next user message.',
+    '- Never print secrets (tokens, API keys, private keys) in your output.',
+].join('\n');
+class ClaudeSession {
+    spec;
+    input = new AsyncQueue();
+    output = new AsyncQueue();
+    pending = new Map();
+    q;
+    stopped = false;
+    /** Guards against overlapping capability probes. */
+    capabilitiesInFlight = false;
+    mode;
+    model;
+    events = this.output;
+    constructor(spec, queryFn) {
+        this.spec = spec;
+        this.mode = spec.mode ?? 'ask';
+        if (spec.model)
+            this.model = spec.model;
+        // Free CHAT sessions start with no prompt: the process boots, reports its
+        // capabilities and waits for the first message (live-verified 2026-07-24).
+        if (spec.prompt && spec.prompt.trim())
+            this.pushUserText(spec.prompt);
+        const options = {
+            cwd: spec.cwd,
+            env: scrubbedEnv(),
+            settingSources: [],
+            permissionMode: MODE_TO_PERMISSION[this.mode],
+            systemPrompt: { type: 'preset', preset: 'claude_code', append: SYSTEM_APPEND },
+            canUseTool: (toolName, input, opts) => this.onCanUseTool(toolName, input, opts),
+            ...(spec.model ? { model: spec.model } : {}),
+            ...(spec.resumeProviderSessionId ? { resume: spec.resumeProviderSessionId } : {}),
+            ...(spec.maxBudgetUsd !== undefined ? { maxBudgetUsd: spec.maxBudgetUsd } : {}),
+            ...(spec.mcp
+                ? {
+                    mcpServers: {
+                        devbridge: {
+                            type: 'http',
+                            url: spec.mcp.url,
+                            headers: { Authorization: `Bearer ${spec.mcp.token}` },
+                        },
+                    },
+                }
+                : {}),
+        };
+        this.q = queryFn({ prompt: this.input, options });
+        void this.consume();
+        // Report what the agent can do right away. `system:init` only arrives with
+        // the first turn (verified live), so a free session waiting for its first
+        // message would otherwise show no model list at all — while the control
+        // requests themselves work as soon as the CLI is up.
+        this.refreshCapabilities();
+    }
+    pushUserText(text) {
+        this.input.push({
+            type: 'user',
+            message: { role: 'user', content: text },
+            parent_tool_use_id: null,
+        });
+    }
+    emit(event) {
+        this.output.push(maskSecrets(event));
+    }
+    /**
+     * How full the context window is, after a finished turn. Fire-and-forget with
+     * a timeout on purpose: this is one more control round-trip on a channel that
+     * can hang, and it must never be able to stall the event loop that carries the
+     * conversation.
+     */
+    refreshContextUsage() {
+        if (this.stopped)
+            return;
+        // The SDK marks this API experimental; an older or newer CLI may not have
+        // it at all, and a throw here would tear down the whole event loop.
+        if (typeof this.q.getContextUsage !== 'function')
+            return;
+        let usage;
+        try {
+            usage = this.q.getContextUsage();
+        }
+        catch (error) {
+            log.warn('claude: context usage unavailable', { error: String(error) });
+            return;
+        }
+        void Promise.race([
+            usage,
+            new Promise((resolve) => setTimeout(() => resolve(null), 5_000).unref()),
+        ])
+            .then((result) => {
+            if (!result || this.stopped)
+                return;
+            if (typeof result.totalTokens !== 'number' || typeof result.maxTokens !== 'number')
+                return;
+            if (result.maxTokens <= 0)
+                return;
+            this.emit({
+                type: 'context_usage',
+                usedTokens: result.totalTokens,
+                maxTokens: result.maxTokens,
+            });
+        })
+            .catch((error) => log.warn('claude: context usage probe failed', { error: String(error) }));
+    }
+    /** Fire-and-forget capability refresh — never throws into the caller. */
+    refreshCapabilities() {
+        if (this.capabilitiesInFlight || this.stopped)
+            return;
+        this.capabilitiesInFlight = true;
+        void this.publishCapabilities()
+            .catch((error) => log.warn('claude: capabilities probe failed', { error: String(error) }))
+            .finally(() => {
+            this.capabilitiesInFlight = false;
+        });
+    }
+    /**
+     * Ask the live CLI what it can do (models, commands, account, MCP) and push
+     * it to the dashboard. Everything is best-effort: a control request that
+     * fails must never take the session down.
+     */
+    async publishCapabilities() {
+        const [models, commands, account, mcpServers] = await Promise.all([
+            this.q.supportedModels().catch((error) => {
+                log.warn('claude: supportedModels failed', { error: String(error) });
+                return [];
+            }),
+            this.q.supportedCommands().catch(() => []),
+            this.q.accountInfo().catch(() => null),
+            this.q.mcpServerStatus().catch(() => []),
+        ]);
+        const capabilities = {
+            // `default` is the alias row the CLI itself resolves to the account's
+            // recommended model — this SDK version has no isDefault flag.
+            models: models.map((m) => ({
+                id: m.value,
+                label: m.displayName,
+                ...(m.description ? { description: truncate(m.description, 160) } : {}),
+                ...(m.value === 'default' ? { isDefault: true } : {}),
+            })),
+            modes: [...AGENT_MODES],
+            // Cap the list: it lands in an event payload with a hard size limit.
+            commands: commands.slice(0, 150).map((c) => ({
+                name: c.name,
+                ...(c.description ? { description: truncate(c.description, 160) } : {}),
+                ...(c.argumentHint ? { argumentHint: truncate(c.argumentHint, 60) } : {}),
+            })),
+            currentMode: this.mode,
+            ...(this.model ? { currentModel: this.model } : {}),
+            ...(account
+                ? {
+                    account: {
+                        ...(account.email ? { email: account.email } : {}),
+                        ...(account.organization ? { organization: account.organization } : {}),
+                        ...(account.subscriptionType ? { plan: account.subscriptionType } : {}),
+                    },
+                }
+                : {}),
+            mcpServers: mcpServers.map((s) => ({ name: s.name, status: String(s.status) })),
+            interrupt: true,
+        };
+        this.emit({ type: 'capabilities', capabilities });
+    }
+    async setModel(model) {
+        await this.q.setModel(model);
+        this.model = model;
+        this.emit({ type: 'settings', model });
+        // Claude's models differ in context size (200k vs 1M), and the meter's
+        // denominator only refreshes at the end of a turn — so switching model mid
+        // session left the gauge reporting the OLD model's window, off by 5x in the
+        // worst case. Fire-and-forget, same as the end-of-turn call.
+        this.refreshContextUsage();
+    }
+    async setMode(mode) {
+        await this.q.setPermissionMode(MODE_TO_PERMISSION[mode]);
+        this.mode = mode;
+        this.emit({ type: 'settings', mode });
+    }
+    async setEffort(_effort) {
+        // Claude Code has no per-model reasoning dial: its models advertise no
+        // `efforts`, so the dashboard never shows the control for this agent.
+    }
+    async onCanUseTool(toolName, input, opts) {
+        // The agent's interactive question tool assumes a terminal picker. There
+        // is none here, and its raw JSON is unreadable in a permission card — turn
+        // it into a proper question card and let the user answer in the chat.
+        if (toolName === 'AskUserQuestion') {
+            const question = parseAskUserQuestion(input);
+            if (question) {
+                this.emit({
+                    type: 'question',
+                    text: question.text,
+                    ...(question.options.length ? { options: question.options } : {}),
+                });
+                return {
+                    behavior: 'deny',
+                    message: 'This session has no interactive picker. Ask the question in plain text and end your turn — the user answers with the next message.',
+                };
+            }
+        }
+        // Plan approval is a user decision by definition — never auto-resolved by
+        // policy, and rendered as a plan card rather than a raw tool prompt.
+        if (toolName === 'ExitPlanMode') {
+            const plan = typeof input['plan'] === 'string' ? input['plan'] : '';
+            this.emit({
+                type: 'permission',
+                requestId: opts.requestId,
+                toolName,
+                title: 'The agent proposes a plan',
+                input: {},
+                plan: truncate(plan, 12_000),
+            });
+            return this.waitForAnswer(opts, toolName);
+        }
+        const verdict = evaluateToolUse(toolName, input, {
+            trustMode: this.spec.trustMode,
+            worktreePath: this.spec.cwd,
+        });
+        if (verdict.decision === 'allow') {
+            return { behavior: 'allow', updatedInput: input };
+        }
+        if (verdict.decision === 'deny') {
+            this.emit({
+                type: 'permission_resolved',
+                requestId: opts.requestId,
+                allow: false,
+                source: 'policy',
+                reason: verdict.reason,
+            });
+            return { behavior: 'deny', message: `Denied by DevBridge policy: ${verdict.reason}` };
+        }
+        // ask → surface a permission card and wait for the dashboard's answer.
+        this.emit({
+            type: 'permission',
+            requestId: opts.requestId,
+            toolName,
+            title: opts.title ?? `Allow ${toolName}?`,
+            ...(opts.description ? { description: opts.description } : {}),
+            input: truncateInput(input),
+        });
+        return this.waitForAnswer(opts, toolName);
+    }
+    /** Park the tool call until the dashboard answers (or the request aborts). */
+    waitForAnswer(opts, toolName) {
+        return new Promise((resolve) => {
+            const settle = (result) => {
+                if (this.pending.delete(opts.requestId))
+                    resolve(result);
+            };
+            this.pending.set(opts.requestId, {
+                toolName,
+                resolve: settle,
+            });
+            opts.signal.addEventListener('abort', () => {
+                this.emit({
+                    type: 'permission_resolved',
+                    requestId: opts.requestId,
+                    allow: false,
+                    source: 'abort',
+                });
+                settle({ behavior: 'deny', message: 'Request aborted' });
+            }, { once: true });
+        });
+    }
+    answerPermission(requestId, allow, note) {
+        const pending = this.pending.get(requestId);
+        if (!pending) {
+            log.warn('claude: permission answer for unknown request', { requestId });
+            return;
+        }
+        this.emit({
+            type: 'permission_resolved',
+            requestId,
+            allow,
+            source: 'user',
+            ...(note ? { reason: note } : {}),
+        });
+        if (allow) {
+            pending.resolve({ behavior: 'allow' });
+        }
+        else {
+            pending.resolve({
+                behavior: 'deny',
+                message: note ? `Denied from dashboard: ${note}` : 'Denied from dashboard',
+            });
+        }
+    }
+    send(text) {
+        const accepted = this.input.push({
+            type: 'user',
+            message: { role: 'user', content: text },
+            parent_tool_use_id: null,
+        });
+        if (!accepted) {
+            log.warn('claude: send after session ended — message dropped', {
+                sessionId: this.spec.sessionId,
+            });
+        }
+    }
+    async interrupt() {
+        try {
+            await this.q.interrupt();
+        }
+        catch (error) {
+            log.warn('claude: interrupt failed', { error: String(error) });
+        }
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        this.input.end();
+        try {
+            this.q.close();
+        }
+        catch {
+            // process already gone
+        }
+    }
+    async consume() {
+        try {
+            for await (const msg of this.q) {
+                switch (msg.type) {
+                    case 'system': {
+                        if (msg.subtype === 'init') {
+                            this.emit({
+                                type: 'provider_session',
+                                providerSessionId: msg.session_id,
+                                model: msg.model,
+                            });
+                            // The live model can differ from what we asked for (alias
+                            // resolution, fallback) — refresh the pickers when it does.
+                            if (msg.model && msg.model !== this.model) {
+                                this.model = msg.model;
+                                this.refreshCapabilities();
+                            }
+                        }
+                        else if (msg.subtype === 'status') {
+                            const status = msg.status;
+                            const compactResult = msg.compact_result;
+                            if (status === 'compacting') {
+                                this.emit({ type: 'notice', level: 'info', text: 'Compacting the conversation…' });
+                            }
+                            else if (compactResult) {
+                                this.emit({
+                                    type: 'notice',
+                                    level: compactResult === 'failed' ? 'warn' : 'info',
+                                    text: compactResult === 'failed'
+                                        ? `Compaction failed: ${maskString(String(msg.compact_error ?? 'unknown')).slice(0, 300)}`
+                                        : 'Conversation compacted',
+                                });
+                            }
+                        }
+                        break;
+                    }
+                    case 'conversation_reset': {
+                        this.emit({ type: 'notice', level: 'info', text: 'Context cleared (/clear)' });
+                        break;
+                    }
+                    case 'assistant': {
+                        for (const block of msg.message.content) {
+                            if (block.type === 'text' && block.text.trim()) {
+                                this.emit({ type: 'message', role: 'assistant', text: truncate(block.text) });
+                            }
+                            else if (block.type === 'thinking' && block.thinking.trim()) {
+                                this.emit({ type: 'thinking', text: truncate(block.thinking, 8_000) });
+                            }
+                            else if (block.type === 'tool_use') {
+                                this.emit({
+                                    type: 'tool',
+                                    phase: 'use',
+                                    name: block.name,
+                                    toolUseId: block.id,
+                                    detail: truncateInput(block.input),
+                                });
+                            }
+                        }
+                        break;
+                    }
+                    case 'user': {
+                        const content = msg.message.content;
+                        if (Array.isArray(content)) {
+                            for (const block of content) {
+                                if (block.type === 'tool_result') {
+                                    this.emit({
+                                        type: 'tool',
+                                        phase: 'result',
+                                        name: 'tool_result',
+                                        toolUseId: block.tool_use_id,
+                                        text: truncate(stringifyContent(block.content), 4_000),
+                                    });
+                                }
+                            }
+                        }
+                        break;
+                    }
+                    case 'result': {
+                        this.emit({
+                            type: 'cost',
+                            costUsd: msg.total_cost_usd,
+                            numTurns: msg.num_turns,
+                            durationMs: msg.duration_ms,
+                        });
+                        this.refreshContextUsage();
+                        if (msg.subtype === 'success') {
+                            this.emit({ type: 'turn_end', ok: true });
+                        }
+                        else {
+                            this.emit({
+                                type: 'turn_end',
+                                ok: false,
+                                errorMessage: classifyError(msg.subtype, msg.errors),
+                            });
+                        }
+                        break;
+                    }
+                    default:
+                        break; // partial/status/etc — not forwarded in v0
+                }
+            }
+        }
+        catch (error) {
+            const message = maskString(String(error instanceof Error ? error.message : error));
+            const code = errorCode(message);
+            this.emit({
+                type: 'error',
+                message: classifyRunError(message),
+                ...(code ? { code } : {}),
+            });
+        }
+        finally {
+            this.stopped = true;
+            this.input.end();
+            this.output.end();
+        }
+    }
+}
+// Recursive: MultiEdit-style inputs nest long strings inside arrays — a
+// shallow pass let them blow past the API's 128KB event cap (QA-96 F2).
+function truncateDeep(value, limit) {
+    if (typeof value === 'string')
+        return truncate(value, limit);
+    if (Array.isArray(value))
+        return value.slice(0, 50).map((v) => truncateDeep(v, limit));
+    if (value && typeof value === 'object') {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = truncateDeep(v, limit);
+        }
+        return out;
+    }
+    return value;
+}
+/**
+ * Flatten the AskUserQuestion payload into plain text + option labels.
+ * Shape: `{ questions: [{ question, header, options: [{ label, description }] }] }`.
+ */
+export function parseAskUserQuestion(input) {
+    const questions = input['questions'];
+    const first = Array.isArray(questions) ? questions[0] : undefined;
+    if (!first || typeof first !== 'object')
+        return null;
+    const row = first;
+    const text = typeof row['question'] === 'string' ? row['question'] : null;
+    if (!text)
+        return null;
+    const rawOptions = Array.isArray(row['options']) ? row['options'] : [];
+    const options = rawOptions
+        .map((option) => {
+        if (typeof option === 'string')
+            return option;
+        const entry = option;
+        const label = typeof entry['label'] === 'string' ? entry['label'] : null;
+        if (!label)
+            return null;
+        const description = typeof entry['description'] === 'string' ? entry['description'] : undefined;
+        return description ? `${label} — ${description}` : label;
+    })
+        .filter((option) => Boolean(option))
+        .map((option) => truncate(option, 300))
+        .slice(0, 8);
+    return { text: truncate(text, 2_000), options };
+}
+function truncateInput(input) {
+    return truncateDeep(input, 2_000);
+}
+function stringifyContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((c) => typeof c === 'object' && c && 'text' in c ? String(c.text) : '')
+            .join('\n');
+    }
+    return content === undefined ? '' : JSON.stringify(content);
+}
+function classifyError(subtype, errors) {
+    const detail = errors.length ? `: ${maskString(errors.join('; ').slice(0, 500))}` : '';
+    switch (subtype) {
+        case 'error_max_budget_usd':
+            return 'Session budget (USD) exceeded — the run was stopped';
+        case 'error_max_turns':
+            return 'Maximum turns reached';
+        default:
+            return `Agent run failed (${subtype})${detail}`;
+    }
+}
+/**
+ * A bare `401` used to be enough here, which meant a 401 from an MCP server or
+ * a proxy was reported to the user as "your Claude login expired". Require the
+ * message to actually be about credentials.
+ */
+function isAuthError(message) {
+    if (/\bmcp\b/i.test(message))
+        return false;
+    if (/login expired|please run \/login|oauth token.*(expired|revoked)/i.test(message))
+        return true;
+    // The corroborating word must be a real one: `\bauth\b` and not a bare
+    // `auth` substring, because "unauthorized" contains "auth" and would happily
+    // vouch for itself.
+    return (/\b401\b|unauthorized/i.test(message) &&
+        /\btoken\b|\bauth\b|\bauthentication\b|\blogin\b|\bsign ?in\b|\bcredentials?\b/i.test(message));
+}
+/** A resume id the CLI no longer knows — the supervisor retries from scratch. */
+function isResumeError(message) {
+    return /no conversation found|session .{0,40}not found|could not resume|invalid session id/i.test(message);
+}
+function errorCode(message) {
+    if (isAuthError(message))
+        return 'auth_expired';
+    if (isResumeError(message))
+        return 'resume_failed';
+    return undefined;
+}
+export function classifyRunError(message) {
+    if (isAuthError(message)) {
+        return 'Claude authentication expired on this server — re-login is required (claude setup-token)';
+    }
+    if (isResumeError(message)) {
+        return 'The previous agent conversation could not be resumed — starting a fresh one';
+    }
+    return `Claude session error: ${message.slice(0, 1_000)}`;
+}
+export class ClaudeAdapter {
+    queryFn;
+    id = 'claude';
+    constructor(queryFn = query) {
+        this.queryFn = queryFn;
+    }
+    startSession(spec) {
+        return new ClaudeSession(spec, this.queryFn);
+    }
+}
+//# sourceMappingURL=claude.js.map

package/dist/adapters/codex-home.d.ts

@@ -0,0 +1,61 @@
+export type CodexAuthMode = 'link' | 'own';
+export interface CodexHome {
+    path: string;
+    /** How the home is authenticated — reported in notices, not a secret. */
+    auth: 'linked' | 'own' | 'missing';
+}
+export declare function codexHomePath(): string;
+/**
+ * Throwaway home for a device-code login. The flow runs here and is promoted
+ * into the real home only on success, so an abandoned or timed-out sign-in
+ * cannot destroy a credential that was working.
+ */
+export declare function stagingCodexHomePath(): string;
+/**
+ * Create (or refresh) the runner's CODEX_HOME and return it.
+ *
+ * `auth: 'link'` (default) symlinks the host user's `~/.codex/auth.json` so the
+ * runner uses their ChatGPT subscription and — importantly — shares one
+ * credential store with their own CLI, so a token refresh on either side keeps
+ * both working. `auth: 'own'` leaves the home unauthenticated until a
+ * device-code login writes into it, which is the choice for full isolation.
+ *
+ * A home under the OS temp dir still works, but codex then refuses to install
+ * its helper binaries ("Refusing to create helper binaries under temporary
+ * dir") — which can quietly break the agent's shell tooling, so it is worth a
+ * warning rather than a failure.
+ */
+export declare function ensureCodexHome(options?: {
+    auth?: CodexAuthMode;
+    homedir?: string;
+}): CodexHome;
+/**
+ * Cheap re-assert of the home's credential, safe to call on every session start
+ * and before every probe. Does NOT rewrite the config or touch codex's caches —
+ * it only answers "is the credential still where we left it, and if not, can we
+ * put it back". This is what makes a credential disappearing under a running
+ * daemon self-healing instead of permanent.
+ */
+export declare function repairCodexAuth(options?: {
+    auth?: CodexAuthMode;
+    homedir?: string;
+}): CodexHome;
+/**
+ * Drop a linked auth.json so a device-code login writes our own file instead.
+ *
+ * Only ever called AFTER a login has actually succeeded in the staging home —
+ * never as a pre-step. Detaching first meant an abandoned or timed-out sign-in
+ * left the server permanently "not signed in", recoverable only by restarting
+ * the daemon.
+ */
+export declare function detachLinkedAuth(dir?: string): void;
+/**
+ * Promote a credential produced by a staging login into the real home, and
+ * record that this home now owns its own login.
+ */
+export declare function adoptLoginResult(stagingDir: string, dir?: string): boolean;
+/** Seed a throwaway home for the device-code flow (config only, no credential). */
+export declare function prepareStagingHome(): string;
+/** Remove the staging home whatever the outcome — it may hold a credential. */
+export declare function discardStagingHome(): void;
+//# sourceMappingURL=codex-home.d.ts.map