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

package/dist/ui/ratatui/headless_pane_manager.js

@@ -1,3 +1,4 @@
+import { displayPaneTitle, replacePaneLabels } from '../../panes/labels.js';
 import { stripPasteMarkers } from './pane_input.js';
 import { CAPABILITY_PANE_DELIVERY_ACK } from './protocol.js';
 /**
@@ -14,11 +15,12 @@ import { CAPABILITY_PANE_DELIVERY_ACK } from './protocol.js';
  * native build), terminal panes fall back to the old piped-stdio behavior.
  */
 import { spawn } from 'child_process';
-import { accessSync, chmodSync, existsSync } from 'fs';
-import { dirname, join } from 'path';
+import { accessSync, chmodSync, constants, existsSync, statSync } from 'fs';
+import { delimiter, dirname, isAbsolute, join, resolve } from 'path';
 import { createRequire } from 'module';
-import { isMuxPaneRestorable, resolveMuxPersistenceOptions, sanitizeMuxSessionState, shouldPersistMuxPaneType } from './mux_persistence.js';
-import { buildUserSubprocessEnv } from '../../utils/subprocess_env.js';
+import { isMuxPaneRestorable, resolveMuxPersistenceOptions, sanitizeMuxSessionState, validateWorkspaceState } from './mux_persistence.js';
+import { buildUserSubprocessEnv, removeUserSubprocessCredentials } from '../../utils/subprocess_env.js';
+import { handleWorkspaceLayout } from '../../workspace_layout.js';
 let _ptyMod;
 function loadPty() {
     if (_ptyMod !== undefined)
@@ -56,6 +58,32 @@ function isTerminalPaneType(paneType) {
     return paneType === 'process' || paneType === 'command';
 }
 const MAX_BUFFER_LINES = 200;
+function restoredPaneStatus(pane) {
+    if (pane.cwd !== undefined) {
+        try {
+            if (!statSync(pane.cwd).isDirectory())
+                return 'missing_directory';
+        }
+        catch {
+            return 'missing_directory';
+        }
+    }
+    if (!pane.command)
+        return 'missing_command';
+    const candidates = isAbsolute(pane.command) || /[/\\]/.test(pane.command)
+        ? [isAbsolute(pane.command) ? pane.command : resolve(pane.cwd ?? process.cwd(), pane.command)]
+        : (process.env.PATH ?? '').split(delimiter).filter(Boolean).map(directory => join(directory, pane.command));
+    for (const candidate of candidates) {
+        try {
+            if (!statSync(candidate).isFile())
+                continue;
+            accessSync(candidate, process.platform === 'win32' ? constants.F_OK : constants.X_OK);
+            return 'not_started';
+        }
+        catch { /* A missing executable is retained as inactive intent. */ }
+    }
+    return 'missing_command';
+}
 // ZTC child panes (--pane / colony) run as headless paneChild processes that
 // read ONE JSON object per stdin line and recover the full (possibly
 // multi-line) prompt via JSON.parse (headless.ts paneChild / --json branches).
@@ -77,16 +105,18 @@ export function encodeZtcPaneInput(input) {
  * buildUserSubprocessEnv so nested user processes don't inherit the parent's
  * control plane. Callers that DO need specific infra vars in a child (e.g.
  * sim agent panes attaching to the message bus) must pass them explicitly via
- * `commandEnv` — those are merged last and survive the stripping.
+ * `commandEnv` — those are merged last. Host RPC credentials are still removed
+ * from user process panes after the merge.
  */
 export function computePaneSpawnEnv(paneType, paneId, options = {}, source = process.env) {
-    return {
+    const env = {
         ...(paneType === 'colony_ztc' ? source : buildUserSubprocessEnv(source)),
         ...(paneType === 'colony_ztc' ? {} : { ZTC_HEADLESS_MUX: '1' }),
         ZTC_PANE_ID: String(paneId),
         ...(options.persona ? { ZTC_SIM_PERSONA: options.persona } : {}),
         ...(options.commandEnv ?? {}),
     };
+    return paneType === 'colony_ztc' ? env : removeUserSubprocessCredentials(env);
 }
 /**
  * Inverse of encodeZtcPaneInput: recover the original input from a stdin line a
@@ -157,25 +187,40 @@ export class HeadlessPaneManager {
     closedPanes = new Map();
     nextPaneId;
     handlers = new Set();
-    hostTitle = 'ZTC';
+    hostTitle = 'Main';
     hostActivity = {};
     layout = { type: 'leaf', pane_id: 0 };
-    constructor(options) {
-        this.nextPaneId = options?.startPaneId ?? 1;
-        // Safety net: force-kill all children when this process exits.
-        // Runs synchronously — works for normal exit, SIGTERM, uncaught exceptions.
-        // SIGKILL cannot be caught, but the OS will clean up child processes if
-        // they're in the same process group (default for spawn with shell: true).
-        process.on('exit', () => {
-            for (const pane of this.panes.values()) {
-                if (pane.isAlive && (pane.process || pane.pty)) {
-                    try {
-                        this.killPaneProc(pane, 'SIGTERM');
-                    }
-                    catch { /* ignore */ }
+    workspaceMetadata = {
+        schema_version: 1,
+        focused_pane_id: 0,
+        geometry: { cols: 120, rows: 40 },
+    };
+    hostLabels = {};
+    exitSubscribed = false;
+    exitHandler = () => {
+        for (const pane of this.panes.values()) {
+            if (pane.isAlive && (pane.process || pane.pty)) {
+                try {
+                    this.killPaneProc(pane, 'SIGTERM');
                 }
+                catch { /* ignore */ }
             }
-        });
+        }
+    };
+    constructor(options) {
+        this.nextPaneId = options?.startPaneId ?? 1;
+        // Synchronous safety net for normal process exit; stopped owners release it.
+        this.subscribeToExit();
+    }
+    subscribeToExit() {
+        if (this.exitSubscribed)
+            return;
+        process.on('exit', this.exitHandler);
+        this.exitSubscribed = true;
+    }
+    unsubscribeFromExit() {
+        process.off('exit', this.exitHandler);
+        this.exitSubscribed = false;
     }
     /** Set the display title for pane 0 (the host ZTC process). */
     setHostTitle(title) {
@@ -217,6 +262,8 @@ export class HeadlessPaneManager {
                 return this.handleCreateDocPane(cmd);
             case 'replace_pane':
                 return this.handleReplacePane(cmd);
+            case 'restart_pane':
+                return this.handleRestartPane(cmd);
             case 'read_pane':
                 return this.handleReadPane(cmd);
             case 'write_pane':
@@ -229,6 +276,16 @@ export class HeadlessPaneManager {
                 return this.handleSetPaneContent(cmd);
             case 'close_pane':
                 return this.handleClosePane(cmd);
+            case 'set_pane_labels':
+                if (cmd.pane_id === 0)
+                    this.hostLabels = replacePaneLabels(this.hostLabels, cmd.labels, cmd.if_newer);
+                else {
+                    const pane = this.panes.get(cmd.pane_id);
+                    if (pane)
+                        pane.labels = replacePaneLabels(pane.labels ?? {}, cmd.labels, cmd.if_newer);
+                }
+                this.publishPaneLabels();
+                return true;
             case 'set_pane_title':
                 return this.handleSetPaneTitle(cmd);
             case 'set_pane_activity':
@@ -237,8 +294,14 @@ export class HeadlessPaneManager {
                 return this.handleListPanes();
             case 'get_session_state':
                 return this.handleGetSessionState();
+            case 'get_terminal_metrics':
+                this.emit({ type: 'error', message: 'terminal frame metrics require the native desktop renderer' });
+                return true;
             case 'restore_session_state':
-                return this.handleRestoreSessionState(cmd);
+                this.handleRestoreSessionState(cmd);
+                return true;
+            case 'workspace_layout':
+                return this.handleNamedWorkspaceLayout(cmd);
             case 'resize_fence':
                 this.emit({ type: 'resize_ack', seq: cmd.seq });
                 return true;
@@ -249,7 +312,7 @@ export class HeadlessPaneManager {
     }
     /** Headless implements correlated pane reads and delivery receipts itself. */
     hasCapability(name) {
-        return name === CAPABILITY_PANE_DELIVERY_ACK;
+        return name === CAPABILITY_PANE_DELIVERY_ACK || name === 'inactive_workspace_restore' || name === 'pane_labels_v1';
     }
     /**
      * Headless mode has no native renderer to read the clipboard, so image
@@ -258,10 +321,14 @@ export class HeadlessPaneManager {
     readClipboardImage() {
         return Promise.resolve(null);
     }
+    readClipboardText() {
+        return Promise.resolve(null);
+    }
     isReady() {
         return true;
     }
     async start(_options) {
+        this.subscribeToExit();
         return { cols: 120, rows: 40 };
     }
     async stop() {
@@ -289,6 +356,7 @@ export class HeadlessPaneManager {
         }
         this.panes.clear();
         this.closedPanes.clear();
+        this.unsubscribeFromExit();
     }
     kill() {
         for (const pane of this.panes.values()) {
@@ -303,6 +371,7 @@ export class HeadlessPaneManager {
         }
         this.panes.clear();
         this.closedPanes.clear();
+        this.unsubscribeFromExit();
     }
     // --------------------------------------------------------------------------
     // Command handlers
@@ -312,11 +381,25 @@ export class HeadlessPaneManager {
         const dir = direction || 'horizontal';
         const r = ratio ?? 0.5;
         this.layout = splitLayoutNode(this.layout, targetId, paneId, dir, r);
+        const window = this.workspaceMetadata.windows?.find(window => window.id === this.workspaceMetadata.active_window_id);
+        if (window)
+            window.layout = this.layout;
     }
     removePaneFromLayout(paneId) {
         const updated = removeLayoutNode(this.layout, paneId);
-        if (updated)
-            this.layout = updated;
+        this.layout = updated ?? { type: 'leaf', pane_id: 0 };
+        for (const window of this.workspaceMetadata.windows ?? []) {
+            window.layout = removeLayoutNode(window.layout, paneId) ?? { type: 'leaf', pane_id: 0 };
+            if (window.focused_pane_id === paneId)
+                window.focused_pane_id = findFirstLeafId(window.layout);
+            if (window.zoomed_pane_id === paneId)
+                delete window.zoomed_pane_id;
+        }
+        if (this.workspaceMetadata.focused_pane_id === paneId) {
+            this.workspaceMetadata.focused_pane_id = findFirstLeafId(this.layout);
+        }
+        if (this.workspaceMetadata.zoomed_pane_id === paneId)
+            delete this.workspaceMetadata.zoomed_pane_id;
     }
     reservePaneId(paneId) {
         const id = paneId ?? this.nextPaneId;
@@ -329,12 +412,14 @@ export class HeadlessPaneManager {
         return id;
     }
     handleCreatePane(cmd, options) {
+        // Direct transport callers may create panes without an explicit start().
+        this.subscribeToExit();
         const id = this.reservePaneId(options?.paneId);
         const title = cmd.title || cmd.command;
         const args = cmd.args || [];
         const cwd = cmd.cwd || process.cwd();
         // Detect whether this is a ZTC child or a generic process
-        const isZtc = args.some(a => /cli_(main|ratatui)\.(js|ts)$/.test(a)) && args.includes('--pane');
+        const isZtc = (args[0] === '--ztc-cli' || args.some(a => /cli_(main|ratatui)\.(js|ts)$/.test(a))) && args.includes('--pane');
         const paneType = cmd.pane_type || (isZtc ? 'ztc' : 'process');
         const groupId = cmd.env?.ZTC_MIRROR_GROUP || '';
         // Reuse the shared env builder (dev's computePaneSpawnEnv) — behaviourally
@@ -350,6 +435,7 @@ export class HeadlessPaneManager {
             paneType,
             outputBuffer: [],
             isAlive: true,
+            windowId: this.workspaceMetadata.active_window_id,
             launch: { command: cmd.command, args, cwd, requestId: cmd.request_id },
         };
         const appendOutput = (text) => {
@@ -440,7 +526,7 @@ export class HeadlessPaneManager {
                     cwd,
                     stdio: ['pipe', 'pipe', 'pipe'],
                     env: childEnv,
-                    shell: paneType !== 'colony_ztc',
+                    shell: !isZtcPaneType(paneType),
                 });
             }
             catch {
@@ -481,6 +567,7 @@ export class HeadlessPaneManager {
             paneType: 'feed',
             outputBuffer: [...(cmd.lines || [])],
             isAlive: true,
+            windowId: this.workspaceMetadata.active_window_id,
             launch: { content: (cmd.lines || []).join('\n') },
         };
         this.panes.set(id, pane);
@@ -504,6 +591,7 @@ export class HeadlessPaneManager {
             paneType: 'doc',
             outputBuffer: splitDocContent(cmd.content || ''),
             isAlive: true,
+            windowId: this.workspaceMetadata.active_window_id,
             launch: { content: cmd.content || '' },
         };
         this.panes.set(id, pane);
@@ -548,7 +636,7 @@ export class HeadlessPaneManager {
                 cwd,
                 stdio: ['pipe', 'pipe', 'pipe'],
                 env: computePaneSpawnEnv(paneType, cmd.pane_id),
-                shell: paneType !== 'colony_ztc',
+                shell: !isZtcPaneType(paneType),
             });
             const nextPane = {
                 id: cmd.pane_id,
@@ -602,6 +690,40 @@ export class HeadlessPaneManager {
         }
         return true;
     }
+    handleRestartPane(cmd) {
+        const pane = this.panes.get(cmd.pane_id);
+        if (!pane) {
+            this.emit({ type: 'error', message: `Pane ${cmd.pane_id} not found; no saved intent was started.` });
+            return true;
+        }
+        if (isZtcPaneType(pane.paneType) || pane.agentSession) {
+            this.emit({ type: 'error', message: `Pane ${cmd.pane_id} is an agent session. Resume its exact saved session through the owning ZTC session controls.` });
+            return true;
+        }
+        if (pane.isAlive || !isTerminalPaneType(pane.paneType)) {
+            this.emit({ type: 'error', message: `Pane ${cmd.pane_id} is not an inactive process; close its current task before relaunching.` });
+            return true;
+        }
+        const launch = pane.launch;
+        if (!launch?.cwd) {
+            this.emit({ type: 'error', message: `Pane ${cmd.pane_id} has no saved working directory; choose an explicit working directory before relaunching.` });
+            return true;
+        }
+        const status = restoredPaneStatus({ id: pane.id, title: pane.title, pane_type: pane.paneType,
+            command: launch.command, args: launch.args, cwd: launch.cwd });
+        if (status !== 'not_started' || !launch.command) {
+            const reason = status === 'missing_directory' ? 'Saved working directory is missing or unavailable'
+                : 'Saved command is missing or unavailable';
+            this.emit({ type: 'error', message: `Pane ${cmd.pane_id}: ${reason}; saved intent was preserved.` });
+            return true;
+        }
+        const created = this.handleCreatePane({ type: 'create_pane', command: launch.command,
+            args: launch.args, cwd: launch.cwd, title: pane.title, pane_type: pane.paneType }, { paneId: pane.id });
+        const nextPane = this.panes.get(pane.id);
+        if (nextPane)
+            nextPane.windowId = pane.windowId;
+        return created;
+    }
     handleReadPane(cmd) {
         const pane = this.panes.get(cmd.pane_id) ?? this.closedPanes.get(cmd.pane_id);
         if (!pane) {
@@ -711,6 +833,10 @@ export class HeadlessPaneManager {
             });
             return true;
         }
+        if (pane.agentSession && !pane.isAlive) {
+            this.emit({ type: 'error', message: `Pane ${cmd.pane_id}: explicit Resume is required before changing saved agent content` });
+            return true;
+        }
         pane.outputBuffer.push(...cmd.lines);
         const trim = cmd.trim ?? MAX_BUFFER_LINES;
         if (pane.outputBuffer.length > trim) {
@@ -727,13 +853,23 @@ export class HeadlessPaneManager {
             });
             return true;
         }
+        if (pane.agentSession && !pane.isAlive) {
+            this.emit({ type: 'error', message: `Pane ${cmd.pane_id}: explicit Resume is required before changing saved agent content` });
+            return true;
+        }
         pane.outputBuffer = splitDocContent(cmd.content);
+        if (pane.launch)
+            pane.launch.content = cmd.content;
         // Publish content update to mirror so the web view stays in sync
         this.emit({ type: 'pane_output', pane_id: cmd.pane_id, content: cmd.content });
         return true;
     }
     handleClosePane(cmd) {
         const pane = this.panes.get(cmd.pane_id);
+        if (pane?.labels?.pinned) {
+            this.emit({ type: 'error', message: `Pane ${cmd.pane_id} is pinned. Unpin it with /label pane ${cmd.pane_id} unpin before closing.` });
+            return true;
+        }
         if (!pane) {
             this.emit({
                 type: 'error',
@@ -775,13 +911,21 @@ export class HeadlessPaneManager {
     }
     handleSetPaneTitle(cmd) {
         if (cmd.pane_id === 0) {
-            this.hostTitle = cmd.title;
+            if (cmd.source === 'inferred')
+                this.hostTitle = cmd.title;
+            else
+                this.hostLabels = replacePaneLabels(this.hostLabels, { ...this.hostLabels, manual_title: cmd.title });
+            this.publishPaneLabels();
             return true;
         }
         const pane = this.panes.get(cmd.pane_id);
         if (pane) {
-            pane.title = cmd.title;
+            if (cmd.source === 'inferred')
+                pane.title = cmd.title;
+            else
+                pane.labels = replacePaneLabels(pane.labels ?? {}, { ...pane.labels, manual_title: cmd.title });
         }
+        this.publishPaneLabels();
         return true;
     }
     handleSetPaneActivity(cmd) {
@@ -802,48 +946,97 @@ export class HeadlessPaneManager {
         }
         return true;
     }
-    handleGetSessionState() {
+    buildSessionState() {
         const persistenceOptions = resolveMuxPersistenceOptions();
         const panes = [];
         for (const pane of this.panes.values()) {
-            if (!shouldPersistMuxPaneType(pane.paneType, persistenceOptions))
+            if (!isMuxPaneRestorable({ id: pane.id, pane_type: pane.paneType,
+                agent_session: pane.agentSession }, persistenceOptions))
                 continue;
             panes.push({
                 id: pane.id,
-                title: pane.title,
+                title: displayPaneTitle(pane.title, pane.labels),
+                inferred_title: pane.title,
+                labels: { ...pane.labels },
                 pane_type: pane.paneType,
                 command: pane.launch?.command,
                 args: pane.launch?.args,
                 cwd: pane.launch?.cwd,
-                content: pane.paneType === 'doc'
+                ...(pane.agentSession ? { agent_session: structuredClone(pane.agentSession) } : {}),
+                ...(pane.restorationStatus ? { restoration_status: pane.restorationStatus } : {}),
+                ...(pane.windowId === undefined ? {} : { window_id: pane.windowId }),
+                content: pane.restorationStatus || pane.paneType === 'doc'
                     ? pane.launch?.content
                     : pane.outputBuffer.length > 0
                         ? pane.outputBuffer.join('\n')
                         : undefined,
             });
         }
-        const state = sanitizeMuxSessionState({
-            focused_pane_id: 0,
-            layout: this.layout,
+        return sanitizeMuxSessionState({
+            ...structuredClone(this.workspaceMetadata),
+            layout: structuredClone(this.layout),
             panes,
         }, persistenceOptions);
+    }
+    handleGetSessionState() {
         this.emit({
             type: 'session_state',
-            state,
+            state: this.buildSessionState(),
         });
         return true;
     }
+    handleNamedWorkspaceLayout(cmd) {
+        let result;
+        try {
+            result = handleWorkspaceLayout(cmd, cmd.action === 'save' && cmd.state === undefined
+                ? this.buildSessionState() : undefined);
+            if (result.ok && cmd.action === 'restore' && result.state
+                && !this.handleRestoreSessionState({ type: 'restore_session_state', state: result.state })) {
+                result.ok = false;
+                result.message = 'Workspace restore was not admitted; close live child tasks before restoring.';
+                delete result.state;
+            }
+        }
+        catch (error) {
+            result = { type: 'workspace_layout_result', request_id: cmd.request_id, action: cmd.action,
+                ok: false, names: [], message: error instanceof Error ? error.message : String(error) };
+        }
+        this.emit(result);
+        return true;
+    }
     handleRestoreSessionState(cmd) {
         const persistenceOptions = resolveMuxPersistenceOptions();
-        const state = sanitizeMuxSessionState(cmd.state, persistenceOptions);
+        let state;
+        try {
+            validateWorkspaceState(cmd.state);
+            state = sanitizeMuxSessionState(structuredClone(cmd.state), persistenceOptions);
+        }
+        catch {
+            this.emit({ type: 'error', message: 'Workspace restore state is invalid; current panes were preserved.' });
+            this.emit({ type: 'session_restored', restored_panes: 0, skipped_panes: 0 });
+            return false;
+        }
         let restored = 0;
         let skipped = 0;
-        const restoredProcessPaneIds = [];
         // Guard against malformed state — emit empty restore and bail
         if (!state || !Array.isArray(state.panes)) {
             this.emit({ type: 'session_restored', restored_panes: 0, skipped_panes: 0 });
-            return true;
+            return false;
         }
+        if ([...this.panes.values()].some(pane => pane.isAlive && (pane.process || pane.pty))) {
+            this.emit({ type: 'error', message: 'Workspace restore refused while a child process is live; close its current task first.' });
+            this.emit({ type: 'session_restored', restored_panes: 0, skipped_panes: state.panes.length });
+            return false;
+        }
+        // Only inactive intent and content panes remain here. Preserve the host
+        // process (pane zero) and replace the old saved workspace as one operation.
+        for (const pane of this.panes.values()) {
+            this.emit({ type: 'pane_closed', pane_id: pane.id, exit_code: pane.exitCode });
+        }
+        this.panes.clear();
+        const { panes: _panes, layout: _layout, ...metadata } = state;
+        this.workspaceMetadata = { ...metadata, schema_version: metadata.schema_version ?? 1,
+            geometry: metadata.geometry ?? { cols: 120, rows: 40 } };
         // Restore the saved layout tree so pane arrangement is preserved.
         // Individual create calls below use paneId option which skips layout insertion.
         if (state.layout) {
@@ -855,81 +1048,68 @@ export class HeadlessPaneManager {
                     skipped++;
                     continue;
                 }
-                if (paneState.pane_type === 'doc' && paneState.content !== undefined) {
+                if (paneState.pane_type === 'doc' && !paneState.agent_session) {
                     this.handleCreateDocPane({
                         type: 'create_doc_pane',
-                        title: paneState.title,
-                        content: paneState.content,
+                        title: paneState.inferred_title ?? paneState.title,
+                        content: paneState.content ?? '',
                     }, { paneId: paneState.id });
                     restored++;
                 }
-                else if (paneState.pane_type === 'feed') {
+                else if (paneState.pane_type === 'feed' && !paneState.agent_session) {
                     const lines = paneState.content ? paneState.content.split('\n') : [];
                     this.handleCreateFeedPane({
                         type: 'create_feed_pane',
-                        title: paneState.title,
+                        title: paneState.inferred_title ?? paneState.title,
                         lines,
                     }, { paneId: paneState.id });
                     restored++;
                 }
-                else if (paneState.command) {
-                    // Validate cwd exists before spawning — stale worktree paths cause immediate failure
-                    let cwd = paneState.cwd;
-                    if (cwd) {
-                        try {
-                            accessSync(cwd);
-                        }
-                        catch {
-                            cwd = process.cwd();
-                        }
-                    }
-                    const restoredOk = this.handleCreatePane({
-                        type: 'create_pane',
-                        command: paneState.command,
-                        args: paneState.args,
-                        cwd,
+                else {
+                    // A saved launch descriptor describes prior work. Restore its slot and
+                    // scrollback without assuming that the old process or job still exists.
+                    const restorationStatus = paneState.restoration_status?.startsWith('session_')
+                        ? paneState.restoration_status : paneState.agent_session ? 'not_started' : restoredPaneStatus(paneState);
+                    const explanation = restorationStatus === 'missing_directory'
+                        ? 'Saved working directory is missing or unavailable.'
+                        : restorationStatus === 'missing_command'
+                            ? 'Saved command is missing or unavailable.'
+                            : restorationStatus.startsWith('session_')
+                                ? `Saved agent session is unavailable (${restorationStatus}).`
+                                : 'Saved command is not started.';
+                    const content = [paneState.content, `[${explanation} Previous job state is unknown; explicitly relaunch to run it.]`]
+                        .filter(Boolean).join('\n');
+                    const pane = {
+                        id: this.reservePaneId(paneState.id),
                         title: paneState.title,
-                        pane_type: paneState.pane_type,
-                    }, { paneId: paneState.id });
-                    if (restoredOk) {
-                        restoredProcessPaneIds.push(paneState.id);
-                        const restoredPane = this.panes.get(paneState.id);
-                        if (restoredPane && paneState.content) {
-                            // Pre-fill output buffer with saved scrollback so read_pane returns previous output
-                            restoredPane.outputBuffer = paneState.content.split('\n').slice(-MAX_BUFFER_LINES);
-                            // Emit content to mirror so the web UI sees the restored scrollback
-                            this.emit({ type: 'pane_output', pane_id: paneState.id, content: paneState.content });
-                        }
-                        else if (paneState.pane_type !== 'ztc') {
-                            // No saved content — emit a synthetic placeholder so the panel isn't blank
-                            this.emit({ type: 'pane_output', pane_id: paneState.id, content: `[restored: ${paneState.title || paneState.command}]\n$ ` });
-                        }
-                    }
+                        paneType: paneState.pane_type,
+                        isAlive: false,
+                        restorationStatus,
+                        agentSession: paneState.agent_session,
+                        windowId: paneState.window_id,
+                        activityStatus: restorationStatus,
+                        activityLabel: 'Prior job state unknown',
+                        outputBuffer: content.split('\n').slice(-MAX_BUFFER_LINES),
+                        launch: { command: paneState.command, args: paneState.args === undefined ? undefined : [...paneState.args],
+                            cwd: paneState.cwd, content: paneState.content },
+                    };
+                    this.panes.set(pane.id, pane);
+                    this.emit({ type: 'pane_created', pane_id: pane.id, title: pane.title, pane_type: pane.paneType });
+                    this.emit({ type: 'pane_output', pane_id: pane.id, content });
                     restored++;
                 }
-                else {
-                    skipped++;
-                }
+                const restoredPane = this.panes.get(paneState.id);
+                if (restoredPane)
+                    restoredPane.labels = { ...paneState.labels };
+                const pane = this.panes.get(paneState.id);
+                if (pane)
+                    pane.windowId = paneState.window_id;
             }
             catch {
                 // Bad pane data — skip it rather than breaking the whole restore
                 skipped++;
             }
         }
-        // Post-restore liveness check: prune process panes that died immediately
-        // after spawning (e.g., bad command, missing binary). Deferred to allow
-        // the process 'close' / 'error' events to fire first.
-        if (restoredProcessPaneIds.length > 0) {
-            setTimeout(() => {
-                for (const id of restoredProcessPaneIds) {
-                    const pane = this.panes.get(id);
-                    if (pane && !pane.isAlive) {
-                        this.panes.delete(id);
-                        this.emit({ type: 'pane_closed', pane_id: id });
-                    }
-                }
-            }, 1500);
-        }
         this.emit({
             type: 'session_restored',
             restored_panes: restored,
@@ -937,16 +1117,18 @@ export class HeadlessPaneManager {
         });
         return true;
     }
-    handleListPanes() {
+    paneInfo() {
         const panes = [
             // Pane 0 = the host ZTC process (overseer). Not in this.panes because
             // it IS the host, not a child — but callers (especially sub-panes via
             // relay) need to see it so they can send messages / interact with it.
             {
                 id: 0,
-                title: this.hostTitle,
+                title: displayPaneTitle(this.hostTitle, this.hostLabels),
+                inferred_title: this.hostTitle,
+                labels: { ...this.hostLabels },
                 pane_type: 'ztc',
-                is_focused: true,
+                is_focused: this.workspaceMetadata.focused_pane_id === 0,
                 is_alive: true,
                 x: undefined,
                 y: undefined,
@@ -964,9 +1146,11 @@ export class HeadlessPaneManager {
         for (const pane of this.panes.values()) {
             panes.push({
                 id: pane.id,
-                title: pane.title,
+                title: displayPaneTitle(pane.title, pane.labels),
+                inferred_title: pane.title,
+                labels: { ...pane.labels },
                 pane_type: pane.paneType,
-                is_focused: false,
+                is_focused: this.workspaceMetadata.focused_pane_id === pane.id,
                 is_alive: pane.isAlive,
                 x: undefined,
                 y: undefined,
@@ -979,14 +1163,18 @@ export class HeadlessPaneManager {
                 activity_status: pane.activityStatus,
                 activity_spinner: pane.activitySpinner,
                 activity_label: pane.activityLabel,
+                window_id: pane.windowId,
             });
         }
-        this.emit({
-            type: 'pane_list',
-            panes,
-        });
+        return panes;
+    }
+    handleListPanes() {
+        this.emit({ type: 'pane_list', panes: this.paneInfo() });
         return true;
     }
+    publishPaneLabels() {
+        this.emit({ type: 'pane_state', cols: 120, rows: 40, panes: this.paneInfo() });
+    }
     finalizePaneClose(pane, exitCode) {
         if (pane.replaced)
             return;
@@ -994,6 +1182,7 @@ export class HeadlessPaneManager {
         pane.exitCode = exitCode;
         if (this.panes.get(pane.id) === pane) {
             this.panes.delete(pane.id);
+            this.removePaneFromLayout(pane.id);
         }
         this.closedPanes.set(pane.id, pane);
         // Cap memory: keep only the most recent closed-pane tails.