@zergai/ztc 0.5.0-beta.1 → 0.6.0-beta.1

package/dist/agent/commands/accounts.js

@@ -248,7 +248,7 @@ function accountFamily(provider) {
         return 'Codex';
     return 'Kimi';
 }
-function interactiveAddPage(ctx, provider) {
+function interactiveAddPage(ctx, provider, onBack) {
     const selected = configStore.getProvider();
     const draft = {
         provider: provider ?? (isAccountProvider(selected) ? selected : 'claude_code'),
@@ -256,7 +256,7 @@ function interactiveAddPage(ctx, provider) {
     };
     const originalFamily = provider ? accountFamily(provider) : undefined;
     const showAccounts = (family) => {
-        void runInteractive(ctx, family).catch((error) => say(ctx, `Could not open Accounts: ${String(error)}`));
+        void runInteractive(ctx, family, onBack).catch((error) => say(ctx, `Could not open Accounts: ${String(error)}`));
     };
     const back = () => showAccounts(originalFamily);
     let error = '';
@@ -356,7 +356,14 @@ function interactiveAddPage(ctx, provider) {
     };
     showPage();
 }
-async function runInteractive(ctx, focus) {
+/**
+ * The account manager opened from the settings panel: Escape hands the user
+ * back to `onBack` (the panel) instead of the transcript.
+ */
+export function openAccountsManager(ctx, options = {}) {
+    return runInteractive(ctx, options.focus, options.onBack);
+}
+async function runInteractive(ctx, focus, onBack) {
     const accounts = configStore.listAccounts();
     const families = [
         { name: 'Claude', provider: 'claude_code', matches: account => account.provider.startsWith('claude_code') },
@@ -366,7 +373,7 @@ async function runInteractive(ctx, focus) {
     const categories = await Promise.all(families.map(async (family) => {
         const group = accounts.filter(family.matches);
         const statuses = await Promise.all(group.map(accountStatusLabel));
-        const refresh = () => { void runInteractive(ctx, family.name); };
+        const refresh = () => { void runInteractive(ctx, family.name, onBack); };
         const runAction = (action) => {
             void action().catch((error) => say(ctx, `Account action failed: ${String(error)}`)).finally(refresh);
         };
@@ -379,7 +386,7 @@ async function runInteractive(ctx, focus) {
                     value: '',
                     type: 'text',
                     description: 'Keep another account signed in for a quick manual switch.',
-                    onActivate: () => interactiveAddPage(ctx, family.provider),
+                    onActivate: () => interactiveAddPage(ctx, family.provider, onBack),
                 },
                 ...(family.name === 'Codex' ? [{
                         name: 'refresh:Codex',
@@ -447,6 +454,7 @@ async function runInteractive(ctx, focus) {
     ctx.settingsPanel?.showSettingsPanel({
         title: 'Accounts', categories, initialCategory: focus ?? defaultFocus,
         onSettingChange: () => { },
+        onClose: onBack,
     });
 }
 export const accountsCommand = {

package/dist/agent/commands/auth.d.ts

@@ -1,4 +1,33 @@
-import type { Command } from './types.js';
+import type { Command, CommandContext } from './types.js';
+/**
+ * How one /auth action ended. A failure's reason is also in the transcript.
+ * `ended` says why a login ended without approval: its grant ran out, it was
+ * cancelled, or another login was already waiting.
+ */
+export type AuthOutcome = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+    ended?: 'expired' | 'cancelled' | 'pending';
+};
+/** The Router origin a ZergAI login is waiting for approval at, if one is. */
+export declare function pendingZergAILogin(): string | undefined;
+/** Call `listener` whenever a login starts or stops waiting; returns the unsubscribe. */
+export declare function onZergAILoginWaitChange(listener: () => void): () => void;
+/** Stop waiting for the ZergAI login's approval. False when none is waiting. */
+export declare function cancelZergAILogin(): boolean;
+/**
+ * Stop the waiting ZergAI login and say so: /auth cancel, the ZergAI row on
+ * Connection, and Escape or Ctrl+C in the terminal. The login itself ends
+ * quietly, so the transcript says it once. False when none was waiting.
+ */
+export declare function stopZergAILogin(report: (content: string) => void): boolean;
+/**
+ * Run one /auth action, reporting to the transcript. Shared by the command and
+ * the settings panel's ZergAI row, which reopens with the outcome.
+ */
+export declare function runAuthAction(args: string[], ctx: CommandContext): Promise<AuthOutcome>;
 export declare const authCommand: Command;
 export declare const loginCommand: Command;
 export declare const logoutCommand: Command;

package/dist/agent/commands/auth.js

@@ -1,62 +1,193 @@
 import { configStore } from '../../config.js';
-import { runRouterAuthCommand } from '../../router_auth.js';
+import { DEFAULT_ROUTER_ORIGIN, namedRouterLoginOptions, RouterLoginEndedError, runRouterAuthCommand } from '../../router_auth.js';
+import { describeActiveRoute } from './credential_status.js';
+import { providerLabel } from './direct_credential_prompt.js';
+/**
+ * The one ZergAI login this session waits on. Its device grant stays open in
+ * the browser until approved, cancelled or run out, so a second login to the
+ * same Router would only leave two codes racing for one credential file.
+ */
+let waitingLogin = null;
+const waitingLoginListeners = new Set();
+function setWaitingLogin(next) {
+    waitingLogin = next;
+    for (const listener of waitingLoginListeners)
+        listener();
+}
+/** The Router origin a ZergAI login is waiting for approval at, if one is. */
+export function pendingZergAILogin() {
+    return waitingLogin?.origin;
+}
+/** Call `listener` whenever a login starts or stops waiting; returns the unsubscribe. */
+export function onZergAILoginWaitChange(listener) {
+    waitingLoginListeners.add(listener);
+    return () => { waitingLoginListeners.delete(listener); };
+}
+/** Stop waiting for the ZergAI login's approval. False when none is waiting. */
+export function cancelZergAILogin() {
+    if (!waitingLogin)
+        return false;
+    waitingLogin.controller.abort();
+    setWaitingLogin(null);
+    return true;
+}
+/**
+ * Stop the waiting ZergAI login and say so: /auth cancel, the ZergAI row on
+ * Connection, and Escape or Ctrl+C in the terminal. The login itself ends
+ * quietly, so the transcript says it once. False when none was waiting.
+ */
+export function stopZergAILogin(report) {
+    const cancelled = cancelZergAILogin();
+    report(cancelled ? '✓ Cancelled the ZergAI login.' : 'No ZergAI login is waiting.');
+    return cancelled;
+}
+/** The Router a login with these arguments goes to, as an origin. */
+function loginOrigin(args, configured) {
+    const flag = args.indexOf('--url');
+    const target = (flag >= 0 ? args[flag + 1] : undefined) ?? configured ?? DEFAULT_ROUTER_ORIGIN;
+    try {
+        return new URL(target).origin;
+    }
+    catch {
+        return target;
+    }
+}
+/**
+ * After a login, say so when the selection still runs on this machine (auto
+ * routing keeps local logins and a Gemini key direct), so the Router routing
+ * line is not read as the route in use.
+ */
+function describeRouteAfterLogin(ctx) {
+    const route = describeActiveRoute(ctx.config);
+    if (!route.ready)
+        return;
+    const label = providerLabel(ctx.config.getProvider());
+    const local = route.kind === 'api-key' ? `your ${label} API key`
+        : route.kind === 'local-login' ? `your ${label} login`
+            : route.kind === 'endpoint' ? 'your custom endpoint' : undefined;
+    if (local)
+        ctx.addMessage({ role: 'system', content: `ZTC still uses ${local} on this machine. To use Zerg Router, pick a Zerg Router choice in /model.` });
+}
+/**
+ * Run one /auth action, reporting to the transcript. Shared by the command and
+ * the settings panel's ZergAI row, which reopens with the outcome.
+ */
+export async function runAuthAction(args, ctx) {
+    if (args[0] === 'login')
+        args = ['login', ...namedRouterLoginOptions(args.slice(1))]; // /login dev: the dev Router's --url
+    // Keep process-only --router-url overrides when signing in from a session.
+    const configured = configStore.get().zergProxyUrl;
+    let login;
+    if (args[0] === 'login') {
+        const target = loginOrigin(args, configured);
+        if (waitingLogin?.origin === target) {
+            const error = `A ZergAI login is already waiting for approval at ${target}. Approve it in your browser, or run /auth cancel.`;
+            ctx.addMessage({ role: 'system', content: error });
+            return { ok: false, error, ended: 'pending' };
+        }
+        // One login at a time: a login to another Router replaces the waiting one.
+        const replaced = waitingLogin?.origin;
+        if (cancelZergAILogin())
+            ctx.addMessage({ role: 'system', content: `Stopped waiting for the ZergAI login at ${replaced}.` });
+        login = new AbortController();
+        setWaitingLogin({ origin: target, controller: login });
+    }
+    // A login stops waiting once the browser approves it (from there it only
+    // finishes, so a cancel no longer applies) or once it ends.
+    const stopWaiting = () => { if (login && waitingLogin?.controller === login)
+        setWaitingLogin(null); };
+    try {
+        const origin = args[0] === 'login' && !args.includes('--url') ? configured : undefined;
+        await runRouterAuthCommand(origin ? [...args, '--url', origin] : args, message => {
+            ctx.addMessage({ role: 'system', content: message.trimEnd() });
+        }, { origin: configured, surface: 'session', signal: login?.signal, onApproved: stopWaiting,
+            // Show the saved login at once, not after the account check, and retire
+            // the backend built for the old route: a turn sent meanwhile builds anew.
+            onSaved: async () => {
+                await configStore.refresh();
+                await ctx.reloadAgent({ defer: true });
+            } });
+        if (args[0] === 'login' || args[0] === 'logout') {
+            await configStore.refresh();
+            if (args[0] === 'login') {
+                // Sign-in changes catalog ownership. Discover before constructing the
+                // backend so the first turn uses the new account's model metadata, and
+                // so the Provider row lists Zerg Router choices while the selection
+                // still runs on this machine.
+                try {
+                    await ctx.models.catalog?.(undefined, { refresh: true });
+                }
+                catch {
+                    // Catalog availability must not undo a successful sign-in.
+                }
+            }
+            // Logout must dispose of the old backend without building a new one
+            // from missing credentials. Login builds from the newly loaded session.
+            ctx.reloadAgent({ defer: args[0] === 'logout' });
+            if (args[0] === 'login')
+                describeRouteAfterLogin(ctx);
+        }
+        return { ok: true };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Router authentication failed.';
+        // Whoever cancelled the login already said so.
+        const cancelled = error instanceof RouterLoginEndedError && error.reason === 'cancelled';
+        if (!cancelled)
+            ctx.addMessage({ role: 'system', content: message });
+        return { ok: false, error: message, ...(error instanceof RouterLoginEndedError ? { ended: error.reason } : {}) };
+    }
+    finally {
+        stopWaiting();
+    }
+}
 export const authCommand = {
     name: 'auth',
-    description: 'Manage Zerg Router authentication',
-    usage: '<login|logout|status|readiness|billing> [options]',
+    description: 'Log in with ZergAI to use Zerg Router',
+    usage: '<login|cancel|logout|status|readiness|billing> [options]',
     agentRunnable: false,
     handler: async (args, ctx) => {
         if (args.length === 0 || args[0] === 'help') {
             ctx.addMessage({ role: 'system', content: [
-                    'Zerg Router authentication:',
-                    '  /auth login [--url <origin>] [--no-browser] - Sign in through your browser',
+                    'ZergAI login (for Zerg Router):',
+                    '  /auth login [dev|prod] [--url <origin>] [--no-browser] - Log in with ZergAI in your browser (dev: the dev Router)',
+                    "  /auth cancel - Stop waiting for a ZergAI login's approval",
                     '  /auth readiness [--json] - Check personal funding and model availability without using quota',
                     '  /auth billing [--no-browser] - Review personal pay-as-you-go funding in the browser',
-                    '  /auth status [--json] - Show the current Router session',
-                    '  /auth logout [--local-only] - Sign out',
+                    '  /auth status [--json] - Show the current Zerg Router session',
+                    '  /auth logout [--local-only] - Log out of ZergAI',
                     '',
                     'These commands share the login and credentials used by ztc auth.',
+                    '/keys shows this login and your API keys together.',
                 ].join('\n') });
             return;
         }
-        try {
-            // Keep process-only --router-url overrides when signing in from a session.
-            const origin = args[0] === 'login' && !args.includes('--url')
-                ? configStore.get().zergProxyUrl : undefined;
-            await runRouterAuthCommand(origin ? [...args, '--url', origin] : args, message => {
-                ctx.addMessage({ role: 'system', content: message.trimEnd() });
-            });
-            if (args[0] === 'login' || args[0] === 'logout') {
-                await configStore.refresh();
-                if (args[0] === 'login' && configStore.resolveLLMBackendConfig().useProxy) {
-                    // Sign-in changes catalog ownership. Discover before constructing the
-                    // backend so the first turn uses the new account's model metadata.
-                    try {
-                        await ctx.models.catalog?.(undefined, { refresh: true });
-                    }
-                    catch {
-                        // Catalog availability must not undo a successful sign-in.
-                    }
-                }
-                // Logout must dispose of the old backend without building a new one
-                // from missing credentials. Login builds from the newly loaded session.
-                ctx.reloadAgent({ defer: args[0] === 'logout' });
-            }
+        if (args[0] === 'cancel') {
+            if (args.length > 1)
+                ctx.addMessage({ role: 'system', content: 'Usage: /auth cancel' });
+            else
+                stopZergAILogin(content => ctx.addMessage({ role: 'system', content }));
+            return;
         }
-        catch (error) {
-            ctx.addMessage({ role: 'system', content: error instanceof Error ? error.message : 'Router authentication failed.' });
+        const outcome = await runAuthAction(args, ctx);
+        // A logout that leaves no model asks how to connect again. The settings
+        // panel's logout returns to Connection instead, which offers the same.
+        if (args[0] === 'logout' && outcome.ok) {
+            // connect.ts imports this module, so load it when a logout needs it.
+            const { offerConnectAfterLogout } = await import('./connect.js');
+            offerConnectAfterLogout(ctx);
         }
     },
 };
 export const loginCommand = {
     name: 'login',
-    description: 'Sign in to Zerg Router (alias for /auth login)',
-    usage: '[--url <origin>] [--no-browser]',
+    description: 'Log in with ZergAI (alias for /auth login)',
+    usage: '[dev|prod] [--url <origin>] [--no-browser]',
     handler: async (args, ctx) => { await authCommand.handler(['login', ...args], ctx); },
 };
 export const logoutCommand = {
     name: 'logout',
-    description: 'Sign out of Zerg Router (alias for /auth logout)',
+    description: 'Log out of ZergAI (alias for /auth logout)',
     usage: '[--local-only]',
     handler: async (args, ctx) => { await authCommand.handler(['logout', ...args], ctx); },
 };

package/dist/agent/commands/command_refusal.d.ts

@@ -0,0 +1,8 @@
+export declare function isCommandRefusal(output: string | null | undefined): boolean;
+export declare function refusalEvent(message: string, timestamp?: string): {
+    type: "error";
+    timestamp: string;
+    data: {
+        message: string;
+    };
+};

package/dist/agent/commands/command_refusal.js

@@ -0,0 +1,8 @@
+export function isCommandRefusal(output) {
+    if (!output)
+        return false;
+    return output.startsWith('Unknown command') || /^Command \/\S+ failed:/.test(output);
+}
+export function refusalEvent(message, timestamp = new Date().toISOString()) {
+    return { type: 'error', timestamp, data: { message } };
+}

package/dist/agent/commands/compact.js

@@ -35,9 +35,24 @@ export const compactCommand = {
             });
             return;
         }
+        // In `tokens` mode the budget is the ceiling the target is measured
+        // against, matching auto-compaction. In `percent` mode a stored budget is
+        // inert, so the target stays a share of the window.
+        const budget = tokenTriggerActive(ctx.config.get())
+            ? resolveContextTokenBudget(ctx.config.get())
+            : undefined;
+        const configuredTarget = budget === undefined
+            ? (catalogWindow === undefined ? undefined : Math.max(1, Math.floor((catalogWindow ?? estimateConversationTokens(messages)) * targetPercent / 100)))
+            : Math.floor(budget * (targetPercent / 100));
+        // Asked for by name, compaction shrinks history even below the configured target: it once reported
+        // "86k -> 86k" at 8% of a 1M window (2026-10-27). It then aims for half of what the conversation uses now.
+        const usedTokens = estimateConversationTokens(messages);
+        const reachedTarget = (configuredTarget ?? Math.floor(status.total * targetPercent / 100)) >= usedTokens;
+        const targetTokens = !args[0] && reachedTarget ? Math.max(1, Math.floor(usedTokens / 2)) : configuredTarget;
+        const shownTarget = targetTokens === undefined || !(status.total > 0) ? targetPercent : Math.round(targetTokens / status.total * 100);
         ctx.addMessage({
             role: 'system',
-            content: `Compacting conversation (${Math.round(status.percentage)}% -> ${targetPercent}% target)...`,
+            content: `Compacting conversation (${Math.round(status.percentage)}% -> ${shownTarget}% target)...`,
         });
         // Determine summarizer based on provider and API key availability
         const provider = ctx.config.getProvider();
@@ -50,15 +65,6 @@ export const compactCommand = {
         };
         try {
             const compaction = resolveCompactionSettings(ctx.config.get());
-            // In `tokens` mode the budget is the ceiling the target is measured
-            // against, matching auto-compaction. In `percent` mode a stored budget is
-            // inert, so the target stays a share of the window.
-            const budget = tokenTriggerActive(ctx.config.get())
-                ? resolveContextTokenBudget(ctx.config.get())
-                : undefined;
-            const targetTokens = budget === undefined
-                ? (catalogWindow === undefined ? undefined : Math.max(1, Math.floor((catalogWindow ?? estimateConversationTokens(messages)) * targetPercent / 100)))
-                : Math.floor(budget * (targetPercent / 100));
             const result = await compactConversation(messages, model, {
                 method: compaction.method,
                 jev: compaction.jev,