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

package/dist/optimize/results.js

@@ -1,42 +1,20 @@
+import { assessOptimizationResult, compareOptimizationResults } from './measurements.js';
+/** A score of comparable reported data, never source verification or benchmark admission. */
 export function result_score(result) {
-    if (!result.ok) {
+    const report = assessOptimizationResult(result);
+    if (report.compatibility !== 'compatible' || report.value === null)
         return null;
-    }
-    if (result.metrics?.candidateValue !== undefined) {
-        return result.metrics.direction === 'minimize'
-            ? -result.metrics.candidateValue
-            : result.metrics.candidateValue;
-    }
-    return null;
+    return report.direction === 'minimize' ? -report.value : report.value;
 }
 export function is_better_result(currentBest, next) {
-    if (!next.ok) {
-        return false;
-    }
-    if (!currentBest || !currentBest.ok) {
-        return true;
-    }
-    const currentScore = result_score(currentBest);
     const nextScore = result_score(next);
-    if (currentScore === null && nextScore === null) {
+    if (nextScore === null)
         return false;
-    }
-    if (currentScore === null) {
-        return nextScore !== null;
-    }
-    if (nextScore === null) {
-        return false;
-    }
-    if (nextScore > currentScore) {
+    if (!currentBest)
         return true;
-    }
-    if (nextScore < currentScore) {
+    // An unqualified incumbent is preserved: there is no declared common baseline to replace.
+    if (compareOptimizationResults(currentBest, next).compatibility !== 'compatible')
         return false;
-    }
-    const currentSecondary = currentBest.metrics?.secondaryValue;
-    const nextSecondary = next.metrics?.secondaryValue;
-    if (currentSecondary !== undefined && nextSecondary !== undefined) {
-        return nextSecondary > currentSecondary;
-    }
-    return false;
+    const currentScore = result_score(currentBest);
+    return currentScore !== null && nextScore > currentScore;
 }

package/dist/optimize/tge.js

@@ -1,3 +1,4 @@
+import { evaluate_optimization_adapter } from './adapters/index.js';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
 import { basename, extname, join } from 'path';
 import { generate_text_with_backend, extract_code_payload } from './llm.js';
@@ -207,7 +208,7 @@ export async function execute_native_tge(spec, adapter, deps, artifacts, current
         writeFileSync(candidateArtifacts.specPath, JSON.stringify(candidateSpec, null, 2), 'utf-8');
         writeFileSync(candidateArtifacts.planPath, '', 'utf-8');
         deps.onProgress?.(`TGE: evaluating candidate ${index}/${totalCandidates} at ${candidatePath}.`);
-        const candidateResult = await adapter.evaluate(candidateSpec, deps, candidateArtifacts);
+        const candidateResult = await evaluate_optimization_adapter(adapter, candidateSpec, deps, candidateArtifacts);
         deps.onProgress?.(`TGE: candidate ${index}/${totalCandidates} finished with candidate_value=${candidateResult.metrics?.candidateValue ?? 'n/a'} status=${candidateResult.status}.`);
         summaries.push({
             index,

package/dist/panes/initial_input.d.ts

@@ -0,0 +1,19 @@
+import type { MessageInput } from '../types.js';
+export interface PaneInitialInput {
+    path: string;
+    sessionId: string;
+    input: MessageInput;
+    digest: string;
+}
+/** Capture immutable image bytes before handing the launch to the renderer. */
+export declare function preparePaneInitialInput(raw: MessageInput, sessionId: string, cwd: string): Promise<PaneInitialInput>;
+/** Fresh child launch only: the persisted pane launch spec never carries this path. */
+export declare function loadPaneInitialInput(path: string, sessionId: string): Promise<PaneInitialInput | null>;
+/** Rebind the live child input to its own checkpoint before releasing transport images. */
+export declare function readSavedPaneInitialInput(captured: PaneInitialInput, cwd: string): Promise<MessageInput | null>;
+/** Only a real saved child checkpoint can acknowledge the captured source. */
+export declare function acknowledgePaneInitialInput(captured: PaneInitialInput, cwd: string): Promise<boolean>;
+export declare function paneInitialInputAcknowledged(captured: PaneInitialInput): Promise<boolean>;
+export declare function waitForPaneInitialInput(captured: PaneInitialInput, cancelled: () => boolean, timeoutMs?: number): Promise<boolean>;
+/** Delete only this owned transport copy, after a confirmed refusal or child checkpoint. */
+export declare function cleanupPaneInitialInput(captured: PaneInitialInput): Promise<void>;

package/dist/panes/initial_input.js

@@ -0,0 +1,206 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { constants, lstatSync, realpathSync } from 'node:fs';
+import { mkdir, mkdtemp, open, rm } from 'node:fs/promises';
+import { homedir, tmpdir } from 'node:os';
+import { basename, dirname, join, resolve, sep } from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { loadSessionByIdOrName, getProjectHash } from '../session.js';
+import { prepareSessionMedia, readDurableSessionImageSync, SESSION_MEDIA_LIMITS } from '../session_media.js';
+import { isMirrorMediaPath, MIRROR_MEDIA_ROOT } from '../utils/mirror_media.js';
+import { writeFileAtomic } from '../utils/atomic_write.js';
+const MAX_INPUT_BYTES = 64 * 1024;
+const MAX_ATTACHMENTS = 32;
+const MEDIA_TYPES = new Set(['image/png', 'image/jpeg', 'image/gif', 'image/webp']);
+async function boundedRead(path, limit) {
+    const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    try {
+        const stat = await handle.stat();
+        if (!stat.isFile() || stat.size > limit)
+            throw new Error('Pane input file is unavailable or exceeds its bound.');
+        const bytes = Buffer.alloc(limit + 1);
+        let size = 0;
+        while (size < bytes.length) {
+            const result = await handle.read(bytes, size, bytes.length - size, null);
+            if (!result.bytesRead)
+                break;
+            size += result.bytesRead;
+        }
+        if (size > limit)
+            throw new Error('Pane input file exceeds its bound.');
+        return bytes.subarray(0, size);
+    }
+    finally {
+        await handle.close();
+    }
+}
+function validateInput(value) {
+    if (typeof value.text !== 'string' || Buffer.byteLength(value.text) > MAX_INPUT_BYTES
+        || !Array.isArray(value.attachments) || value.attachments.length > MAX_ATTACHMENTS) {
+        throw new Error('Pane input exceeds its text or attachment bound.');
+    }
+    if (!value.text.trim() && value.attachments.length === 0)
+        throw new Error('Empty pane input has no source to transfer.');
+    const ids = new Set();
+    for (const image of value.attachments) {
+        if (image.kind !== 'image' || !MEDIA_TYPES.has(image.mediaType) || image.stale
+            || typeof image.id !== 'string' || !image.id || ids.has(image.id)
+            || typeof image.name !== 'string' || image.name.length > 1024
+            || !Number.isSafeInteger(image.size) || image.size <= 0 || image.size > SESSION_MEDIA_LIMITS.imageBytes) {
+            throw new Error('Unsupported, duplicate or unavailable pane attachment; the draft is retained.');
+        }
+        ids.add(image.id);
+    }
+}
+function digestInput(input) {
+    return createHash('sha256').update(JSON.stringify({ text: input.text, attachments: input.attachments.map(image => ({
+            id: image.id, name: image.name, kind: image.kind, mediaType: image.mediaType,
+            size: image.size, sha256: image.durable?.sha256,
+        })) })).digest('hex');
+}
+function checkedPath(path) {
+    const root = realpathSync(tmpdir());
+    const directory = dirname(resolve(path));
+    if (basename(path) !== 'input.json' || dirname(directory) !== root
+        || !/^ztc-pane-input-[A-Za-z0-9]{6}$/u.test(basename(directory))
+        || realpathSync(directory) !== directory || lstatSync(directory).isSymbolicLink()
+        || !lstatSync(directory).isDirectory())
+        throw new Error('Invalid pane input handoff path.');
+    return join(directory, 'input.json');
+}
+/** Capture immutable image bytes before handing the launch to the renderer. */
+export async function preparePaneInitialInput(raw, sessionId, cwd) {
+    validateInput(raw);
+    const input = structuredClone(raw);
+    delete input.pane_id;
+    const directory = await mkdtemp(join(realpathSync(tmpdir()), 'ztc-pane-input-'));
+    const path = join(directory, 'input.json');
+    let clipboardCopies = null;
+    try {
+        for (const image of input.attachments) {
+            if (image.durable !== undefined || isMirrorMediaPath(image.localPath))
+                continue;
+            const source = image.localPath ? resolve(image.localPath) : '';
+            const clipboardRoot = join(homedir(), '.ztc', 'clipboard');
+            if (!source.startsWith(clipboardRoot + sep) || dirname(source) !== clipboardRoot
+                || !/^clipboard-\d+-[0-9a-f]{8}\.png$/u.test(basename(source))
+                || realpathSync(clipboardRoot) !== clipboardRoot)
+                throw new Error('Unsupported pane attachment source; the draft is retained.');
+            const bytes = await boundedRead(source, SESSION_MEDIA_LIMITS.imageBytes);
+            await mkdir(MIRROR_MEDIA_ROOT, { recursive: true, mode: 0o700 });
+            clipboardCopies ??= await mkdtemp(join(MIRROR_MEDIA_ROOT, 'pane-input-'));
+            const copied = join(clipboardCopies, randomUUID() + '.png');
+            const handle = await open(copied, 'wx', 0o600);
+            try {
+                await handle.writeFile(bytes);
+            }
+            finally {
+                await handle.close();
+            }
+            image.localPath = copied;
+        }
+        const message = { id: 'pane-input-' + sessionId, role: 'user', content: input.text,
+            attachments: input.attachments, timestamp: new Date() };
+        const prepared = await prepareSessionMedia({ sessionFile: path, sessionId, messages: [message] });
+        try {
+            input.attachments = prepared.messages[0].attachments ?? [];
+            if (input.attachments.some(image => image.durable === undefined))
+                throw new Error('Pane image capture was not durable.');
+            const now = new Date().toISOString();
+            const payload = JSON.stringify({ schemaVersion: 1, metadata: { id: sessionId, projectHash: getProjectHash(cwd),
+                    cwd, model: '', provider: '', createdAt: now, updatedAt: now, messageCount: 1 }, messages: prepared.messages });
+            if (Buffer.byteLength(payload) > SESSION_MEDIA_LIMITS.checkpointBytes)
+                throw new Error('Pane input metadata exceeds its bound.');
+            const handle = await open(path, 'wx', 0o600);
+            try {
+                await handle.writeFile(payload);
+            }
+            finally {
+                await handle.close();
+            }
+            prepared.markCommitted();
+            return { path, sessionId, input, digest: digestInput(input) };
+        }
+        catch (error) {
+            await prepared.rollback();
+            throw error;
+        }
+    }
+    catch (error) {
+        await rm(directory, { recursive: true, force: true });
+        throw error;
+    }
+    finally {
+        if (clipboardCopies !== null)
+            await rm(clipboardCopies, { recursive: true, force: true });
+    }
+}
+/** Fresh child launch only: the persisted pane launch spec never carries this path. */
+export async function loadPaneInitialInput(path, sessionId) {
+    const checked = checkedPath(path);
+    const payload = JSON.parse((await boundedRead(checked, SESSION_MEDIA_LIMITS.checkpointBytes)).toString('utf8'));
+    if (payload.schemaVersion !== 1 || payload.metadata.id !== sessionId || payload.messages.length !== 1
+        || payload.messages[0]?.role !== 'user')
+        throw new Error('Pane input does not match this fresh child session.');
+    const source = payload.messages[0];
+    const input = { text: source.content, attachments: source.attachments ?? [] };
+    validateInput(input);
+    for (const image of input.attachments) {
+        if (!image.durable || image.durable.sessionFile !== checked || !readDurableSessionImageSync(image)) {
+            throw new Error('Pane image capture is unavailable or belongs to another source.');
+        }
+    }
+    const captured = { path: checked, sessionId, input, digest: digestInput(input) };
+    return await paneInitialInputAcknowledged(captured) ? null : captured;
+}
+/** Rebind the live child input to its own checkpoint before releasing transport images. */
+export async function readSavedPaneInitialInput(captured, cwd) {
+    const checkpoint = await loadSessionByIdOrName(captured.sessionId, cwd);
+    const source = checkpoint?.messages.find(message => message.role === 'user' && message.content === captured.input.text
+        && digestInput({ text: message.content, attachments: message.attachments ?? [] }) === captured.digest);
+    if (!source)
+        return null;
+    for (const image of source.attachments ?? []) {
+        if (!image.durable || image.durable.sessionFile === captured.path || !readDurableSessionImageSync(image))
+            return null;
+    }
+    return { text: source.content, attachments: source.attachments ?? [] };
+}
+/** Only a real saved child checkpoint can acknowledge the captured source. */
+export async function acknowledgePaneInitialInput(captured, cwd) {
+    if (!await readSavedPaneInitialInput(captured, cwd))
+        return false;
+    await writeFileAtomic(checkedPath(captured.path) + '.accepted', JSON.stringify({ sessionId: captured.sessionId, digest: captured.digest }));
+    return true;
+}
+export async function paneInitialInputAcknowledged(captured) {
+    try {
+        const receipt = JSON.parse((await boundedRead(checkedPath(captured.path) + '.accepted', 1024)).toString('utf8'));
+        return receipt.sessionId === captured.sessionId && receipt.digest === captured.digest;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+export async function waitForPaneInitialInput(captured, cancelled, timeoutMs = 15000) {
+    const deadline = Date.now() + timeoutMs;
+    do {
+        if (await paneInitialInputAcknowledged(captured))
+            return true;
+        if (cancelled())
+            return false;
+        await delay(25);
+    } while (Date.now() < deadline);
+    return false;
+}
+/** Delete only this owned transport copy, after a confirmed refusal or child checkpoint. */
+export async function cleanupPaneInitialInput(captured) {
+    try {
+        await rm(dirname(checkedPath(captured.path)), { recursive: true, force: true });
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}

package/dist/panes/labels.d.ts

@@ -0,0 +1,16 @@
+import type { PaneLabels, RustCommand, RustEvent } from '../ui/ratatui/protocol.js';
+export declare function replacePaneLabels(current: PaneLabels, incoming: PaneLabels, ifNewer?: boolean): PaneLabels;
+export declare function readPaneLabels(transport: {
+    send(command: RustCommand): boolean;
+    on(handler: (event: RustEvent) => void): () => void;
+    hasCapability?(name: string): boolean;
+}, paneId: number): Promise<PaneLabels>;
+/** Mirror of the native PaneLabels projection; inferred state stays independent. */
+export declare function displayPaneTitle(inferred: string, labels?: PaneLabels): string;
+export declare function inferAgentPaneTitle(input: {
+    cwd: string;
+    branch?: string;
+    sessionId: string;
+    paneId: number;
+    task?: string;
+}): string;

package/dist/panes/labels.js

@@ -0,0 +1,42 @@
+export function replacePaneLabels(current, incoming, ifNewer = false) {
+    const previous = current.updated_at_ms ?? 0;
+    const timestamp = incoming.updated_at_ms ?? 0;
+    if (ifNewer && previous > 0 && timestamp <= previous)
+        return current;
+    return { ...incoming, updated_at_ms: ifNewer ? timestamp : Math.max(Date.now(), previous + 1, timestamp + 1) };
+}
+export async function readPaneLabels(transport, paneId) {
+    if (transport.hasCapability && !transport.hasCapability('pane_labels_v1')) {
+        throw new Error('This native renderer needs an update to support /label.');
+    }
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => { off(); reject(new Error('Pane labels timed out.')); }, 2000);
+        const off = transport.on(event => {
+            if (event.type !== 'pane_list')
+                return;
+            clearTimeout(timer);
+            off();
+            const pane = event.panes.find(pane => pane.id === paneId);
+            if (!pane)
+                reject(new Error(`Pane ${paneId} does not exist.`));
+            else
+                resolve({ ...pane.labels });
+        });
+        if (!transport.send({ type: 'list_panes' })) {
+            clearTimeout(timer);
+            off();
+            reject(new Error('Pane transport is unavailable.'));
+        }
+    });
+}
+/** Mirror of the native PaneLabels projection; inferred state stays independent. */
+export function displayPaneTitle(inferred, labels = {}) {
+    const title = labels.manual_title || [labels.project, labels.task, inferred].filter(Boolean).join(' · ');
+    return labels.group ? `[${labels.group}] ${title}` : title;
+}
+export function inferAgentPaneTitle(input) {
+    const project = input.cwd.replace(/[\\/]+$/, '').split(/[\\/]/).pop() || input.cwd;
+    const task = input.task ? Array.from(input.task.replace(/\s+/g, ' ').trim()).slice(0, 40).join('') : undefined;
+    const identity = `${input.paneId}:${input.sessionId.slice(-6)}`;
+    return [project, input.branch, task, identity].filter(Boolean).join(' · ');
+}

package/dist/panes/model_catalog.d.ts

@@ -1,5 +1,5 @@
 export declare const PANE_PROVIDERS: readonly ["anthropic", "claude_code", "openai", "codex_app_server", "codex_legacy", "gemini", "deepseek", "fireworks", "modal", "kimi", "kimi_code"];
-export type PaneProvider = typeof PANE_PROVIDERS[number];
+export type PaneProvider = string;
 export interface CatalogModel {
     id: string;
     name: string;
@@ -14,13 +14,13 @@ export interface CatalogProviderGroup {
     models: CatalogModel[];
 }
 export declare const MODEL_CATALOG: CatalogProviderGroup[];
-export declare function isPaneProvider(value: string | undefined): value is PaneProvider;
+export declare function isPaneProvider(value: string | undefined, route?: 'auto' | 'direct' | 'zrouter'): value is PaneProvider;
 export declare function getModelDisplayName(modelId: string): string;
 export declare function getProviderForModel(modelId: string): PaneProvider | undefined;
 /** Provider-aware membership for duplicate model IDs such as the Codex catalogs. */
 export declare function isModelAvailableForProvider(provider: string, modelId: string): boolean;
 export declare function isCatalogModelForProvider(provider: PaneProvider, modelId: string): boolean;
-export declare function resolveModelAndProvider(rawModel: string, rawProvider?: string): {
+export declare function resolveModelAndProvider(rawModel: string, rawProvider?: string, route?: 'auto' | 'direct' | 'zrouter'): {
     model: string;
     provider?: PaneProvider | string;
 };

package/dist/panes/model_catalog.js

@@ -1,3 +1,4 @@
+import { configStore } from '../config.js';
 import { GPT_6_API_EFFORTS, getKimiModelInfo, getSupportedCodexReasoningEfforts, KIMI_CODE_MODEL_IDS, KIMI_MODEL_IDS, KIMI_MODEL_INFO, OFFICIAL_CODEX_MODEL_IDS, OFFICIAL_CODEX_MODEL_INFO, } from '../utils/models.js';
 import { DEEPSEEK_FLASH_EFFORTS, DEEPSEEK_FLASH_MODEL, MODAL_DEEPSEEK_FLASH_EFFORTS, MODAL_DEEPSEEK_FLASH_MODEL } from '../utils/deepseek.js';
 import { FIREWORKS_CHAT_MODELS, FIREWORKS_FUNDED_MODEL } from '../utils/fireworks.js';
@@ -183,8 +184,8 @@ function getCodexModelAliases(id) {
             return [];
     }
 }
-export function isPaneProvider(value) {
-    return !!value && PROVIDER_SET.has(value);
+export function isPaneProvider(value, route) {
+    return !!value && (PROVIDER_SET.has(value) || ((route === 'zrouter' || route === 'auto') && /^[a-z][a-z0-9_-]{0,127}$/.test(value)));
 }
 export function getModelDisplayName(modelId) {
     return MODEL_BY_ID.get(modelId)?.name
@@ -203,8 +204,17 @@ export function isModelAvailableForProvider(provider, modelId) {
 export function isCatalogModelForProvider(provider, modelId) {
     return MODEL_CATALOG.some((group) => group.provider === provider && group.models.some((model) => model.id === modelId));
 }
-export function resolveModelAndProvider(rawModel, rawProvider) {
+export function resolveModelAndProvider(rawModel, rawProvider, route) {
     const trimmed = rawModel.trim();
+    if (route === 'zrouter' && rawProvider)
+        return { model: trimmed, provider: rawProvider };
+    if (route === 'zrouter') {
+        const matches = configStore.getRouterCatalog()?.models.filter(row => row.id === trimmed && row.capabilities?.chat);
+        if (matches?.length === 1)
+            return { model: trimmed, provider: matches[0].owned_by };
+        if (matches && matches.length > 1)
+            throw new Error('Ambiguous Router model. Specify --provider.');
+    }
     const normalized = normalizeLookupValue(trimmed);
     const providerNormalized = (rawProvider || '').toLowerCase();
     // A custom OpenAI-compatible endpoint names its own models, so the id is a
@@ -289,5 +299,19 @@ function getCodexLegacyModelAliases(id) {
     }
 }
 export function getModelCatalogPayload() {
-    return { providers: MODEL_CATALOG };
+    const catalog = configStore.getRoutedModelCatalog();
+    if (catalog?.version !== 1)
+        return { providers: MODEL_CATALOG };
+    const groups = new Map();
+    for (const row of catalog.models) {
+        if (!row.capabilities?.chat)
+            continue;
+        const group = groups.get(row.owned_by) ?? { provider: row.owned_by, label: row.provider_display_name || row.owned_by, models: [] };
+        group.models.push({ id: row.id, name: row.display_name || row.id,
+            description: [row.capabilities.tools === false ? 'Chat only' : '', row.available === false ? 'Access unavailable' : ''].filter(Boolean).join(' · '),
+            supportedReasoningEfforts: row.capabilities.reasoning?.choices,
+            defaultReasoningEffort: row.capabilities.reasoning?.default });
+        groups.set(row.owned_by, group);
+    }
+    return { providers: [...groups.values()] };
 }

package/dist/panes/pane_registry.js

@@ -26,15 +26,19 @@ function inferZtcLaunchSpec(pane) {
     }
     if (!sessionId)
         return undefined;
+    const route = parseFlagValue(args, '--auth-mode');
+    const authMode = route === 'zrouter' || route === 'direct' || route === 'auto' ? route : undefined;
     const explicitProvider = parseFlagValue(args, '--provider');
     const explicitModel = parseFlagValue(args, '--model');
-    const resolved = explicitModel ? resolveModelAndProvider(explicitModel, explicitProvider) : { model: undefined, provider: explicitProvider };
+    const resolved = explicitModel ? resolveModelAndProvider(explicitModel, explicitProvider, authMode) : { model: undefined, provider: explicitProvider };
     return {
         kind: 'ztc',
+        authMode,
+        routerOrigin: parseFlagValue(args, '--router-url'),
         session: { mode: sessionMode, id: sessionId },
         cwd: pane.cwd,
         title: pane.title,
-        providerOverride: isPaneProvider(resolved.provider) ? resolved.provider : undefined,
+        providerOverride: isPaneProvider(resolved.provider, authMode) ? resolved.provider : undefined,
         modelOverride: resolved.model,
     };
 }

package/dist/panes/types.d.ts

@@ -13,6 +13,8 @@ export type PaneSessionSelector = {
     id: string;
 };
 export interface ZtcPaneLaunchSpec {
+    authMode?: 'auto' | 'direct' | 'zrouter';
+    routerOrigin?: string;
     kind: 'ztc';
     session: PaneSessionSelector;
     cwd?: string;
@@ -30,6 +32,7 @@ export interface ProcessPaneLaunchSpec {
     paneType: 'process' | 'command';
 }
 export interface DocPaneLaunchSpec {
+    commandPaneId?: string;
     kind: 'doc' | 'feed';
     title: string;
     content?: string;

package/dist/panes/ztc_launch.js

@@ -1,7 +1,10 @@
+import { isLocalSubscriptionProvider } from '../agent/backends/provider_ids.js';
+import { configStore } from '../config.js';
 import { existsSync } from 'fs';
 import { dirname, join } from 'path';
 import { generateSessionId } from '../session.js';
 import { activeProfile } from '../config/profiles.js';
+import { resolveOwnedCliLaunch } from '../desktop/cli_launch.js';
 const CHILD_ZTC_SCRIPT_RE = /(?:^|[\\/])cli_(?:main|ratatui)\.(?:js|ts)$/;
 function filterChildZtcArgs(args) {
     const skipFlags = new Set([
@@ -21,12 +24,17 @@ function filterChildZtcArgs(args) {
         '--voyager',
     ]);
     const skipWithArg = new Set([
+        '--layout',
+        '--layout-refresh-ms',
+        '--layout-workers',
         '--num-zergs',
         '--mirror-port',
         '--resume',
         '--continue',
         '-c',
         '--session-id',
+        '--auth-mode',
+        '--router-url',
         '--provider',
         '--model',
         '--profile',
@@ -77,10 +85,19 @@ export function buildZtcPaneLaunchCommand(spec, argv = process.argv) {
         childArgs.push('--session-id', spec.session.id || generateSessionId());
     }
     childArgs.push('--pane');
+    const local = isLocalSubscriptionProvider(spec.providerOverride ?? configStore.getProvider());
+    const authMode = local ? 'direct' : spec.authMode ?? configStore.getChildAuthMode();
+    childArgs.push('--auth-mode', authMode);
+    const origin = spec.routerOrigin ?? configStore.get().zergProxyUrl;
+    if (authMode !== 'direct' && origin)
+        childArgs.push('--router-url', origin);
     if (spec.providerOverride)
         childArgs.push('--provider', spec.providerOverride);
     if (spec.modelOverride)
         childArgs.push('--model', spec.modelOverride);
+    const owned = resolveOwnedCliLaunch(childArgs);
+    if (owned)
+        return { command: owned.command, args: owned.args, cwd: spec.cwd, childSessionId: spec.session.id };
     if (scriptPath.endsWith('.ts')) {
         const tsxBin = join(dirname(dirname(scriptPath)), 'node_modules', '.bin', process.platform === 'win32' ? 'tsx.cmd' : 'tsx');
         if (existsSync(tsxBin)) {
@@ -113,6 +130,8 @@ export function createZtcLaunchSpec(options) {
         session: { mode: sessionMode, id: sessionId },
         cwd: options?.cwd,
         title: options?.title || 'ZTC',
+        authMode: isLocalSubscriptionProvider(options?.providerOverride ?? configStore.getProvider()) ? 'direct' : configStore.getChildAuthMode(),
+        routerOrigin: configStore.get().zergProxyUrl,
         providerOverride: options?.providerOverride,
         modelOverride: options?.modelOverride,
         extraArgs: options?.extraArgs,

package/dist/plugin/optimization.d.ts

@@ -5,3 +5,5 @@ export { compile_optimization_spec } from '../optimize/planner.js';
 export { resolve_path_reference, resolve_path_within_cwd } from '../optimize/paths.js';
 export type { OptimizationPlanArtifacts, OptimizationSpec } from '../optimize/types.js';
 export type { OptimizationStrategyVariant } from '../optimize/arl.js';
+export { captureOptimizationMeasurement, describeOptimizationResult, assessOptimizationResult, compareOptimizationResults } from '../optimize/measurements.js';
+export type { OptimizationMeasurementSource, OptimizationMeasurementDeclaration, OptimizationMeasurementReport } from '../optimize/measurements.js';

package/dist/plugin/optimization.js

@@ -2,3 +2,4 @@ export { run_shell_with_timeout, sh_quote } from '../optimize/adapters/runtime.j
 export { execute_optimization_spec } from '../optimize/executor.js';
 export { compile_optimization_spec } from '../optimize/planner.js';
 export { resolve_path_reference, resolve_path_within_cwd } from '../optimize/paths.js';
+export { captureOptimizationMeasurement, describeOptimizationResult, assessOptimizationResult, compareOptimizationResults } from '../optimize/measurements.js';

package/dist/plugin/runtime.d.ts

@@ -4,7 +4,9 @@ export type { EmbeddedRuntimeContext, EmbeddedRuntimeSession, } from '../embedde
 export type { EmbeddedBackendType, EmbeddedDocPaneDefinition, EmbeddedEmulatorDefinition, EmbeddedFeedPaneDefinition, EmbeddedPaneDefinition, EmbeddedProcessPaneDefinition, EmbeddedRuntimeDefinition, EmbeddedSystemDefinition, EmbeddedSystemSummary, EmbeddedWorkflowDefinition, LoadedEmbeddedSystem, } from '../embedded/types.js';
 export type { Command, CommandContext, ShellResult } from '../agent/commands/types.js';
 export type { CommandJobView, MirrorViewState, ViewPlugin, ViewPluginContext } from '../web/view_plugin.js';
+export type { CommandPaneView } from '../agent/runtime/command_panes.js';
 export type { MirrorEvent, MirrorPaneRecord } from '../web/mirror_stream.js';
+export type { AttentionItem, AttentionKind, AttentionSnapshot } from '../attention/queue.js';
 export { COLONY_WORKTREE_MARKER, generateSessionId, getMuxStatePathForCwd, getSessionDirForCwd, getSessionPathForCwd, loadSessionById, saveSession, } from '../session.js';
 export type { PaneCommandTransport } from '../ui/ratatui/pane_relay.js';
 export type { RustCommand, RustEvent, MuxSessionState, PaneInfo } from '../ui/ratatui/protocol.js';

package/dist/plugin/simulation.d.ts

@@ -1,2 +1,7 @@
 export { SIMULATION_PLUGIN_API_VERSION } from './simulation_contract.js';
-export type { SimulationActorSeedV1, SimulationActorSnapshotV1, SimulationCheckpointExtensionV1, SimulationCheckpointRefV1, SimulationCheckpointRequestV1, SimulationCompatibilityV1, SimulationCreateSessionRequestV1, SimulationDocumentNotificationV1, SimulationDocumentSnapshotV1, SimulationDocumentWriteV1, SimulationDriverAuthorityV1, SimulationDriverContextV1, SimulationDriverRegistrationV1, SimulationDriverV1, SimulationHostCapabilitiesV1, SimulationHostV1, SimulationInferenceContextV1, SimulationInferenceRequestV1, SimulationInferenceResultV1, SimulationJsonObjectV1, SimulationJsonPrimitiveV1, SimulationJsonValueV1, SimulationLifecycleNotificationV1, SimulationLoadSessionRequestV1, SimulationNotificationV1, SimulationPluginActivationContextV1, SimulationPluginDataWriteV1, SimulationProgressNotificationV1, SimulationRuntimeOptionsV1, SimulationSessionRefV1, SimulationSessionSnapshotV1, SimulationSessionStatusV1, SimulationSessionV1, SimulationStartSessionRequestV1, SimulationTelemetryNotificationV1, SimulationTransitionBatchV1, SimulationTransitionOperationV1, SimulationTransitionResultV1, SimulationWorldPatchV1, SimulationWorldWriteV1, } from './simulation_contract.js';
+export type * from './simulation_interventions.js';
+export type { SimulationActorSeedV1, SimulationActorSnapshotV1, SimulationCheckpointExtensionV1, SimulationCheckpointRefV1, SimulationCheckpointRequestV1, SimulationCompatibilityV1, SimulationCreateSessionRequestV1, SimulationDocumentNotificationV1, SimulationDocumentSnapshotV1, SimulationDocumentWriteV1, SimulationDefinitionV1, SimulationDriverAuthorityV1, SimulationDriverContextV1, SimulationDriverRegistrationV1, SimulationDriverV1, SimulationHostCapabilitiesV1, SimulationHostV1, SimulationInferenceContextV1, SimulationInferenceRoutingV1, SimulationInferenceRequestV1, SimulationInferenceResultV1, SimulationAgentBeliefV1, SimulationAgentGoalV1, SimulationAgentIntentV1, SimulationAgentMemoryV1, SimulationAgentRelationshipV1, SimulationAgentUpdateProposalV1, SimulationCharacterActionMotivationV1, SimulationCharacterActionProposalV1, SimulationCharacterProposalV1, SimulationDynamicIntentActivityV1, SimulationDynamicActivityV1, SimulationDomainActionProposalV1, SimulationDynamicAgentViewV1, SimulationDynamicAuditEntryV1, SimulationNativeCallV1, SimulationNativeGmCallV1, SimulationNativeParticipantCallV1, SimulationInferenceSettlementV1, SimulationDynamicDomainObjectLinkV1, SimulationDynamicDomainObjectV1, SimulationDynamicDomainObjectViewV1, SimulationDynamicHistoryEntryV1, SimulationDynamicInferenceCallV1, SimulationDynamicInferenceV1, SimulationDynamicKnowledgeViewV1, SimulationDynamicMechanicDefinitionV1, SimulationDynamicParameterDefinitionV1, SimulationDynamicPlayerActionV1, SimulationDynamicPlayFrameV1, SimulationDynamicResourceDefinitionV1, SimulationDynamicRunStatusV1, SimulationDynamicStateCommitV1, SimulationDynamicStateV1, SimulationDynamicTimelineKindV1, SimulationDynamicObjectVisibilityV1, SimulationDynamicWorldEffectV1, SimulationDynamicWorldEffectViewV1, SimulationDynamicWorldStateV1, SimulationGmProposalV1, SimulationKnowledgeVisibilityV1, SimulationPersistentAgentStateV1, SimulationJsonObjectV1, SimulationJsonPrimitiveV1, SimulationJsonValueV1, SimulationLifecycleNotificationV1, SimulationLoadSessionRequestV1, SimulationNotificationV1, SimulationPluginActivationContextV1, SimulationPluginDataWriteV1, SimulationPlayerCommandResultV1, SimulationPlayerCommandV1, SimulationProgressNotificationV1, SimulationRuntimeOptionsV1, SimulationSessionRefV1, SimulationSessionSnapshotV1, SimulationSessionStatusV1, SimulationSessionV1, SimulationStartSessionRequestV1, SimulationTelemetryNotificationV1, SimulationTransitionBatchV1, SimulationTransitionOperationV1, SimulationTransitionResultV1, SimulationWorldPatchV1, SimulationWorldWriteV1, SimulationRouterAuditRouteV1, SimulationRouterModelV1, SimulationServingRouteV1, } from './simulation_contract.js';
+export type * from './simulation_meetings.js';
+export type { SimulationDocumentProvenanceV1, SimulationDocumentPolicyV1 } from './simulation_documents.js';
+export type { DynamicInitialization, DynamicInitializationV1, DynamicInitializationV2, DynamicSelectionV1, StorytellerPersonalityV1, StorytellerDecisionV1, StorytellerReceiptV1, StorytellerObservationV1, StorytellerSetbackV2, StorytellerOpportunityV2, StorytellerRecoveryV2 } from './simulation_storyteller.js';
+export type { StoryEvidenceV1, StoryReviewDecisionV1, StoryReviewReceiptV1, StoryEpisodeV1, StoryReviewViewV1 } from './simulation_story_review.js';