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

package/dist/cli_ratatui.js

@@ -1,3 +1,5 @@
+import { reconcileOrderedTranscript } from './app/ordered_transcript.js';
+import { shutdownCommandJobs, subscribeCommandJobs } from './agent/runtime/command_jobs.js';
 /**
  * RatatuiApp — the interactive TUI application class.
  *
@@ -1732,6 +1734,7 @@ export class RatatuiApp {
             retry: () => { },
             exit: () => this.exit(),
             getSessionId: () => this.sessionId,
+            getExecutionContext: () => this.agent?.getExecutionContext(),
             getSessionName: () => this.sessionName,
             setSessionName: (name) => {
                 this.sessionName = name && name.length > 0 ? name : undefined;
@@ -7255,6 +7258,17 @@ export class RatatuiApp {
         }
         // Snapshot message count before the run so we can roll back on cancel
         const preRunMessageCount = this.controller.getState().messages.length;
+        let historyCheckpoint = [];
+        const transcriptIterations = [];
+        const toolIterations = new Map();
+        const retainCheckpoint = () => {
+            if (!historyCheckpoint.length)
+                return;
+            this.controller.setMessages(reconcileOrderedTranscript({
+                live: this.controller.getState().messages, ordered: historyCheckpoint,
+                iterations: transcriptIterations, toolIterations,
+            }));
+        };
         // Any steering retained across a prior interrupted or widget-ended turn
         // is already present in this snapshot. It must not be injected twice.
         this.pendingSteering = [];
@@ -7287,9 +7301,13 @@ export class RatatuiApp {
                 // Liveness clock: any agent event proves the model is still producing.
                 this.lastAgentEventAt = Date.now();
                 switch (event.type) {
+                    case 'history_checkpoint':
+                        historyCheckpoint = event.messages;
+                        break;
                     case 'thinking_start': {
                         this.flushLocalStreamDelta();
                         this.finishLocalStreamingMessages();
+                        transcriptIterations.push({ start: this.controller.getState().messages.length });
                         this.controller.setAgentState(applyAgentEventToState(this.controller.getState().agentState, event));
                         break;
                     }
@@ -7297,6 +7315,11 @@ export class RatatuiApp {
                         this.flushLocalStreamDelta();
                         this.finishLocalStreamingMessages();
                         this.controller.setAgentState(applyAgentEventToState(this.controller.getState().agentState, event));
+                        const frameIndex = Math.max(0, transcriptIterations.length - 1);
+                        if (!transcriptIterations.length)
+                            transcriptIterations.push({ start: preRunMessageCount });
+                        transcriptIterations[frameIndex].toolStart ??= this.controller.getState().messages.length;
+                        toolIterations.set(event.toolCallId, frameIndex);
                         this.turnToolCallCount++;
                         const toolCallId = event.toolCallId;
                         this.mirror?.publishToolCall(event.tool, event.args || {}, toolCallId);
@@ -7449,6 +7472,7 @@ export class RatatuiApp {
             }
         }
         catch (err) {
+            retainCheckpoint();
             this.flushLocalStreamDelta();
             this.finishLocalStreamingMessages();
             this.finishToolGroups(err.message);
@@ -7496,6 +7520,7 @@ export class RatatuiApp {
         this.finishLocalStreamingMessages();
         this.finishToolGroups(cancelled ? 'Cancelled' : 'No result received');
         if (cancelled) {
+            retainCheckpoint();
             // Clean up partial state from cancelled run
             this.clearLocalStreamDelta();
             // Codex parity: an interrupt stops the run but keeps everything the run
@@ -7534,41 +7559,15 @@ export class RatatuiApp {
             // calls onto the final assistant message, which would replay a steering
             // prompt before the tool result it followed.
             const turnMessages = result.turnMessages ?? [];
-            const steeredTurn = turnMessages.some(message => message.metadata?.steering === true);
-            if (steeredTurn) {
-                const live = this.controller.getState().messages;
-                // A steering message the turn actually consumed is replayed from
-                // `turnMessages`, so keeping the live copy would duplicate it. One still
-                // in `pendingSteering` never met a tool boundary: dropping it here loses
-                // the prompt from both the transcript and every request. Keep it, and
-                // `movePendingSteeringToEnd` will place it after the answer and take the
-                // follow-up turn.
-                const unconsumedSteering = new Set(this.pendingSteering.map(message => message.id));
-                const retainedMessages = live.slice(preRunMessageCount)
-                    .filter(message => message.role === 'system' || message.role === 'tool'
-                    || (message.role === 'user'
-                        && (message.metadata?.steering !== true || unconsumedSteering.has(message.id))));
-                const orderedMessages = turnMessages.map(message => ({
-                    ...message,
-                    ...(message.toolCalls ? {
-                        toolCalls: message.toolCalls.map(toolCall => {
-                            const { result: _result, error: _error, ...lightCall } = toolCall;
-                            return lightCall;
-                        }),
-                        metadata: { ...message.metadata, toolCallsInTranscript: true },
-                    } : {}),
-                }));
-                const finalAssistant = result.content.trim()
-                    ? {
-                        id: generateId(), role: 'assistant', content: result.content,
-                        timestamp: new Date(),
+            if (turnMessages.length > 0) {
+                this.controller.setMessages(reconcileOrderedTranscript({
+                    live: this.controller.getState().messages, ordered: turnMessages,
+                    iterations: transcriptIterations, toolIterations,
+                    finalMessage: result.content.trim() ? {
+                        id: generateId(), role: 'assistant', content: result.content, timestamp: new Date(),
                         ...(result.reasoning ? { metadata: { reasoningContent: result.reasoning } } : {}),
-                    }
-                    : null;
-                this.controller.setMessages([
-                    ...live.slice(0, preRunMessageCount), ...orderedMessages,
-                    ...(finalAssistant ? [finalAssistant] : []), ...retainedMessages,
-                ]);
+                    } : undefined,
+                }));
             }
             else {
                 // Add final response if not already streamed
@@ -7628,6 +7627,7 @@ export class RatatuiApp {
                         .map(tc => ({
                         tool_use_id: tc.id,
                         content: tc.error ? `Error: ${tc.error}` : (tc.result || ''),
+                        is_error: tc.status === 'error',
                     }));
                     if (toolResultContent.length > 0) {
                         this.controller.addMessage({
@@ -8683,7 +8683,23 @@ export class RatatuiApp {
         }
         return paneMode === 'sim-pane' ? 'sim-pane' : controllerMode;
     }
+    commandJobsUnsubscribe;
+    commandJobStates = new Map();
     createAgent() {
+        this.commandJobsUnsubscribe?.();
+        this.commandJobsUnsubscribe = subscribeCommandJobs(this.sessionId, jobs => {
+            const snapshot = { type: 'command_jobs', data: { jobs } };
+            if (this.mirrorServer)
+                this.mirrorServer.publish(snapshot);
+            else
+                this.mirrorClient?.publish(snapshot);
+            for (const job of jobs) {
+                if (this.commandJobStates.get(job.job_id) !== job.status) {
+                    this.commandJobStates.set(job.job_id, job.status);
+                    this.addSystemMessage(`Command ${job.job_id}: ${job.status}${job.exit_code === undefined ? '' : ` (exit ${job.exit_code})`}. ${job.command.slice(0, 120)}`);
+                }
+            }
+        });
         const currentMode = this.getEffectiveAgentMode();
         if (currentMode === 'plan' && !this.controller.getPlanFile()) {
             throw new PlanFileCreationError('<unset>', new Error('refusing to construct a plan agent without an artifact path'));
@@ -10270,6 +10286,9 @@ export class RatatuiApp {
             await batch.shutdown(5000);
             clearCurrentBatch();
         }
+        await shutdownCommandJobs(this.sessionId);
+        this.commandJobsUnsubscribe?.();
+        this.commandJobsUnsubscribe = undefined;
         // Shut down background agents before clearing tool callbacks
         const bgRegistry = getBackgroundRegistry();
         if (bgRegistry) {

package/dist/config/execution.d.ts

@@ -0,0 +1,12 @@
+/** Execution controls shared by the agent, command jobs, and settings surfaces. */
+export interface ExecutionSettings {
+    shellPanePolicy?: 'on_request' | 'auto';
+    readConcurrency?: number;
+    maxCallsPerResponse?: number;
+    recovery?: 'automatic' | 'pause';
+    repeatedFailureLimit?: number;
+    recoveryAttempts?: number;
+    interruptBackgroundJobs?: boolean;
+    maxBackgroundJobs?: number;
+}
+export declare function resolveExecutionSettings(settings?: ExecutionSettings): Required<ExecutionSettings>;

package/dist/config/execution.js

@@ -0,0 +1,13 @@
+export function resolveExecutionSettings(settings = {}) {
+    const count = (value, fallback, max, min = 1) => Number.isSafeInteger(value) && value >= min && value <= max ? value : fallback;
+    return {
+        shellPanePolicy: settings.shellPanePolicy === 'auto' ? 'auto' : 'on_request',
+        readConcurrency: count(settings.readConcurrency, 4, 32),
+        maxCallsPerResponse: count(settings.maxCallsPerResponse, 16, 256),
+        recovery: settings.recovery === 'pause' ? 'pause' : 'automatic',
+        repeatedFailureLimit: count(settings.repeatedFailureLimit, 3, 20),
+        recoveryAttempts: count(settings.recoveryAttempts, 1, 5, 0),
+        interruptBackgroundJobs: settings.interruptBackgroundJobs === true,
+        maxBackgroundJobs: count(settings.maxBackgroundJobs, 4, 32),
+    };
+}

package/dist/config/types.d.ts

@@ -326,6 +326,7 @@ export interface ZTCConfig {
     contextProgressBar?: ContextProgressBarSettings;
     /** Retry and timeout policy for LLM requests. */
     apiRetry?: ApiRetrySettings;
+    execution?: import('./execution.js').ExecutionSettings;
     /** Terminal transcript density and reasoning visibility. */
     messageDisplay?: MessageDisplaySettings;
     /** Context compaction strategy (summarize, or Jev delete-only). */

package/dist/config.d.ts

@@ -49,6 +49,7 @@ export declare class ConfigStore {
     getConfigWithoutEffortOverride(): ZTCConfig;
     private composeConfig;
     private cliOverridesWithoutEffort;
+    getMaxTokensSource(): string;
     getConfigScope(): ZTCConfigScope;
     setConfigScope(scope: ZTCConfigScope): void;
     clearSessionOverrides(): void;

package/dist/config.js

@@ -734,6 +734,11 @@ export class ConfigStore {
             ...(this.cliOverrides.model !== undefined ? { model: this.cliOverrides.model } : {}),
         };
     }
+    getMaxTokensSource() {
+        if (Object.prototype.hasOwnProperty.call(this.sessionOverrides, 'maxTokens'))
+            return 'session override';
+        return this.config.maxTokens === undefined ? 'provider default' : `saved profile (${this.getConfigPath()})`;
+    }
     getConfigScope() {
         return this.configScope;
     }

package/dist/emulation/tool_adapters.js

@@ -14,7 +14,7 @@ export function buildEmulationCompatibilityTools(emulationId, tools) {
             return;
         }
         existing.add(tool.definition.name);
-        adapters.push(tool);
+        adapters.push({ ...tool, parallelSafe: ['Read', 'Grep', 'LS'].includes(tool.definition.name) });
     };
     const factories = [];
     if (CLAUDE_PROFILE_IDS.has(emulationId)) {
@@ -286,7 +286,10 @@ async function callTool(tools, name, args, context) {
     if (!tool) {
         throw new Error(`Compatibility adapter target is unavailable: ${name}`);
     }
-    return tool.execute(args, context);
+    const output = await tool.execute(args, context);
+    if (tool.isErrorResult?.(output))
+        throw new Error(output);
+    return output;
 }
 async function executeCodexShell(tools, args, context) {
     const command = requiredString(args, ['cmd', 'command']);

package/dist/headless.d.ts

@@ -1,21 +1,3 @@
-/**
- * Headless Mode for ZTC
- *
- * Enables programmatic control of ZTC via stdin/stdout.
- * Useful for:
- * - Automated testing of modes (e.g., DCAIG)
- * - CI/CD pipelines
- * - Agent orchestration (outer agent driving ZTC)
- *
- * Headless shell mode:
- * - `ZTC_HEADLESS_SHELL_MODE=real` allows slash-command shell execution on the host
- * - `ZTC_HEADLESS_SHELL_MODE=stub` keeps shell calls inert and returns empty results
- * - default: `real`
- *
- * Usage:
- *   echo "build a JIRA connector" | ztc --headless --mode ~/dcaig/ztc/modes/dcaig.yaml
- *   echo '{"prompt": "...", "session_id": "..."}' | ztc --headless --json
- */
 import type { MessageAttachment } from './types.js';
 import type { CodexReasoningEffort } from './config/types.js';
 interface HeadlessOptions {
@@ -217,6 +199,7 @@ export declare class HeadlessApp {
     /**
      * Create the agent
      */
+    private commandJobsUnsubscribe;
     private createAgent;
     private bindAgentStore;
     private awaitAgentBind;

package/dist/headless.js

@@ -1,3 +1,4 @@
+import { shutdownCommandJobs, subscribeCommandJobs } from './agent/runtime/command_jobs.js';
 /**
  * Headless Mode for ZTC
  *
@@ -743,6 +744,10 @@ export class HeadlessApp {
                     // Always show errors
                     console.error(`${ts}[error] ${data.data.message}`);
                     break;
+                case 'command_jobs':
+                    if (!this.options.quiet || this.options.verbose)
+                        console.log(`${ts}[commands] ${JSON.stringify(data.data.jobs)}`);
+                    break;
                 case 'status':
                     // In quiet mode, skip status unless verbose
                     if (this.options.quiet && !this.options.verbose)
@@ -1412,7 +1417,13 @@ export class HeadlessApp {
     /**
      * Create the agent
      */
+    commandJobsUnsubscribe;
     createAgent() {
+        this.commandJobsUnsubscribe?.();
+        this.commandJobsUnsubscribe = subscribeCommandJobs(this.sessionId, jobs => {
+            this.output({ type: 'command_jobs', timestamp: new Date().toISOString(), data: { jobs } });
+            this.autoMirror?.publish({ type: 'command_jobs', data: { jobs } });
+        });
         const isEvolveMode = this.currentMode === 'evolved-swarm';
         const hookDispatcher = this.hookLifecycle.refresh();
         const agent = createAgentWithConfig({
@@ -1620,6 +1631,7 @@ export class HeadlessApp {
             },
             setDebug: () => { },
             getSessionId: () => this.sessionId,
+            getExecutionContext: () => this.agent?.getExecutionContext(),
             getSessionName: () => this.sessionName,
             setSessionName: (name) => {
                 this.sessionName = name && name.length > 0 ? name : undefined;
@@ -2335,6 +2347,9 @@ export class HeadlessApp {
      * Shut down background agents and batch orchestrator gracefully before exiting.
      */
     async shutdownBackgroundAgents() {
+        await shutdownCommandJobs(this.sessionId);
+        this.commandJobsUnsubscribe?.();
+        this.commandJobsUnsubscribe = undefined;
         if (this.batchEventUnsub) {
             this.batchEventUnsub();
             this.batchEventUnsub = null;

package/dist/plugin/runtime.d.ts

@@ -3,7 +3,7 @@ export type { EmbeddedRuntimeFactory, ZtcPluginContext, ZtcMuxStartContext, ZtcM
 export type { EmbeddedRuntimeContext, EmbeddedRuntimeSession, } from '../embedded/runtime.js';
 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 { MirrorViewState, ViewPlugin, ViewPluginContext } from '../web/view_plugin.js';
+export type { CommandJobView, MirrorViewState, ViewPlugin, ViewPluginContext } from '../web/view_plugin.js';
 export type { MirrorEvent, MirrorPaneRecord } from '../web/mirror_stream.js';
 export { COLONY_WORKTREE_MARKER, generateSessionId, getMuxStatePathForCwd, getSessionDirForCwd, getSessionPathForCwd, loadSessionById, saveSession, } from '../session.js';
 export type { PaneCommandTransport } from '../ui/ratatui/pane_relay.js';

package/dist/types.d.ts

@@ -152,6 +152,9 @@ export interface ToolDefinition {
     overlapsProviderHarness?: boolean;
 }
 export type AgentEvent = {
+    type: 'history_checkpoint';
+    messages: Message[];
+} | {
     type: 'thinking_start';
 } | {
     type: 'tool_start';

package/dist/ui/ratatui/headless_pane_manager.d.ts

@@ -1,16 +1,3 @@
-/**
- * HeadlessPaneManager — manages child processes for headless mux mode.
- *
- * Implements PaneCommandTransport so pane tools work identically to zmux mode,
- * but spawns/manages child processes directly via Node.js instead of going
- * through the zmux Rust binary.
- *
- * Interactive terminal panes (shell, run-command) get a REAL PTY via node-pty
- * when it's installed (prompt/echo/line-editing, vim/less/top, colors). ZTC and
- * colony panes use piped child_process stdio (they speak the JSON-line pane
- * protocol, not a terminal). If node-pty isn't available (e.g. a CI box with no
- * native build), terminal panes fall back to the old piped-stdio behavior.
- */
 import type { RustCommand } from './protocol.js';
 import type { PaneCommandTransport, PaneEventHandler } from './pane_relay.js';
 export declare function isZtcPaneType(paneType: string): boolean;
@@ -59,12 +46,8 @@ export declare class HeadlessPaneManager implements PaneCommandTransport {
     on(handler: PaneEventHandler): () => void;
     private emit;
     send(cmd: RustCommand): boolean;
-    /**
-     * Capability shim. Headless mode never spawns a real binary, so it
-     * advertises no capabilities. Callers gating on `hasCapability(...)`
-     * correctly fall back to the legacy path.
-     */
-    hasCapability(_name: string): boolean;
+    /** Headless implements correlated pane reads and delivery receipts itself. */
+    hasCapability(name: string): boolean;
     /**
      * Headless mode has no native renderer to read the clipboard, so image
      * pastes are unavailable (mirror clients attach images over HTTP instead).

package/dist/ui/ratatui/headless_pane_manager.js

@@ -1,3 +1,5 @@
+import { stripPasteMarkers } from './pane_input.js';
+import { CAPABILITY_PANE_DELIVERY_ACK } from './protocol.js';
 /**
  * HeadlessPaneManager — manages child processes for headless mux mode.
  *
@@ -245,13 +247,9 @@ export class HeadlessPaneManager {
                 return true;
         }
     }
-    /**
-     * Capability shim. Headless mode never spawns a real binary, so it
-     * advertises no capabilities. Callers gating on `hasCapability(...)`
-     * correctly fall back to the legacy path.
-     */
-    hasCapability(_name) {
-        return false;
+    /** Headless implements correlated pane reads and delivery receipts itself. */
+    hasCapability(name) {
+        return name === CAPABILITY_PANE_DELIVERY_ACK;
     }
     /**
      * Headless mode has no native renderer to read the clipboard, so image
@@ -355,6 +353,16 @@ export class HeadlessPaneManager {
             launch: { command: cmd.command, args, cwd, requestId: cmd.request_id },
         };
         const appendOutput = (text) => {
+            const modeText = (pane.terminalModeTail ?? '') + text;
+            for (const match of modeText.matchAll(/\x1b(?:\[\?([0-9;]+)([hl])|\[!p|c)/g)) {
+                if (!match[1])
+                    pane.bracketedPaste = false;
+                else if (match[1].split(';').includes('2004'))
+                    pane.bracketedPaste = match[2] === 'h';
+            }
+            // Retain only an unfinished escape sequence, never replay a completed mode.
+            const tail = modeText.slice(modeText.lastIndexOf('\x1b'));
+            pane.terminalModeTail = tail.length <= 256 && /^\x1b(?:\[(?:\?[0-9;]*|!)?)?$/.test(tail) ? tail : '';
             const lines = text.split('\n');
             for (const line of lines) {
                 pane.outputBuffer.push(line);
@@ -598,13 +606,14 @@ export class HeadlessPaneManager {
         const pane = this.panes.get(cmd.pane_id) ?? this.closedPanes.get(cmd.pane_id);
         if (!pane) {
             // Return a deterministic read event so callers don't hang on timeout.
-            this.emit({ type: 'pane_read', pane_id: cmd.pane_id, content: '', viewport: cmd.viewport ? true : undefined });
+            this.emit({ type: 'pane_read', request_id: cmd.request_id, error: `Pane ${cmd.pane_id} not found`, pane_id: cmd.pane_id, content: '', viewport: cmd.viewport ? true : undefined });
             return true;
         }
-        const lines = cmd.lines ?? MAX_BUFFER_LINES;
+        const lines = Math.min(cmd.lines ?? 200, 2000);
         const content = pane.outputBuffer.slice(-lines).join('\n');
         this.emit({
             type: 'pane_read',
+            request_id: cmd.request_id,
             pane_id: cmd.pane_id,
             content,
             viewport: cmd.viewport ? true : undefined,
@@ -628,37 +637,34 @@ export class HeadlessPaneManager {
     }
     handleWritePane(cmd) {
         const pane = this.panes.get(cmd.pane_id);
-        if (!pane || !pane.isAlive || (!pane.process && !pane.pty)) {
-            this.emit({
-                type: 'error',
-                message: `Pane ${cmd.pane_id} not found or not alive`,
-            });
+        const acknowledge = (error, queued = false, bytes) => this.emit({ type: 'pane_write_result',
+            request_id: cmd.request_id, pane_id: cmd.pane_id, delivered: !error && !queued, queued,
+            ...(bytes === undefined ? {} : { total_bytes: bytes, ...(queued ? {} : { delivered_bytes: error ? 0 : bytes, partial: false }) }),
+            ...(error ? { error } : {}) });
+        if (!pane || !pane.isAlive || pane.closing || (!pane.process && !pane.pty)) {
+            acknowledge(`Pane ${cmd.pane_id} not found or not alive`);
             return true;
         }
         try {
-            // PTY panes: write raw keystrokes (xterm sends \r and control codes itself);
-            // the PTY handles echo/line-discipline. Do NOT append \n.
             if (pane.pty) {
-                pane.pty.write(cmd.input);
+                const text = cmd.input.replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\n+$/, '');
+                const payload = cmd.control ? cmd.input.replace(/[\r\n]+$/, '') + '\r'
+                    : cmd.submit ? (pane.bracketedPaste ? `\x1b[200~${stripPasteMarkers(text)}\x1b[201~\r` : text.replace(/\n/g, '\r') + '\r') : cmd.input;
+                pane.pty.write(payload);
+                acknowledge(undefined, payload.length > 0, Buffer.byteLength(payload));
                 return true;
             }
-            // Control commands ({"__ztc_cmd":...}) are written BARE (one \n-terminated
-            // line, no prompt envelope) so the child's classifier sees them on the
-            // control channel. User input to a ZTC pane is wrapped via encodeZtcPaneInput
-            // as {"type":"prompt","text":...} — that envelope means "verbatim user
-            // prompt", so its text is never re-interpreted as a control command (a user
-            // whose message IS a __ztc_cmd JSON string still reaches the LLM). Other pane
-            // types receive the text as-is. Either way the trailing \n is the readline
-            // line delimiter on the child (ZTC-18).
-            const payload = cmd.control
-                ? (cmd.input.endsWith('\n') ? cmd.input : cmd.input + '\n')
-                : isZtcPaneType(pane.paneType)
-                    ? encodeZtcPaneInput(cmd.input)
-                    : (cmd.input.endsWith('\n') ? cmd.input : cmd.input + '\n');
-            pane.process?.stdin?.write(payload);
-        }
-        catch {
-            // Process stdin may be closed
+            const stdin = pane.process?.stdin;
+            if (!stdin || stdin.destroyed || !stdin.writable)
+                throw new Error('Pane input stream is closed');
+            // ZTC child prompts and control lines retain their separate JSON protocol.
+            const payload = cmd.control ? cmd.input.replace(/\n+$/, '') + '\n'
+                : isZtcPaneType(pane.paneType) ? encodeZtcPaneInput(cmd.input)
+                    : cmd.submit ? cmd.input.replace(/\r\n/g, '\n').replace(/\r/g, '\n').replace(/\n+$/, '') + '\n' : cmd.input;
+            stdin.write(payload, error => acknowledge(error?.message, false, Buffer.byteLength(payload)));
+        }
+        catch (error) {
+            acknowledge(error.message);
         }
         return true;
     }
@@ -737,6 +743,7 @@ export class HeadlessPaneManager {
         }
         if (pane.isAlive && (pane.process || pane.pty)) {
             try {
+                pane.closing = true;
                 this.killPaneProc(pane, 'SIGTERM');
             }
             catch {

package/dist/ui/ratatui/pane_input.d.ts

@@ -0,0 +1,4 @@
+/** Remove paste delimiters, including ones revealed by removing an inner marker.
+ * A stack bounds work to O(n) even for deeply nested input.
+ */
+export declare function stripPasteMarkers(text: string): string;

package/dist/ui/ratatui/pane_input.js

@@ -0,0 +1,15 @@
+/** Remove paste delimiters, including ones revealed by removing an inner marker.
+ * A stack bounds work to O(n) even for deeply nested input.
+ */
+export function stripPasteMarkers(text) {
+    const body = [];
+    for (const character of text) {
+        body.push(character);
+        if (character === '~' && body.length >= 6) {
+            const suffix = body.slice(-6).join('');
+            if (suffix === '\x1b[200~' || suffix === '\x1b[201~')
+                body.length -= 6;
+        }
+    }
+    return body.join('');
+}

package/dist/ui/ratatui/pane_relay.d.ts

@@ -15,6 +15,7 @@ export interface PaneCommandTransport {
     send(cmd: RustCommand): boolean;
     on(handler: PaneEventHandler): () => void;
     readonly isMuxMode: boolean;
+    hasCapability?(name: string): boolean;
 }
 export declare class PaneRelayServer {
     private transport;
@@ -35,6 +36,7 @@ export declare class PaneRelayClient implements PaneCommandTransport {
     private readline;
     private handlers;
     private ready;
+    private capabilities;
     private socketPath;
     constructor(socketPath: string);
     /** Connect to the parent's relay socket */
@@ -44,6 +46,7 @@ export declare class PaneRelayClient implements PaneCommandTransport {
     send(cmd: RustCommand): boolean;
     /** Subscribe to pane events from the parent */
     on(handler: PaneEventHandler): () => void;
+    hasCapability(name: string): boolean;
     /** Child has pane capabilities via relay */
     get isMuxMode(): boolean;
     /** Disconnect from the relay */

package/dist/ui/ratatui/pane_relay.js

@@ -12,7 +12,7 @@
 import { createServer, createConnection } from 'net';
 import { createInterface } from 'readline';
 import { unlinkSync } from 'fs';
-import { serializeCommand, parseEvent } from './protocol.js';
+import { serializeCommand, parseEvent, CAPABILITY_PANE_DELIVERY_ACK } from './protocol.js';
 import { generateIpcPath, isNamedPipePath } from './ipc_path.js';
 // ============================================================================
 // PaneRelayServer — runs in parent ZTC (--mux mode)
@@ -22,6 +22,7 @@ const PANE_EVENT_TYPES = new Set([
     'pane_created',
     'pane_closed',
     'pane_read',
+    'pane_write_result',
     'pane_list',
     'pane_state',
     'pane_output',
@@ -47,6 +48,9 @@ export class PaneRelayServer {
         });
         this.server = createServer((client) => {
             this.clients.add(client);
+            client.write(JSON.stringify({ type: 'ready', version: 'pane-relay', cols: 0, rows: 0,
+                capabilities: this.transport.hasCapability?.(CAPABILITY_PANE_DELIVERY_ACK) ? [CAPABILITY_PANE_DELIVERY_ACK] : [],
+            }) + '\n');
             const rl = createInterface({ input: client, crlfDelay: Infinity });
             rl.on('line', (line) => {
                 const parsed = parseEvent(line);
@@ -125,6 +129,7 @@ export class PaneRelayClient {
     readline = null;
     handlers = new Set();
     ready = false;
+    capabilities = new Set();
     socketPath;
     constructor(socketPath) {
         this.socketPath = socketPath;
@@ -140,7 +145,16 @@ export class PaneRelayClient {
                 this.socket = createConnection(this.socketPath, () => {
                     this.ready = true;
                     this.setupHandlers();
-                    resolve();
+                    // New parents advertise transport capabilities. Old parents have no
+                    // handshake, so retain their unconfirmed-delivery path after a short grace.
+                    const timer = setTimeout(() => { unsubscribe(); resolve(); }, 100);
+                    const unsubscribe = this.on(event => {
+                        if (event.type === 'ready') {
+                            clearTimeout(timer);
+                            unsubscribe();
+                            resolve();
+                        }
+                    });
                 });
                 this.socket.on('error', (err) => {
                     if (attempts < maxAttempts && err.code === 'ENOENT') {
@@ -167,6 +181,8 @@ export class PaneRelayClient {
             const event = parseEvent(line);
             if (!event)
                 return;
+            if (event.type === 'ready')
+                this.capabilities = new Set(event.capabilities ?? []);
             for (const handler of this.handlers) {
                 try {
                     handler(event);
@@ -201,6 +217,7 @@ export class PaneRelayClient {
         this.handlers.add(handler);
         return () => { this.handlers.delete(handler); };
     }
+    hasCapability(name) { return this.capabilities.has(name); }
     /** Child has pane capabilities via relay */
     get isMuxMode() {
         return this.ready;
@@ -211,6 +228,7 @@ export class PaneRelayClient {
         this.cleanup();
     }
     cleanup() {
+        this.capabilities.clear();
         if (this.readline) {
             this.readline.close();
             this.readline = null;