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

package/dist/app/selection_completion.js

@@ -1,7 +1,9 @@
+import { routerModelIds, routerModelsForProvider, resolveRouterModel } from '../utils/router_catalog.js';
+import { reasoningCommandChoices, reasoningEnabled } from '../utils/reasoning.js';
 import { MODEL_CATALOG } from '../panes/model_catalog.js';
 import { canRouteThroughRouter, canonicalProvider, PROVIDER_CHOICES } from '../agent/commands/provider_choices.js';
 import { resolveSlashUsage } from '../agent/commands/usage_spec.js';
-import { splitInputArgs } from '../agent/commands/usage_parser.js';
+import { parseSlashUsage, splitInputArgs } from '../agent/commands/usage_parser.js';
 const fold = (value) => value.toLowerCase().replace(/[^\p{L}\p{N}]/gu, '');
 function score(value, query) {
     const target = fold(value);
@@ -42,6 +44,18 @@ function commandUsage(text, commands) {
 function parseSelectionInput(text, commands) {
     if (commands.length && /^\/[\w-]*$/.test(text))
         return { kind: 'command', prefix: '/', query: text.slice(1) };
+    const auth = text.match(/^\/auth[ \t]+([^\s]*)$/);
+    const authCommand = auth && commands.find(command => command.name === 'auth');
+    const actions = authCommand && parseSlashUsage(authCommand.usage)[0]?.choices;
+    if (auth && actions?.length) {
+        return { kind: 'command', prefix: '/', query: `auth ${auth[1]}`,
+            selections: actions.map(action => ({ value: `auth ${action}`, label: `/auth ${action}` })) };
+    }
+    const reasoning = text.match(/^\/(effort|thinking)\s+([^\s]*)\s*$/i);
+    if (reasoning && commands.some(command => command.name === reasoning[1].toLowerCase())) {
+        const command = reasoning[1].toLowerCase();
+        return { kind: 'reasoning', command, prefix: `/${command} `, query: reasoning[2] };
+    }
     const model = text.match(/^\/(model|models)\s+([^\n]*)$/i);
     if (!model)
         return commandUsage(text, commands);
@@ -98,10 +112,13 @@ function commandSelections(commands) {
 /** Static preview for renderers without a completion controller. Explicit null hides it. */
 export function commandCompletionView(text, commands) {
     const parsed = parseSelectionInput(text, commands);
+    if (parsed?.kind === 'reasoning')
+        return { kind: 'usage', candidates: [], selected: 0, loading: false,
+            usage: `/${parsed.command} [${parsed.command === 'effort' ? 'level|default' : 'setting'}]` };
     if (parsed?.kind !== 'command' && parsed?.kind !== 'usage')
         return null;
     return { kind: parsed.kind, query: parsed.query, usage: parsed.usage,
-        candidates: parsed.kind === 'command' ? fuzzySelections(commandSelections(commands), parsed.query) : [], selected: 0, loading: false };
+        candidates: parsed.kind === 'command' ? fuzzySelections(parsed.selections ?? commandSelections(commands), parsed.query) : [], selected: 0, loading: false };
 }
 /** Owns suggestion selection and one model request per editing session.
  * Late HTTP results may refresh suggestions, but never change typed input.
@@ -126,23 +143,31 @@ export class SelectionCompletion {
     requestController = null;
     commands = [];
     currentModel;
+    routerCatalog;
+    reasoning = {};
     constructor(changed = () => { }) {
         this.changed = changed;
     }
-    update(text, provider, loadModels, commands = [], currentModel) {
+    update(text, provider, loadModels, commands = [], currentModel, loadCatalog, activeRouted = false, reasoning = {}) {
         this.commands = commands;
-        this.currentModel = currentModel;
         const parsed = parseSelectionInput(text, commands);
         const catalogProvider = parsed?.modelProvider ?? provider;
+        const routed = parsed?.routed ?? ((parsed?.includeModels || parsed?.kind === 'reasoning') && activeRouted ? true : undefined);
         if (provider !== this.provider || catalogProvider !== this.catalogProvider
-            || parsed?.routed !== this.catalogRoute || parsed?.kind !== this.parsed?.kind) {
+            || routed !== this.catalogRoute || parsed?.kind !== this.parsed?.kind
+            || reasoning.scope !== this.reasoning.scope || (parsed?.kind === 'reasoning' && currentModel !== this.currentModel)) {
             this.requestController?.abort();
             this.generation++;
             this.requested = false;
             this.loading = false;
             this.unavailable = false;
             this.discovered = undefined;
+            this.routerCatalog = undefined;
         }
+        this.currentModel = currentModel;
+        this.reasoning = reasoning;
+        if (reasoning.catalog)
+            this.routerCatalog = reasoning.catalog;
         if (text !== this.text || provider !== this.provider) {
             this.selected = 0;
             this.firstVisible = 0;
@@ -153,9 +178,28 @@ export class SelectionCompletion {
         this.text = text;
         this.provider = provider;
         this.catalogProvider = catalogProvider;
-        this.catalogRoute = parsed?.routed;
+        this.catalogRoute = routed;
         this.parsed = parsed;
         this.filter();
+        if ((parsed?.routerOnly || routed) && !this.requested && loadCatalog) {
+            this.requested = true;
+            this.loading = true;
+            this.requestController = new AbortController();
+            const generation = this.generation;
+            void loadCatalog(this.requestController.signal).then(catalog => {
+                if (generation !== this.generation)
+                    return;
+                this.routerCatalog = catalog;
+                this.discovered = routerModelIds(catalog, catalogProvider);
+            }).catch(() => { if (generation === this.generation)
+                this.unavailable = true; }).finally(() => {
+                if (generation !== this.generation)
+                    return;
+                this.loading = false;
+                this.filter();
+                this.changed();
+            });
+        }
         if ((parsed?.kind === 'model' || parsed?.includeModels) && !this.requested && loadModels) {
             this.requested = true;
             this.loading = true;
@@ -181,12 +225,38 @@ export class SelectionCompletion {
     }
     filter() {
         const selectedValue = this.candidates[this.selected]?.value;
-        const models = modelSelections(this.catalogProvider, this.discovered)
+        if (this.parsed?.kind === 'reasoning') {
+            const catalog = this.routerCatalog;
+            const contract = this.catalogRoute
+                ? catalog?.version === 1 && !catalog.authRequired
+                    ? resolveRouterModel(catalog, this.provider, this.currentModel ?? '')?.capabilities?.reasoning ?? []
+                    : catalog?.version === 0 && !catalog.authRequired ? this.reasoning.contract : []
+                : this.reasoning.contract;
+            const command = this.parsed.command;
+            const current = command === 'effort' ? this.reasoning.current
+                : this.reasoning.current === undefined ? undefined : reasoningEnabled(this.reasoning.current) ? 'on' : 'off';
+            this.candidates = fuzzySelections(reasoningCommandChoices(command, this.provider, this.currentModel ?? '', contract)
+                .map(value => ({ value, label: value, current: value === current,
+                description: value === 'default' ? 'Inherit model/provider defaults' : undefined })), this.parsed.query);
+            const previousIndex = this.candidates.findIndex(candidate => candidate.value === selectedValue);
+            this.selected = previousIndex >= 0 ? previousIndex : 0;
+            this.revealSelection();
+            return;
+        }
+        const routed = this.catalogRoute && this.routerCatalog?.version === 1;
+        const models = (routed ? routerModelsForProvider(this.routerCatalog, this.catalogProvider).map(row => ({
+            value: row.id, label: row.display_name || row.id,
+            description: [row.capabilities?.tools === false ? 'Chat only' : '', row.available === false ? 'Access unavailable' : '', this.routerCatalog?.cached ? 'Cached catalog' : ''].filter(Boolean).join(' · '),
+        })) : modelSelections(this.catalogProvider, this.discovered))
             .map(model => ({ ...model, current: this.catalogProvider === this.provider && model.value === this.currentModel }));
-        const providers = PROVIDER_CHOICES.filter(p => !this.parsed?.routerOnly || canRouteThroughRouter(p.id))
+        const routerProviders = this.parsed?.routerOnly && this.routerCatalog
+            ? [...new Map(this.routerCatalog.models.filter(row => this.routerCatalog?.version === 0 || row.capabilities?.chat).map(row => [row.owned_by, {
+                        id: row.owned_by, label: row.provider_display_name || row.owned_by, description: this.routerCatalog?.cached ? 'Cached catalog' : 'Via Zerg Router', aliases: [],
+                    }])).values()] : PROVIDER_CHOICES;
+        const providers = routerProviders.filter(p => !this.parsed?.routerOnly || canRouteThroughRouter(p.id))
             .map(p => ({ value: p.id, label: p.label, description: p.description, aliases: p.aliases,
             current: p.id === this.provider, needsArgument: true }));
-        const source = this.parsed?.kind === 'command' ? commandSelections(this.commands)
+        const source = this.parsed?.kind === 'command' ? this.parsed.selections ?? commandSelections(this.commands)
             : this.parsed?.kind === 'model' ? models
                 : this.parsed?.includeModels ? [...providers, ...models] : providers;
         this.candidates = this.parsed && this.parsed.kind !== 'usage' ? fuzzySelections(source, this.parsed.query) : [];
@@ -218,6 +288,7 @@ export class SelectionCompletion {
             return null;
         return { candidates: this.candidates, selected: this.selected, firstVisible: this.firstVisible, loading: this.loading, unavailable: this.unavailable,
             kind: this.parsed.kind, query: this.parsed.query, usage: this.parsed.usage,
+            command: this.parsed.command, model: this.parsed.kind === 'reasoning' ? this.currentModel : undefined,
             provider: this.parsed.kind === 'model' ? this.catalogProvider : undefined,
             routed: this.parsed.kind === 'model' ? this.catalogRoute : undefined,
             mixed: this.parsed.includeModels };
@@ -255,6 +326,10 @@ export class SelectionCompletion {
             if (this.parsed.kind === 'provider' && candidate.needsArgument) {
                 return { handled: true, text: `${completed} ` };
             }
+            if (key.return && (this.parsed.kind === 'model' || this.parsed.kind === 'reasoning' || (this.parsed.includeModels && !candidate.needsArgument))) {
+                this.dismissedInput = this.text;
+                return { handled: true, text: completed, submit: true };
+            }
             if (key.return && completed === this.text)
                 return { handled: false };
             this.dismissedInput = completed;

package/dist/app/session_manager.d.ts

@@ -4,13 +4,19 @@
  * Eliminates duplicated session logic between TUI (cli_ratatui.ts) and headless (headless.ts).
  * Each renderer provides its own deps for message access and logging.
  */
-import type { SessionRuntimeState } from '../session.js';
+import { type UsageSnapshot } from '../usage_snapshot.js';
+import { type DiagnosticSnapshot, type DiagnosticEventKind, type DiagnosticJsonObject } from '../diagnostics/session_export.js';
+import type { CommandReceipt } from '../agent/runtime/command_jobs.js';
+import type { Session, SessionRuntimeState } from '../session.js';
 import type { Message } from '../types.js';
+import type { ModelUsageObserver } from '../types.js';
 import type { MuxSessionState } from '../ui/ratatui/protocol.js';
 import type { PaneSessionSpec } from '../panes/types.js';
 import type { HostedSessionSettings } from '../hosted/session_settings.js';
 export interface SessionManagerDeps {
     sessionId: string;
+    /** Stable session storage origin when an environment changes process.cwd(). */
+    getSessionCwd?: () => string;
     /**
      * Optional absolute path for session persistence.
      * When set, save() writes here instead of the default ~/.ztc/sessions/{projectHash}/{id}.json.
@@ -34,11 +40,17 @@ export interface SessionManagerDeps {
      *  static). Auto-compact uses it so it triggers at the same percentage the bar
      *  shows — not a stale static window that would compact too early/late. */
     getContextWindow?: () => number | undefined;
+    /** Capture the originating prompt before an asynchronous compaction starts. */
+    getUsageObserver?: () => ModelUsageObserver | undefined;
     /** Optional renderer-specific state to persist alongside the conversation. */
     getMuxState?: () => Promise<MuxSessionState | undefined>;
     getPaneSpecs?: () => PaneSessionSpec[];
     getRuntimeState?: () => SessionRuntimeState;
+    /** Await raw-source and evidence-index durability before extracting the checkpoint. */
+    flushToolResponses?: () => Promise<void>;
     getHostedSettings?: () => HostedSessionSettings | undefined;
+    /** Publish only the admitted checkpoint actually written to disk. */
+    onCheckpoint?: (session: Session) => void;
     debugLog: (msg: string) => void;
 }
 export interface SessionSaveOptions {
@@ -46,27 +58,45 @@ export interface SessionSaveOptions {
     persistEmpty?: boolean;
     /** Reject on persistence errors when proceeding would lose restart state. */
     required?: boolean;
+    /** Request a fresh optional renderer projection, including on a final required save. */
+    captureLayout?: boolean;
+    /** Retire an uncommitted admission write during normal host shutdown. */
+    signal?: AbortSignal;
 }
 /**
  * Manages session persistence, auto-save timers, and context compaction.
  */
 export declare class SessionManager {
     private deps;
+    private diagnostics;
+    private usage;
+    private jobDiagnosticStates;
     private autoSaveTimer;
     private saveQueue;
-    private cleanupDone;
+    private muxSnapshot;
+    private muxCapture;
+    private muxGeneration;
+    private cleanupPromise;
     constructor(deps: SessionManagerDeps);
     setSessionId(sessionId: string): void;
+    /** Capture the current agent before replacement, then return detached canonical facts. */
+    getDiagnostics(): DiagnosticSnapshot;
+    restoreDiagnostics(snapshot: DiagnosticSnapshot | undefined): void;
+    getUsageSnapshot(): UsageSnapshot;
+    restoreUsageSnapshot(snapshot: UsageSnapshot | undefined): void;
+    recordHostDiagnostic(kind: DiagnosticEventKind, data: DiagnosticJsonObject): void;
+    recordCommandJob(job: CommandReceipt): void;
     /**
      * Run one-time cleanup of stale sessions and temp dirs.
      * Called after session load so we never delete a session the caller
      * is about to resume.
      */
-    runStartupCleanup(): void;
+    runStartupCleanup(): Promise<void>;
     /**
      * Save the current session, filtering out ephemeral system messages.
      */
     save(options?: SessionSaveOptions): Promise<void>;
+    private refreshMuxState;
     private writeCurrentSession;
     /**
      * Lightweight save: only persist mux state (layout + pane content), skipping message serialization.
@@ -103,8 +133,10 @@ export declare class SessionManager {
      * Stop the auto-save timer.
      */
     stopAutoSave(): void;
-    /**
-     * Build a summarizer function using the current config's provider/API key.
-     */
+    /** Capture source signatures before awaiting, including IDs of ordinary rows. */
+    private captureCheckpointSources;
+    private checkpointSourceState;
+    /** Preserve current invocation and correction sources without restoring old settled history. */
+    private preserveCheckpointSources;
     private buildSummarizer;
 }