tmux-ide 2.7.0 → 2.9.0-beta.5

package/packages/daemon/dist/lib/daemon-session-monitor.d.ts

@@ -0,0 +1,50 @@
+export interface DaemonMonitorPane {
+    readonly id: string;
+    readonly pid: string;
+    readonly cmd?: string;
+    readonly title?: string;
+    readonly role?: string;
+    readonly type?: string;
+    readonly name?: string;
+}
+export type DaemonMonitoredSessionState = "yes" | "no" | "unknown";
+export interface DaemonSessionMonitorBackend {
+    inspectSession(sessionName: string, signal: AbortSignal): Promise<DaemonMonitoredSessionState>;
+    listCredentialSessions(): readonly string[];
+    reconcileCredentials(sessionName: string, signal: AbortSignal): Promise<void>;
+    hasClients(signal: AbortSignal): Promise<boolean | null>;
+    listPanes(sessionName: string, signal: AbortSignal): Promise<readonly DaemonMonitorPane[] | null>;
+    readPortProcessFacts(signal: AbortSignal): Promise<{
+        readonly listeners: Set<string>;
+        readonly tree: Map<string, string>;
+    } | null>;
+    setPaneOption(paneId: string, option: string, value: string, signal: AbortSignal): Promise<void>;
+    setPaneTitle(paneId: string, title: string, signal: AbortSignal): Promise<void>;
+    refreshClients(signal: AbortSignal): Promise<void>;
+    onSessionGone(): void;
+}
+export interface DaemonSessionMonitorOptions {
+    readonly sessionName: string;
+    readonly backend: DaemonSessionMonitorBackend;
+    readonly intervalMs?: number;
+    readonly operationConcurrency?: number;
+    readonly setTimer?: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+    readonly clearTimer?: (timer: ReturnType<typeof setTimeout>) => void;
+}
+/** Async, non-overlapping reconciliation for one daemon-owned tmux session. */
+export declare class DaemonSessionMonitor {
+    #private;
+    constructor(options: DaemonSessionMonitorOptions);
+    start(): void;
+    runOnce(): Promise<void>;
+    stop(): Promise<void>;
+}
+export declare function parseDaemonMonitorPanes(raw: string): DaemonMonitorPane[];
+export declare function execTmuxAsync(args: readonly string[], signal?: AbortSignal): Promise<string>;
+export declare function readPortProcessFactsAsync(signal?: AbortSignal): Promise<{
+    readonly listeners: Set<string>;
+    readonly tree: Map<string, string>;
+}>;
+export declare function classifySessionInspectionError(error: unknown): DaemonMonitoredSessionState;
+/** Only explicit tmux target disappearance is safe to treat as an idempotent no-op. */
+export declare function isConfirmedMissingTmuxTarget(error: unknown): boolean;

package/packages/daemon/dist/lib/daemon-session-monitor.js

@@ -0,0 +1,194 @@
+import { execFile } from "node:child_process";
+import { computeAgentStates, computePortPanes, parseListeningPids, parseProcessTree, } from "./session-monitor.js";
+/** Async, non-overlapping reconciliation for one daemon-owned tmux session. */
+export class DaemonSessionMonitor {
+    #options;
+    #intervalMs;
+    #operationConcurrency;
+    #setTimer;
+    #clearTimer;
+    #timer = null;
+    #running = null;
+    #abortController = null;
+    #stopped = false;
+    #lastState = "";
+    constructor(options) {
+        this.#options = options;
+        this.#intervalMs = options.intervalMs ?? 1_000;
+        this.#operationConcurrency = Math.max(1, options.operationConcurrency ?? 4);
+        this.#setTimer =
+            options.setTimer ??
+                ((callback, delayMs) => {
+                    const timer = setTimeout(callback, delayMs);
+                    timer.unref?.();
+                    return timer;
+                });
+        this.#clearTimer = options.clearTimer ?? clearTimeout;
+    }
+    start() {
+        if (this.#stopped || this.#timer || this.#running)
+            return;
+        this.#schedule();
+    }
+    runOnce() {
+        if (this.#stopped)
+            return Promise.resolve();
+        if (this.#timer) {
+            this.#clearTimer(this.#timer);
+            this.#timer = null;
+        }
+        if (this.#running)
+            return this.#running;
+        const controller = new AbortController();
+        this.#abortController = controller;
+        this.#running = this.#cycle(controller.signal)
+            .catch((error) => {
+            if (!controller.signal.aborted) {
+                // A transient monitor failure holds the last accepted state. The
+                // recursive scheduler retries without overlapping this cycle.
+                void error;
+            }
+        })
+            .finally(() => {
+            this.#abortController = null;
+            this.#running = null;
+            if (!this.#stopped)
+                this.#schedule();
+        });
+        return this.#running;
+    }
+    async stop() {
+        if (this.#stopped) {
+            await this.#running;
+            return;
+        }
+        this.#stopped = true;
+        if (this.#timer)
+            this.#clearTimer(this.#timer);
+        this.#timer = null;
+        this.#abortController?.abort();
+        await this.#running;
+    }
+    #schedule() {
+        this.#timer = this.#setTimer(() => {
+            this.#timer = null;
+            void this.runOnce();
+        }, this.#intervalMs);
+    }
+    async #cycle(signal) {
+        const backend = this.#options.backend;
+        const session = await backend.inspectSession(this.#options.sessionName, signal);
+        if (signal.aborted)
+            return;
+        if (session === "no") {
+            backend.onSessionGone();
+            return;
+        }
+        if (session === "unknown")
+            return;
+        await mapBounded(backend.listCredentialSessions(), this.#operationConcurrency, (workspaceSession) => backend.reconcileCredentials(workspaceSession, signal));
+        if (signal.aborted)
+            return;
+        const clients = await backend.hasClients(signal);
+        if (clients !== true || signal.aborted)
+            return;
+        const panes = await backend.listPanes(this.#options.sessionName, signal);
+        if (!panes || panes.length === 0 || signal.aborted)
+            return;
+        const portFacts = await backend.readPortProcessFacts(signal);
+        if (!portFacts || signal.aborted)
+            return;
+        const mutablePanes = [...panes];
+        const portPanes = computePortPanes(mutablePanes, portFacts);
+        const agentStates = computeAgentStates(mutablePanes);
+        const stateKey = panes
+            .map((pane) => {
+            const portState = portPanes.has(pane.id) ? "1" : "0";
+            const agent = agentStates.get(pane.id) ?? "-";
+            const titleDrift = pane.name && pane.title !== pane.name ? "d" : "ok";
+            return `${pane.id}:${portState}:${agent}:${titleDrift}`;
+        })
+            .join("|");
+        if (stateKey === this.#lastState)
+            return;
+        const mutations = [];
+        for (const pane of panes) {
+            const agent = agentStates.get(pane.id);
+            mutations.push((activeSignal) => backend.setPaneOption(pane.id, "@has_port", portPanes.has(pane.id) ? "1" : "0", activeSignal), (activeSignal) => backend.setPaneOption(pane.id, "@agent_busy", agent === "busy" ? "1" : "0", activeSignal), (activeSignal) => backend.setPaneOption(pane.id, "@agent_idle", agent === "idle" ? "1" : "0", activeSignal));
+            if (pane.name && pane.title !== pane.name) {
+                mutations.push((activeSignal) => backend.setPaneTitle(pane.id, pane.name, activeSignal));
+            }
+        }
+        await mapBounded(mutations, this.#operationConcurrency, (mutation) => mutation(signal));
+        if (signal.aborted)
+            return;
+        await backend.refreshClients(signal);
+        if (!signal.aborted)
+            this.#lastState = stateKey;
+    }
+}
+export function parseDaemonMonitorPanes(raw) {
+    if (!raw)
+        return [];
+    return raw.split("\n").map((line) => {
+        const [id, pid, cmd, title, role, type, name] = line.split("\t");
+        return {
+            id: id,
+            pid: pid,
+            cmd,
+            title,
+            role: role || undefined,
+            type: type || undefined,
+            name: name || undefined,
+        };
+    });
+}
+export function execTmuxAsync(args, signal) {
+    return execMonitorCommandAsync("tmux", args, signal);
+}
+function execMonitorCommandAsync(executable, args, signal) {
+    return new Promise((resolve, reject) => {
+        execFile(executable, [...args], { encoding: "utf8", maxBuffer: 1024 * 1024, signal }, (error, stdout) => {
+            if (error)
+                reject(error);
+            else
+                resolve(stdout.trim());
+        });
+    });
+}
+export async function readPortProcessFactsAsync(signal) {
+    const [listeners, processes] = await Promise.all([
+        execMonitorCommandAsync("lsof", ["-nP", "-iTCP", "-sTCP:LISTEN", "-FpPn"], signal),
+        execMonitorCommandAsync("ps", ["-axo", "pid=,ppid="], signal),
+    ]);
+    return { listeners: parseListeningPids(listeners), tree: parseProcessTree(processes) };
+}
+export function classifySessionInspectionError(error) {
+    const candidate = error;
+    const message = candidate.message ?? "";
+    if (candidate.code === "EBADF" ||
+        candidate.code === "EAGAIN" ||
+        candidate.code === "EMFILE" ||
+        candidate.code === "ENFILE" ||
+        message.includes("EBADF") ||
+        message.includes("EAGAIN")) {
+        return "unknown";
+    }
+    return "no";
+}
+/** Only explicit tmux target disappearance is safe to treat as an idempotent no-op. */
+export function isConfirmedMissingTmuxTarget(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /(?:can't find|no such|unknown) (?:pane|session|window|target)/iu.test(message);
+}
+async function mapBounded(values, concurrency, operation) {
+    let cursor = 0;
+    const workers = Array.from({ length: Math.min(concurrency, values.length) }, async () => {
+        while (cursor < values.length) {
+            const index = cursor;
+            cursor += 1;
+            await operation(values[index]);
+        }
+    });
+    await Promise.all(workers);
+}

package/packages/daemon/dist/lib/daemon.js

@@ -7,7 +7,7 @@
  */
 import { fileURLToPath } from "node:url";
 import { resolve } from "node:path";
-import { startEmbeddedDaemon } from "./daemon-embed.js";
+import { runHeadlessDaemon } from "./headless-daemon.js";
 async function main() {
     // Accept the legacy `node daemon.ts <session> <port>` invocation: the
     // first positional may be a session name OR (when omitted) a port. We
@@ -21,58 +21,14 @@ async function main() {
     const sessionName = arg2IsPort ? undefined : arg2;
     const rawPort = arg2IsPort ? arg2 : arg3;
     const port = rawPort === undefined || rawPort === "0" ? undefined : Number.parseInt(rawPort, 10);
-    let handle;
     try {
-        handle = await startEmbeddedDaemon({
-            port,
-            bindHostname: "127.0.0.1",
-            ...(sessionName ? { sessionName } : {}),
-        });
+        await runHeadlessDaemon({ port, sessionName });
+        process.exit(0);
     }
     catch (err) {
         console.error("[daemon] failed to start:", err);
         process.exit(1);
     }
-    let stopping = false;
-    const exitAfterStop = (code) => {
-        if (stopping)
-            return;
-        stopping = true;
-        // Defer one tick so any awaiter of handle.stop() observes the resolved
-        // promise before we tear the process down.
-        process.nextTick(() => process.exit(code));
-    };
-    const shutdown = async () => {
-        if (stopping)
-            return;
-        try {
-            await handle.stop();
-            exitAfterStop(0);
-        }
-        catch (err) {
-            console.error("[daemon] failed to stop:", err);
-            exitAfterStop(1);
-        }
-    };
-    // Wrap handle.stop so non-signal stop paths terminate the process. Without
-    // this, the canonical-daemon takeover action (POST /api/v2/action/daemon.shutdown
-    // from a competing launcher), the tick() that calls stopSelf when the
-    // tmux session disappears, and the remote-access restart backend all
-    // close the HTTP listener but leave the Node event loop spinning on
-    // task-store WAL timers and other handles. The visible symptom is a
-    // ghost daemon: process alive, port 6060 dead, takeover falls back to
-    // its 10s SIGTERM/SIGKILL deadline before the next launch can bind.
-    const origStop = handle.stop.bind(handle);
-    handle.stop = async (opts) => {
-        try {
-            await origStop(opts);
-        }
-        finally {
-            exitAfterStop(0);
-        }
-    };
-    process.on("SIGTERM", () => void shutdown());
-    process.on("SIGINT", () => void shutdown());
 }
 const isMainModule = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
 if (isMainModule)

package/packages/daemon/dist/lib/directory-watcher.d.ts

@@ -0,0 +1,12 @@
+export interface WatchEvent {
+    type: "create" | "update" | "delete";
+    path: string;
+}
+export declare function watchDirectory(dir: string, onChange: (events: WatchEvent[]) => void, options?: {
+    debounceMs?: number;
+    ignore?: string[];
+    requireInstalled?: boolean;
+    /** Called once when an installed native watcher dies unexpectedly. */
+    onUnavailable?: (error: Error) => void;
+}): Promise<() => Promise<void>>;
+export declare function watchGitHead(dir: string, onBranchChange: () => void): Promise<(() => Promise<void>) | null>;

package/packages/daemon/dist/lib/directory-watcher.js

@@ -0,0 +1,118 @@
+import { watch as fsWatch } from "node:fs";
+import { join, sep } from "node:path";
+let parcel;
+async function loadParcel() {
+    if (parcel !== undefined)
+        return parcel;
+    try {
+        const mod = (await import("@parcel/watcher"));
+        if (typeof mod.subscribe !== "function")
+            throw new Error("no subscribe");
+        parcel = mod;
+    }
+    catch {
+        parcel = null;
+    }
+    return parcel;
+}
+function fsWatchDirectory(dir, onChange, ignore, debounceMs, requireInstalled, onUnavailable) {
+    const ignoreSet = new Set(ignore);
+    let timeout = null;
+    let handle = null;
+    let stopping = false;
+    let unavailable = false;
+    const reportUnavailable = (error) => {
+        if (stopping || unavailable)
+            return;
+        unavailable = true;
+        onUnavailable(error);
+    };
+    try {
+        handle = fsWatch(dir, { recursive: true }, (_event, filename) => {
+            if (!filename)
+                return;
+            const rel = filename.toString();
+            if (rel.split(sep).some((part) => ignoreSet.has(part)))
+                return;
+            if (timeout)
+                clearTimeout(timeout);
+            timeout = setTimeout(() => onChange([{ type: "update", path: join(dir, rel) }]), debounceMs);
+        });
+        handle.on("error", reportUnavailable);
+        handle.on("close", () => {
+            reportUnavailable(new Error(`Directory watcher closed unexpectedly for ${dir}`));
+        });
+    }
+    catch (error) {
+        if (requireInstalled)
+            throw error;
+    }
+    return async () => {
+        stopping = true;
+        if (timeout)
+            clearTimeout(timeout);
+        handle?.close();
+    };
+}
+export async function watchDirectory(dir, onChange, options) {
+    const debounceMs = options?.debounceMs ?? 300;
+    const ignore = options?.ignore ?? ["node_modules", ".git", "dist", "build", ".next"];
+    const native = await loadParcel();
+    if (!native) {
+        return fsWatchDirectory(dir, onChange, ignore, debounceMs, options?.requireInstalled ?? false, options?.onUnavailable ?? (() => undefined));
+    }
+    let timeout = null;
+    let stopping = false;
+    let unavailable = false;
+    const reportUnavailable = (error) => {
+        if (stopping || unavailable)
+            return;
+        unavailable = true;
+        options?.onUnavailable?.(error);
+    };
+    const subscription = await native.subscribe(dir, (err, events) => {
+        if (err) {
+            reportUnavailable(err);
+            return;
+        }
+        if (stopping || unavailable)
+            return;
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(() => onChange(events), debounceMs);
+    }, { ignore });
+    return async () => {
+        stopping = true;
+        if (timeout)
+            clearTimeout(timeout);
+        await subscription.unsubscribe();
+    };
+}
+export async function watchGitHead(dir, onBranchChange) {
+    const gitDir = join(dir, ".git");
+    const native = await loadParcel();
+    if (!native) {
+        try {
+            const handle = fsWatch(gitDir, (_event, filename) => {
+                if (filename && filename.toString().endsWith("HEAD"))
+                    onBranchChange();
+            });
+            return async () => handle.close();
+        }
+        catch {
+            return null;
+        }
+    }
+    try {
+        const subscription = await native.subscribe(gitDir, (err, events) => {
+            if (err)
+                return;
+            if (events.some((event) => event.path.endsWith("HEAD")))
+                onBranchChange();
+        }, { ignore: ["objects", "pack", "refs", "logs"] });
+        return () => subscription.unsubscribe();
+    }
+    catch {
+        return null;
+    }
+}

package/packages/daemon/dist/lib/environment-identity.d.ts

@@ -0,0 +1,9 @@
+/** Absolute path to the identity file: `<state-home>/environment.json`. */
+export declare function environmentIdentityPath(): string;
+/**
+ * Return the environment id for this daemon home, minting and persisting one
+ * when no valid record exists. A concurrent minter is resolved by re-reading
+ * after publication: the id on disk wins so every process converges on one
+ * identity.
+ */
+export declare function readOrMintEnvironmentId(): string;

package/packages/daemon/dist/lib/environment-identity.js

@@ -0,0 +1,79 @@
+/**
+ * The stable environment identity — a UUID minted ONCE per daemon state home
+ * and preserved across every daemon restart. It answers "which environment is
+ * this?" for clients that keep their own catalog of access endpoints, while
+ * `instanceId`/`startedAt` remain the per-process generation nonce and keep
+ * sole authority over generation checks.
+ *
+ * Persistence follows the state-home discipline (`TMUX_IDE_HOME` when set,
+ * else `~/.tmux-ide`): the read degrades to a re-mint on anything absent,
+ * unreadable, or malformed, and a failed write only costs stability across
+ * restarts — the freshly minted id still identifies this process lifetime,
+ * which is exactly the pre-environment-identity world. Never throws.
+ */
+import { randomUUID } from "node:crypto";
+import { linkSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { stateHome } from "./state-home.js";
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu;
+/** Absolute path to the identity file: `<state-home>/environment.json`. */
+export function environmentIdentityPath() {
+    return join(stateHome(), "environment.json");
+}
+function readPersistedEnvironmentId(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        const id = parsed.environmentId;
+        return typeof id === "string" && UUID_PATTERN.test(id) ? id : null;
+    }
+    catch {
+        return null;
+    }
+}
+function persistEnvironmentId(path, environmentId) {
+    const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+        writeFileSync(temporary, `${JSON.stringify({ environmentId, mintedAt: new Date().toISOString() }, null, 2)}\n`, { encoding: "utf-8", mode: 0o600 });
+        // link(2) is create-if-absent: a concurrent minter cannot overwrite an
+        // already-published identity, so every process converges on one id.
+        linkSync(temporary, path);
+    }
+    catch {
+        // Persistence is best-effort; the minted id below still identifies this
+        // process lifetime, and the next start simply mints again.
+    }
+    finally {
+        try {
+            rmSync(temporary, { force: true });
+        }
+        catch {
+            // The stray temp file is harmless.
+        }
+    }
+}
+/**
+ * Return the environment id for this daemon home, minting and persisting one
+ * when no valid record exists. A concurrent minter is resolved by re-reading
+ * after publication: the id on disk wins so every process converges on one
+ * identity.
+ */
+export function readOrMintEnvironmentId() {
+    const path = environmentIdentityPath();
+    const existing = readPersistedEnvironmentId(path);
+    if (existing)
+        return existing;
+    try {
+        // A malformed record would otherwise block create-if-absent publication
+        // forever; healing it restores a stable identity from the next line on.
+        rmSync(path, { force: true });
+    }
+    catch {
+        // Unremovable state degrades to a per-process id, never a crash.
+    }
+    const minted = randomUUID();
+    persistEnvironmentId(path, minted);
+    return readPersistedEnvironmentId(path) ?? minted;
+}

package/packages/daemon/dist/lib/errors.d.ts

@@ -23,7 +23,7 @@ export declare class SessionError extends IdeError {
         cause?: Error;
     });
 }
-export type DaemonStartupReason = "port_in_use" | "port_invalid" | "bind_failed" | "tmux_session_missing" | "canonical_already_running";
+export type DaemonStartupReason = "port_in_use" | "port_invalid" | "bind_failed" | "tmux_session_missing" | "canonical_already_running" | "canonical_record_invalid" | "canonical_claim_busy" | "canonical_publication_lost" | "canonical_takeover_refused" | "canonical_takeover_timeout" | "canonical_takeover_identity_mismatch";
 export declare class DaemonStartupError extends IdeError {
     readonly reason: DaemonStartupReason;
     constructor(message: string, reason: DaemonStartupReason, { cause }?: {

package/packages/daemon/dist/lib/fleet-agent-lifecycle.d.ts

@@ -0,0 +1,8 @@
+export declare const INTERRUPT_TAP_GAP_MS = 250;
+export declare const RESTART_GRACE_MS = 1000;
+export declare function launchCommandForHarness(harness: string): string;
+export declare function paneStartHostsShell(startCommand: string): boolean;
+export declare function interruptArgs(paneId: string): string[];
+export declare function relaunchArgs(paneId: string, command: string): string[][];
+export declare function respawnArgs(paneId: string, command: string, dir: string | null): string[];
+export declare function clearAuthorityArgs(paneId: string): string[][];

package/packages/daemon/dist/lib/fleet-agent-lifecycle.js

@@ -0,0 +1,65 @@
+/** Engine-neutral lifecycle model for daemon-owned fleet mutations. */
+import { TMUX_TRUECOLOR_ENVIRONMENT_ARGS, truecolorShellCommand } from "./tmux-terminal-color.js";
+const LAUNCH_COMMANDS = {
+    claude: "claude",
+    codex: "codex",
+    opencode: "opencode",
+    gemini: "gemini",
+    aider: "aider",
+    copilot: "copilot",
+    cursor: "cursor-agent",
+    goose: "goose",
+    amp: "amp",
+    devin: "devin",
+    kimi: "kimi",
+    pi: "pi",
+    grok: "grok",
+    kiro: "kiro-cli",
+    cline: "cline",
+    droid: "droid",
+    kilo: "kilo",
+};
+const SHELLS = new Set([
+    "sh",
+    "bash",
+    "zsh",
+    "fish",
+    "dash",
+    "ksh",
+    "nu",
+    "pwsh",
+    "powershell",
+    "cmd",
+]);
+export const INTERRUPT_TAP_GAP_MS = 250;
+export const RESTART_GRACE_MS = 1_000;
+export function launchCommandForHarness(harness) {
+    return LAUNCH_COMMANDS[harness] ?? harness;
+}
+export function paneStartHostsShell(startCommand) {
+    const token = startCommand.trim().split(/\s+/u)[0] ?? "";
+    const basename = token.replace(/^-/, "").replace(/\\/gu, "/").split("/").pop()?.toLowerCase() ?? "";
+    return basename === "" || SHELLS.has(basename.replace(/\.exe$/u, ""));
+}
+export function interruptArgs(paneId) {
+    return ["send-keys", "-t", paneId, "C-c"];
+}
+export function relaunchArgs(paneId, command) {
+    return [
+        ["send-keys", "-t", paneId, "-l", truecolorShellCommand(command)],
+        ["send-keys", "-t", paneId, "Enter"],
+    ];
+}
+export function respawnArgs(paneId, command, dir) {
+    const args = ["respawn-pane", "-k", "-t", paneId, ...TMUX_TRUECOLOR_ENVIRONMENT_ARGS];
+    if (dir)
+        args.push("-c", dir);
+    args.push(truecolorShellCommand(command));
+    return args;
+}
+export function clearAuthorityArgs(paneId) {
+    return [
+        ["set-option", "-p", "-t", paneId, "-u", "@agent_state"],
+        ["set-option", "-p", "-t", paneId, "-u", "@agent_session_id"],
+    ];
+}

package/packages/daemon/dist/lib/fleet-lifecycle-authority.d.ts

@@ -0,0 +1,21 @@
+import { type FleetAgentMutateArguments, type FleetAgentMutateResult, type FleetAgentProvisionArguments, type FleetAgentProvisionResult, type WorkspaceSessionCreateArguments, type WorkspaceSessionCreateResult } from "@tmux-ide/contracts";
+import type { WorkspaceRegistry } from "./workspace-registry.ts";
+import type { FleetSessionFacts } from "../command-center/discovery.ts";
+export declare class FleetLifecycleAuthorityError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export declare class FleetLifecycleAuthority {
+    #private;
+    constructor(options: {
+        daemonInstanceId: string;
+        productVersion: string;
+        startedAt: string;
+        registry: Pick<WorkspaceRegistry, "list" | "add">;
+        runTmux: (args: readonly string[]) => string;
+        readFleet?: () => FleetSessionFacts[] | null;
+    });
+    createSession(operationId: string, generation: string, input: WorkspaceSessionCreateArguments): Promise<WorkspaceSessionCreateResult>;
+    mutateAgent(operationId: string, generation: string, input: FleetAgentMutateArguments): Promise<FleetAgentMutateResult>;
+    provisionAgent(operationId: string, generation: string, input: FleetAgentProvisionArguments): Promise<FleetAgentProvisionResult>;
+}