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

package/dist/agent/commands/clipboard.js

@@ -1,3 +1,5 @@
+import { exportSessionDiagnostics, formatSessionDiagnosticsMarkdown } from '../../diagnostics/session_export.js';
+import { buildSessionEvidencePackage, saveSessionEvidencePackage } from '../../diagnostics/session_evidence_package.js';
 function formatMessages(messages) {
     return messages
         .map(msg => {
@@ -23,12 +25,59 @@ export const clipboardCommand = {
     name: 'clipboard',
     description: 'Copy conversation text to the clipboard',
     usage: {
-        default: '<all|last|assistant|user|system>',
+        default: '<all|last|assistant|user|system|diagnostic|evidence>',
         variants: [
             { when: { 0: ['last'] }, usage: '<all|last|assistant|user|system> [assistant|user|system]' },
+            { when: { 0: ['diagnostic'] }, usage: 'diagnostic <markdown|jsonl>' },
+            { when: { 0: ['evidence'] }, usage: 'evidence <preview|copy|save <file>>' },
         ],
     },
     handler: async (args, ctx) => {
+        if (args[0]?.toLowerCase() === 'evidence') {
+            const action = (args[1] ?? 'copy').toLowerCase();
+            const destination = args.slice(2).join(' ');
+            if (!['preview', 'copy', 'save'].includes(action) || (action === 'save' ? !destination.trim() : args.length > 2)) {
+                ctx.addMessage({ role: 'system', content: 'Usage: /clipboard evidence <preview|copy|save <file>> (copy is the default)' });
+                return;
+            }
+            try {
+                const pkg = buildSessionEvidencePackage({ sessionId: ctx.getSessionId?.() ?? null,
+                    messages: ctx.getMessages(), diagnostics: ctx.getDiagnostics?.(), evidence: ctx.getEvidenceSnapshot?.(),
+                    taskHandoff: ctx.getTaskHandoff?.() ?? null });
+                if (action === 'preview')
+                    ctx.addMessage({ role: 'system', content: pkg.indexMarkdown });
+                else if (action === 'copy') {
+                    await ctx.clipboard.writeText(pkg.indexMarkdown);
+                    ctx.addMessage({ role: 'system', content: `✓ Copied ZTC evidence package index (${Buffer.byteLength(pkg.indexMarkdown)} bytes; retained checkpoint ${pkg.packageId})` });
+                }
+                else {
+                    await saveSessionEvidencePackage(pkg, destination);
+                    ctx.addMessage({ role: 'system', content: `✓ Saved ZTC evidence package to ${destination} (retained checkpoint ${pkg.packageId}; credentials redacted)` });
+                }
+            }
+            catch (error) {
+                ctx.addMessage({ role: 'system', content: `Evidence package error: ${error instanceof Error ? error.message : 'Sharing failed'}` });
+            }
+            return;
+        }
+        if (args[0]?.toLowerCase() === 'diagnostic') {
+            const format = (args[1] ?? 'markdown').toLowerCase();
+            if (format !== 'markdown' && format !== 'jsonl') {
+                ctx.addMessage({ role: 'system', content: 'Usage: /clipboard diagnostic <markdown|jsonl>' });
+                return;
+            }
+            try {
+                const input = { sessionId: ctx.getSessionId?.() ?? null, messages: ctx.getMessages(), diagnostics: ctx.getDiagnostics?.() };
+                const text = format === 'jsonl' ? exportSessionDiagnostics(input) : formatSessionDiagnosticsMarkdown(input);
+                await ctx.clipboard.writeText(text);
+                ctx.addMessage({ role: 'system', content: `✓ Copied ${text.length} chars (diagnostic ${format}; credentials redacted)` });
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : 'Failed to copy diagnostic export';
+                ctx.addMessage({ role: 'system', content: `Clipboard error: ${message}` });
+            }
+            return;
+        }
         const messages = ctx.getMessages();
         if (messages.length === 0) {
             ctx.addMessage({ role: 'system', content: 'Clipboard: no messages to copy.' });

package/dist/agent/commands/compact.js

@@ -1,5 +1,5 @@
 import { compactConversation, describeCompaction, smartSummarizer, localSummarizer } from '../../utils/compaction.js';
-import { getContextStatus, contextStatusFromUsed, formatTokenCount } from '../../utils/context.js';
+import { estimateConversationTokens, getContextStatus, contextStatusFromUsed, formatTokenCount } from '../../utils/context.js';
 import { MAX_COMPACTION_TARGET_PERCENT, MIN_COMPACTION_TARGET_PERCENT, resolveCompactionSettings, resolveCompactionTargetPercent, resolveContextTokenBudget, tokenTriggerActive, } from '../../config/compaction.js';
 export const compactCommand = {
     name: 'compact',
@@ -7,6 +7,7 @@ export const compactCommand = {
     usage: '/compact [target%]',
     handler: async (args, ctx) => {
         const messages = ctx.getMessages();
+        const authoredHistory = JSON.stringify(messages.filter(message => message.role !== 'system'));
         if (messages.length < 3) {
             ctx.addMessage({
                 role: 'system',
@@ -18,9 +19,10 @@ export const compactCommand = {
         // The "before" percentage should match the context bar (the real provider
         // token count); fall back to the char/4 estimate only before the first call.
         const realUsed = ctx.getContextTokens?.() ?? 0;
+        const catalogWindow = ctx.config.getModelContextWindow?.(model);
         const status = realUsed > 0
-            ? contextStatusFromUsed(realUsed, model, ctx.getContextWindow?.())
-            : getContextStatus(messages, model);
+            ? contextStatusFromUsed(realUsed, model, catalogWindow !== undefined ? catalogWindow : ctx.getContextWindow?.())
+            : getContextStatus(messages, model, catalogWindow);
         // An explicit argument wins; otherwise the configured target applies, so
         // /compact and auto-compaction aim at the same place.
         const targetPercent = args[0] ? parseInt(args[0], 10) : resolveCompactionTargetPercent(ctx.config.get());
@@ -55,7 +57,7 @@ export const compactCommand = {
                 ? resolveContextTokenBudget(ctx.config.get())
                 : undefined;
             const targetTokens = budget === undefined
-                ? 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,
@@ -65,16 +67,22 @@ export const compactCommand = {
                 keepRecentMin: 10,
                 targetTokens,
             });
-            ctx.clearMessages();
-            for (const msg of result.messages) {
-                ctx.addMessage({
-                    role: msg.role,
-                    content: msg.content,
-                    ...(msg.toolCalls ? { toolCalls: msg.toolCalls } : {}),
-                    ...(msg.metadata ? { metadata: msg.metadata } : {}),
-                });
+            // The summarizer yields while the host can admit steering or a user clear.
+            // Never replace that newer canonical history with an earlier snapshot.
+            if (JSON.stringify(ctx.getMessages().filter(message => message.role !== 'system')) !== authoredHistory) {
+                ctx.addMessage({ role: 'system', content: 'Conversation changed during compaction; current history is unchanged. Retry against the current conversation.' });
+                return;
             }
-            const newStatus = getContextStatus(result.messages, model);
+            // A summary that could not fit is not a surviving copy of the evicted task.
+            // Preserve the authored history rather than silently manufacturing continuity.
+            const hasNewSummary = result.messages.some(message => message.metadata?.compactionSummary === true
+                && message.content.trim().length > 0 && !messages.some(original => original.id === message.id));
+            if (result.method !== 'jev' && result.removed > 0 && !hasNewSummary) {
+                ctx.addMessage({ role: 'system', content: 'Compaction summary cannot fit the target; history is unchanged. Choose a larger target.' });
+                return;
+            }
+            ctx.setMessages(result.messages);
+            const newStatus = getContextStatus(result.messages, model, catalogWindow);
             // Reactively shrink the context bar to the compacted size — the backend
             // won't report this until the next turn, and the bar would otherwise stay
             // stuck at the pre-compaction (larger) value.

package/dist/agent/commands/config.js

@@ -894,7 +894,10 @@ Usage: /config context-progress-bar <enabled|accent|warning|critical|track|reset
                 return;
             }
             case 'effort': {
-                const EFFORT_LEVELS = CODEX_REASONING_EFFORTS;
+                const catalog = ctx.config.getRoutedModelCatalog?.();
+                const EFFORT_LEVELS = catalog?.version === 1
+                    ? catalog.models.find(row => row.owned_by === ctx.config.getProvider() && row.id === getEffectiveModel(ctx))?.capabilities?.reasoning?.choices ?? []
+                    : CODEX_REASONING_EFFORTS;
                 const CLEAR_WORDS = ['clear', 'default', 'unset', 'reset'];
                 const config = ctx.config.get();
                 const activeEffort = () => `Active (${config.provider} · ${config.model}): ${formatReasoningEffort(resolveCodexEffort(ctx.config.get(), config.provider, config.model))}`;

package/dist/agent/commands/context.js

@@ -55,7 +55,12 @@ export const contextCommand = {
         const estimated = realTokens <= 0;
         const usedTokens = estimated ? estimateConversationTokens(messages) : realTokens;
         // Use the provider-reported window the bar used (Codex) so /context agrees.
-        const status = contextStatusFromUsed(usedTokens, model, estimated ? undefined : ctx.getContextWindow?.());
+        const catalogWindow = ctx.config.getModelContextWindow?.(model);
+        const status = contextStatusFromUsed(usedTokens, model, catalogWindow !== undefined ? catalogWindow : estimated ? undefined : ctx.getContextWindow?.());
+        if (status.total === 0) {
+            ctx.addMessage({ role: 'system', content: `Context: ${formatTokens(usedTokens)} tokens${estimated ? ' (estimated)' : ''}. Context limit is unknown for this Router model.` });
+            return;
+        }
         const total = status.total;
         const usedPct = status.percentage;
         const freeTokens = Math.max(0, total - usedTokens);

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

@@ -0,0 +1,2 @@
+import type { Command } from './types.js';
+export declare const desktopCommand: Command;

package/dist/agent/commands/desktop.js

@@ -0,0 +1,29 @@
+import { installDesktopCli } from '../../desktop/cli_shim.js';
+export const desktopCommand = {
+    name: 'desktop',
+    description: 'Install the bundled app’s optional ztc terminal command',
+    agentRunnable: false,
+    usage: '/desktop install-cli [directory]',
+    handler: async (args, ctx) => {
+        if (ctx.commandOrigin === 'agent') {
+            ctx.addMessage({ role: 'system', content: 'CLI installation requires the user to type /desktop install-cli [directory].' });
+            return;
+        }
+        if (args[0] !== 'install-cli' || args.length < 1 || args.length > 2) {
+            ctx.addMessage({ role: 'system', content: 'Usage: /desktop install-cli [directory]' });
+            return;
+        }
+        try {
+            const result = await installDesktopCli(args[1]);
+            const notice = result.pathStatus === 'selected'
+                ? 'Your current PATH selects this bundled command.'
+                : result.pathStatus === 'shadowed'
+                    ? `Your current PATH selects ${result.selectedCommand} first. Use the installed path directly or move its directory earlier in PATH.`
+                    : 'Use this path directly or add its directory to PATH in your shell configuration.';
+            ctx.addMessage({ role: 'system', content: `${result.status === 'installed' ? 'Installed' : 'Already installed'}: ${result.path}\n${notice}\nYour PATH and shell configuration were not changed.` });
+        }
+        catch (error) {
+            ctx.addMessage({ role: 'system', content: `CLI installation failed: ${error.message}` });
+        }
+    },
+};

package/dist/agent/commands/effort.js

@@ -1,15 +1,23 @@
 import { CODEX_REASONING_EFFORTS } from '../../config/types.js';
 import { resolveCodexEffort } from '../../config/defaults.js';
 import { getSupportedCodexReasoningEfforts } from '../../utils/models.js';
-import { formatReasoningEffort, parseReasoningSelection } from '../../utils/reasoning.js';
+import { formatReasoningEffort, parseReasoningSelection, reasoningCommandChoices } from '../../utils/reasoning.js';
+import { resolveRouterModel } from '../../utils/router_catalog.js';
 async function configureReasoning(kind, args, ctx) {
     const config = ctx.config.get();
     const provider = ctx.config.getProvider?.() || config.provider || 'anthropic';
     const model = ctx.config.getModel?.() || config.model;
-    const current = resolveCodexEffort(config, provider, model);
-    const supported = getSupportedCodexReasoningEfforts(model, provider);
+    const surface = ctx.config.getReasoningWireSurface?.(provider, model)
+        ?? (config.authMode === 'zrouter' || provider === 'openai_compatible' ? 'chat_tools' : 'native_api');
+    const catalog = ctx.config.getRoutedModelCatalog?.();
+    const capabilities = catalog?.version === 1 ? resolveRouterModel(catalog, provider, model)?.capabilities : undefined;
+    const current = resolveCodexEffort(config, provider, model, capabilities ?? surface);
+    const supported = catalog?.version === 1 ? capabilities?.reasoning?.choices ?? [] : getSupportedCodexReasoningEfforts(model, provider, surface);
+    const contract = ctx.config.getReasoningContract?.(provider, model)
+        ?? (catalog?.version === 1 ? capabilities?.reasoning ?? [] : surface);
+    const thinkingChoices = reasoningCommandChoices('thinking', provider, model, contract);
     const status = () => {
-        const effective = resolveCodexEffort(ctx.config.get(), provider, model);
+        const effective = resolveCodexEffort(ctx.config.get(), provider, model, capabilities ?? surface);
         // A startup flag is this process's value, never the saved default, so say
         // where an effort that came from one is coming from.
         const processEffort = ctx.config.getCodexEffortOverride?.();
@@ -20,7 +28,7 @@ async function configureReasoning(kind, args, ctx) {
         ctx.addMessage({ role: 'system', content: status() +
                 (supported?.length === 0 ? '\nThis model does not support a reasoning-effort setting.' :
                     `\nSupported: ${(supported ?? CODEX_REASONING_EFFORTS).join(', ')}. /effort default inherits provider/global defaults.`) +
-                (supported?.includes('none') ? '\n/thinking off disables reasoning; /thinking on enables it.' : '') });
+                (thinkingChoices.length ? `\nThinking settings: ${thinkingChoices.join(', ')}.` : '') });
         return;
     }
     if (args.length !== 1) {
@@ -29,7 +37,7 @@ async function configureReasoning(kind, args, ctx) {
     }
     let level;
     try {
-        level = parseReasoningSelection(provider, model, current, { [kind]: args[0] });
+        level = parseReasoningSelection(provider, model, current, { [kind]: args[0] }, contract);
     }
     catch (error) {
         ctx.addMessage({ role: 'system', content: error.message });

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

@@ -0,0 +1,3 @@
+import type { Command } from './types.js';
+export declare function environmentOperationInProgress(sessionId: string): boolean;
+export declare const environmentCommand: Command;

package/dist/agent/commands/environment.js

@@ -0,0 +1,109 @@
+import { createEnvironment, getEnvironment, listEnvironments, openEnvironment, releaseEnvironment, checkpointEnvironment, restoreEnvironment, pauseEnvironment, resumeEnvironment, discardEnvironment, addEnvironmentNote, startEnvironmentService, environmentForWorkspace, environmentSummary, } from '../../environment/store.js';
+import { activeProfile } from '../../config/profiles.js';
+const usage = '/environment [list|create <name>|open <name>|status [--json]|checkpoint [label]|restore <ID>|pause|resume|leave|note <text>|service start <name> <command>|discard]';
+const activeOperations = new Set();
+export function environmentOperationInProgress(sessionId) { return activeOperations.has(sessionId); }
+export const environmentCommand = {
+    name: 'environment', description: 'Manage durable local workspaces, checkpoints and services', usage, category: 'core',
+    handler: async (args, ctx) => {
+        const say = (content) => ctx.addMessage({ role: 'system', content });
+        const action = args[0] ?? 'status';
+        let operationSession;
+        try {
+            if (ctx.commandOrigin === 'agent' && !['list', 'status'].includes(action))
+                throw new Error('Environment lifecycle requires an operator command.');
+            if (!ctx.environmentAvailable?.())
+                throw new Error('Local environment management is unavailable in this runtime.');
+            if (!['list', 'status'].includes(action) && ctx.isAgentRunning?.())
+                throw new Error('Wait for the active agent turn to finish before changing its environment.');
+            const sessionId = ctx.getSessionId?.();
+            if (!sessionId)
+                throw new Error('Environment management requires a persistent ZTC session.');
+            if (!['list', 'status'].includes(action)) {
+                if (activeOperations.has(sessionId))
+                    throw new Error('Wait for the current environment operation to finish.');
+                activeOperations.add(sessionId);
+                operationSession = sessionId;
+            }
+            if (action === 'list') {
+                say(JSON.stringify((await listEnvironments()).map(environmentSummary), null, 2));
+                return;
+            }
+            const current = ctx.getEnvironment?.() ?? await environmentForWorkspace(ctx.shell.getCwd());
+            if (action === 'create' || action === 'open') {
+                if (current && current.name !== args[1])
+                    throw new Error('Leave the current environment before opening another.');
+                const returnCwd = ctx.shell.getCwd();
+                const record = action === 'create' ? await createEnvironment(args[1] ?? '', sessionId) : await openEnvironment(args[1] ?? '', sessionId);
+                await ctx.shell.setCwd(record.workspacePath);
+                await ctx.environmentChanged?.(record.name, current ? undefined : returnCwd);
+                ctx.reloadAgent({ defer: true });
+                say(`Environment ${action === 'create' ? 'created' : 'opened'}: ${record.name}\nWorkspace: ${record.workspacePath}\nCredentials: profile ${record.credentialProfile}. Services are never restarted automatically.`);
+                return;
+            }
+            if (!current)
+                throw new Error('No environment open. Use /environment create <name> or open <name>.');
+            const record = await getEnvironment(current.name);
+            if (record.id !== current.id)
+                throw new Error('The environment was replaced; inspect it before recovery.');
+            if (action === 'status') {
+                say(JSON.stringify(environmentSummary(record), null, 2));
+                return;
+            }
+            if (record.credentialProfile !== activeProfile())
+                throw new Error(`Select profile ${record.credentialProfile} before changing this environment.`);
+            let message;
+            if (action === 'checkpoint') {
+                const point = await checkpointEnvironment(record.name, sessionId, args.slice(1).join(' ') || 'Checkpoint');
+                message = `Checkpoint created: ${point.id} · ${point.files.filter(f => f.kind !== 'directory').length} retained files`;
+            }
+            else if (action === 'restore') {
+                const restored = await restoreEnvironment(record.name, sessionId, args[1] ?? '');
+                // A rename leaves process.cwd() in the recovery backup until explicitly rebound.
+                await ctx.shell.setCwd(restored.workspacePath);
+                message = `Environment restored: ${restored.recovery?.checkpointId}\n${restored.recovery?.retainedFiles} files retained. Services needing explicit restart: ${restored.recovery?.servicesNeedingRestart.join(', ') || 'none'}\nExternal symlinks requiring separate recovery: ${restored.recovery?.externalLinks.join(', ') || 'none'}`;
+            }
+            else if (action === 'pause') {
+                await pauseEnvironment(record.name, sessionId);
+                message = 'Environment paused. Workspace and dependencies retained. Agent turns require /environment resume.';
+            }
+            else if (action === 'resume') {
+                await resumeEnvironment(record.name, sessionId);
+                message = 'Environment resumed. Services require explicit start.';
+            }
+            else if (action === 'note') {
+                await addEnvironmentNote(record.name, sessionId, args.slice(1).join(' '));
+                message = 'Setup note saved. Future agent turns receive this note.';
+            }
+            else if (action === 'service' && args[1] === 'start') {
+                const config = ctx.config.get();
+                const permissionId = config.permissionProfile || 'trusted';
+                const receipt = await startEnvironmentService(record.name, sessionId, args[2] ?? '', args.slice(3).join(' '), {
+                    profileId: permissionId, profile: ctx.config.getEffectivePermissionProfile?.(permissionId), sandbox: config.sandbox,
+                }, ctx.shell.getCwd());
+                message = `Service launching: ${receipt.name}\nDirectory: ${receipt.cwd}\nLog: ${receipt.logPath}\nUse /environment status to check its receipt; launch does not guarantee readiness.`;
+            }
+            else if (action === 'leave' || action === 'discard') {
+                const archive = action === 'discard' ? await discardEnvironment(record.name, sessionId) : undefined;
+                if (!archive)
+                    await releaseEnvironment(record.name, sessionId);
+                await ctx.environmentChanged?.(null);
+                ctx.reloadAgent({ defer: true });
+                say(archive ? `Environment discarded to recovery archive: ${archive}` : 'Environment left. Files and running services retained.');
+                return;
+            }
+            else
+                throw new Error(usage);
+            await ctx.environmentChanged?.(record.name);
+            ctx.reloadAgent({ defer: true });
+            say(message);
+        }
+        catch (error) {
+            say(`Environment: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        finally {
+            if (operationSession)
+                activeOperations.delete(operationSession);
+        }
+    },
+};

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

@@ -0,0 +1,2 @@
+import type { Command } from './types.js';
+export declare const evidenceCommand: Command;

package/dist/agent/commands/evidence.js

@@ -0,0 +1,9 @@
+import { formatEvidenceContext } from '../runtime/evidence.js';
+export const evidenceCommand = {
+    name: 'evidence', description: 'Inspect retained observations and interpretation sources', usage: '/evidence',
+    handler: (_args, ctx) => {
+        const snapshot = ctx.getEvidenceSnapshot?.();
+        ctx.addMessage({ role: 'system', content: !snapshot ? 'Retained evidence unavailable in this host.'
+                : snapshot.records.length ? formatEvidenceContext(snapshot) : 'No retained evidence in this session.' });
+    },
+};

package/dist/agent/commands/fork.js

@@ -7,7 +7,8 @@
  * would have decided. A task argument becomes the child's first message.
  */
 async function createSidePane(args, ctx, commandName) {
-    const task = args.join(' ').trim();
+    const task = args.join(' ');
+    const hasTask = task.trim().length > 0;
     const createZtcPane = ctx.zmux?.createZtcPane;
     if (!createZtcPane) {
         ctx.addMessage({
@@ -16,13 +17,13 @@ async function createSidePane(args, ctx, commandName) {
         });
         return;
     }
-    const result = await createZtcPane(task ? { task } : {});
+    const result = await createZtcPane(hasTask ? { task } : {});
     if (result.error) {
         ctx.addMessage({ role: 'system', content: `/${commandName} could not open a pane: ${result.error}` });
         return;
     }
     const where = result.cwd ? ` in ${result.cwd}` : '';
-    const handoff = task ? ' and sent it the task' : '';
+    const handoff = hasTask ? ' with its startup task' : '';
     ctx.addMessage({
         role: 'system',
         content: `Opened ZTC pane ${result.paneId}${where}${handoff}.`,

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

@@ -53,6 +53,9 @@
  * stop decision live here in one pure, unit-tested place: decideContinuation().
  */
 import { Command } from './types.js';
+import type { Message, AgentEvent } from '../../types.js';
+import type { EvidenceSnapshot } from '../runtime/evidence.js';
+import { type GoalPlateauCriteria, type GoalPlateauState, type GoalExitReason } from './goal_exit.js';
 export type GoalStatus = 'active' | 'paused' | 'complete' | 'budget_limited' | 'blocked';
 export interface GoalRecord {
     /** Unique identity for this goal instance, regenerated on every `set`. A fresh
@@ -87,6 +90,18 @@ export interface GoalRecord {
     blockedSource?: GoalBlockedSource;
     createdAt: number;
     updatedAt: number;
+    plateau?: GoalPlateauState;
+    exitReason?: GoalExitReason;
+    /** Exact authored request provenance; its original text remains in canonical user evidence. */
+    sustained?: {
+        sourceMessageId: string;
+        sourceTextSha256: string;
+        hostExitOnly: boolean;
+    };
+    blockedAudit?: {
+        condition: string;
+        streak: number;
+    };
 }
 /** Why a goal reached `blocked`. Drives the wording, never the behaviour. */
 export type GoalBlockedSource = 'agent' | 'execution';
@@ -102,6 +117,10 @@ export interface GoalTurnAccounting {
 }
 /** Facts about the turn that just finished, fed to the continuation decision. */
 export interface GoalTurnFacts extends GoalTurnAccounting {
+    /** Agent-reported missing prerequisite; this is not a host verification claim. */
+    blockedReason?: string;
+    /** Canonical host evidence, never reported scores or parsed model prose. */
+    evidence?: EvidenceSnapshot;
     /** Number of tool calls the just-finished turn made. */
     toolCallCount: number;
     /**
@@ -394,6 +413,7 @@ export declare function parseGoalArgs(args: string[]): {
     objective: string;
     tokenBudget?: number;
     maxTurns?: number;
+    plateau?: GoalPlateauCriteria;
 } | {
     error: string;
 };
@@ -440,15 +460,27 @@ export declare class GoalManager {
      * gets a fresh final turn.
      */
     private finalTurnAccounted;
+    private sustainedFirstTurnPending;
     constructor(clock?: GoalClock);
     /** A defensive copy so callers cannot mutate internal state. */
     get(): GoalRecord | null;
+    /** Admit an explicit authored sustained-work request into the existing loop, without deriving extra scope or budget. */
+    adoptUserIntent(message: Message, opts?: {
+        configuredMaxTurns?: number | null;
+    }): GoalRecord | null;
+    /** The authored opening turn spends the same budget as later automatic turns. */
+    accountSustainedFirstTurn(facts: GoalTurnFacts): GoalContinuationDecision | null;
+    /** Host wait events retain an owned job reference; tool text never establishes waiting. */
+    observeHostWait(event: Extract<AgentEvent, {
+        type: 'command_wait' | 'command_wait_end';
+    }>): GoalRecord | null;
     /** Start a brand-new goal (replaces any existing one) and arm the first turn. */
     set(objective: string, opts?: {
         tokenBudget?: number;
         maxTurns?: number;
+        plateau?: GoalPlateauCriteria;
     }): GoalRecord;
-    pause(): GoalRecord | null;
+    pause(kind?: 'user_pause' | 'user_cancelled'): GoalRecord | null;
     /**
      * Re-activate a paused / budget-limited goal and arm a continuation turn.
      * Resuming also clears whatever stop condition fired so the goal makes