@byokit/openclaw 0.6.2 → 0.6.3

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+## 0.6.3 (2026-10-07)
+
+- Dependency update: pins @byokit/relay 0.5.3.
+- Dependency update: pins @byokit/link 0.7.1.
+
+- FIX: Route `anthropic-cli` now reports provider `claude-cli`, the id `signedIn`, `providers()` and runs already use for a Claude Code login, so `kit.signedIn(member, route.provider)` answers true once Claude Code is signed in. **Deprecated:** the old provider `anthropic` on this route; it stays readable as `route.deprecatedProvider` (`'anthropic'`) through 0.7.x and is removed in 0.8.0. Match this route by `provider === 'claude-cli'` (or by `choice === 'anthropic-cli'`). The route id `anthropic:cli:anthropic-cli` is kept through 0.7.x and becomes `claude-cli:cli:anthropic-cli` in 0.8.0; choice `anthropic-cli` and the `{ provider: 'claude-cli', via: 'browser' }` link selector are unchanged. `anthropic` remains the API-billed provider only: a Claude Code login never makes `signedIn(member, 'anthropic')` true.
+FIX: Engine start on macOS no longer sticks on a dead-but-unreaped guard process. `pidAlive` detects zombies portably — `ps` state where there is no `/proc` — instead of Linux-only `/proc`, so a stale guard reads as stopped and start can recover. A live pid still reads as owned, an invalid guard still reads as ambiguous, and anything unexpected from the probe keeps the guard. Linux answers are unchanged.
+- FIX: Code sign-ins whose pinned engine prints the code only into a note now hand the caller the code, link, expiry (`expiresAt`) and instructions (`message`) in the same `SignInView` shape as structured codes, and wait out device approval instead of failing with `gateway request timeout for wizard.next` after two minutes.
+- The O16 day-usage engine tests no longer fail when a run straddles UTC midnight: a case that could still be running at midnight starts just after it, so the day (and month) it reads is the day its engine stamps charges in.
+- The `relay` option takes anything with `RelayClient`'s `notify`, so a host can hand the kit a relay it opens after `Host.open` (the client needs the open host). A `RelayClient` still fits; behaviour is unchanged.
+- FIX: The sealed credential store is written as `v: 1` again. 0.6.2's `v: 2` tag made every earlier kit (through 0.6.1) refuse an intact store with `invalid sealed credential store`, so a host rolled back to an earlier kit could not start and lost its saved sign-in. `v: 2` stores still restore and re-seal as `v: 1`.
+- A saved store the key cannot open (a different key, damaged or tampered bytes) or whose payload is not a credential snapshot no longer blocks engine start: it is kept as `auth-store.sealed.unreadable-<ms>` (never overwritten or deleted), the engine starts signed out, and the kit reports `{ phase: 'ready', why: 'sign-in-reset' }` with the words "Your saved sign-in couldn't be opened, so it was kept aside. Sign in again." until a sign-in through the kit completes.
+- FIX: Every wizard `text` step now reaches the caller as `SignInView.prompt`, not only sensitive ones. A non-sensitive step shows the engine's question as written (`github-copilot-enterprise` asks for the Enterprise domain first), so the sign-in no longer waits 15 minutes on a screen with nothing to answer. Once a step is sensitive (or the choice is `setup-token`), the prompt stays the fixed `Sign-in token` label and no gateway prose is shown, as before.
+- FIX: `setup-token` is no longer offered. The pinned Gateway has no app-guided sign-in for it and refuses every attempt with "That provider setup is not available on this Gateway.", so it is listed with `readiness: 'no_upstream_flow'`, the link no longer maps `{ provider: 'anthropic', via: 'browser' }` to it. `plugins.allow` now holds the plugin of every default-eligible bundled route rather than only the ready ones, so `anthropic-cli` and `apiKey` keep the `anthropic` plugin allowed without app config.
+- The R1 restart-recovery probe accepts both restart-time gate denials for the unowned recovering session (HEAD's `unknown run` and the published kit's `can't check this action right now`); any other transcript text still fails the denial assertion.
+
 ## 0.6.2 (2026-10-05)
 
 FIX: The browser broker now holds its CDP endpoint back until Chromium's initial tab exists, so `/json/list` can never serve an empty browser to an attaching engine on a cold or slow start; a browser that never lists a tab fails the launch honestly instead.

package/README.md

@@ -102,6 +102,9 @@ just to read a final result: on cache eviction that would start another run. App
 recovery. Typed `kit.call('agent', ...)` remains exact upstream pass-through. Details and real-engine proof are
 in [the run contract](../../docs/runtime-kits.md#58-runs-members-and-streams).
 
+Every code route shows its code the same way: a waiting view carries `code`, `url`, `expiresAt` (epoch ms, when
+the engine gives a lifetime) and the engine's own instructions in `message`, including routes whose pinned engine
+prints the code only into a note's text.
 Device approval can take longer than two minutes. The kit waits through the engine's advertised code lifetime
 (`expiresInMinutes` on the pin, or `expires_in` seconds when supplied), including progress pulls. If the engine
 supplies no lifetime, it owns the deadline. Ordinary wizard requests keep their 120-second timeout.
@@ -109,7 +112,7 @@ supplies no lifetime, it owns the deadline. Ordinary wizard requests keep their
 `done` returns a typed `SignInView`: `why: 'expired'` for an expired code, `why: 'declined'` for cancellation,
 with a plain sentence in `error`. `SignInOptions` is exported from the host entry.
 
-For a subscription setup-token or any sensitive wizard text step, pass the token once through the same
+For any sensitive wizard text step, pass the secret once through the same
 `signIn.paste(token)` channel and clear the input afterwards. The kit displays only a fixed entry label;
 subsequent wizard errors, links and codes are withheld, and failures use a fixed message rather than
 engine text that could echo the token. It is sent only as this member's wizard answer, never in views,
@@ -288,7 +291,6 @@ state: ready | protocol: 4
 event: {"type":"text","text":"fake: Say hello."}
 event: {"type":"text","text":"fake: Say hello."}
 end: {"ok":true,"text":"fake: Say hello.","usage":{"input":10,"output":16,"total":26}}
-route: setup-token                subscription setup_token
 route: github-copilot             subscription code
 route: github-copilot-enterprise  subscription code
 route: minimax-global-oauth       subscription code
@@ -481,7 +483,9 @@ separately; dual-wrap rotation retains old wrapping keys for backups.
 Without `authSeal`, engine credentials remain plaintext. With it, successful `prepare()` and `stop()` leave
 only a sealed snapshot, `auth-store.sealed`, for the sealed credential paths; regenerable caches stay on
 disk unsealed. The adapter authenticates the snapshot
-before any restoration; a wrong key, tampering, or a missing adapter rejects. Files restored for the engine
+before any restoration; a missing adapter rejects. A store the key cannot open (a wrong key,
+damaged or tampered bytes) or whose payload is not a credential snapshot is kept aside as
+`auth-store.sealed.unreadable-<ms>` and the engine starts signed out (`why: 'sign-in-reset'`); sign in again. Files restored for the engine
 have mode 0600 and directories 0700. File symlinks are sealed only when their fully resolved targets are
 regular files inside the isolated engine root; they restore as regular files at the link paths. Outside-root,
 dangling and directory symlinks (including loops), sockets, FIFOs and devices are skipped.
@@ -536,4 +540,4 @@ frozen (docs/runtime-kits.md §5).
 
 Apache-2.0. See [LICENSE](LICENSE); the bundled engine's MIT text is [engine/OPENCLAW-LICENSE](engine/OPENCLAW-LICENSE).
 
-Claude: `anthropic-cli` uses your own unmodified Claude Code login on this machine (provider `claude-cli`, plugin `anthropic`; subscription billing), with login kept in Claude Code under the kit’s isolated `HOME=<stateDir>/openclaw/home` and `CLAUDE_CONFIG_DIR=<stateDir>/openclaw/home/.claude`; sign in there with `claude auth login`, then call `signIn`. Activation live-tests the route; native sign-out is through Claude Code. `apiKey` is explicit API billing (“API key (billed per use)”, `offer: false`): `signIn` asks for the key through `paste`, then engine activation verifies it. The kit never imports Claude credentials or implements direct Claude.ai OAuth; [Anthropic’s terms](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use) apply.
+Claude: `anthropic-cli` uses your own unmodified Claude Code login on this machine (provider `claude-cli`, plugin `anthropic`; subscription billing; `kit.signedIn(member, 'claude-cli')` is true once Claude Code is signed in, and `'anthropic'` stays the API-billed provider a Claude Code login never satisfies. Before 0.7.0 this route reported provider `anthropic`; that value is deprecated, kept as `deprecatedProvider` until 0.8.0), with login kept in Claude Code under the kit’s isolated `HOME=<stateDir>/openclaw/home` and `CLAUDE_CONFIG_DIR=<stateDir>/openclaw/home/.claude`; sign in there with `claude auth login`, then call `signIn`. Activation live-tests the route; native sign-out is through Claude Code. `apiKey` is explicit API billing (“API key (billed per use)”, `offer: false`): `signIn` asks for the key through `paste`, then engine activation verifies it. The `setup-token` choice is listed but never offered: the pinned Gateway has no app-guided sign-in for it. The kit never imports Claude credentials or implements direct Claude.ai OAuth; [Anthropic’s terms](https://code.claude.com/docs/en/legal-and-compliance#authentication-and-credential-use) apply.

package/SECURITY.md

@@ -28,7 +28,10 @@ resolve with `phase: 'locked'`, do not restore plaintext or launch the engine, a
 retries after unlock. Opt-in dual wrapping opens through an owner-only host key without prompting;
 its protection is only as strong as that file, which must stay outside sealed-store backups.
 Unlocked keyring-only snapshots upgrade atomically under the store's exclusive lock after verifying
-the replacement decrypts to identical contents. Other sealing failures still reject.
+the replacement decrypts to identical contents. A store the key cannot authenticate, or whose authentic
+payload is not a snapshot, is never restored, overwritten or deleted: it is kept as
+`auth-store.sealed.unreadable-<ms>` and the engine starts signed out (`why: 'sign-in-reset'`). Other sealing
+failures still reject.
 
 ## Secrets at rest and in memory
 

package/dist/auth-store.d.ts

@@ -2,6 +2,8 @@ import type { SealingAdapter } from '@byokit/secrets';
 /** True for the regenerable cache paths the collector never seals; tests assert these are all that stay at rest. */
 export declare function cached(name: string): boolean;
 export declare class AuthStore {
+    /** Set when an unreadable store was kept aside and the engine starts signed out; the kit clears it on sign-in. */
+    reset: boolean;
     private active;
     private owned;
     private queue;
@@ -21,6 +23,8 @@ export declare class AuthStore {
     private acquire;
     private release;
     private read;
+    /** Never overwrite or delete a store this kit cannot open: keep its bytes aside and start signed out. */
+    private setAside;
     private collect;
     /** Remove the live credential trees: `state` entirely (it is all credential state, including the
      *  runtime entries the collector skips), and in `home` exactly the sealed paths — regenerable caches

package/dist/auth-store.js

@@ -3,7 +3,7 @@
 // `home` — never the regenerable tool caches, transcripts and logs a signed-in home accumulates.
 // Sealing those too once produced a snapshot past the runtime string limit and aborted boot.
 import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, rmdirSync, writeFileSync, closeSync, fsyncSync, openSync } from 'node:fs';
-import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { EngineAlreadyRunningError, pidAlive as live } from "./engine-status.js";
 const encoder = new TextEncoder();
 const archive = (name) => /^(auth-profiles|auth-state|auth|oauth)\.json\.(migrated-.+|sqlite-import\..+\.bak)$/.test(name)
@@ -89,6 +89,8 @@ function snapshot(text) {
     return s;
 }
 export class AuthStore {
+    /** Set when an unreadable store was kept aside and the engine starts signed out; the kit clears it on sign-in. */
+    reset = false;
     active = false;
     owned = false;
     queue = Promise.resolve();
@@ -174,8 +176,22 @@ export class AuthStore {
         regular(this.file);
         const seal = this.o.seal;
         const bytes = readFileSync(this.file);
-        const text = seal.decryptString(bytes);
-        const saved = snapshot(text);
+        let text;
+        try {
+            text = seal.decryptString(bytes);
+        }
+        catch (error) {
+            if (error?.code !== 'auth-failed')
+                throw error;
+            return this.setAside('could not be authenticated');
+        }
+        let saved;
+        try {
+            saved = snapshot(text);
+        }
+        catch {
+            return this.setAside('is not a credential snapshot');
+        }
         const upgraded = seal.upgrade?.(bytes);
         if (upgraded) {
             if (seal.decryptString(Buffer.from(upgraded)) !== text)
@@ -184,8 +200,17 @@ export class AuthStore {
         }
         return saved;
     }
+    /** Never overwrite or delete a store this kit cannot open: keep its bytes aside and start signed out. */
+    setAside(why) {
+        const aside = `${this.file}.unreadable-${Date.now()}`;
+        renameSync(this.file, aside);
+        syncDir(this.o.root);
+        this.reset = true;
+        this.o.log?.(`sealed credential store ${why}; kept as ${basename(aside)}; sign in again`);
+        return undefined;
+    }
     collect() {
-        const s = { v: 2, dirs: [], files: [] };
+        const s = { v: 1, dirs: [], files: [] };
         const root = realpathSync(this.o.root);
         const walk = (path) => {
             const name = relative(this.o.root, path).split('\\').join('/');
@@ -272,7 +297,7 @@ export class AuthStore {
         put(this.file, sealed);
         if (this.o.seal.decryptString(readFileSync(this.file)) !== payload)
             throw new Error('credential seal verification failed');
-        if (previous?.v === 1)
+        if (previous?.dirs.some(cached))
             this.o.log?.('sealed credential store re-sealed: tool caches no longer sealed');
         put(this.cleanup, encoder.encode('1'));
         this.remove(saved);

package/dist/config.js

@@ -56,7 +56,10 @@ export function reconcileConfig(saved, o) {
     c.plugins.load ??= {};
     c.plugins.load.paths = [...new Set([...(c.plugins.load.paths ?? []).filter((p) => !p.includes('byokit-openclaw-bridge')), o.pluginDir])];
     c.plugins.allow = [...new Set([...(c.plugins.allow ?? []), o.pluginId,
-            ...routes().filter(route => route.offer && route.plugin).map(route => route.plugin)])];
+            // Every default-eligible bundled route, not only the ready ones: anthropic-cli waits on its binary and
+            // shares its plugin with the explicit apiKey route, so neither may depend on another route being offered.
+            ...routes().filter(route => route.offerPolicy === 'default' && !route.needs?.plugin && route.plugin)
+                .map(route => route.plugin)])];
     c.plugins.entries ??= {};
     c.plugins.entries[o.pluginId] = merge(c.plugins.entries[o.pluginId] ?? {}, { hooks: { timeouts: { before_tool_call: 200_000 } } });
     if (o.browser) {

package/dist/engine-status.d.ts

@@ -1,4 +1,4 @@
-import type { ChildProcess } from 'node:child_process';
+import { type ChildProcess } from 'node:child_process';
 /** Every process the kit itself spawned, held for shutdown by pid. */
 export declare class StartedProcesses {
     private readonly started;
@@ -16,4 +16,4 @@ export declare class EngineAlreadyRunningError extends Error {
     readonly code = "engine-already-running";
     constructor();
 }
-export declare function pidAlive(pid: number): boolean;
+export declare function pidAlive(pid: number, platform?: NodeJS.Platform): boolean;

package/dist/engine-status.js

@@ -1,4 +1,5 @@
 import { readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
 /** Every process the kit itself spawned, held for shutdown by pid. */
 export class StartedProcesses {
     started = new Set();
@@ -38,20 +39,40 @@ export class EngineAlreadyRunningError extends Error {
         this.name = 'EngineAlreadyRunningError';
     }
 }
-export function pidAlive(pid) {
+export function pidAlive(pid, platform = process.platform) {
     if (!Number.isSafeInteger(pid) || pid < 1)
         return true; // An invalid guard is ambiguous, never stale.
     try {
         process.kill(pid, 0);
         // An orphan can remain a zombie until its new parent reaps it; it has no writer left.
-        if (process.platform === 'linux') {
+        if (platform === 'linux') {
             const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
             if (stat.slice(stat.lastIndexOf(')') + 2).startsWith('Z '))
                 return false;
         }
+        else if (platform !== 'win32' && psReportsZombie(pid)) {
+            // No /proc here (notably macOS): only a definite zombie reads as stale.
+            return false;
+        }
         return true;
     }
     catch (error) {
         return error.code !== 'ESRCH';
     }
 }
+/**
+ * Why ps: `ps -o stat=` exists on macOS and Linux with the same leading-letter state
+ * convention, so a `Z` first letter names the same kernel fact the /proc read names on
+ * Linux. Linux keeps its /proc read (no subprocess, unchanged answers); every other Unix
+ * asks ps. Only positive `Z` evidence flips the answer — a missing ps, an empty reply,
+ * or gibberish keeps the guard, so a reused live pid is never stolen.
+ */
+function psReportsZombie(pid) {
+    try {
+        const probed = spawnSync('ps', ['-o', 'stat=', '-p', String(pid)], { encoding: 'utf8', timeout: 5000 });
+        return (probed.stdout ?? '').trimStart().startsWith('Z');
+    }
+    catch {
+        return false;
+    }
+}

package/dist/engine.d.ts

@@ -1,3 +1,4 @@
+import { AuthStore } from './auth-store.ts';
 import type { KitOptions } from './kit.ts';
 import type { KitState, ToolSpec } from './types.ts';
 export type EngineOptions = Pick<KitOptions, 'stateDir' | 'engineDir' | 'npmPath' | 'enginePath' | 'config' | 'appOwnedSessions' | 'installPolicy' | 'log' | 'bridge' | 'authSeal'> & {
@@ -24,7 +25,7 @@ export declare class Engine {
     private child?;
     private readonly started;
     private starting?;
-    private readonly authStore;
+    readonly authStore: AuthStore;
     private stopping;
     private credentialsLocked;
     private repaired;

package/dist/kit.js

@@ -736,7 +736,7 @@ export class OpenClawKit {
             await this.bridge.start();
             this.off.push(transport.onEvent((e) => this.approvalsCtl.handleEvent(e)));
             this.failures = 0;
-            this.setState({ phase: 'ready' });
+            this.setState(this.engine.authStore.reset ? { phase: 'ready', why: 'sign-in-reset' } : { phase: 'ready' });
             if (this.o.browser)
                 await this.checkBrowserTools();
             // Replays the engine's native approval lists over the now-live transport (N9).
@@ -882,7 +882,14 @@ export class OpenClawKit {
         return engineProviders(this.signInCtx(), member).then((names) => names.includes(provider)).catch(() => false);
     }
     signIn(member, o, on) {
-        return startSignIn(this.signInCtx(), member, o, on);
+        return startSignIn(this.signInCtx(), member, o, (view) => {
+            if (view.state === 'done' && this.engine.authStore.reset) {
+                this.engine.authStore.reset = false;
+                if (this.current.phase === 'ready')
+                    this.setState({ phase: 'ready' });
+            }
+            on(view);
+        });
     }
     signOut(member, provider) {
         return engineSignOut(this.signInCtx(), member, provider);

package/dist/link.d.ts

@@ -1,7 +1,7 @@
 import type { BrowserHost } from './browser.ts';
 import { type IncomingMessage, type ServerResponse } from 'node:http';
 import { type Grant, type Host, type HostOptions } from '@byokit/link';
-import { type ServeIngress, type Via } from '@byokit/reach';
+import { type ServeIngress, type Via } from '@byokit/discover';
 import type { PushAction, RelayClient } from '@byokit/relay';
 import type { OpenClawKit } from './kit.ts';
 import type { Member } from './types.ts';
@@ -9,7 +9,7 @@ import type { Member } from './types.ts';
 export type OpenClawLinkOptions = {
     memberOf: (grant: Grant) => Member | undefined;
     passThrough?: (method: string, grant: Grant) => boolean;
-    relay?: RelayClient;
+    relay?: Pick<RelayClient, 'notify'>;
 };
 /** What `openclawLink` hands the link host: its request/stream handlers plus the kit's push entry point. */
 export type OpenClawLinkHost = Pick<HostOptions, 'handle' | 'stream' | 'allow' | 'onGrantRemoved'> & {

package/dist/link.js

@@ -6,7 +6,7 @@ import { readFileSync } from 'node:fs';
 import { createServer } from 'node:http';
 import { WebSocketServer } from 'ws';
 import { PublicLinkError, } from '@byokit/link';
-import { reach } from '@byokit/reach';
+import { reach } from '@byokit/discover';
 import { ENGINE_VERSION } from "./constants.js";
 import { b64urlDecode, b64urlEncode, sealNotice } from "./notices.js";
 import { routeFor } from "./routes.js";

package/dist/routes.json

@@ -122,7 +122,7 @@
     },
     {
         "choice": "anthropic-cli",
-        "provider": "anthropic",
+        "provider": "claude-cli",
         "plugin": "anthropic",
         "billing": "subscription",
         "via": "cli",
@@ -134,6 +134,7 @@
             "provider": "claude-cli",
             "via": "browser"
         },
+        "deprecatedProvider": "anthropic",
         "reason": "Anthropic Claude CLI: subscription sign-in.",
         "source": "extensions/anthropic/openclaw.plugin.json (2026.8.1)",
         "revision": "2026.8.1",
@@ -173,13 +174,9 @@
         "via": "setup_token",
         "auth": "token",
         "prerequisite": null,
-        "offer": true,
-        "offerPolicy": "default",
-        "legacy": {
-            "provider": "anthropic",
-            "via": "browser"
-        },
-        "reason": "Anthropic setup-token: subscription sign-in.",
+        "offer": false,
+        "offerPolicy": "explicit",
+        "reason": "The pinned Gateway has no app-guided sign-in for this choice.",
         "source": "extensions/anthropic/openclaw.plugin.json (2026.8.1)",
         "revision": "2026.8.1",
         "checked": "2026-10-02",
@@ -201,7 +198,7 @@
             "id": "anthropic",
             "method": "setup-token",
             "revision": "ea806575e6450e4d1efdfc72c19f04be982a1b9b",
-            "flow": "present"
+            "flow": "absent"
         }
     },
     {

package/dist/signin.js

@@ -15,6 +15,19 @@ const CANCEL_MS = 10_000;
 const RECONFIRM_MS = 60_000;
 const TURNS = 200;
 const PASTE_MS = 15 * 60_000;
+// Two of the pin's code routes print their code only into a note's text ("Code: X" with
+// "Code expires in N minutes", or "enter the code X." with "Expires at: <ISO>"), never as `deviceCode`.
+// Read it back so every code route reaches the caller in the one structured shape.
+const noteCode = (step) => {
+    const text = step.type === 'note' ? step.message ?? '' : '';
+    const code = /^Code: (\S+)$/m.exec(text)?.[1] ?? /enter the code (\S+?)\.?$/m.exec(text)?.[1];
+    if (!code)
+        return undefined;
+    const minutes = /Code expires in (\d+) minutes/.exec(text)?.[1];
+    const at = Date.parse(/Expires at: (\S+)/.exec(text)?.[1] ?? '');
+    return { code, message: text, ...(minutes ? { expiresInMinutes: Number(minutes) }
+            : Number.isFinite(at) ? { expires_in: Math.max(0, Math.floor((at - Date.now()) / 1_000)) } : {}) };
+};
 const cut = (value) => (value instanceof Error ? value.message : String(value)).slice(0, 200);
 const pullOptions = (signal) => ({ timeoutMs: PULL_MS, signal });
 /**
@@ -268,19 +281,22 @@ export function signIn(ctx, member, o, on) {
             step = undefined;
             if (current.type === 'text' && current.sensitive)
                 sensitive = true;
-            if (current.deviceCode && current.type !== 'text') {
+            const deviceCode = current.type === 'text' ? undefined : current.deviceCode ?? noteCode(current);
+            if (deviceCode) {
                 stopApproval();
                 approval = true;
                 sawDeviceCode = true;
                 // The pin converts its provider duration to minutes. Prefer exact seconds if the engine supplies them.
-                const duration = current.deviceCode.expires_in !== undefined
-                    ? Number(current.deviceCode.expires_in) * 1_000
-                    : Number(current.deviceCode.expiresInMinutes) * 60_000;
-                if (Number.isFinite(duration) && duration >= 0) {
+                const duration = deviceCode.expires_in !== undefined
+                    ? Number(deviceCode.expires_in) * 1_000
+                    : Number(deviceCode.expiresInMinutes) * 60_000;
+                const timed = Number.isFinite(duration) && duration >= 0;
+                if (timed)
                     codeTimer = setTimeout(() => { codeExpired = true; owner.abort(); }, duration);
-                }
+                const message = deviceCode.message ?? current.message;
                 // The code is on the card; acknowledging it lets the engine poll the provider itself.
-                say({ ...(current.deviceCode.code ? { code: current.deviceCode.code } : {}), ...(current.externalUrl ? { url: current.externalUrl } : {}) });
+                say({ ...(deviceCode.code ? { code: deviceCode.code } : {}), ...(current.externalUrl ? { url: current.externalUrl } : {}),
+                    ...(timed ? { expiresAt: Date.now() + duration } : {}), ...(message ? { message } : {}) });
                 const next = await answer(current);
                 if (next.done) {
                     terminal = next;
@@ -292,8 +308,9 @@ export function signIn(ctx, member, o, on) {
             if (current.type !== 'progress')
                 stopApproval();
             if (current.type === 'text') {
-                if (current.sensitive)
-                    say({ prompt: 'Sign-in token' });
+                // Every text step is a question the person must answer, so it is always asked. A non-sensitive one is not a
+                // secret by the engine's own flag: its question is shown as written. Once anything is sensitive, only the fixed label is.
+                say({ prompt: sensitive ? 'Sign-in token' : current.message || 'Paste what the sign-in page gave you' });
                 const value = await waitForPaste();
                 if (value === undefined)
                     return signal.aborted ? cancelled() : expired();

package/dist/types.d.ts

@@ -103,6 +103,8 @@ export type SignInView = {
     via: 'browser' | 'code';
     url?: string;
     code?: string;
+    expiresAt?: number;
+    message?: string;
     prompt?: string;
     error?: string;
     why?: 'busy' | 'declined' | 'expired' | 'failed';
@@ -125,7 +127,7 @@ export type Decision = {
 };
 export type KitState = {
     phase: 'stopped' | 'installing' | 'starting' | 'repairing' | 'ready' | 'restarting' | 'failed' | 'needs-update' | 'locked';
-    why?: 'install' | 'handshake' | 'exited' | 'port' | 'version' | 'engine-already-running' | 'engine-patch';
+    why?: 'install' | 'handshake' | 'exited' | 'port' | 'version' | 'engine-already-running' | 'engine-patch' | 'sign-in-reset';
     retryAt?: number;
     patchSet?: string | null;
 };
@@ -157,6 +159,10 @@ export type Route = {
         provider: string;
         via: 'browser' | 'code';
     };
+    /** @deprecated This route's `provider` before 0.7.0 (`anthropic` on `anthropic-cli`); use `provider` (`claude-cli`).
+     * Discovery data only, never a sign-in or `signedIn` id. Removed in 0.8.0, when that route's id becomes
+     * `claude-cli:cli:anthropic-cli`. */
+    deprecatedProvider?: string;
     billingFrom?: 'source' | 'host';
     group?: 'models' | 'services';
     platforms?: {

package/dist/words.js

@@ -21,6 +21,8 @@ export function stateWords(s) {
     // 'stopped' is never on screen (4.3 covers what a person can see), so 5.14 has no row for it.
     if (s.phase === 'failed' && s.why === 'engine-already-running')
         return words('engine.alreadyRunning');
+    if (s.why === 'sign-in-reset')
+        return words('engine.signInAgain');
     return s.phase === 'stopped' ? '' : words(PHASE_WORDS[s.phase]);
 }
 export function toAccountView(view, ready) {

package/dist/words.json

@@ -3,6 +3,7 @@
     "engine.starting": "Starting up…",
     "engine.repairing": "Fixing a small problem with the setup. This takes a moment.",
     "engine.locked": "Your saved sign-in is locked. Unlock your password storage, then try again.",
+    "engine.signInAgain": "Your saved sign-in couldn't be opened, so it was kept aside. Sign in again.",
     "engine.ready": "Ready.",
     "engine.restarting": "Something stopped. Starting it again by itself.",
     "engine.alreadyRunning": "Your saved sign-in is in use. Try again after the other session stops.",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byokit/openclaw",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "The OpenClaw runtime kit: the pinned engine's full operator surface with plain-words helpers for members, sign-in, runs and approvals.",
   "license": "Apache-2.0",
   "type": "module",
@@ -60,9 +60,9 @@
     "prepack": "tsc -b && node ../../scripts/fix-words-dts.cjs"
   },
   "dependencies": {
-    "@byokit/link": "0.7.0",
-    "@byokit/relay": "0.5.2",
-    "@byokit/reach": "0.6.0",
+    "@byokit/link": "0.7.1",
+    "@byokit/relay": "0.5.3",
+    "@byokit/discover": "0.6.0",
     "@byokit/seal": "0.3.0",
     "@byokit/secrets": "0.5.0",
     "@openclaw/gateway-client": "2026.9.6",