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

package/dist/skills/bundled/measurement-validation/SKILL.md

@@ -0,0 +1,144 @@
+---
+id: measurement-validation
+name: measurement-validation
+description: Establish measurement meaning, comparability and instrumentation before optimizing a reported bottleneck
+keywords: [measurement, profiling, benchmark, performance, optimization, instrumentation]
+---
+
+# Measurement validation workflow
+
+Before expensive implementation or a full benchmark, define the discriminating
+check: which measured field, workload and runtime path would support or refute
+the proposed bottleneck? A plausible number does not answer that question.
+
+1. **Declare the question.** State the metric definition, unit, timing domain,
+   workload, stage, input shape, selected ranks and scope. Prefill and decode
+   are different workloads. Host time, device time, diagnostic synchronization,
+   logical allocation counts and fresh physical allocations are different
+   measurements. Do not infer these definitions from a field name.
+2. **Capture the original source.** Use a managed `run_command`/`read_command`
+   observation whose entire output is one JSON envelope, as shown below. Keep
+   its observation ID and captured digest through `session_evidence`. Project
+   analyzers produce this generic format; domain-specific profile interpretation
+   belongs in the project, not in ZTC core. Do not strip arbitrary log text to
+   find a convenient numeric JSON object.
+3. **Run a small instrumentation smoke.** In the requested mode and selected
+   runtime path, demonstrate the expected field actually appears. Check that
+   field's unit, timing domain, rank and shape before the expensive full run.
+   A field emitted in another mode or path is insufficient. If the field is
+   absent, stop to resolve the instrumentation rather than claiming a zero cost.
+4. **Validate retained observations.** Discover `measurement_report` with
+   `tool_search`, then pass one observation ID for assessment or two IDs in
+   baseline/candidate order for comparison. Pass declared requirements, not
+   copied values, fabricated receipts or model-written measurements. Check
+   compatibility and every reason before using the numbers.
+5. **Respect lifecycle.** A startup artifact with `passed: false` and a running
+   owner job is incomplete. It is not a failed final run. Re-read the same job
+   from cursor 0 until a complete terminal observation is available; do not relaunch it just
+   to obtain a final-looking artifact. Unavailable, partial or malformed source
+   observations remain unknown.
+6. **Keep hierarchy and overlap explicit.** Never sum an inclusive parent and
+   child, or an ancestor and descendant, as exclusive wall-time shares. Sum
+   only explicitly exclusive measurements in the same timing domain, scope
+   and rank. Cross-rank overlap is not serial wall time. A parent denominator
+   must use the same units/domain/scope/rank as its selected components.
+7. **Interpret conservatively.** Arithmetic residuals stay unattributed. Record
+   a residual explanation as a hypothesis with supporting observation IDs via
+   `session_evidence`; demonstrate independent attribution before calling it a
+   measured removable performance win. An increase from 78.58 to 79.63 ms is
+   an increase of 1.05 ms, not a speedup. A zero baseline has no defined relative
+   percentage. Do not manufacture component shares from unexplained remainder.
+
+Compatibility checks reported shape and meaning against the visible declaration.
+It does not prove producer truth, current source identity or correctness:
+benchmark eligibility remains unknown. Source qualification, correctness checks
+and benchmark admission are separate requirements. A report never authorizes a
+command or changes user instructions.
+
+## Producer envelope (one complete JSON document)
+
+```json
+{
+  "schemaVersion": 1,
+  "runId": "smoke-baseline",
+  "source": {
+    "revision": "reported-project-revision",
+    "artifactSha256": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+  },
+  "workload": {
+    "id": "decode-fixture",
+    "stage": "decode",
+    "inputShape": { "batch": 1, "tokens": 1 }
+  },
+  "instrumentation": {
+    "mode": "production-timing",
+    "version": "1",
+    "synchronization": "production",
+    "runtimePath": "fixture/decode"
+  },
+  "completion": { "status": "completed", "passed": true },
+  "smoke": {
+    "mode": "production-timing",
+    "runtimePath": "fixture/decode",
+    "fields": ["step-r0"],
+    "passed": true
+  },
+  "metrics": [
+    {
+      "id": "step-r0",
+      "value": 78.58,
+      "unit": "ms",
+      "timingDomain": "host-wall",
+      "scope": "step",
+      "rank": 0,
+      "worldSize": 1,
+      "coverage": "inclusive"
+    }
+  ]
+}
+```
+
+Metric IDs are unique across ranks. Child metrics declare `parentId`. Requested
+`smokeFields` name actual metric IDs present in both `metrics` and `smoke.fields`.
+The terminal observation must capture the output from byte 0; a final JSON
+suffix after earlier log text is incomplete. The whole serialized command
+receipt must fit 32768 UTF-8 bytes, and the tool report is bounded to 64 KiB.
+The
+source revision/hash above are producer reports, not a host certification.
+
+## Tool requirements
+
+```json
+{
+  "observation_ids": ["original-baseline-observation", "original-candidate-observation"],
+  "requirements": {
+    "workload": {
+      "id": "decode-fixture",
+      "stage": "decode",
+      "inputShape": { "batch": 1, "tokens": 1 }
+    },
+    "instrumentation": {
+      "mode": "production-timing",
+      "version": "1",
+      "synchronization": "production",
+      "runtimePath": "fixture/decode"
+    },
+    "metricIds": ["step-r0"],
+    "unit": "ms",
+    "timingDomain": "host-wall",
+    "scope": "step",
+    "worldSize": 1,
+    "expectedRanks": [0],
+    "smokeFields": ["step-r0"],
+    "aggregation": "none"
+  }
+}
+```
+
+Declare every rank needed for the question; an explicit rank-0 selection does
+not establish all-rank coverage. No automatic unit conversion is performed.
+Use `aggregation: "sum_exclusive"` only for comparable exclusive components;
+optional `totalMetricId` names an inclusive denominator and requests an
+arithmetic residual with no attribution.
+If source capture cannot fit the bounded envelope, reduce the project analyzer's
+output to a focused profile while retaining its original source identity.

package/dist/terminal_attach.d.ts

@@ -0,0 +1 @@
+export declare function runTerminalAttachCli(args: string[]): Promise<number>;

package/dist/terminal_attach.js

@@ -0,0 +1,113 @@
+/** Durable terminal attachment through local tmux or authenticated OpenSSH. */
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+const HELP = `Usage: ztc attach --session <tmux-session> [--ssh <host>] [--ssh-config <file>] [--read-only] [--no-reconnect]
+
+Attach to an existing tmux session. The task keeps running in tmux when you detach or the connection drops.
+Local native ZTC sessions also remain available through Ctrl+B W.
+Remote hosts use your OpenSSH configuration and require a verified known host key.
+--read-only observes the tmux session without forwarding input or changing its size.
+This flag restricts the terminal client; it does not reduce your SSH account permissions.
+Remote connections retry up to three times after a transport interruption. Run the same command to reconnect later.
+Ctrl+B D detaches without ending the task. Create the backend on its host first: tmux new-session -s <name> ztc
+`;
+export async function runTerminalAttachCli(args) {
+    if (args.length === 1 && ['--help', '-h'].includes(args[0])) {
+        process.stdout.write(HELP);
+        return 0;
+    }
+    let session = '';
+    let host = '';
+    let sshConfig = '';
+    let readOnly = false;
+    let reconnect = true;
+    const seen = new Set();
+    try {
+        for (let i = 0; i < args.length; i++) {
+            const flag = args[i];
+            if (seen.has(flag))
+                throw new Error(`Specify ${flag} only once.`);
+            seen.add(flag);
+            if (flag === '--read-only') {
+                readOnly = true;
+                continue;
+            }
+            if (flag === '--no-reconnect') {
+                reconnect = false;
+                continue;
+            }
+            if (!['--session', '--ssh', '--ssh-config'].includes(flag))
+                throw new Error(`Unknown attach option: ${flag}`);
+            const value = args[++i];
+            if (!value)
+                throw new Error(`Missing value for ${flag}.`);
+            if (flag === '--session') {
+                if (!/^[A-Za-z0-9_][A-Za-z0-9_.-]{0,63}$/.test(value))
+                    throw new Error('Invalid tmux session. Use 1–64 letters, numbers, underscores, dots or dashes.');
+                session = value;
+            }
+            else if (flag === '--ssh') {
+                if (value.startsWith('-') || !/^[A-Za-z0-9_.@:[\]-]+$/.test(value))
+                    throw new Error('Invalid SSH host. Use a trusted OpenSSH host alias or user@hostname.');
+                host = value;
+            }
+            else
+                sshConfig = resolve(value);
+        }
+        if (!session)
+            throw new Error('A named tmux backend is required: --session <name>.');
+        if (sshConfig && !host)
+            throw new Error('--ssh-config requires --ssh.');
+    }
+    catch (error) {
+        process.stderr.write(`[ztc attach] ${error instanceof Error ? error.message : String(error)}\n${HELP}`);
+        return 2;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stderr.write('[ztc attach] Attachment requires an interactive terminal.\n');
+        return 2;
+    }
+    const tmuxArgs = ['attach-session', ...(readOnly ? ['-r'] : []), '-t', `=${session}`];
+    const executable = host ? 'ssh' : 'tmux';
+    const command = host
+        ? [...(sshConfig ? ['-F', sshConfig] : []), '-tt', '-o', 'StrictHostKeyChecking=yes', '-o', 'ServerAliveInterval=5', '-o', 'ServerAliveCountMax=2', '--', host, 'tmux', ...tmuxArgs]
+        : tmuxArgs;
+    process.stderr.write(`[ztc attach] ${readOnly ? 'Read-only observation' : 'Terminal control'} · ${host || 'local host'} · tmux ${session}\n`);
+    const limit = host && reconnect ? 4 : 1;
+    for (let attempt = 0; attempt < limit; attempt++) {
+        const code = await new Promise(resolveExit => {
+            const child = spawn(executable, command, { stdio: 'inherit' });
+            let interrupted = null;
+            let forceStop = null;
+            const stop = (signal, exitCode) => {
+                if (interrupted !== null)
+                    return;
+                interrupted = exitCode;
+                child.kill(signal);
+                forceStop = setTimeout(() => {
+                    if (child.exitCode === null && child.signalCode === null)
+                        child.kill('SIGKILL');
+                }, 2000);
+                forceStop.unref();
+            };
+            const onInterrupt = () => stop('SIGINT', 130);
+            const onTerminate = () => stop('SIGTERM', 143);
+            process.on('SIGINT', onInterrupt);
+            process.on('SIGTERM', onTerminate);
+            const finish = (status) => {
+                process.off('SIGINT', onInterrupt);
+                process.off('SIGTERM', onTerminate);
+                if (forceStop)
+                    clearTimeout(forceStop);
+                resolveExit(interrupted ?? status);
+            };
+            child.once('error', error => { process.stderr.write(`[ztc attach] ${error.message}\n`); finish(127); });
+            child.once('exit', (status, signal) => finish(status ?? (signal ? 130 : 1)));
+        });
+        if (code !== 255 || attempt + 1 === limit)
+            return code;
+        process.stderr.write(`[ztc attach] SSH disconnected. Reconnecting to the same tmux session (${attempt + 1}/3).\n`);
+        await new Promise(resolveWait => setTimeout(resolveWait, 1000));
+    }
+    return 1;
+}

package/dist/tool_progress.d.ts

@@ -0,0 +1,3 @@
+import type { AgentState } from './types.js';
+/** Parse only bounded display facts; this DTO grants no execution or evidence authority. */
+export declare function parseToolProgress(value: unknown): NonNullable<AgentState['toolProgress']> | null;

package/dist/tool_progress.js

@@ -0,0 +1,27 @@
+/** Parse only bounded display facts; this DTO grants no execution or evidence authority. */
+export function parseToolProgress(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return null;
+    const row = value;
+    if (typeof row.toolCallId !== 'string' || !row.toolCallId
+        || new TextEncoder().encode(row.toolCallId).length > 256 || /[\u0000-\u001f\u007f]/u.test(row.toolCallId)
+        || typeof row.tool !== 'string' || !row.tool
+        || new TextEncoder().encode(row.tool).length > 128 || /[\u0000-\u001f\u007f]/u.test(row.tool)
+        || typeof row.progress !== 'object' || row.progress === null || Array.isArray(row.progress))
+        return null;
+    const progress = row.progress;
+    const { startedAt, lastOutputAt, outputBytes, outputLines, latestLine } = progress;
+    if (typeof startedAt !== 'number' || !Number.isSafeInteger(startedAt) || startedAt < 0
+        || (lastOutputAt !== undefined && (typeof lastOutputAt !== 'number'
+            || !Number.isSafeInteger(lastOutputAt) || lastOutputAt < startedAt))
+        || typeof outputBytes !== 'number' || !Number.isSafeInteger(outputBytes) || outputBytes < 0
+        || typeof outputLines !== 'number' || !Number.isSafeInteger(outputLines) || outputLines < 0
+        || typeof latestLine !== 'string' || new TextEncoder().encode(latestLine).length > 512)
+        return null;
+    return {
+        toolCallId: row.toolCallId,
+        tool: row.tool,
+        progress: { startedAt, ...(lastOutputAt === undefined ? {} : { lastOutputAt: lastOutputAt }),
+            outputBytes, outputLines, latestLine },
+    };
+}

package/dist/types.d.ts

@@ -1,4 +1,5 @@
-import type { RequestMetrics, TokenUsage } from './agent/backends/types.js';
+import type { RequestContentBlock, RequestMetrics, TokenUsage } from './agent/backends/types.js';
+import type { EvidenceSnapshot } from './agent/runtime/evidence.js';
 export type MessageRole = 'user' | 'assistant' | 'tool' | 'system';
 export type ToolStatus = 'pending' | 'running' | 'complete' | 'error';
 export type AgentStatus = 'idle' | 'thinking' | 'tool_use' | 'streaming' | 'error';
@@ -11,7 +12,10 @@ export type TodoStatus = typeof TODO_STATUSES[number];
  * never ASCII `...`) if they want one.
  */
 export declare const AGENT_STATUS_LABELS: Record<AgentStatus, string>;
-export type InputMode = 'queue' | 'interrupt';
+export type CanonicalInputMode = 'steer' | 'interrupt';
+/** `queue` is a legacy spelling of steer; Tab owns end-of-turn queuing. */
+export type InputMode = CanonicalInputMode | 'queue';
+export declare function normalizeInputMode(mode: InputMode): CanonicalInputMode;
 /**
  * When a busy-turn submission should reach the model.
  *
@@ -66,6 +70,13 @@ export interface FormWidgetData {
     submitLabel?: string;
     formId: string;
 }
+/** Source-qualified image bytes owned by the checkpoint beside which they are stored. */
+export interface DurableImageReference {
+    version: 1;
+    sessionFile: string;
+    file: string;
+    sha256: string;
+}
 export interface MessageAttachment {
     id: string;
     kind: 'image';
@@ -75,26 +86,110 @@ export interface MessageAttachment {
     url?: string;
     localPath?: string;
     stale?: boolean;
+    durable?: DurableImageReference;
 }
 export interface MessageInput {
     text: string;
     attachments: MessageAttachment[];
     pane_id?: number;
 }
+/** Usage belongs to the prompt which dispatched the request, including its workers. */
+export interface ModelUsage extends TokenUsage {
+    /** The call completed without reporting usage; a complete total is unavailable. */
+    unreported?: boolean;
+}
+export type ModelUsageObserver = ((usage: ModelUsage) => void) & {
+    forRequest?: () => ModelUsageObserver;
+    workerStarted?: () => () => void;
+    getTurn?: () => PromptTurnMetadata;
+};
+export interface PromptTurnMetadata {
+    id: string;
+    startedAt: number;
+    finishedAt?: number;
+    tokens: number;
+    estimated: boolean;
+    usageIncomplete?: boolean;
+}
+/** Bounded, source-linked host warning about a claim; not an execution receipt. */
+export interface HostClaimObservation {
+    version: 1;
+    sourceMessageId: string;
+    sourceSha256: string;
+    basis: 'no_tool_calls' | 'contradictory_tool_output';
+    toolCallCount: number;
+    observedAt: string;
+}
 export interface Message {
     id: string;
     role: MessageRole;
     content: string;
+    /** Ordered model-facing blocks, including opaque signed thinking. Not UI text. */
+    nativeContent?: string | RequestContentBlock[];
+    /** Model that produced/submitted nativeContent; do not replay across models. */
+    nativeModel?: string;
+    /** Stable system/tool prefix identity for opaque native reasoning. */
+    nativeContextId?: string;
     timestamp: Date;
+    turn?: PromptTurnMetadata;
     toolCalls?: ToolCall[];
     isStreaming?: boolean;
-    metadata?: Record<string, unknown>;
+    metadata?: Record<string, unknown> & {
+        /** Opaque provider context for API replay; never displayed as assistant reasoning. */
+        providerReasoning?: string;
+        /** Durable host Clear event UUID; resaves and compaction preserve its identity. */
+        taskHandoffReset?: string;
+        /** Historical host warning replayed only while its authored source still matches. */
+        hostClaimObservation?: HostClaimObservation;
+        /** Host observations are literal text; quoted media/tool-result tokens authorize no new reads. */
+        hostContext?: boolean;
+    };
     attachments?: MessageAttachment[];
     widget?: FormWidgetData;
 }
+/** Bounded host observation of an active managed-command wait, never inferred from tool text. */
+export interface CommandWaitingState {
+    kind: 'managed_command';
+    toolCallId: string;
+    jobId: string;
+    cursor: number;
+    startedAt: number;
+    deadlineAt?: number;
+}
+/** Informational output observed while an owned tool invocation is running. */
+export interface AgentToolProgress {
+    startedAt: number;
+    lastOutputAt?: number;
+    outputBytes: number;
+    outputLines: number;
+    /** Latest observed logical line/current partial, capped at 512 UTF-8 bytes. */
+    latestLine: string;
+}
 export interface AgentState {
     status: AgentStatus;
+    /** Fresh, bounded local advisory evidence, never a remote mutation grant. */
+    workspaceCollision?: import('./workspace_collision.js').WorkspaceCollisionSnapshot;
+    taskHandoff?: {
+        sessionId: string;
+        projection: import('./session_handoff_contract.js').TaskHandoffProjection | null;
+    };
+    evidence?: {
+        sessionId: string;
+        snapshot: EvidenceSnapshot;
+    };
+    waiting?: CommandWaitingState;
+    requestRetry?: {
+        phase: 'retry' | 'recovery';
+        attempt: number;
+        delay: number;
+        rateLimited?: boolean;
+    };
     currentTool?: string;
+    toolProgress?: {
+        toolCallId: string;
+        tool: string;
+        progress: AgentToolProgress;
+    };
     tokensUsed?: number;
     contextTokens?: number;
     /**
@@ -128,19 +223,33 @@ export interface ZTCConfig {
     timeout?: number;
     tools?: string[];
 }
+export interface ToolParameterSchema {
+    type: string;
+    description?: string;
+    enum?: string[];
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    properties?: Record<string, ToolParameterSchema>;
+    items?: ToolParameterSchema;
+    required?: string[];
+    additionalProperties?: boolean;
+}
 export interface ToolDefinition {
     name: string;
     description: string;
     parameters: {
         type: 'object';
-        properties: Record<string, {
-            type: string;
-            description: string;
-            enum?: string[];
-            minimum?: number;
-            maximum?: number;
-        }>;
+        properties: Record<string, ToolParameterSchema>;
         required?: string[];
+        oneOf?: {
+            required: string[];
+        }[];
+        additionalProperties?: boolean;
     };
     /**
      * This tool duplicates a capability that harness-owning providers (Codex App
@@ -152,6 +261,17 @@ export interface ToolDefinition {
     overlapsProviderHarness?: boolean;
 }
 export type AgentEvent = {
+    type: 'request_usage';
+    receipt: import('./usage_snapshot.js').UsageReceipt;
+} | {
+    type: 'task_handoff';
+    sessionId: string;
+    projection: import('./session_handoff_contract.js').TaskHandoffProjection | null;
+} | {
+    type: 'evidence';
+    sessionId: string;
+    snapshot: EvidenceSnapshot;
+} | {
     type: 'history_checkpoint';
     messages: Message[];
 } | {
@@ -161,6 +281,11 @@ export type AgentEvent = {
     tool: string;
     args: Record<string, unknown>;
     toolCallId: string;
+} | {
+    type: 'tool_progress';
+    toolCallId: string;
+    tool: string;
+    progress: AgentToolProgress;
 } | {
     type: 'tool_end';
     tool: string;
@@ -171,6 +296,13 @@ export type AgentEvent = {
     tool: string;
     error: string;
     toolCallId: string;
+} | {
+    type: 'command_wait';
+    waiting: CommandWaitingState;
+} | {
+    type: 'command_wait_end';
+    toolCallId: string;
+    reason: 'output' | 'terminal' | 'deadline' | 'steering' | 'cancelled' | 'error';
 } | {
     type: 'stream_start';
 } | {
@@ -197,6 +329,9 @@ export type AgentEvent = {
     maxAttempts: number;
     delay: number;
     reason: string;
+    phase?: 'retry' | 'recovery';
+    elapsedMs?: number;
+    rateLimited?: boolean;
 } | {
     type: 'auto_continue';
     reason?: string;

package/dist/types.js

@@ -12,3 +12,6 @@ export const AGENT_STATUS_LABELS = {
     streaming: 'Streaming',
     error: 'Error',
 };
+export function normalizeInputMode(mode) {
+    return mode === 'queue' ? 'steer' : mode;
+}

package/dist/ui/core/input.d.ts

@@ -7,6 +7,8 @@ export interface InputKey {
     rightArrow?: boolean;
     ctrl?: boolean;
     meta?: boolean;
+    alt?: boolean;
+    super?: boolean;
     backspace?: boolean;
     delete?: boolean;
     tab?: boolean;
@@ -19,6 +21,7 @@ export interface InputKey {
 export interface InputEvent {
     input: string;
     key: InputKey;
+    paste?: true;
 }
 export interface InputBus {
     subscribe(handler: (event: InputEvent) => void): () => void;

package/dist/ui/core/input_segments.d.ts

@@ -1,10 +1,16 @@
-import { InputSegment, InputCursor, InputState } from './input_state.js';
+import { InputSegment, InputCursor, InputState, InputKill, InputDraftSnapshot } from './input_state.js';
+import type { MessageInput } from '../../types.js';
 export declare const PASTE_BADGE_THRESHOLD = 4;
 export declare function normalizeSegments(segments: InputSegment[]): InputSegment[];
 export declare function clampCursor(segments: InputSegment[], cursor: InputCursor): InputCursor;
 export declare function insertText(state: InputState, text: string): InputState;
 export declare function insertSegment(state: InputState, segment: InputSegment): InputState;
 export declare function insertBadge(state: InputState, segment: InputSegment): InputState;
+/** The focused text badge, or its immediate neighbor across a text boundary. */
+export declare function getExpandablePasteIndex(state: Pick<InputState, 'segments' | 'cursor'>): number;
+export declare function getPasteExpansionHint(state: Pick<InputState, 'segments' | 'cursor'>): string | null;
+/** Expand only the targeted text badge, preserving attachments and draft bytes. */
+export declare function expandPasteBadge(state: InputState): InputState;
 export declare function backspace(state: InputState): InputState;
 export declare function deleteForward(state: InputState): InputState;
 export declare function killToEnd(state: InputState): InputState;
@@ -18,6 +24,8 @@ export declare function textCursorIndex(segments: InputSegment[], cursor: InputC
 export declare function cursorFromTextIndex(segments: InputSegment[], pos: number): InputCursor;
 export declare function getPlainText(segments: InputSegment[]): string;
 export declare function serializeSegments(segments: InputSegment[]): string;
+/** Capture admitted images separately; path-only badges keep their legacy tokens. */
+export declare function serializeMessageInput(segments: readonly InputSegment[]): MessageInput;
 export declare function createEmptyState(): InputState;
 export declare function moveToStart(state: InputState): InputState;
 export declare function moveToEnd(state: InputState): InputState;
@@ -65,5 +73,14 @@ export interface VerticalMove {
  * caller's signal that the caret is at an edge, where history takes over.
  */
 export declare function moveVertical(state: InputState, direction: -1 | 1, goalColumn?: number): VerticalMove;
+/** Whole-draft kills retain badge identity and the original caret. */
+export declare function killInputDraft(state: InputState): {
+    state: InputState;
+    killed: InputDraftSnapshot;
+};
+export declare function yankInputKill(state: InputState, killed: InputKill): InputState;
+export declare function getInputShortcutHint(state: Pick<InputState, 'segments' | 'cursor'>, running?: boolean, canYank?: boolean): string | null;
+/** Save history and clear a submitted draft in one place for both renderers. */
+export declare function recordInputHistory(state: InputState, entry?: string, maxEntries?: number): InputState;
 export declare function historyUp(state: InputState): InputState;
 export declare function historyDown(state: InputState): InputState;