tmux-ide 2.7.0 → 2.9.0-beta.5

package/packages/daemon/dist/tui/team/wait-receipts.js

@@ -0,0 +1,153 @@
+/**
+ * Receipt-driven `wait agent-status` — the push twin of the polling loop in
+ * `wait.ts`.
+ *
+ * When a canonical daemon is running, its agent-status watcher already
+ * observes every `@agent_state` transition and emits a typed
+ * `agent.turn-completed` receipt on the `/ws/events` bus. Waiting on that
+ * receipt replaces the CLI's local poll (which re-scrapes the whole fleet
+ * every 750 ms) with a single WebSocket that sits idle until the daemon
+ * pushes the completion.
+ *
+ * Honest degrade: this path only answers for the receipt-covered targets
+ * (`done` / `idle` — the "turn finished" statuses). Every other case — no
+ * daemon record, dead daemon, connection failure, socket drop mid-wait, or a
+ * non-receipt target status — returns `null` and the caller falls back to the
+ * existing polling implementation. A timeout is a real answer, not a fallback.
+ *
+ * Deps are injected (daemon record reader, liveness probe, socket factory,
+ * one-shot status read, clock) so the waiting logic unit-tests without a
+ * daemon; the exported defaults wire the real io.
+ */
+import { WebSocket as WsWebSocket } from "ws";
+import { DaemonEventServerFrameSchemaZ } from "@tmux-ide/contracts";
+import { canonicalDaemonUrl, isCanonicalDaemonAlive, readCanonicalDaemonInfo, } from "../../lib/canonical-daemon.js";
+import { createStatusTracker } from "../detect/classify.js";
+import { findSessionStatus } from "./report.js";
+import { listTeamSessions } from "./sessions.js";
+import { WAIT_DEFAULT_TIMEOUT_MS } from "./wait.js";
+/** How long to give the daemon socket to open before falling back to polling. */
+export const RECEIPT_CONNECT_TIMEOUT_MS = 1_500;
+/** The statuses a turn-completed receipt can settle; all others need the poll. */
+export function isReceiptCoveredStatus(want) {
+    return want === "done" || want === "idle";
+}
+function messageText(data) {
+    if (typeof data === "string")
+        return data;
+    if (Buffer.isBuffer(data))
+        return data.toString("utf8");
+    if (data instanceof ArrayBuffer)
+        return Buffer.from(data).toString("utf8");
+    if (Array.isArray(data))
+        return Buffer.concat(data).toString("utf8");
+    return String(data);
+}
+/**
+ * Wait for `session` to reach `want` by listening for the daemon's
+ * `agent.turn-completed` receipt. Returns `null` whenever this path cannot
+ * answer (see module doc) so the caller falls back to polling; returns a
+ * {@link WaitAgentStatusResult} — success or honest timeout — when it can.
+ */
+export async function waitForAgentStatusViaReceipts(session, want, opts = {}) {
+    if (!isReceiptCoveredStatus(want))
+        return null;
+    const readInfo = opts.readDaemonInfo ?? readCanonicalDaemonInfo;
+    let info;
+    try {
+        info = readInfo();
+    }
+    catch {
+        return null;
+    }
+    if (!info)
+        return null;
+    const probeAlive = opts.probeAlive ?? isCanonicalDaemonAlive;
+    if (!(await probeAlive(info)))
+        return null;
+    const timeoutMs = opts.timeoutMs ?? WAIT_DEFAULT_TIMEOUT_MS;
+    const connectTimeoutMs = opts.connectTimeoutMs ?? RECEIPT_CONNECT_TIMEOUT_MS;
+    // A loopback-bound daemon admits same-machine upgrades without a token; a
+    // remote-bound daemon enforces its token even locally, so present the one
+    // the user-owned daemon.json already carries.
+    const authToken = info.authToken;
+    const openSocket = opts.openSocket ??
+        ((url) => new WsWebSocket(url, authToken ? { headers: { Authorization: `Bearer ${authToken}` } } : undefined));
+    const currentStatus = opts.currentStatus ??
+        (() => findSessionStatus(listTeamSessions(createStatusTracker()), session));
+    const url = canonicalDaemonUrl("ws", info.bindHostname, info.port, "/ws/events");
+    let socket;
+    try {
+        socket = openSocket(url);
+    }
+    catch {
+        return null;
+    }
+    return new Promise((resolve) => {
+        let settled = false;
+        let lastStatus = null;
+        let deadlineTimer = null;
+        let connectTimer = null;
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            if (connectTimer !== null)
+                clearTimeout(connectTimer);
+            if (deadlineTimer !== null)
+                clearTimeout(deadlineTimer);
+            try {
+                socket.close();
+            }
+            catch {
+                // already gone — nothing to release
+            }
+            resolve(result);
+        };
+        connectTimer = setTimeout(() => settle(null), connectTimeoutMs);
+        connectTimer.unref?.();
+        socket.on("error", () => settle(null));
+        socket.on("close", () => settle(null));
+        socket.on("open", () => {
+            if (settled)
+                return;
+            if (connectTimer !== null)
+                clearTimeout(connectTimer);
+            deadlineTimer = setTimeout(() => settle({ ok: false, session, want, status: lastStatus, timedOutAfterMs: timeoutMs }), timeoutMs);
+            deadlineTimer.unref?.();
+            // The watcher baselines when the first client connects, so a receipt can
+            // only describe a transition AFTER this socket exists. Answer the
+            // already-finished case with one direct read.
+            try {
+                lastStatus = currentStatus();
+            }
+            catch {
+                lastStatus = null;
+            }
+            if (lastStatus === want) {
+                settle({ ok: true, session, want, status: want });
+            }
+        });
+        socket.on("message", (data) => {
+            if (settled)
+                return;
+            let raw;
+            try {
+                raw = JSON.parse(messageText(data));
+            }
+            catch {
+                return; // not a protocol frame — ignore
+            }
+            const parsed = DaemonEventServerFrameSchemaZ.safeParse(raw);
+            if (!parsed.success)
+                return;
+            const frame = parsed.data;
+            if (frame.type !== "agent.turn-completed" || frame.sessionName !== session)
+                return;
+            lastStatus = frame.toStatus;
+            if (frame.toStatus === want) {
+                settle({ ok: true, session, want, status: want });
+            }
+        });
+    });
+}

package/packages/daemon/dist/tui/team/wait.d.ts

@@ -0,0 +1,62 @@
+import type { AgentStatus, StatusTracker } from "../detect/classify.ts";
+import { type TeamSession } from "./sessions.ts";
+/** Default overall timeout (matches the CLI's historical default). */
+export declare const WAIT_DEFAULT_TIMEOUT_MS = 60000;
+/** Poll cadence for the agent-status wait. */
+export declare const WAIT_STATUS_POLL_MS = 750;
+/** Poll cadence for the output-match wait. */
+export declare const WAIT_OUTPUT_POLL_MS = 500;
+/**
+ * PURE — test `text` (a pane capture) against `pattern`, line by line, and
+ * report the first matching LINE; falls back to whole-text matching (with the
+ * last line reported) so multi-line patterns still hit. A fresh RegExp per
+ * test so a user-supplied /g flag can't carry `lastIndex` between calls.
+ * Returns null when nothing matches.
+ */
+export declare function matchOutput(text: string, pattern: string): string | null;
+export interface WaitAgentStatusResult {
+    ok: boolean;
+    session: string;
+    want: AgentStatus;
+    /** The session's last observed status (null = session absent). */
+    status: AgentStatus | null;
+    /** Set when `ok` is false: how long we waited. */
+    timedOutAfterMs?: number;
+}
+export interface WaitAgentStatusOpts {
+    timeoutMs?: number;
+    pollMs?: number;
+    /**
+     * The tracker threaded across polls (one PERSISTS per wait so the
+     * cross-tick working→idle `done` transition can be observed). Injected by
+     * tests; defaults to a fresh tracker.
+     */
+    tracker?: StatusTracker;
+    listSessions?: (tracker: StatusTracker) => TeamSession[];
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}
+/** Block until `session` reaches `want`, or time out. Never throws. */
+export declare function waitForAgentStatus(session: string, want: AgentStatus, opts?: WaitAgentStatusOpts): Promise<WaitAgentStatusResult>;
+export interface WaitOutputResult {
+    ok: boolean;
+    target: string;
+    pattern: string;
+    /** The matching line when `ok`; null on timeout. */
+    matched: string | null;
+    timedOutAfterMs?: number;
+}
+export interface WaitOutputOpts {
+    timeoutMs?: number;
+    pollMs?: number;
+    /** Pane capture (defaults to tmux-bridge's `capturePane`, 200 lines). */
+    capture?: (target: string) => string;
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}
+/**
+ * Block until `target`'s captured output matches `pattern`, or time out.
+ * A capture failure (pane/session not (yet) available) keeps polling until
+ * the timeout. Throws only on an invalid regex — validate before looping.
+ */
+export declare function waitForOutputMatch(target: string, pattern: string, opts?: WaitOutputOpts): Promise<WaitOutputResult>;

package/packages/daemon/dist/tui/team/wait.js

@@ -0,0 +1,90 @@
+/**
+ * The `wait` conditions — the SHARED implementation behind `tmux-ide wait
+ * agent-status` / `tmux-ide wait output` (bin/cli.ts) and the control
+ * socket's `wait` verb (src/control/). Extracted from the CLI case so the
+ * socket is a transport over the same logic, not a second implementation.
+ *
+ * Both loops are deps-injected (fleet lister / pane capture, clock, sleep)
+ * so the polling logic unit-tests without tmux; the exported defaults wire
+ * the real io.
+ */
+import { capturePane } from "@tmux-ide/tmux-bridge";
+import { createStatusTracker } from "../detect/classify.js";
+import { findSessionStatus } from "./report.js";
+import { listTeamSessions } from "./sessions.js";
+/** Default overall timeout (matches the CLI's historical default). */
+export const WAIT_DEFAULT_TIMEOUT_MS = 60_000;
+/** Poll cadence for the agent-status wait. */
+export const WAIT_STATUS_POLL_MS = 750;
+/** Poll cadence for the output-match wait. */
+export const WAIT_OUTPUT_POLL_MS = 500;
+const sleepMs = (ms) => new Promise((r) => setTimeout(r, ms));
+/**
+ * PURE — test `text` (a pane capture) against `pattern`, line by line, and
+ * report the first matching LINE; falls back to whole-text matching (with the
+ * last line reported) so multi-line patterns still hit. A fresh RegExp per
+ * test so a user-supplied /g flag can't carry `lastIndex` between calls.
+ * Returns null when nothing matches.
+ */
+export function matchOutput(text, pattern) {
+    const lines = text.split("\n");
+    for (const line of lines) {
+        if (new RegExp(pattern).test(line))
+            return line;
+    }
+    if (new RegExp(pattern).test(text))
+        return lines[lines.length - 1] ?? "";
+    return null;
+}
+/** Block until `session` reaches `want`, or time out. Never throws. */
+export async function waitForAgentStatus(session, want, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? WAIT_DEFAULT_TIMEOUT_MS;
+    const pollMs = opts.pollMs ?? WAIT_STATUS_POLL_MS;
+    const tracker = opts.tracker ?? createStatusTracker();
+    const list = opts.listSessions ?? listTeamSessions;
+    const now = opts.now ?? Date.now;
+    const sleep = opts.sleep ?? sleepMs;
+    const started = now();
+    for (;;) {
+        const status = findSessionStatus(list(tracker), session);
+        if (status === want)
+            return { ok: true, session, want, status };
+        if (now() - started >= timeoutMs) {
+            return { ok: false, session, want, status, timedOutAfterMs: timeoutMs };
+        }
+        await sleep(pollMs);
+    }
+}
+/**
+ * Block until `target`'s captured output matches `pattern`, or time out.
+ * A capture failure (pane/session not (yet) available) keeps polling until
+ * the timeout. Throws only on an invalid regex — validate before looping.
+ */
+export async function waitForOutputMatch(target, pattern, opts = {}) {
+    new RegExp(pattern); // an invalid pattern is a usage error, surfaced up front
+    const timeoutMs = opts.timeoutMs ?? WAIT_DEFAULT_TIMEOUT_MS;
+    const pollMs = opts.pollMs ?? WAIT_OUTPUT_POLL_MS;
+    const capture = opts.capture ?? defaultCapture;
+    const now = opts.now ?? Date.now;
+    const sleep = opts.sleep ?? sleepMs;
+    const started = now();
+    for (;;) {
+        let text = "";
+        try {
+            text = capture(target);
+        }
+        catch {
+            // not capturable yet — keep polling
+        }
+        const matched = matchOutput(text, pattern);
+        if (matched !== null)
+            return { ok: true, target, pattern, matched };
+        if (now() - started >= timeoutMs) {
+            return { ok: false, target, pattern, matched: null, timedOutAfterMs: timeoutMs };
+        }
+        await sleep(pollMs);
+    }
+}
+function defaultCapture(target) {
+    return capturePane(target, { lines: 200 });
+}

package/packages/daemon/dist/validate.js

@@ -1,7 +1,7 @@
 import { resolve } from "node:path";
-import { readConfig } from "./lib/yaml-io.js";
 import { outputError } from "./lib/output.js";
 import { IdeConfigSchema } from "./schemas/ide-config.js";
+import { resolveConfig } from "./lib/resolved-config.js";
 export function validateConfig(config) {
     if (config == null || typeof config !== "object" || Array.isArray(config)) {
         return ["config must be an object"];
@@ -157,25 +157,31 @@ function mapZodIssue(issue, config) {
 }
 export async function validate(targetDir, { json } = {}) {
     const dir = resolve(targetDir ?? ".");
-    let config;
-    try {
-        ({ config } = readConfig(dir));
-    }
-    catch (e) {
-        outputError(`Cannot read ide.yml: ${e.message}`, "READ_ERROR");
+    const resolved = await resolveConfig(dir);
+    const config = resolved.launchConfig;
+    if (!config) {
+        outputError("Cannot read workspace config: no config found", "READ_ERROR");
         return;
     }
     const errors = validateConfig(config);
     const valid = errors.length === 0;
     if (json) {
-        console.log(JSON.stringify({ valid, errors }, null, 2));
+        console.log(JSON.stringify({
+            valid,
+            errors,
+            configKind: resolved.kind,
+            configPath: resolved.path,
+            legacyDiagnostics: resolved.diagnostics,
+        }, null, 2));
         return;
     }
     if (valid) {
-        console.log("✓ ide.yml is valid");
+        console.log(`✓ ${resolved.kind === "legacy" ? "legacy ide.yml" : "workspace config"} is valid`);
+        if (resolved.migrationHint)
+            console.log(resolved.migrationHint);
     }
     else {
-        console.log("✗ ide.yml has errors:");
+        console.log("✗ workspace config has errors:");
         for (const e of errors) {
             console.log(`  - ${e}`);
         }

package/packages/daemon/dist/widgets/lib/watcher.d.ts

@@ -1,9 +1,5 @@
-export interface WatchEvent {
-    type: "create" | "update" | "delete";
-    path: string;
-}
-export declare function watchDirectory(dir: string, onChange: (events: WatchEvent[]) => void, options?: {
-    debounceMs?: number;
-    ignore?: string[];
-}): Promise<() => Promise<void>>;
-export declare function watchGitHead(dir: string, onBranchChange: () => void): Promise<(() => Promise<void>) | null>;
+/**
+ * Adapter compatibility export. Watcher ownership lives in the daemon engine;
+ * widget surfaces consume it without becoming a dependency of command-center.
+ */
+export { watchDirectory, watchGitHead, type WatchEvent } from "../../lib/directory-watcher.ts";

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

@@ -1,92 +1,5 @@
-import { watch as fsWatch } from "node:fs";
-import { join, sep } from "node:path";
-// undefined = not attempted yet, null = confirmed unavailable (compiled binary).
-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) {
-    const ignoreSet = new Set(ignore);
-    let timeout = null;
-    let handle = null;
-    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);
-        });
-    }
-    catch {
-        // Directory may be unreadable/vanished — degrade to a no-op watcher.
-    }
-    return async () => {
-        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);
-    let timeout = null;
-    const subscription = await native.subscribe(dir, (err, events) => {
-        if (err)
-            return;
-        if (timeout)
-            clearTimeout(timeout);
-        timeout = setTimeout(() => onChange(events), debounceMs);
-    }, { ignore });
-    return async () => {
-        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((e) => e.path.endsWith("HEAD"))) {
-                onBranchChange();
-            }
-        }, { ignore: ["objects", "pack", "refs", "logs"] });
-        return () => subscription.unsubscribe();
-    }
-    catch {
-        return null;
-    }
-}
+/**
+ * Adapter compatibility export. Watcher ownership lives in the daemon engine;
+ * widget surfaces consume it without becoming a dependency of command-center.
+ */
+export { watchDirectory, watchGitHead } from "../../lib/directory-watcher.js";

package/packages/daemon/dist/widgets/resolve.js

@@ -2,7 +2,7 @@ import { resolve, dirname } from "node:path";
 import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { shellEscape } from "../lib/shell.js";
-import { resolveTuiLaunch, findCompiledTui, isBunAvailable } from "../tui/compiled.js";
+import { ensureCompiledTuiRuntimeDir, resolveTuiLaunch, findCompiledTui, isBunAvailable, } from "../tui/compiled.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // The .tsx extension is used at runtime; Bun handles JSX via preload plugin.
 // Exactly the widgets that exist — a stale entry here becomes a dead
@@ -57,6 +57,7 @@ export function resolveWidgetCommand(type, opts) {
         checkoutExists: existsSync(scriptPath),
         bunAvailable: isBunAvailable(),
         compiledBinary: findCompiledTui(),
+        preferSource: process.env.TMUX_IDE_TUI_SOURCE === "1",
     });
     if (launch.mode === "unavailable") {
         throw new Error(`Cannot launch ${type} widget: ${launch.reasons.join("; ")}`);
@@ -67,9 +68,10 @@ export function resolveWidgetCommand(type, opts) {
         // preload is found; the project dir rides in via --dir.
         return `cd ${shellEscape(REPO_ROOT)} && bun ${escapedArgs}`;
     }
-    // Compiled binary: no bunfig to find (JSX + native dylib are baked in). Run
-    // from the pane's dir so a stray repo-root bunfig can't hijack the preload.
-    return `cd ${shellEscape(opts.dir)} && ${shellEscape(launch.bin)} ${escapedArgs}`;
+    // Compiled Bun executables still inspect bunfig.toml in their cwd before the
+    // embedded entry runs. Keep them in the private config-free runtime dir;
+    // the widget's project directory is already explicit in --dir.
+    return `cd ${shellEscape(ensureCompiledTuiRuntimeDir())} && ${shellEscape(launch.bin)} ${escapedArgs}`;
 }
 /**
  * Structured form of `resolveWidgetCommand` for direct PTY spawning. Callers
@@ -88,13 +90,14 @@ export function resolveWidgetSpawn(type, opts) {
         checkoutExists: existsSync(scriptPath),
         bunAvailable: isBunAvailable(),
         compiledBinary: findCompiledTui(),
+        preferSource: process.env.TMUX_IDE_TUI_SOURCE === "1",
     });
     if (launch.mode === "unavailable") {
         throw new Error(`Cannot launch ${type} widget: ${launch.reasons.join("; ")}`);
     }
-    // Bun spawns from the repo root (bunfig preload); the binary spawns from the
-    // pane's dir (self-contained, avoids a stray bunfig preload).
-    const cwd = launch.mode === "bun" ? REPO_ROOT : opts.dir;
+    // Bun source needs the repo preload; the compiled executable must be
+    // isolated from every ambient bunfig. Project identity rides in --dir.
+    const cwd = launch.mode === "bun" ? REPO_ROOT : ensureCompiledTuiRuntimeDir();
     return { cwd, cmd: [launch.bin, ...launch.argv] };
 }
 export const WIDGET_TYPES = Object.keys(WIDGET_ENTRY_POINTS);

package/packages/daemon/dist/widgets/setup/setup-model.js

@@ -115,39 +115,37 @@ export const PRESETS = [
     {
         id: "agent-team",
         label: "Agent Team",
-        description: "Lead + 2 teammates on top, mission control/explorer/preview widgets below with orchestrator.",
+        description: "Lead + 2 teammates on top, changes/explorer/preview widgets below.",
         diagram: [
             "┌───────────┬───────────┬───────────┐",
             "│           │           │           │",
             "│   Lead    │ Teammate1 │ Teammate2 │  70%",
             "│           │           │           │",
             "├───────────┼───────────┴───────────┤",
-            "│  Mission  │  Explorer  │ Preview  │  30%",
-            "│  Control  │            │          │",
+            "│ Changes   │  Explorer  │ Preview  │  30%",
+            "│           │            │          │",
             "└───────────┴────────────┴──────────┘",
         ],
         buildConfig(name, _detected) {
             return {
                 name,
-                team: { name: name },
                 rows: [
                     {
                         size: "70%",
                         panes: [
-                            { title: "Lead", command: "claude", role: "lead", focus: true, size: "33%" },
-                            { title: "Teammate 1", command: "claude", role: "teammate", size: "34%" },
-                            { title: "Teammate 2", command: "claude", role: "teammate" },
+                            { title: "Lead", command: "claude", focus: true, size: "33%" },
+                            { title: "Teammate 1", command: "claude", size: "34%" },
+                            { title: "Teammate 2", command: "claude" },
                         ],
                     },
                     {
                         panes: [
-                            { title: "Mission Control", type: "mission-control", size: "40%" },
+                            { title: "Changes", type: "changes", size: "40%" },
                             { title: "Explorer", type: "explorer", size: "30%" },
                             { title: "Preview", type: "preview" },
                         ],
                     },
                 ],
-                orchestrator: { enabled: true, auto_dispatch: true },
             };
         },
     },

package/packages/daemon/src/attach.ts

@@ -1,14 +1,14 @@
 import { resolve } from "node:path";
-import { getSessionName } from "./lib/yaml-io.ts";
 import { outputError } from "./lib/output.ts";
 import { attachSession, getSessionState } from "@tmux-ide/tmux-bridge";
+import { resolveProjectConfigContext } from "./lib/config-context.ts";
 
 export async function attach(
   targetDir: string | undefined,
   { json: _json }: { json?: boolean } = {},
 ): Promise<void> {
   const dir = resolve(targetDir ?? ".");
-  const { name: session } = getSessionName(dir);
+  const { sessionName: session } = await resolveProjectConfigContext(dir);
   const state = getSessionState(session);
 
   if (!state.running) {

package/packages/daemon/src/canonical.ts

@@ -1,7 +1,24 @@
 export {
-  clearCanonicalDaemonInfo,
+  canonicalDaemonUrl,
+  canonicalDaemonClaimAllowsStartupAttempt,
+  clearCanonicalDaemonInfoIfOwned,
+  clearCanonicalDaemonInfoIfUnchanged,
+  getCanonicalDaemonClaimPath,
+  inspectCanonicalDaemonInfo,
   isCanonicalDaemonAlive,
+  isCanonicalDaemonRecordOwnerProvenDead,
+  probeCanonicalDaemonHealth,
+  probeCanonicalDaemonIdentity,
   readCanonicalDaemonInfo,
+  releaseCanonicalDaemonClaim,
+  tryAcquireCanonicalDaemonClaim,
   writeCanonicalDaemonInfo,
 } from "./lib/canonical-daemon.ts";
-export type { CanonicalDaemonInfo } from "./lib/canonical-daemon.ts";
+export type {
+  CanonicalDaemonInfo,
+  CanonicalDaemonInfoInvalidReason,
+  CanonicalDaemonInfoObservation,
+  CanonicalDaemonInfoState,
+  CanonicalDaemonClaim,
+  CanonicalDaemonClaimAttempt,
+} from "./lib/canonical-daemon.ts";