tmux-ide 2.7.0 → 2.9.0-beta.5

package/packages/daemon/dist/config.js

@@ -4,6 +4,7 @@ import { setByPath } from "./lib/dot-path.js";
 import { outputError } from "./lib/output.js";
 import { IdeConfigSchema } from "./schemas/ide-config.js";
 import { CliActionInvocationError, tryDispatchAction } from "./lib/cli-action-bridge.js";
+import { resolveProjectConfigContext } from "./lib/config-context.js";
 /**
  * Read config safely (read-only, no write). Returns config or undefined on error.
  */
@@ -13,7 +14,7 @@ function readConfigSafe(dir) {
         ({ config: cfg } = readConfig(dir));
     }
     catch (e) {
-        outputError(`Cannot read ide.yml: ${e.message}`, "READ_ERROR");
+        outputError(`Cannot read project config: ${e.message}`, "READ_ERROR");
         return;
     }
     return cfg;
@@ -27,7 +28,7 @@ function withConfig(dir, mutator) {
     if (cfg === undefined)
         return;
     if (!isConfigObject(cfg)) {
-        outputError("Invalid ide.yml: config root must be an object", "INVALID_CONFIG");
+        outputError("Invalid project config: config root must be an object", "INVALID_CONFIG");
         return;
     }
     const result = mutator(cfg);
@@ -45,7 +46,7 @@ function withConfig(dir, mutator) {
 export function mutateConfig(dir, mutator) {
     const { config: cfg } = readConfig(dir);
     if (!isConfigObject(cfg)) {
-        throw new Error("Invalid ide.yml: config root must be an object");
+        throw new Error("Invalid project config: config root must be an object");
     }
     const result = mutator(cfg);
     const validation = IdeConfigSchema.safeParse(cfg);
@@ -75,13 +76,13 @@ export function configSetValue(dir, path, value) {
 export function configAddPane(dir, rowIndex, pane) {
     return mutateConfig(dir, (cfg) => {
         if (!Array.isArray(cfg.rows)) {
-            throw new Error("Invalid ide.yml: 'rows' must be an array");
+            throw new Error("Invalid project config: 'rows' must be an array");
         }
         if (!cfg.rows[rowIndex]) {
             throw new Error(`Row ${rowIndex} does not exist`);
         }
         if (!Array.isArray(cfg.rows[rowIndex].panes)) {
-            throw new Error(`Invalid ide.yml: row ${rowIndex} panes must be an array`);
+            throw new Error(`Invalid project config: row ${rowIndex} panes must be an array`);
         }
         cfg.rows[rowIndex].panes.push(pane);
     }).config;
@@ -89,10 +90,10 @@ export function configAddPane(dir, rowIndex, pane) {
 export function configRemovePane(dir, rowIndex, paneIndex) {
     const updated = mutateConfig(dir, (cfg) => {
         if (!Array.isArray(cfg.rows)) {
-            throw new Error("Invalid ide.yml: 'rows' must be an array");
+            throw new Error("Invalid project config: 'rows' must be an array");
         }
         if (!Array.isArray(cfg.rows[rowIndex]?.panes)) {
-            throw new Error(`Invalid ide.yml: row ${rowIndex} panes must be an array`);
+            throw new Error(`Invalid project config: row ${rowIndex} panes must be an array`);
         }
         const removed = cfg.rows[rowIndex].panes[paneIndex];
         if (!removed) {
@@ -106,7 +107,7 @@ export function configRemovePane(dir, rowIndex, paneIndex) {
 export function configAddRow(dir, size) {
     return mutateConfig(dir, (cfg) => {
         if (cfg.rows !== undefined && !Array.isArray(cfg.rows)) {
-            throw new Error("Invalid ide.yml: 'rows' must be an array");
+            throw new Error("Invalid project config: 'rows' must be an array");
         }
         const row = { panes: [{ title: "Shell" }] };
         if (size)
@@ -118,7 +119,7 @@ export function configAddRow(dir, size) {
 export function configEnableTeam(dir, name) {
     return mutateConfig(dir, (cfg) => {
         if (cfg.rows !== undefined && !Array.isArray(cfg.rows)) {
-            throw new Error("Invalid ide.yml: 'rows' must be an array");
+            throw new Error("Invalid project config: 'rows' must be an array");
         }
         cfg.team = { name: name ?? cfg.name ?? "my-team" };
         let leadAssigned = false;
@@ -139,7 +140,7 @@ export function configEnableTeam(dir, name) {
 export function configDisableTeam(dir) {
     return mutateConfig(dir, (cfg) => {
         if (cfg.rows !== undefined && !Array.isArray(cfg.rows)) {
-            throw new Error("Invalid ide.yml: 'rows' must be an array");
+            throw new Error("Invalid project config: 'rows' must be an array");
         }
         delete cfg.team;
         for (const row of cfg.rows ?? []) {
@@ -156,23 +157,28 @@ export async function config(targetDir, { json, action, args } = {}) {
     const dir = resolve(targetDir ?? ".");
     if (await tryDispatchConfigAction(dir, { json, action, args: args ?? [] }))
         return;
+    const configContext = await resolveProjectConfigContext(dir);
+    if (!configContext.configExists) {
+        outputError(`No workspace config found in ${configContext.projectRoot}. Run "tmux-ide init" first.`, "CONFIG_NOT_FOUND");
+    }
+    const configDir = configContext.configWriteRoot;
     switch (action) {
         case "dump":
-            return dumpConfig(dir, { json });
+            return dumpConfig(configDir, { json });
         case "set":
-            return setConfig(dir, args ?? [], { json });
+            return setConfig(configDir, args ?? [], { json });
         case "add-pane":
-            return addPane(dir, args ?? [], { json });
+            return addPane(configDir, args ?? [], { json });
         case "remove-pane":
-            return removePane(dir, args ?? [], { json });
+            return removePane(configDir, args ?? [], { json });
         case "add-row":
-            return addRow(dir, args ?? [], { json });
+            return addRow(configDir, args ?? [], { json });
         case "enable-team":
-            return enableTeam(dir, args ?? [], { json });
+            return enableTeam(configDir, args ?? [], { json });
         case "disable-team":
-            return disableTeam(dir, { json });
+            return disableTeam(configDir, { json });
         default:
-            return dumpConfig(dir, { json });
+            return dumpConfig(configDir, { json });
     }
 }
 function dumpConfig(dir, { json }) {
@@ -332,13 +338,13 @@ function addPane(dir, args, { json }) {
         pane.size = size;
     withConfig(dir, (cfg) => {
         if (!Array.isArray(cfg.rows)) {
-            outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+            outputError("Invalid project config: 'rows' must be an array", "INVALID_CONFIG");
         }
         if (!cfg.rows[rowIdx]) {
             outputError(`Row ${rowIdx} does not exist`, "INVALID_ROW");
         }
         if (!Array.isArray(cfg.rows[rowIdx].panes)) {
-            outputError(`Invalid ide.yml: row ${rowIdx} panes must be an array`, "INVALID_CONFIG");
+            outputError(`Invalid project config: row ${rowIdx} panes must be an array`, "INVALID_CONFIG");
         }
         cfg.rows[rowIdx].panes.push(pane);
     });
@@ -364,10 +370,10 @@ function removePane(dir, args, { json }) {
     let removed;
     withConfig(dir, (cfg) => {
         if (!Array.isArray(cfg.rows)) {
-            outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+            outputError("Invalid project config: 'rows' must be an array", "INVALID_CONFIG");
         }
         if (!Array.isArray(cfg.rows[rowIdx]?.panes)) {
-            outputError(`Invalid ide.yml: row ${rowIdx} panes must be an array`, "INVALID_CONFIG");
+            outputError(`Invalid project config: row ${rowIdx} panes must be an array`, "INVALID_CONFIG");
         }
         if (!cfg.rows[rowIdx].panes[paneIdx]) {
             outputError(`Pane ${paneIdx} in row ${rowIdx} does not exist`, "INVALID_PANE");
@@ -386,7 +392,7 @@ function addRow(dir, args, { json }) {
     let rowIdx;
     withConfig(dir, (cfg) => {
         if (cfg.rows !== undefined && !Array.isArray(cfg.rows)) {
-            outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+            outputError("Invalid project config: 'rows' must be an array", "INVALID_CONFIG");
         }
         const row = { panes: [{ title: "Shell" }] };
         if (size)
@@ -408,7 +414,7 @@ function enableTeam(dir, args, { json }) {
     let result;
     withConfig(dir, (cfg) => {
         if (cfg.rows !== undefined && !Array.isArray(cfg.rows)) {
-            outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+            outputError("Invalid project config: 'rows' must be an array", "INVALID_CONFIG");
         }
         teamName = name ?? cfg.name ?? "my-team";
         cfg.team = { name: teamName };
@@ -442,7 +448,7 @@ function enableTeam(dir, args, { json }) {
 function disableTeam(dir, { json }) {
     withConfig(dir, (cfg) => {
         if (cfg.rows !== undefined && !Array.isArray(cfg.rows)) {
-            outputError("Invalid ide.yml: 'rows' must be an array", "INVALID_CONFIG");
+            outputError("Invalid project config: 'rows' must be an array", "INVALID_CONFIG");
         }
         delete cfg.team;
         for (const row of cfg.rows ?? []) {

package/packages/daemon/dist/control/client.d.ts

@@ -0,0 +1,23 @@
+import { type ControlEventFrame } from "@tmux-ide/contracts";
+/** A failed verb, carrying the server's machine-readable error code. */
+export declare class ControlRequestError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface ControlClient {
+    /** Send one verb; resolves with the response `data`, rejects with
+     *  {@link ControlRequestError} on an error response or a dropped socket. */
+    request(verb: string, params?: Record<string, unknown>): Promise<unknown>;
+    /** Receive pushed event frames (also sends the `subscribe` verb). */
+    subscribe(onEvent: (event: ControlEventFrame) => void): Promise<void>;
+    close(): void;
+    /** Resolves when the connection ends (server shutdown → EOF). */
+    done: Promise<void>;
+}
+/**
+ * Connect to a control server. Rejects (quickly) when nothing is listening —
+ * callers treat that as "no server, fall back to polling".
+ */
+export declare function connectControl(opts?: {
+    socketPath?: string;
+}): Promise<ControlClient>;

package/packages/daemon/dist/control/client.js

@@ -0,0 +1,105 @@
+/**
+ * A minimal control-socket client — what the CLI's `--socket` fast-paths
+ * (`events --follow --socket`, `wait … --socket`) ride on. Connect, send
+ * id-correlated requests, optionally receive pushed event frames. Kept
+ * dependency-light on purpose: this is also the reference for "how would an
+ * agent drive the socket from node" (see skill/SKILL.md).
+ */
+import { connect } from "node:net";
+import { CONTROL_PROTOCOL_VERSION, controlEventSchema, controlResponseSchema, } from "@tmux-ide/contracts";
+import { createFrameSplitter, encodeFrame } from "./frames.js";
+import { defaultControlSocketPath } from "./server.js";
+/** A failed verb, carrying the server's machine-readable error code. */
+export class ControlRequestError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+/**
+ * Connect to a control server. Rejects (quickly) when nothing is listening —
+ * callers treat that as "no server, fall back to polling".
+ */
+export function connectControl(opts = {}) {
+    const path = opts.socketPath ?? defaultControlSocketPath();
+    return new Promise((resolve, reject) => {
+        const socket = connect(path);
+        socket.once("error", reject);
+        socket.once("connect", () => {
+            socket.removeListener("error", reject);
+            resolve(wrap(socket));
+        });
+    });
+}
+function wrap(socket) {
+    socket.setEncoding("utf8");
+    const split = createFrameSplitter();
+    const pending = new Map();
+    const eventSinks = [];
+    let nextId = 1;
+    let markDone;
+    const done = new Promise((r) => {
+        markDone = r;
+    });
+    socket.on("data", (chunk) => {
+        for (const line of split(chunk)) {
+            let raw;
+            try {
+                raw = JSON.parse(line);
+            }
+            catch {
+                continue; // a malformed server frame — skip, ids keep us honest
+            }
+            const event = controlEventSchema.safeParse(raw);
+            if (event.success) {
+                for (const sink of eventSinks)
+                    sink(event.data);
+                continue;
+            }
+            const response = controlResponseSchema.safeParse(raw);
+            if (!response.success || response.data.id === null)
+                continue;
+            const waiter = pending.get(response.data.id);
+            if (!waiter)
+                continue;
+            pending.delete(response.data.id);
+            if (response.data.ok)
+                waiter.resolve(response.data.data);
+            else {
+                waiter.reject(new ControlRequestError(response.data.error.code, response.data.error.message));
+            }
+        }
+    });
+    const teardown = () => {
+        for (const { reject } of pending.values()) {
+            reject(new ControlRequestError("disconnected", "control socket closed"));
+        }
+        pending.clear();
+        markDone();
+    };
+    socket.on("close", teardown);
+    socket.on("error", () => {
+        // 'close' follows and runs the teardown
+    });
+    const request = (verb, params) => {
+        const id = nextId++;
+        return new Promise((resolve, reject) => {
+            if (socket.destroyed) {
+                reject(new ControlRequestError("disconnected", "control socket closed"));
+                return;
+            }
+            pending.set(id, { resolve, reject });
+            socket.write(encodeFrame({ v: CONTROL_PROTOCOL_VERSION, id, verb, params }));
+        });
+    };
+    return {
+        request,
+        subscribe: async (onEvent) => {
+            eventSinks.push(onEvent);
+            await request("subscribe");
+        },
+        close: () => socket.destroy(),
+        done,
+    };
+}

package/packages/daemon/dist/control/dispatch.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Request dispatch for the control socket — PURE given its handler map.
+ *
+ * Takes one raw frame line, parses + validates the versioned envelope,
+ * routes to the verb's handler, and shapes the response envelope — including
+ * every failure mode (unparseable JSON, bad envelope, unknown verb, invalid
+ * params, handler error). Handlers are injected, so this whole layer unit-
+ * tests without a socket or a tmux server.
+ *
+ * Error codes on the wire:
+ *   bad-request    unparseable frame / envelope / params (message says which)
+ *   unknown-verb   the verb isn't in this server's handler map
+ *   not-found      the named pane/session/target doesn't exist
+ *   timeout        a `wait` ran out of time
+ *   internal       the handler threw something unexpected
+ */
+import { type ControlResponse } from "@tmux-ide/contracts";
+/** Thrown by handlers to reach the wire with a specific code. */
+export declare class ControlVerbError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+/** What a handler gets besides its (already unknown-typed) params. */
+export interface VerbContext {
+    /** Flip this connection into receiving event frames (the `subscribe` verb). */
+    subscribe: () => void;
+}
+export type VerbHandler = (params: unknown, ctx: VerbContext) => Promise<unknown> | unknown;
+/**
+ * Dispatch one raw line to `handlers`. ALWAYS resolves to a response frame —
+ * a protocol error is an answer, never a dropped request or a thrown error
+ * (only the transport decides to drop connections).
+ */
+export declare function dispatchLine(line: string, handlers: Record<string, VerbHandler>, ctx: VerbContext): Promise<ControlResponse>;

package/packages/daemon/dist/control/dispatch.js

@@ -0,0 +1,83 @@
+/**
+ * Request dispatch for the control socket — PURE given its handler map.
+ *
+ * Takes one raw frame line, parses + validates the versioned envelope,
+ * routes to the verb's handler, and shapes the response envelope — including
+ * every failure mode (unparseable JSON, bad envelope, unknown verb, invalid
+ * params, handler error). Handlers are injected, so this whole layer unit-
+ * tests without a socket or a tmux server.
+ *
+ * Error codes on the wire:
+ *   bad-request    unparseable frame / envelope / params (message says which)
+ *   unknown-verb   the verb isn't in this server's handler map
+ *   not-found      the named pane/session/target doesn't exist
+ *   timeout        a `wait` ran out of time
+ *   internal       the handler threw something unexpected
+ */
+import { CONTROL_PROTOCOL_VERSION, controlRequestSchema, } from "@tmux-ide/contracts";
+import { IdeError } from "../lib/errors.js";
+/** Thrown by handlers to reach the wire with a specific code. */
+export class ControlVerbError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+const ok = (id, data) => ({
+    v: CONTROL_PROTOCOL_VERSION,
+    id,
+    ok: true,
+    data,
+});
+const fail = (id, code, message) => ({
+    v: CONTROL_PROTOCOL_VERSION,
+    id,
+    ok: false,
+    error: { code, message },
+});
+/** Best-effort id recovery from a frame that failed envelope validation. */
+function extractId(value) {
+    if (typeof value === "object" && value !== null && "id" in value) {
+        const id = value.id;
+        if (typeof id === "string" || typeof id === "number")
+            return id;
+    }
+    return null;
+}
+/**
+ * Dispatch one raw line to `handlers`. ALWAYS resolves to a response frame —
+ * a protocol error is an answer, never a dropped request or a thrown error
+ * (only the transport decides to drop connections).
+ */
+export async function dispatchLine(line, handlers, ctx) {
+    let raw;
+    try {
+        raw = JSON.parse(line);
+    }
+    catch {
+        return fail(null, "bad-request", "frame is not valid JSON");
+    }
+    const parsed = controlRequestSchema.safeParse(raw);
+    if (!parsed.success) {
+        return fail(extractId(raw), "bad-request", `invalid request envelope (need {v:${CONTROL_PROTOCOL_VERSION}, id, verb})`);
+    }
+    const { id, verb, params } = parsed.data;
+    const handler = handlers[verb];
+    if (!handler) {
+        return fail(id, "unknown-verb", `unknown verb "${verb}"`);
+    }
+    try {
+        return ok(id, await handler(params ?? {}, ctx));
+    }
+    catch (err) {
+        if (err instanceof ControlVerbError)
+            return fail(id, err.code, err.message);
+        if (err instanceof IdeError) {
+            // Data-layer errors carry honest codes already (SESSION_NOT_FOUND, …).
+            const code = err.code === "USAGE" ? "bad-request" : "not-found";
+            return fail(id, code, err.message);
+        }
+        return fail(id, "internal", err?.message ?? "internal error");
+    }
+}

package/packages/daemon/dist/control/fanout.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Subscriber fan-out bookkeeping for the control server — PURE.
+ *
+ * Tracks the set of live subscribers and delivers each emitted event to all
+ * of them. The `onFirst`/`onLast` edges let the server run its detection
+ * tick ONLY while someone is listening (0→1 starts it, 1→0 stops it), so an
+ * idle `tmux-ide serve` costs nothing between requests.
+ */
+export interface Fanout<T> {
+    /** Register a sink. Returns its unsubscribe (idempotent). */
+    add(sink: (event: T) => void): () => void;
+    /** Deliver `event` to every sink. A throwing sink is dropped, not fatal. */
+    emit(event: T): void;
+    size(): number;
+}
+export declare function createFanout<T>(edges?: {
+    onFirst?: () => void;
+    onLast?: () => void;
+}): Fanout<T>;

package/packages/daemon/dist/control/fanout.js

@@ -0,0 +1,37 @@
+/**
+ * Subscriber fan-out bookkeeping for the control server — PURE.
+ *
+ * Tracks the set of live subscribers and delivers each emitted event to all
+ * of them. The `onFirst`/`onLast` edges let the server run its detection
+ * tick ONLY while someone is listening (0→1 starts it, 1→0 stops it), so an
+ * idle `tmux-ide serve` costs nothing between requests.
+ */
+export function createFanout(edges = {}) {
+    const sinks = new Set();
+    const remove = (sink) => {
+        if (!sinks.delete(sink))
+            return;
+        if (sinks.size === 0)
+            edges.onLast?.();
+    };
+    return {
+        add(sink) {
+            sinks.add(sink);
+            if (sinks.size === 1)
+                edges.onFirst?.();
+            return () => remove(sink);
+        },
+        emit(event) {
+            for (const sink of [...sinks]) {
+                try {
+                    sink(event);
+                }
+                catch {
+                    // A sink that throws (a torn-down connection) removes itself.
+                    remove(sink);
+                }
+            }
+        },
+        size: () => sinks.size,
+    };
+}

package/packages/daemon/dist/control/frames.d.ts

@@ -0,0 +1,23 @@
+/**
+ * NDJSON framing for the control socket — PURE.
+ *
+ * One frame = one JSON object on one `\n`-terminated line. TCP-style streams
+ * deliver arbitrary chunk boundaries, so the splitter buffers a partial
+ * trailing line across feeds and hands back only COMPLETE lines. Encoding is
+ * the trivial inverse; it lives here so every writer produces identical
+ * frames (a `JSON.stringify` can never contain a raw newline, so one write
+ * call per frame is atomic on the wire).
+ */
+/** Refuse to buffer a partial line beyond this — a client streaming an
+ *  unterminated megabyte is broken or hostile, not slow. */
+export declare const MAX_FRAME_BYTES: number;
+/** Serialize one frame: the JSON line plus its terminator. */
+export declare function encodeFrame(message: unknown): string;
+/**
+ * A stateful chunk → complete-lines splitter. Feed it raw socket data; it
+ * returns every COMPLETE line received so far (blank lines are dropped) and
+ * keeps the trailing partial line buffered for the next feed. Throws when the
+ * partial line outgrows {@link MAX_FRAME_BYTES} — the caller should drop the
+ * connection.
+ */
+export declare function createFrameSplitter(): (chunk: string) => string[];

package/packages/daemon/dist/control/frames.js

@@ -0,0 +1,37 @@
+/**
+ * NDJSON framing for the control socket — PURE.
+ *
+ * One frame = one JSON object on one `\n`-terminated line. TCP-style streams
+ * deliver arbitrary chunk boundaries, so the splitter buffers a partial
+ * trailing line across feeds and hands back only COMPLETE lines. Encoding is
+ * the trivial inverse; it lives here so every writer produces identical
+ * frames (a `JSON.stringify` can never contain a raw newline, so one write
+ * call per frame is atomic on the wire).
+ */
+/** Refuse to buffer a partial line beyond this — a client streaming an
+ *  unterminated megabyte is broken or hostile, not slow. */
+export const MAX_FRAME_BYTES = 4 * 1024 * 1024;
+/** Serialize one frame: the JSON line plus its terminator. */
+export function encodeFrame(message) {
+    return `${JSON.stringify(message)}\n`;
+}
+/**
+ * A stateful chunk → complete-lines splitter. Feed it raw socket data; it
+ * returns every COMPLETE line received so far (blank lines are dropped) and
+ * keeps the trailing partial line buffered for the next feed. Throws when the
+ * partial line outgrows {@link MAX_FRAME_BYTES} — the caller should drop the
+ * connection.
+ */
+export function createFrameSplitter() {
+    let buffer = "";
+    return (chunk) => {
+        buffer += chunk;
+        const parts = buffer.split("\n");
+        buffer = parts.pop() ?? "";
+        if (buffer.length > MAX_FRAME_BYTES) {
+            buffer = "";
+            throw new Error(`frame exceeds ${MAX_FRAME_BYTES} bytes without a newline`);
+        }
+        return parts.filter((line) => line.trim().length > 0);
+    };
+}

package/packages/daemon/dist/control/lifecycle.d.ts

@@ -0,0 +1,45 @@
+import { type SpawnPlacement } from "../tui/mirror/agent-lifecycle.ts";
+/** Resolve `kind`/`command` params to the command that actually launches. */
+export declare function resolveLaunchCommand(params: {
+    kind?: string;
+    command?: string;
+}): string;
+export interface SpawnOutcome {
+    paneId: string;
+    session: string;
+    command: string;
+    placement: SpawnPlacement | "new-session";
+}
+/**
+ * Spawn an agent. With `session` the shared placement argv is used (window /
+ * split); without it a fresh detached session named `sessionName` starts in
+ * `dir`. `-P -F #{pane_id}` is threaded right after the tmux subcommand so
+ * the caller learns WHICH pane the agent got (the argv builders stay
+ * untouched — the app's flows don't want the print).
+ */
+export declare function spawnAgent(params: {
+    command: string;
+    session?: string;
+    sessionName?: string;
+    dir?: string;
+    placement?: SpawnPlacement;
+    paneId?: string;
+}): Promise<SpawnOutcome>;
+/** Stop the agent in `paneId`: interrupt + authority cleanup. The pane (and
+ *  its shell, if any) stays open — `kill-pane` is deliberately NOT offered
+ *  over the socket; that is a human, confirmed-destructive verb. */
+export declare function stopAgent(paneId: string): Promise<{
+    paneId: string;
+    stopped: true;
+}>;
+/**
+ * Restart the agent in `paneId` running `command`, using the app's two
+ * strategies: a SHELL-hosted agent is interrupted and relaunched via
+ * send-keys (the shell survives to type into); an agent that IS the pane's
+ * own process is respawned in place (ctrl-c would end the pane).
+ */
+export declare function restartAgent(paneId: string, command: string): Promise<{
+    paneId: string;
+    command: string;
+    strategy: "relaunch" | "respawn";
+}>;