tmux-ide 2.1.4 → 2.6.0

package/packages/daemon/dist/restore.js

@@ -0,0 +1,406 @@
+/**
+ * `tmux-ide restore` — rebuild the fleet from the last snapshot.
+ *
+ * The chrome updater continuously writes `~/.tmux-ide/snapshot.json`
+ * ({@link ./tui/chrome/snapshot.ts}); when the tmux server dies for real, this
+ * rebuilds every session it recorded — windows, split layouts, per-pane cwds,
+ * and titles — and re-adopts the sessions that were adopted.
+ *
+ * Safety first: an already-live session is NEVER clobbered (it's skipped), and
+ * recorded pane commands are NOT auto-run unless `--run-commands` is passed —
+ * a restored agent pane is a plain shell in the right directory with its title
+ * restored.
+ *
+ * `--resume-agents` (or `{ "restore": { "resumeAgents": true } }` in
+ * `~/.tmux-ide/config.json`) layers native agent-resume on top: a rebuilt
+ * claude pane that carries a recorded `@agent_session_id` relaunches as
+ * `claude --resume <id>`, reviving the actual conversation rather than opening
+ * a fresh shell. See {@link paneResumeCommand} for the exact decision table.
+ *
+ * {@link buildRestorePlan} + {@link paneResumeCommand} + {@link restorePrefs}
+ * are PURE (unit-tested); {@link restore} is the thin io wrapper that reads the
+ * snapshot + registry + live tmux + config, then executes the plan.
+ */
+import { runTmux } from "@tmux-ide/tmux-bridge";
+import { appConfigPath, loadAppConfig, parseAppConfig } from "./lib/app-config.js";
+import { IdeError } from "./lib/errors.js";
+import { listProjects } from "./lib/project-registry.js";
+import { adoptSession } from "./tui/chrome/statusline.js";
+import { readSnapshot, } from "./tui/chrome/snapshot.js";
+/**
+ * PURE — decide what to do with each snapshot session.
+ *
+ * Sessions are processed in snapshot order. A name that's already live is
+ * skipped. Otherwise, when `ideProjects` maps the name to a directory (a
+ * registry project whose dir has an ide.yml), we prefer relaunching from that
+ * config; failing that, we raw-rebuild from the recorded windows/panes.
+ */
+export function buildRestorePlan(snapshot, liveSessionNames, ideProjects = new Map()) {
+    const live = new Set(liveSessionNames);
+    const actions = [];
+    let paneCount = 0;
+    for (const session of snapshot.sessions) {
+        if (live.has(session.name)) {
+            actions.push({ kind: "skip", session: session.name });
+            continue;
+        }
+        const dir = ideProjects.get(session.name);
+        if (dir) {
+            actions.push({ kind: "launch", session: session.name, dir });
+            continue;
+        }
+        actions.push({ kind: "rebuild", session });
+        for (const window of session.windows)
+            paneCount += window.panes.length;
+    }
+    return { actions, paneCount };
+}
+// ---------------------------------------------------------------------------
+// Pure — agent resume decision
+// ---------------------------------------------------------------------------
+/** A session id is trusted only if it's the uuid alphabet — nothing shell-active. */
+const SAFE_SESSION_ID = /^[A-Za-z0-9-]+$/;
+/**
+ * PURE — the command to relaunch a pane so its agent conversation is revived,
+ * or `null` for "no resume — leave it a plain shell (or replay `command`)".
+ *
+ * Decision table (only fires when `resumeAgents` is on):
+ *  - claude + a recorded `@agent_session_id` → `claude --resume <id>`. The id is
+ *    a uuid, but we don't trust the snapshot: unless it matches
+ *    {@link SAFE_SESSION_ID} (`[A-Za-z0-9-]`) we bail to `null` rather than risk
+ *    feeding shell metacharacters into send-keys.
+ *  - claude with NO session id → `null`. `claude --continue` would be too
+ *    magical here (it resumes the most-recent conversation in the cwd, which may
+ *    belong to a different pane); a fresh shell is the safe, predictable default.
+ *  - any other agent → `null`. No native resume story yet.
+ *  - `resumeAgents` off → always `null`.
+ */
+export function paneResumeCommand(pane, opts) {
+    if (!opts.resumeAgents)
+        return null;
+    if (pane.agent !== "claude")
+        return null;
+    const id = pane.agentSessionId;
+    if (!id || !SAFE_SESSION_ID.test(id))
+        return null;
+    return `claude --resume ${id}`;
+}
+/** PURE — how many of a session's panes would resume under `resumeAgents`. */
+export function countResumableAgents(session, resumeAgents) {
+    let n = 0;
+    for (const window of session.windows) {
+        for (const pane of window.panes) {
+            if (paneResumeCommand(pane, { resumeAgents }))
+                n++;
+        }
+    }
+    return n;
+}
+/** Default: don't resume agents unless asked (flag or config). */
+export const DEFAULT_RESTORE_PREFS = { resumeAgents: false };
+/**
+ * PURE — read `{ restore: { resumeAgents } }` out of a parsed config, falling
+ * back to {@link DEFAULT_RESTORE_PREFS} for anything missing or mistyped.
+ * Delegates to the shared {@link parseAppConfig} so restore parsing can't drift
+ * from the rest of the config.
+ */
+export function restorePrefs(parsedConfig) {
+    return parseAppConfig(parsedConfig).restore;
+}
+/** Absolute path to the shared config (honors `TMUX_IDE_CONFIG`). */
+export function restoreConfigPath() {
+    return appConfigPath();
+}
+/** io — resolve restore prefs from the shared app config; missing/invalid → defaults. */
+export function readRestorePrefs() {
+    return loadAppConfig().restore;
+}
+// ---------------------------------------------------------------------------
+// io — execute a rebuild action against live tmux
+// ---------------------------------------------------------------------------
+function tmuxCapture(args) {
+    return runTmux(args, { encoding: "utf-8" }).toString().trim();
+}
+/**
+ * Raw-rebuild one session from its snapshot: create the session + its first
+ * window, add the remaining windows, split each window's panes (with their
+ * cwds), apply the recorded layout, restore titles, set the active window, and
+ * relaunch each pane per {@link RebuildOptions}.
+ *
+ * Per pane, at most ONE command is ever sent: an agent-resume command (when
+ * eligible under {@link paneResumeCommand}) takes precedence and, if it fires,
+ * suppresses the `--run-commands` replay for that pane. Returns the titles of
+ * the panes that were resumed (for the report).
+ */
+function rebuildSession(session, opts) {
+    const { runCommands, resumeAgents } = opts;
+    const resumedTitles = [];
+    const windows = session.windows;
+    if (windows.length === 0) {
+        runTmux(["new-session", "-d", "-s", session.name, "-c", session.cwd]);
+        return resumedTitles;
+    }
+    windows.forEach((window, w) => {
+        const windowCwd = window.panes[0]?.cwd || session.cwd;
+        // First window comes from new-session; the rest are added detached.
+        const windowId = w === 0
+            ? tmuxCapture([
+                "new-session",
+                "-d",
+                "-P",
+                "-F",
+                "#{window_id}",
+                "-s",
+                session.name,
+                "-c",
+                windowCwd,
+            ])
+            : tmuxCapture([
+                "new-window",
+                "-d",
+                "-P",
+                "-F",
+                "#{window_id}",
+                "-t",
+                `${session.name}:`,
+                "-c",
+                windowCwd,
+            ]);
+        // The window opens with one pane (snapshot pane 0). Create the rest; the
+        // layout string below fixes geometry, so split direction is irrelevant.
+        const paneIds = [tmuxCapture(["display-message", "-p", "-t", windowId, "#{pane_id}"])];
+        for (let p = 1; p < window.panes.length; p++) {
+            const paneCwd = window.panes[p].cwd || windowCwd;
+            paneIds.push(tmuxCapture([
+                "split-window",
+                "-d",
+                "-P",
+                "-F",
+                "#{pane_id}",
+                "-t",
+                paneIds[p - 1],
+                "-c",
+                paneCwd,
+            ]));
+        }
+        // Restore geometry from the recorded layout (tmux accepts the checksummed
+        // #{window_layout} string verbatim), then name the window.
+        if (window.layout)
+            runTmux(["select-layout", "-t", windowId, window.layout]);
+        if (window.name)
+            runTmux(["rename-window", "-t", windowId, window.name]);
+        // Restore per-pane titles (and optionally replay commands). Titles are
+        // paired by creation order, which matches the snapshot's index order.
+        window.panes.forEach((pane, p) => {
+            const paneId = paneIds[p];
+            if (!paneId)
+                return;
+            if (pane.title)
+                runTmux(["select-pane", "-t", paneId, "-T", pane.title]);
+            // Re-stamp agent identity so the next snapshot keeps it and 0037's
+            // agent-resume can find the conversation to revive.
+            if (pane.agentSessionId) {
+                runTmux(["set-option", "-p", "-t", paneId, "@agent_session_id", pane.agentSessionId]);
+            }
+            if (pane.agent) {
+                runTmux(["set-option", "-p", "-t", paneId, "@agent_hint", pane.agent]);
+            }
+            // Resume the agent conversation if eligible; that takes precedence over
+            // the recorded-command replay so a pane is never sent two commands.
+            const resumeCmd = paneResumeCommand(pane, { resumeAgents });
+            if (resumeCmd) {
+                runTmux(["send-keys", "-t", paneId, "-l", "--", resumeCmd]);
+                runTmux(["send-keys", "-t", paneId, "Enter"]);
+                resumedTitles.push(pane.title || paneId);
+            }
+            else if (runCommands && pane.command) {
+                runTmux(["send-keys", "-t", paneId, "-l", "--", pane.command]);
+                runTmux(["send-keys", "-t", paneId, "Enter"]);
+            }
+        });
+    });
+    // Set the active window to whatever the snapshot had focused.
+    const activeIndex = windows.findIndex((w) => w.active);
+    if (activeIndex >= 0) {
+        runTmux(["select-window", "-t", `${session.name}:${windows[activeIndex].index}`]);
+    }
+    return resumedTitles;
+}
+// ---------------------------------------------------------------------------
+// io — the command
+// ---------------------------------------------------------------------------
+/** Registry sessions whose dir has an ide.yml → name -> dir (the launch path). */
+function ideBackedProjects() {
+    const map = new Map();
+    try {
+        for (const project of listProjects()) {
+            if (project.hasIdeYml && project.dir)
+                map.set(project.name, project.dir);
+        }
+    }
+    catch {
+        // no registry → nothing prefers a launch; everything raw-rebuilds
+    }
+    return map;
+}
+function liveSessions() {
+    try {
+        const raw = tmuxCapture(["list-sessions", "-F", "#{session_name}"]);
+        return raw ? raw.split("\n").filter(Boolean) : [];
+    }
+    catch {
+        // no server / no sessions → nothing is live, rebuild everything
+        return [];
+    }
+}
+/**
+ * Rebuild the fleet from the last snapshot. Missing snapshot → friendly exit 1.
+ * `dryRun` prints the plan without touching tmux; `runCommands` opts into
+ * replaying recorded pane commands (off by default for safety); `resumeAgents`
+ * (flag ORed with the `~/.tmux-ide/config.json` default) revives agent
+ * conversations via `claude --resume <id>`.
+ */
+export async function restore({ json = false, dryRun = false, runCommands = false, resumeAgents = false, } = {}) {
+    const snapshot = readSnapshot();
+    if (!snapshot) {
+        throw new IdeError("no snapshot yet — the updater writes one every ~30s while any session is adopted", { code: "NO_SNAPSHOT", exitCode: 1 });
+    }
+    // The flag forces resume on; config makes it the default. No negative flag.
+    const resume = resumeAgents || readRestorePrefs().resumeAgents;
+    const plan = buildRestorePlan(snapshot, liveSessions(), ideBackedProjects());
+    if (dryRun) {
+        reportPlan(plan, snapshot, {
+            json,
+            dryRun: true,
+            restored: [],
+            launched: [],
+            resumed: [],
+            resumeAgents: resume,
+        });
+        return;
+    }
+    const restored = [];
+    const launched = [];
+    const resumed = [];
+    const recordResumed = (session, panes) => {
+        if (panes.length)
+            resumed.push({ session, panes });
+    };
+    for (const action of plan.actions) {
+        if (action.kind === "skip")
+            continue;
+        if (action.kind === "launch") {
+            const ok = await launchProject(action.dir, json);
+            if (ok)
+                launched.push(action.session);
+            else {
+                // Launch failed — fall back to a raw rebuild from the snapshot so the
+                // session still comes back.
+                const snap = snapshot.sessions.find((s) => s.name === action.session);
+                if (snap) {
+                    recordResumed(snap.name, rebuildSession(snap, { runCommands, resumeAgents: resume }));
+                    if (snap.adopted)
+                        safeAdopt(snap.name);
+                    restored.push(action.session);
+                }
+            }
+            continue;
+        }
+        recordResumed(action.session.name, rebuildSession(action.session, { runCommands, resumeAgents: resume }));
+        if (action.session.adopted)
+            safeAdopt(action.session.name);
+        restored.push(action.session.name);
+    }
+    reportPlan(plan, snapshot, {
+        json,
+        dryRun: false,
+        restored,
+        launched,
+        resumed,
+        resumeAgents: resume,
+    });
+}
+/** Adopt a restored session into the chrome; never let a chrome failure abort restore. */
+function safeAdopt(session) {
+    try {
+        adoptSession(session);
+    }
+    catch {
+        // chrome is optional — the session is already rebuilt
+    }
+}
+/**
+ * Relaunch a project from its ide.yml (config is the source of truth). Returns
+ * false on any failure so the caller can fall back to a raw rebuild. Launch's
+ * own stdout is swallowed in `--json` mode so the report stays parseable.
+ */
+async function launchProject(dir, json) {
+    const restoreLog = console.log;
+    if (json)
+        console.log = () => { };
+    try {
+        const { launch } = await import("./launch.js");
+        await launch(dir, { attach: false });
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        console.log = restoreLog;
+    }
+}
+function reportPlan(plan, snapshot, { json, dryRun, restored, launched, resumed, resumeAgents }) {
+    const skipped = plan.actions.filter((a) => a.kind === "skip").map((a) => a.session);
+    const willLaunch = plan.actions.filter((a) => a.kind === "launch").map((a) => a.session);
+    const willRebuild = plan.actions.filter((a) => a.kind === "rebuild").map((a) => a.session.name);
+    const resumedPanes = resumed.reduce((n, r) => n + r.panes.length, 0);
+    if (json) {
+        console.log(JSON.stringify({
+            dryRun,
+            savedAt: snapshot.savedAt,
+            skipped,
+            launched: dryRun ? willLaunch : launched,
+            restored: dryRun ? willRebuild : restored,
+            panes: plan.paneCount,
+            resumeAgents,
+            resumedPanes,
+            resumed,
+        }, null, 2));
+        return;
+    }
+    if (dryRun) {
+        console.log(`Restore plan (snapshot from ${snapshot.savedAt}):`);
+        for (const action of plan.actions) {
+            if (action.kind === "skip") {
+                console.log(`  skip     ${action.session} (already running)`);
+            }
+            else if (action.kind === "launch") {
+                console.log(`  launch   ${action.session} (ide.yml at ${action.dir})`);
+            }
+            else {
+                const w = action.session.windows.length;
+                const p = action.session.windows.reduce((n, win) => n + win.panes.length, 0);
+                const wouldResume = countResumableAgents(action.session, resumeAgents);
+                const resumeNote = wouldResume
+                    ? `, would resume ${wouldResume} agent${wouldResume === 1 ? "" : "s"}`
+                    : "";
+                console.log(`  rebuild  ${action.session.name} (${w} window${w === 1 ? "" : "s"}, ${p} pane${p === 1 ? "" : "s"}${resumeNote})`);
+            }
+        }
+        return;
+    }
+    const resumedBySession = new Map(resumed.map((r) => [r.session, r.panes.length]));
+    const resumeSuffix = (name) => {
+        const n = resumedBySession.get(name) ?? 0;
+        return n ? ` (resumed ${n} agent${n === 1 ? "" : "s"})` : "";
+    };
+    const parts = [];
+    if (restored.length)
+        parts.push(`rebuilt ${restored.map((s) => `${s}${resumeSuffix(s)}`).join(", ")}`);
+    if (launched.length)
+        parts.push(`launched ${launched.join(", ")}`);
+    if (skipped.length)
+        parts.push(`skipped ${skipped.join(", ")} (already running)`);
+    console.log(parts.length ? `Restored: ${parts.join("; ")}` : "Nothing to restore.");
+}

package/packages/daemon/dist/schemas/domain.d.ts

@@ -0,0 +1 @@
+export * from "@tmux-ide/contracts";

package/packages/daemon/dist/schemas/domain.js

@@ -0,0 +1,2 @@
+// Schemas extracted to @tmux-ide/contracts (T056). Re-export shim.
+export * from "@tmux-ide/contracts";

package/packages/daemon/dist/schemas/filesystem.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Filesystem browsing contracts. Powers the dashboard's directory picker
+ * (used in AddProjectDialog and elsewhere). The shape mirrors t3code's
+ * `FilesystemBrowseResult` so the consuming pattern (browse on partial
+ * path, render entries, click to navigate) ports straight across.
+ *
+ * The shape is FROZEN — the dashboard imports these via `@tmux-ide/schemas`.
+ * Add new fields by appending optional properties; do not rename existing
+ * fields without bumping a major.
+ */
+import { z } from "zod";
+export declare const FilesystemEntrySchemaZ: z.ZodObject<{
+    name: z.ZodString;
+    fullPath: z.ZodString;
+    isDir: z.ZodBoolean;
+    isSymlink: z.ZodBoolean;
+}, z.core.$strip>;
+export type FilesystemEntry = z.infer<typeof FilesystemEntrySchemaZ>;
+export declare const FilesystemBrowseResultSchemaZ: z.ZodObject<{
+    path: z.ZodString;
+    parentPath: z.ZodNullable<z.ZodString>;
+    entries: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        fullPath: z.ZodString;
+        isDir: z.ZodBoolean;
+        isSymlink: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type FilesystemBrowseResult = z.infer<typeof FilesystemBrowseResultSchemaZ>;

package/packages/daemon/dist/schemas/filesystem.js

@@ -0,0 +1,29 @@
+/**
+ * Filesystem browsing contracts. Powers the dashboard's directory picker
+ * (used in AddProjectDialog and elsewhere). The shape mirrors t3code's
+ * `FilesystemBrowseResult` so the consuming pattern (browse on partial
+ * path, render entries, click to navigate) ports straight across.
+ *
+ * The shape is FROZEN — the dashboard imports these via `@tmux-ide/schemas`.
+ * Add new fields by appending optional properties; do not rename existing
+ * fields without bumping a major.
+ */
+import { z } from "zod";
+export const FilesystemEntrySchemaZ = z.object({
+    /** Basename only (e.g. "src", "package.json"). Never contains a slash. */
+    name: z.string(),
+    /** Absolute, canonical path to the entry. */
+    fullPath: z.string(),
+    /** True if the entry is a directory (or a symlink pointing at one). */
+    isDir: z.boolean(),
+    /** True if the dirent itself is a symlink (regardless of target type). */
+    isSymlink: z.boolean(),
+});
+export const FilesystemBrowseResultSchemaZ = z.object({
+    /** Canonical absolute path of the directory listed. */
+    path: z.string(),
+    /** Parent directory path, or null if at filesystem / sandbox root. */
+    parentPath: z.string().nullable(),
+    /** Directories first, then files; alphabetical (case-insensitive) within group. */
+    entries: z.array(FilesystemEntrySchemaZ),
+});

package/packages/daemon/dist/schemas/ide-config.d.ts

@@ -0,0 +1 @@
+export * from "@tmux-ide/contracts";

package/packages/daemon/dist/schemas/ide-config.js

@@ -0,0 +1,2 @@
+// Schemas extracted to @tmux-ide/contracts (T056). Re-export shim.
+export * from "@tmux-ide/contracts";

package/packages/daemon/dist/schemas/index.d.ts

@@ -0,0 +1,12 @@
+export { PaneSchema, RowSchema, ThemeConfigSchema, OrchestratorYamlConfigSchema, IdeConfigSchema, PaneActionSchema, SessionStateSchema, } from "./ide-config.ts";
+export type { Pane, Row, ThemeConfig, OrchestratorYamlConfig, IdeConfig, PaneAction, SessionState, } from "./ide-config.ts";
+export { SessionOverviewSchemaZ, PaneInfoSchemaZ } from "./domain.ts";
+export type { SessionOverview, PaneInfo } from "./domain.ts";
+export { ClientFrameSchemaZ, ServerFrameSchemaZ, SessionSnapshotSchemaZ } from "./ws-events.ts";
+export type { ClientFrame, ServerFrame, SessionSnapshot } from "./ws-events.ts";
+export { RegisteredProjectSchemaZ, RegisterProjectRequestSchemaZ, InitProjectRequestSchemaZ, ProjectTemplateSchemaZ, } from "./registry.ts";
+export type { RegisteredProject, RegisterProjectRequest, InitProjectRequest, ProjectTemplate, } from "./registry.ts";
+export { FilesystemEntrySchemaZ, FilesystemBrowseResultSchemaZ } from "./filesystem.ts";
+export type { FilesystemEntry, FilesystemBrowseResult } from "./filesystem.ts";
+export { ProjectInspectDetectedSchemaZ, ProjectInspectSchemaZ, InspectFilesystemRequestSchemaZ, OnboardProjectRequestSchemaZ, } from "./inspect.ts";
+export type { ProjectInspectDetected, ProjectInspect, InspectFilesystemRequest, OnboardProjectRequest, } from "./inspect.ts";

package/packages/daemon/dist/schemas/index.js

@@ -0,0 +1,6 @@
+export { PaneSchema, RowSchema, ThemeConfigSchema, OrchestratorYamlConfigSchema, IdeConfigSchema, PaneActionSchema, SessionStateSchema, } from "./ide-config.js";
+export { SessionOverviewSchemaZ, PaneInfoSchemaZ } from "./domain.js";
+export { ClientFrameSchemaZ, ServerFrameSchemaZ, SessionSnapshotSchemaZ } from "./ws-events.js";
+export { RegisteredProjectSchemaZ, RegisterProjectRequestSchemaZ, InitProjectRequestSchemaZ, ProjectTemplateSchemaZ, } from "./registry.js";
+export { FilesystemEntrySchemaZ, FilesystemBrowseResultSchemaZ } from "./filesystem.js";
+export { ProjectInspectDetectedSchemaZ, ProjectInspectSchemaZ, InspectFilesystemRequestSchemaZ, OnboardProjectRequestSchemaZ, } from "./inspect.js";

package/packages/daemon/dist/schemas/inspect.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Project inspect + onboard contracts. Used by the dashboard's "Add project"
+ * dialog to inspect an arbitrary directory (without registering it) and to
+ * onboard a directory that has no `ide.yml` yet (compose, write, register).
+ *
+ * The shape is FROZEN — the dashboard imports these via `@tmux-ide/schemas`.
+ */
+import { z } from "zod";
+export declare const ProjectInspectDetectedSchemaZ: z.ZodObject<{
+    packageManager: z.ZodNullable<z.ZodEnum<{
+        pnpm: "pnpm";
+        bun: "bun";
+        yarn: "yarn";
+        npm: "npm";
+    }>>;
+    frameworks: z.ZodArray<z.ZodString>;
+    devCommand: z.ZodNullable<z.ZodString>;
+    testCommand: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type ProjectInspectDetected = z.infer<typeof ProjectInspectDetectedSchemaZ>;
+export declare const ProjectInspectSchemaZ: z.ZodObject<{
+    name: z.ZodString;
+    dir: z.ZodString;
+    hasIdeYml: z.ZodBoolean;
+    gitOrigin: z.ZodNullable<z.ZodString>;
+    gitBranch: z.ZodNullable<z.ZodString>;
+    detected: z.ZodObject<{
+        packageManager: z.ZodNullable<z.ZodEnum<{
+            pnpm: "pnpm";
+            bun: "bun";
+            yarn: "yarn";
+            npm: "npm";
+        }>>;
+        frameworks: z.ZodArray<z.ZodString>;
+        devCommand: z.ZodNullable<z.ZodString>;
+        testCommand: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ProjectInspect = z.infer<typeof ProjectInspectSchemaZ>;
+export declare const InspectFilesystemRequestSchemaZ: z.ZodObject<{
+    dir: z.ZodString;
+}, z.core.$strip>;
+export type InspectFilesystemRequest = z.infer<typeof InspectFilesystemRequestSchemaZ>;
+export declare const OnboardProjectRequestSchemaZ: z.ZodObject<{
+    dir: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    agents: z.ZodNumber;
+    agentNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    devCommand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    testCommand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    lintCommand: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type OnboardProjectRequest = z.infer<typeof OnboardProjectRequestSchemaZ>;

package/packages/daemon/dist/schemas/inspect.js

@@ -0,0 +1,57 @@
+/**
+ * Project inspect + onboard contracts. Used by the dashboard's "Add project"
+ * dialog to inspect an arbitrary directory (without registering it) and to
+ * onboard a directory that has no `ide.yml` yet (compose, write, register).
+ *
+ * The shape is FROZEN — the dashboard imports these via `@tmux-ide/schemas`.
+ */
+import { z } from "zod";
+export const ProjectInspectDetectedSchemaZ = z.object({
+    /** Detected package manager from lockfile, or `null`. */
+    packageManager: z.enum(["pnpm", "npm", "yarn", "bun"]).nullable(),
+    /** Detected frameworks (e.g. `["next", "convex"]`). Empty array when none. */
+    frameworks: z.array(z.string()),
+    /** Suggested dev command (e.g. `pnpm dev`). `null` if no dev script found. */
+    devCommand: z.string().nullable(),
+    /** Suggested test command (e.g. `pnpm test`). `null` if no test script found. */
+    testCommand: z.string().nullable(),
+});
+export const ProjectInspectSchemaZ = z.object({
+    /** Sanitized basename of the directory — safe to use as a tmux session name. */
+    name: z.string(),
+    /** Absolute, canonical path to the directory. */
+    dir: z.string(),
+    /** Whether `<dir>/ide.yml` exists. */
+    hasIdeYml: z.boolean(),
+    /** Git remote origin URL, or `null` if not a git repo / no origin / probe failed. */
+    gitOrigin: z.string().nullable(),
+    /** Current git branch, or `null` if not a git repo / detached HEAD / probe failed. */
+    gitBranch: z.string().nullable(),
+    /** Detected stack signals (reuses `tmux-ide detect` logic). */
+    detected: ProjectInspectDetectedSchemaZ,
+});
+// ---------------------------------------------------------------------------
+// REST request bodies
+// ---------------------------------------------------------------------------
+export const InspectFilesystemRequestSchemaZ = z.object({
+    dir: z.string().min(1),
+});
+export const OnboardProjectRequestSchemaZ = z.object({
+    dir: z.string().min(1),
+    /** Optional override for the project name — defaults to inspect.name. */
+    name: z.string().min(1).optional(),
+    /** 1, 2, or 3 — how many Claude panes to scaffold in the top row. */
+    agents: z.number().int().min(1).max(3),
+    /**
+     * Optional per-agent pane titles. When provided, length must equal
+     * `agents`; the server uses these as `title:` for the Claude panes
+     * instead of the canonical `Lead`/`Teammate N`/`Claude N` defaults.
+     */
+    agentNames: z.array(z.string().min(1)).optional(),
+    /** Dev server command (e.g. `pnpm dev`). Omit / null to skip the dev pane. */
+    devCommand: z.string().min(1).nullable().optional(),
+    /** Test command (e.g. `pnpm test`). Currently informational; stored for later. */
+    testCommand: z.string().min(1).nullable().optional(),
+    /** Lint command (e.g. `pnpm lint`). Currently informational; stored for later. */
+    lintCommand: z.string().min(1).nullable().optional(),
+});

package/packages/daemon/dist/schemas/registry.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Project registry contracts. The dashboard manages a list of projects the
+ * user has registered with tmux-ide; this schema is the wire shape exchanged
+ * over `/api/projects` and the `/ws/events` WebSocket channel.
+ *
+ * The shape is FROZEN — the dashboard imports these via `@tmux-ide/schemas`.
+ * Add new fields by appending optional properties; do not rename existing
+ * fields without bumping a major.
+ */
+import { z } from "zod";
+export declare const RegisteredProjectSchemaZ: z.ZodObject<{
+    name: z.ZodString;
+    dir: z.ZodString;
+    hasIdeYml: z.ZodBoolean;
+    gitOrigin: z.ZodNullable<z.ZodString>;
+    gitBranch: z.ZodNullable<z.ZodString>;
+    registeredAt: z.ZodString;
+}, z.core.$strip>;
+export type RegisteredProject = z.infer<typeof RegisteredProjectSchemaZ>;
+export declare const RegisterProjectRequestSchemaZ: z.ZodObject<{
+    dir: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RegisterProjectRequest = z.infer<typeof RegisterProjectRequestSchemaZ>;
+export declare const InitProjectRequestSchemaZ: z.ZodObject<{
+    dir: z.ZodString;
+    template: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type InitProjectRequest = z.infer<typeof InitProjectRequestSchemaZ>;
+export declare const ProjectTemplateSchemaZ: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+export type ProjectTemplate = z.infer<typeof ProjectTemplateSchemaZ>;