tmux-ide 2.7.0 → 2.9.0-beta.5

package/packages/daemon/dist/doctor.js

@@ -1,11 +1,14 @@
 import { execSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { accessSync, constants, existsSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { getCurrentVersion, getUpdateStatus } from "./lib/update-check.js";
 import { installedSkillVersion } from "./lib/skill-sync.js";
 import { discoverAgents, presentAgents } from "./lib/agent-discovery.js";
 import { findCompiledTui, isBunAvailable } from "./tui/compiled.js";
+import { claudeSettingsPath } from "./tui/integrations/claude.js";
+import { readNotificationPrefs, resolveNativeMacosNotifierPath } from "./tui/chrome/notify.js";
+import { resolveConfig } from "./lib/resolved-config.js";
 /**
  * PURE — the "agent integrations" doctor rows, one per DISCOVERED agent (absent
  * agents produce nothing — no noise). All rows are optional (informational, they
@@ -19,12 +22,18 @@ export function agentIntegrationRows(agents) {
     return presentAgents(agents).map((agent) => {
         const label = `agent: ${agent.id}`;
         if (agent.integration) {
+            // What installing actually buys, honestly per mechanism: claude's hooks
+            // give ground-truth status (and record resume ids); opencode's plugin
+            // records resume ids only.
+            const benefit = agent.capture === "hooks"
+                ? "for ground-truth status"
+                : "to record session ids for restore --resume-agents";
             return agent.installed
                 ? { label, pass: true, detail: "integration installed ✓", optional: true }
                 : {
                     label,
                     pass: false,
-                    detail: `found on PATH — run \`tmux-ide integration install ${agent.id}\` for ground-truth status`,
+                    detail: `found on PATH — run \`tmux-ide integration install ${agent.id}\` ${benefit}`,
                     optional: true,
                 };
         }
@@ -36,6 +45,52 @@ export function agentIntegrationRows(agents) {
         };
     });
 }
+/**
+ * PURE — the "Claude hooks target writable" row from observed facts. Both
+ * `integration install claude` and the npm postinstall write the settings
+ * file; surface a permissions problem BEFORE an install fails halfway.
+ * Optional: a machine without Claude Code shouldn't fail doctor over this.
+ */
+export function hooksTargetRow(facts) {
+    const label = "Claude hooks target writable";
+    if (facts.writable) {
+        return {
+            label,
+            pass: true,
+            detail: facts.fileExists ? facts.settingsPath : `${facts.settingsPath} (will be created)`,
+            optional: true,
+        };
+    }
+    return {
+        label,
+        pass: false,
+        detail: `cannot write ${facts.settingsPath} — fix its permissions (chown/chmod), or point TMUX_IDE_CLAUDE_SETTINGS at a writable path`,
+        optional: true,
+    };
+}
+/**
+ * PURE — native notifier health, shown only when macOS notifications are ON.
+ * Release packages always include the helper; absence means an incomplete or
+ * old installation, which can still fall back to the unbranded AppleScript path.
+ * Optional — informational, never fails doctor.
+ */
+export function notifierRow(present) {
+    const label = "native macOS notifications";
+    if (present) {
+        return {
+            label,
+            pass: true,
+            detail: "bundled — branded banners and click-to-jump are ready",
+            optional: true,
+        };
+    }
+    return {
+        label,
+        pass: false,
+        detail: "native helper missing — reinstall tmux-ide; unbranded AppleScript banners remain available",
+        optional: true,
+    };
+}
 function check(label, fn, { optional = false } = {}) {
     try {
         const result = fn();
@@ -48,7 +103,12 @@ function check(label, fn, { optional = false } = {}) {
 export async function doctor({ json, } = {}) {
     const checks = [];
     checks.push(check("tmux installed", () => {
-        execSync("which tmux", { stdio: "ignore" });
+        try {
+            execSync("which tmux", { stdio: "ignore" });
+        }
+        catch {
+            throw new Error("not found on PATH — install it (macOS: `brew install tmux`; Debian/Ubuntu: `sudo apt install tmux`)");
+        }
         return "found";
     }));
     checks.push(check("tmux version ≥ 3.0", () => {
@@ -74,12 +134,27 @@ export async function doctor({ json, } = {}) {
         }
         return term;
     }, { optional: true }));
-    checks.push(check("ide.yml exists", () => {
-        const path = resolve(".", "ide.yml");
-        if (!existsSync(path))
-            throw new Error("not found in current directory");
-        return "found";
-    }));
+    checks.push(await (async () => {
+        try {
+            const resolved = await resolveConfig(resolve("."));
+            if (resolved.kind === "none")
+                throw new Error("not found in current directory");
+            return {
+                label: "workspace config exists",
+                pass: true,
+                detail: resolved.kind === "legacy" ? "legacy ide.yml compatibility" : "found",
+                optional: false,
+            };
+        }
+        catch (e) {
+            return {
+                label: "workspace config exists",
+                pass: false,
+                detail: e.message,
+                optional: false,
+            };
+        }
+    })());
     checks.push(check("TUI surfaces (cockpit / widgets)", () => {
         // The OpenTUI/Solid surfaces run either from a dev checkout (bun + the
         // `.tsx` sources) or, when installed, from the compiled `tmux-ide-tui`
@@ -103,18 +178,45 @@ export async function doctor({ json, } = {}) {
         }
         return "enabled";
     }, { optional: true }));
-    checks.push(check("tailscale CLI", () => {
-        const version = execSync("tailscale version", { encoding: "utf-8" }).trim().split("\n")[0];
-        return version;
-    }, { optional: true }));
-    checks.push(check("ngrok CLI", () => {
-        const version = execSync("ngrok version", { encoding: "utf-8" }).trim();
-        return version;
-    }, { optional: true }));
-    checks.push(check("cloudflared CLI", () => {
-        const version = execSync("cloudflared --version", { encoding: "utf-8" }).trim();
-        return version;
-    }, { optional: true }));
+    // Optional tunnel CLIs: probe quietly (a missing binary must not leak
+    // "command not found" stderr into doctor's own output) and fail with a
+    // plain hint rather than execSync's raw error.
+    const tunnelCli = (label, cmd) => check(label, () => {
+        try {
+            return execSync(cmd, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] })
+                .trim()
+                .split("\n")[0];
+        }
+        catch {
+            throw new Error("not found (optional — used for remote access tunnels)");
+        }
+    }, { optional: true });
+    checks.push(tunnelCli("tailscale CLI", "tailscale version"));
+    checks.push(tunnelCli("ngrok CLI", "ngrok version"));
+    checks.push(tunnelCli("cloudflared CLI", "cloudflared --version"));
+    checks.push((() => {
+        // Claude hooks target: the settings file `integration install claude`
+        // (and the npm postinstall) will write. Writability of the file itself
+        // when it exists, else of its nearest existing ancestor directory.
+        const settingsPath = claudeSettingsPath();
+        const fileExists = existsSync(settingsPath);
+        let probe = fileExists ? settingsPath : dirname(settingsPath);
+        while (!existsSync(probe)) {
+            const parent = dirname(probe);
+            if (parent === probe)
+                break;
+            probe = parent;
+        }
+        let writable = false;
+        try {
+            accessSync(probe, constants.W_OK);
+            writable = true;
+        }
+        catch {
+            // leave writable=false — the row explains the fix
+        }
+        return hooksTargetRow({ settingsPath, fileExists, writable });
+    })());
     checks.push(check("tmux-ide up to date", () => {
         const current = getCurrentVersion();
         const { latest, updateAvailable } = getUpdateStatus({ currentVersion: current });
@@ -137,6 +239,10 @@ export async function doctor({ json, } = {}) {
         }
         return `in sync (v${installed})`;
     }, { optional: true }));
+    // Native branded sender: only when the macOS channel is actually on.
+    if (process.platform === "darwin" && readNotificationPrefs().macos) {
+        checks.push(notifierRow(resolveNativeMacosNotifierPath() !== null));
+    }
     // Agent integrations: one row per agent discovered on PATH (absent → no row).
     checks.push(...agentIntegrationRows(discoverAgents()));
     const allPass = checks.every((c) => c.pass || c.optional);

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

@@ -1,3 +1,22 @@
 export { startEmbeddedDaemon, type EmbeddedDaemonHandle, type EmbeddedDaemonOptions, } from "./embed.ts";
-export { clearCanonicalDaemonInfo, isCanonicalDaemonAlive, readCanonicalDaemonInfo, writeCanonicalDaemonInfo, } from "./canonical.ts";
-export type { CanonicalDaemonInfo } from "./canonical.ts";
+export { canonicalDaemonUrl, clearCanonicalDaemonInfoIfOwned, clearCanonicalDaemonInfoIfUnchanged, getCanonicalDaemonClaimPath, inspectCanonicalDaemonInfo, isCanonicalDaemonAlive, isCanonicalDaemonRecordOwnerProvenDead, probeCanonicalDaemonHealth, probeCanonicalDaemonIdentity, readCanonicalDaemonInfo, releaseCanonicalDaemonClaim, tryAcquireCanonicalDaemonClaim, writeCanonicalDaemonInfo, } from "./canonical.ts";
+export type { CanonicalDaemonInfo, CanonicalDaemonInfoInvalidReason, CanonicalDaemonInfoObservation, CanonicalDaemonInfoState, CanonicalDaemonClaim, CanonicalDaemonClaimAttempt, } from "./canonical.ts";
+export { MissionRepository, MissionRepositoryError, applyMissionEvent, replayMissionEvents, type MissionAttempt, type MissionHistoryEntry, type MissionProjectState, type MissionRepositorySnapshot, type MissionSnapshot, type MissionTask, } from "./lib/mission-repository.ts";
+export { MissionProjectionError, missionStatusToBoardColumn, projectMissionBoard, projectMissionDetail, projectMissionHistory, projectMissionTimeline, taskStatusToBoardColumn, type MissionProjectionErrorCode, type MissionProjectionOptions, } from "./lib/mission-projections.ts";
+export { APP_WINDOW_DOCUMENT_PATH, AppWindowRepositoryError, AppWindowService, type AppWindowRepositoryDiagnostic, type AppWindowRepositoryErrorCode, type AppWindowServiceMigrationOptions, type AppWindowServiceOptions, type AppWindowWriterLockOptions, type ExecuteAppWindowCommandOptions, type LoadedAppWindowDocument, type ResetAppWindowDocumentRequest, type ResetAppWindowDocumentResult, } from "./lib/app-window-repository.ts";
+export { APP_WINDOW_FLOAT_MIN_HEIGHT, APP_WINDOW_FLOAT_MIN_WIDTH, AppWindowKernelError, type AppWindowCommand, type AppWindowKernelErrorCode, } from "./lib/app-window-kernel.ts";
+export { CorruptRuntimeDocumentError, MissingRuntimeDocumentError, ProjectRuntimeRepository, ProjectRuntimeRepositoryError, ProjectRuntimeWriterLockTimeoutError, RevisionConflictError, createProjectRuntimeRepository, openProjectRuntimeRepository, type OpenProjectRuntimeRepositoryOptions, type ProjectRuntimeDocument, type ProjectRuntimeMetadata, type ProjectRuntimeRepositoryOptions, type ProjectRuntimeWriterLockOptions, type RecoverDocumentOptions, type RecoverDocumentResult, type WriteDocumentOptions, type WriteDocumentResult, } from "./lib/project-runtime-repository.ts";
+export { classifyProjectReadiness, type AuthenticationReadiness, type Availability, type CommandReadiness, type ConfigFreeLaunchPane, type ConfigFreeLaunchPlan, type HarnessKind, type HarnessReadinessState, type ProjectHarnessReadiness, type ProjectReadinessGitProbe, type ProjectReadinessHarnessProbe, type ProjectReadinessIssue, type ProjectReadinessIssueCode, type ProjectReadinessIssueSeverity, type ProjectReadinessPlatformProbe, type ProjectPathKind, type ProjectReadinessProbe, type ProjectReadinessProjectProbe, type ProjectReadinessResult, type ProjectReadinessToolProbe, type ProjectRecoveryAction, type ProjectRecoveryActionKind, type ProjectRegistrationState, } from "./lib/project-readiness.ts";
+export { assessProjectReadiness, probeProjectReadiness, type CustomReadinessHarnessProfile, type ProjectReadinessProbeIo, type ProjectReadinessProbeOptions, type ReadinessCommandOptions, type ReadinessCommandResult, type ReadinessCommandStatus, type ReadinessExecutableKind, type ReadinessPathKind, } from "./lib/project-readiness-probe.ts";
+export { WorkspacePaneCreationAuthority, WorkspacePaneCreationError, resolveWorkspacePaneTmuxAuthority, type WorkspacePaneCreationErrorCode, type WorkspacePaneCreationIo, type WorkspacePaneTmuxAuthority, } from "./lib/workspace-pane-creation.ts";
+export { AppWindowMutationAuthority, AppWindowMutationError, type AppWindowMutationErrorCode, } from "./lib/app-window-mutation.ts";
+export { SemanticPaneCatalog, SemanticPaneCatalogError, TrustedSemanticPaneSnapshotSchemaZ, semanticPaneTargetKey, type SemanticPaneCatalogErrorCode, type SemanticPaneCatalogOptions, type SemanticPaneResolution, type SemanticPaneRuntimeProof, type TrustedSemanticPaneSnapshot, } from "./terminal/attachments/semantic-pane-catalog.ts";
+export { AttachmentLeaseError, AttachmentLeaseManager, type AttachmentCleanupStatus, type AttachmentIssueContext, type AttachmentLeaseAuditEvent, type AttachmentLeaseBinding, type AttachmentLeaseDescriptor, type AttachmentLeaseErrorCode, type AttachmentLeaseManagerOptions, type AttachmentLeaseStatus, type AttachmentOrphanReconciliationResult, type AttachmentViewOperation, type AttachmentViewClientClaimKey, type AttachmentViewExecutor, type EnumeratedMarkedAttachmentView, type ExecutedAttachmentViewOperation, type ExecutedGuardedAttachmentClientOperation, type GuardedAttachmentViewOperation, type GuardedAttachmentViewOperationResult, type GuardedAttachmentCleanup, type GuardedAttachmentCleanupResult, type IssuedAttachmentLease, type RedeemedAttachmentLease, type ReconciledOrphanAttachmentDescriptor, } from "./terminal/attachments/lease-manager.ts";
+export { TmuxAttachmentViewExecutor, TmuxAttachmentOperationSerializer, TmuxAttachmentViewExecutorError, TmuxAttachmentClientTransportError, planCanonicalTmuxAttachmentClientCommand, type TmuxAttachmentCommandResult, type TmuxAttachmentCommandRunner, type TmuxAttachmentClientTransport, type TmuxAttachmentClientTransportErrorCode, type TmuxAttachmentClientTransportAttempt, type TmuxAttachmentClientTransportInput, type TmuxAttachmentClientTransportOutcome, type TmuxAttachmentViewExecutorErrorCode, type TmuxAttachmentViewExecutorOptions, } from "./terminal/attachments/tmux-view-executor.ts";
+export { PaneStreamLeaseError, PaneStreamLeaseManager, type IssuedPaneStreamLease, type PaneStreamIssueContext as PaneStreamLeaseIssueContext, type PaneStreamLeaseBinding, type PaneStreamLeaseDescriptor, type PaneStreamLeaseErrorCode, type PaneStreamLeaseManagerOptions, type PaneStreamLeaseStatus, } from "./terminal/pane-stream/lease-manager.ts";
+export { PANE_STREAM_MAX_CONTROL_BYTES, PANE_STREAM_MAX_REDEMPTION_BYTES, PANE_STREAM_MAX_REDEMPTION_MS, PaneStreamAdmissionCoordinator, PaneStreamAdmissionError, PaneStreamLiveConnection, type PaneStreamAdmissionCoordinatorOptions, type PaneStreamAdmissionErrorCode, type PaneStreamAdmissionSnapshot, type PaneStreamDescriptor, type PaneStreamIssueContext, type PaneStreamLeaseAuthority, type PaneStreamMirror, type PaneStreamPreAuthAdmission, type PaneStreamUpgradeDecision, } from "./terminal/pane-stream/pane-stream-websocket.ts";
+export { DEFAULT_PANE_STREAM_FLOW_BUDGETS, PANE_STREAM_FLOW_OWNERS, PaneStreamWireLedger, type PaneStreamFlowBudget, type PaneStreamFlowBudgets, type PaneStreamFlowOwner, type PaneStreamReturnedTickets, } from "./terminal/pane-stream/wire-ledger.ts";
+export { PaneStreamRuntime, createPaneStreamRuntime, type PaneStreamRuntimeOptions, } from "./terminal/pane-stream/runtime.ts";
+export { SessionRuntimeRegistry, SessionRuntimeControllerLeaseError, type SessionRuntimeConsumer, type SessionRuntimeControllerLease, type SessionRuntimeControllerLeaseErrorCode, type SessionRuntimeControllerRole, type SessionRuntimeControllerSnapshot, type SessionRuntimeRegistryOptions, } from "./terminal/session-runtime/registry.ts";
+export { createSessionRuntimeMultiplexerBackend, type SessionRuntimeMultiplexerBackendOptions, } from "./terminal/session-runtime/multiplexer-backend.ts";
+export { attachPaneStreamWebSocket, type PaneStreamWebSocketBoundary, } from "./server/pane-stream-upgrade.ts";

package/packages/daemon/dist/index.js

@@ -1,2 +1,21 @@
 export { startEmbeddedDaemon, } from "./embed.js";
-export { clearCanonicalDaemonInfo, isCanonicalDaemonAlive, readCanonicalDaemonInfo, writeCanonicalDaemonInfo, } from "./canonical.js";
+export { canonicalDaemonUrl, clearCanonicalDaemonInfoIfOwned, clearCanonicalDaemonInfoIfUnchanged, getCanonicalDaemonClaimPath, inspectCanonicalDaemonInfo, isCanonicalDaemonAlive, isCanonicalDaemonRecordOwnerProvenDead, probeCanonicalDaemonHealth, probeCanonicalDaemonIdentity, readCanonicalDaemonInfo, releaseCanonicalDaemonClaim, tryAcquireCanonicalDaemonClaim, writeCanonicalDaemonInfo, } from "./canonical.js";
+export { MissionRepository, MissionRepositoryError, applyMissionEvent, replayMissionEvents, } from "./lib/mission-repository.js";
+export { MissionProjectionError, missionStatusToBoardColumn, projectMissionBoard, projectMissionDetail, projectMissionHistory, projectMissionTimeline, taskStatusToBoardColumn, } from "./lib/mission-projections.js";
+export { APP_WINDOW_DOCUMENT_PATH, AppWindowRepositoryError, AppWindowService, } from "./lib/app-window-repository.js";
+export { APP_WINDOW_FLOAT_MIN_HEIGHT, APP_WINDOW_FLOAT_MIN_WIDTH, AppWindowKernelError, } from "./lib/app-window-kernel.js";
+export { CorruptRuntimeDocumentError, MissingRuntimeDocumentError, ProjectRuntimeRepository, ProjectRuntimeRepositoryError, ProjectRuntimeWriterLockTimeoutError, RevisionConflictError, createProjectRuntimeRepository, openProjectRuntimeRepository, } from "./lib/project-runtime-repository.js";
+export { classifyProjectReadiness, } from "./lib/project-readiness.js";
+export { assessProjectReadiness, probeProjectReadiness, } from "./lib/project-readiness-probe.js";
+export { WorkspacePaneCreationAuthority, WorkspacePaneCreationError, resolveWorkspacePaneTmuxAuthority, } from "./lib/workspace-pane-creation.js";
+export { AppWindowMutationAuthority, AppWindowMutationError, } from "./lib/app-window-mutation.js";
+export { SemanticPaneCatalog, SemanticPaneCatalogError, TrustedSemanticPaneSnapshotSchemaZ, semanticPaneTargetKey, } from "./terminal/attachments/semantic-pane-catalog.js";
+export { AttachmentLeaseError, AttachmentLeaseManager, } from "./terminal/attachments/lease-manager.js";
+export { TmuxAttachmentViewExecutor, TmuxAttachmentOperationSerializer, TmuxAttachmentViewExecutorError, TmuxAttachmentClientTransportError, planCanonicalTmuxAttachmentClientCommand, } from "./terminal/attachments/tmux-view-executor.js";
+export { PaneStreamLeaseError, PaneStreamLeaseManager, } from "./terminal/pane-stream/lease-manager.js";
+export { PANE_STREAM_MAX_CONTROL_BYTES, PANE_STREAM_MAX_REDEMPTION_BYTES, PANE_STREAM_MAX_REDEMPTION_MS, PaneStreamAdmissionCoordinator, PaneStreamAdmissionError, PaneStreamLiveConnection, } from "./terminal/pane-stream/pane-stream-websocket.js";
+export { DEFAULT_PANE_STREAM_FLOW_BUDGETS, PANE_STREAM_FLOW_OWNERS, PaneStreamWireLedger, } from "./terminal/pane-stream/wire-ledger.js";
+export { PaneStreamRuntime, createPaneStreamRuntime, } from "./terminal/pane-stream/runtime.js";
+export { SessionRuntimeRegistry, SessionRuntimeControllerLeaseError, } from "./terminal/session-runtime/registry.js";
+export { createSessionRuntimeMultiplexerBackend, } from "./terminal/session-runtime/multiplexer-backend.js";
+export { attachPaneStreamWebSocket, } from "./server/pane-stream-upgrade.js";

package/packages/daemon/dist/init.js

@@ -1,9 +1,13 @@
-import { existsSync, readFileSync, writeFileSync, renameSync, mkdirSync, readdirSync, copyFileSync, } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, copyFileSync, } from "node:fs";
 import { resolve, join, basename, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 import { detectStack, suggestConfig } from "./detect.js";
 import { outputError, printLayout } from "./lib/output.js";
+import { writeConfig } from "./lib/yaml-io.js";
+import { workspaceConfigToLegacyProjection } from "./lib/legacy-config-migration.js";
+import { resolveProjectConfigContext } from "./lib/config-context.js";
+import { WorkspaceConfigV1SchemaZ } from "@tmux-ide/contracts";
 function copyTemplateSkills(targetDir) {
     const created = [];
     const templateSkillsDir = resolve(__dirname, "..", "..", "..", "templates", "skills");
@@ -82,10 +86,11 @@ function scaffoldMissionsWorkspace(dir, name) {
     return created;
 }
 export async function init({ template, json, } = {}) {
-    const dir = process.cwd();
-    const configPath = resolve(dir, "ide.yml");
-    if (existsSync(configPath)) {
-        outputError("ide.yml already exists in this directory", "EXISTS");
+    const inputDir = process.cwd();
+    const context = await resolveProjectConfigContext(inputDir);
+    const dir = context.configWriteRoot;
+    if (context.configExists) {
+        outputError(`workspace config already exists at ${context.configPath}`, "EXISTS");
     }
     // If a specific template is requested, use it
     if (template) {
@@ -96,9 +101,10 @@ export async function init({ template, json, } = {}) {
         let content = readFileSync(templatePath, "utf-8");
         const name = basename(dir);
         content = content.replace(/^name: .+/m, `name: ${name}`);
-        const tmpPath = configPath + ".tmp";
-        writeFileSync(tmpPath, content);
-        renameSync(tmpPath, configPath);
+        const yaml = (await import("js-yaml")).default;
+        const workspace = WorkspaceConfigV1SchemaZ.parse(yaml.load(content));
+        const config = workspaceConfigToLegacyProjection(workspace);
+        writeConfig(dir, config);
         let created;
         if (template === "missions") {
             created = scaffoldMissionsWorkspace(dir, name);
@@ -116,9 +122,8 @@ export async function init({ template, json, } = {}) {
             console.log(JSON.stringify({ created: true, template, name, paths: created }));
         }
         else {
-            console.log(`Created ide.yml from "${template}" template for "${name}"`);
-            const yaml = (await import("js-yaml")).default;
-            printLayout(yaml.load(content));
+            console.log(`Created .tmux-ide/workspace.yml from "${template}" template for "${name}"`);
+            printLayout(config);
             for (const createdPath of created) {
                 console.log(`Created ${createdPath.replace(dir + "/", "")}`);
             }
@@ -131,16 +136,13 @@ export async function init({ template, json, } = {}) {
     if (detected.frameworks.length > 0) {
         // Use detected stack to generate config
         const config = suggestConfig(dir, detected);
-        const yaml = (await import("js-yaml")).default;
-        const tmpPath2 = configPath + ".tmp";
-        writeFileSync(tmpPath2, yaml.dump(config, { lineWidth: -1, noRefs: true, quotingType: '"' }));
-        renameSync(tmpPath2, configPath);
+        writeConfig(dir, config);
         const desc = detected.frameworks.join(" + ");
         if (json) {
             console.log(JSON.stringify({ created: true, detected: detected.frameworks, name }));
         }
         else {
-            console.log(`Detected ${desc}. Created ide.yml for "${name}".`);
+            console.log(`Detected ${desc}. Created .tmux-ide/workspace.yml for "${name}".`);
             printLayout(config);
             console.log("Edit it to customize, then run: tmux-ide");
         }
@@ -150,16 +152,16 @@ export async function init({ template, json, } = {}) {
         const templatePath = resolve(__dirname, "..", "..", "..", "templates", "default.yml");
         let content = readFileSync(templatePath, "utf-8");
         content = content.replace(/^name: .+/m, `name: ${name}`);
-        const tmpPath3 = configPath + ".tmp";
-        writeFileSync(tmpPath3, content);
-        renameSync(tmpPath3, configPath);
+        const yaml = (await import("js-yaml")).default;
+        const workspace = WorkspaceConfigV1SchemaZ.parse(yaml.load(content));
+        const config = workspaceConfigToLegacyProjection(workspace);
+        writeConfig(dir, config);
         if (json) {
             console.log(JSON.stringify({ created: true, template: "default", name }));
         }
         else {
-            console.log(`Created ide.yml for "${name}"`);
-            const yaml = (await import("js-yaml")).default;
-            printLayout(yaml.load(content));
+            console.log(`Created .tmux-ide/workspace.yml for "${name}"`);
+            printLayout(config);
             console.log("Edit it to configure your workspace, then run: tmux-ide");
         }
     }

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

@@ -1,5 +1,6 @@
 import { listPanes } from "@tmux-ide/tmux-bridge";
 import type { IdeConfig } from "./types.ts";
+import type { ResolvedConfigKind } from "./lib/resolved-config.ts";
 interface ResolvedPane {
     index: number;
     title: string | null;
@@ -19,6 +20,8 @@ interface ResolvedRow {
 interface Inspection {
     dir: string;
     configPath: string;
+    configKind: ResolvedConfigKind;
+    ideConfigPath: string | null;
     valid: boolean;
     errors: string[];
     session: string;
@@ -42,9 +45,12 @@ interface Inspection {
         panes: ReturnType<typeof listPanes>;
     };
 }
-export declare function buildInspection(dir: string, { config, configPath, running, panes, }: {
+export declare function buildInspection(dir: string, { config, configPath, running, panes, configKind, ideConfigPath, session, }: {
     config: IdeConfig;
     configPath: string;
+    configKind: ResolvedConfigKind;
+    ideConfigPath: string | null;
+    session: string;
     running: boolean;
     panes: ReturnType<typeof listPanes>;
 }): Inspection;

package/packages/daemon/dist/inspect.js

@@ -1,9 +1,10 @@
-import { resolve, basename } from "node:path";
-import { readConfig } from "./lib/yaml-io.js";
+import { resolve } from "node:path";
 import { validateConfig } from "./validate.js";
 import { outputError } from "./lib/output.js";
+import { ConfigError } from "./lib/errors.js";
 import { getSessionState, listPanes } from "@tmux-ide/tmux-bridge";
-export function buildInspection(dir, { config, configPath, running, panes, }) {
+import { resolveProjectConfigContext } from "./lib/config-context.js";
+export function buildInspection(dir, { config, configPath, running, panes, configKind, ideConfigPath, session, }) {
     const errors = validateConfig(config);
     const rows = Array.isArray(config?.rows) ? config.rows : [];
     const resolvedRows = rows.map((row, rowIndex) => ({
@@ -24,10 +25,11 @@ export function buildInspection(dir, { config, configPath, running, panes, }) {
     const focusPane = resolvedRows
         .flatMap((row) => row.panes.map((pane) => ({ row: row.index, pane })))
         .find(({ pane }) => pane.focus) ?? null;
-    const session = config?.name ?? basename(dir);
     return {
         dir,
         configPath,
+        configKind,
+        ideConfigPath,
         valid: errors.length === 0,
         errors,
         session,
@@ -58,23 +60,46 @@ export async function inspect(targetDir, { json } = {}) {
     const dir = resolve(targetDir ?? ".");
     let config;
     let configPath;
+    let configKind;
+    let session;
     try {
-        ({ config, configPath } = readConfig(dir));
+        const context = await resolveProjectConfigContext(dir);
+        const resolved = context.resolved;
+        if (!resolved?.launchConfig || !resolved.path) {
+            outputError("Cannot read workspace config: no config found", "READ_ERROR");
+            return;
+        }
+        config = resolved.launchConfig;
+        configPath = resolved.path;
+        configKind = resolved.kind;
+        session = context.sessionName;
     }
     catch (error) {
-        outputError(`Cannot read ide.yml: ${error.message}`, "READ_ERROR");
+        if (error instanceof ConfigError) {
+            outputError(error.message, error.code ?? "READ_ERROR");
+            return;
+        }
+        outputError(`Cannot read workspace config: ${error.message}`, "READ_ERROR");
         return;
     }
-    const session = config?.name ?? basename(dir);
     const state = getSessionState(session);
     const panes = state.running ? listPanes(session) : [];
-    const data = buildInspection(dir, { config, configPath, running: state.running, panes });
+    const data = buildInspection(dir, {
+        config,
+        configPath,
+        configKind,
+        ideConfigPath: configKind === "legacy" ? configPath : null,
+        session,
+        running: state.running,
+        panes,
+    });
     if (json) {
         console.log(JSON.stringify(data, null, 2));
         return;
     }
     console.log(`Directory: ${data.dir}`);
     console.log(`Config:    ${data.configPath}`);
+    console.log(`Kind:      ${data.configKind}`);
     console.log(`Valid:     ${data.valid ? "yes" : "no"}`);
     console.log(`Session:   ${data.session}`);
     console.log(`Running:   ${data.tmux.running ? "yes" : "no"}`);

package/packages/daemon/dist/launch.d.ts

@@ -1,3 +1,4 @@
+import { type ProjectConfigContext } from "./lib/config-context.ts";
 import type { Row } from "./types.ts";
 interface SplitPaneArgs {
     targetPane: string;
@@ -15,6 +16,7 @@ export declare function buildPaneMap(rows: Row[], dir: string, rootPaneId: strin
     paneMap: string[][];
     firstPanesOfRows: Set<string>;
 };
+export declare function launchRuntimeDir(context: ProjectConfigContext): string;
 export declare function launch(targetDir: string | undefined, { json, attach, sessionName, }?: {
     json?: boolean;
     attach?: boolean;

package/packages/daemon/dist/launch.js

@@ -1,12 +1,13 @@
 import { resolve } from "node:path";
 import { execSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import { readConfig, getSessionName } from "./lib/yaml-io.js";
+import { resolveProjectConfigContext } from "./lib/config-context.js";
 import { computeSizes, toSplitPercents } from "./lib/sizes.js";
 import { outputError } from "./lib/output.js";
-import { collectPaneStartupPlan } from "./lib/launch-plan.js";
+import { collectPaneStartupPlan, paneIdentityOptions, semanticWindowIdForSession, } from "./lib/launch-plan.js";
+import { WORKSPACE_SEMANTIC_WINDOW_OPTION } from "@tmux-ide/contracts";
 import { buildSessionOptions } from "./lib/session-options.js";
-import { attachSession, createDetachedSession, getPaneCurrentCommand, getSessionVariable, hasSession, runSessionCommand, selectPane, sendLiteral, setPaneOption, setPaneTitle, setSessionEnvironment, setSessionVariable, splitPane, } from "@tmux-ide/tmux-bridge";
+import { attachSession, createDetachedSession, getPaneCurrentCommand, getSessionVariable, hasSession, runSessionCommand, selectPane, sendLiteral, setPaneOption, setPaneTitle, setWindowOption, setSessionEnvironment, setSessionVariable, splitPane, } from "@tmux-ide/tmux-bridge";
 import { validateConfig } from "./validate.js";
 import { resolveSidebarConfig } from "./tui/chrome/sidebar.js";
 import { resolveWidgetCommand } from "./widgets/resolve.js";
@@ -82,20 +83,18 @@ export function buildPaneMap(rows, dir, rootPaneId, splitPaneFn) {
     }
     return { paneMap, firstPanesOfRows };
 }
-function loadLaunchConfig(dir) {
-    let config;
-    try {
-        ({ config } = readConfig(dir));
-    }
-    catch (error) {
-        if (error?.code === "ENOENT") {
-            outputError(`No ide.yml found in ${dir}. Run "tmux-ide init" or "tmux-ide detect --write" to create one.`, "CONFIG_NOT_FOUND");
-        }
-        outputError(`Cannot read ide.yml: ${error.message}`, "READ_ERROR");
+async function loadLaunchConfig(context, json) {
+    const config = context.resolved?.launchConfig ?? null;
+    if (!config) {
+        outputError(`No workspace config found in ${context.inputDir}. Run "tmux-ide init" or "tmux-ide detect --write" to create one.`, "CONFIG_NOT_FOUND");
     }
     const errors = validateConfig(config);
     if (errors.length > 0) {
-        outputError(`Invalid ide.yml in ${dir}. Run "tmux-ide validate" for details.`, "INVALID_CONFIG");
+        const configLocation = context.configPath ?? context.inputDir ?? context.projectRoot;
+        outputError(`Invalid workspace config in ${configLocation}. Run "tmux-ide validate" for details.`, "INVALID_CONFIG");
+    }
+    if (context.resolved?.migrationHint && !json && !process.env.TMUX_IDE_SUPPRESS_MIGRATION_HINT) {
+        console.log(context.resolved.migrationHint);
     }
     return config;
 }
@@ -125,15 +124,19 @@ function runBeforeHook(command, dir) {
         outputError(`The before hook failed: ${command}`, "BEFORE_HOOK_FAILED");
     }
 }
+export function launchRuntimeDir(context) {
+    return context.configWriteRoot;
+}
 export async function launch(targetDir, { json = false, attach = true, sessionName, } = {}) {
-    const dir = resolve(targetDir ?? ".");
-    const config = loadLaunchConfig(dir);
-    const { name: fallbackName } = getSessionName(dir);
+    const inputDir = resolve(targetDir ?? ".");
+    const context = await resolveProjectConfigContext(inputDir);
+    const dir = launchRuntimeDir(context);
+    const config = await loadLaunchConfig(context, json);
     // A `sessionName` override lets a worktree checkout run under its own session
     // name (e.g. `app@branch`) instead of colliding with the parent repo's
     // `config.name`; the whole flow keys off `session`, so the override threads
     // through session creation, adoption, and drift detection unchanged.
-    const session = sessionName ?? config.name ?? fallbackName;
+    const session = sessionName ?? config.name ?? context.sessionName;
     const headless = config.orchestrator?.widgets === false;
     const rows = headless ? stripWidgetPanes(config.rows) : config.rows;
     const theme = config.theme ?? {};
@@ -148,7 +151,7 @@ export async function launch(targetDir, { json = false, attach = true, sessionNa
             console.log(JSON.stringify({ session, running: true, configChanged }));
         }
         else if (configChanged) {
-            console.log(`Session "${session}" is running but ide.yml has changed.`);
+            console.log(`Session "${session}" is running but workspace config has changed.`);
             console.log(`Run "tmux-ide restart" to apply changes.`);
         }
         else {
@@ -171,15 +174,24 @@ export async function launch(targetDir, { json = false, attach = true, sessionNa
         setSessionEnvironment(session, "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS", "1");
     }
     const { paneMap, firstPanesOfRows } = buildPaneMap(rows, dir, rootPaneId, ({ targetPane, direction, cwd, percent }) => splitPane(targetPane, direction, cwd, percent));
-    const { focusPane, paneActions } = collectPaneStartupPlan(rows, paneMap, firstPanesOfRows, dir);
+    const { focusPane, paneActions, diagnostics: launchDiagnostics, } = collectPaneStartupPlan(rows, paneMap, firstPanesOfRows, dir);
+    for (const diagnostic of launchDiagnostics) {
+        console.error(`tmux-ide: warning: ${diagnostic.message}`);
+    }
+    // The CLI creates one root tmux window. Stamp it before the pane processes
+    // start so a recreated, already-registered workspace remains immediately
+    // attachable from the browser without an owner-side promotion replay.
+    setWindowOption(rootPaneId, WORKSPACE_SEMANTIC_WINDOW_OPTION, semanticWindowIdForSession(session));
     for (const action of paneActions) {
         if (action.title) {
             setPaneTitle(action.targetPane, action.title);
         }
-        // Set pane identity options for discovery by orchestrator/widgets
-        setPaneOption(action.targetPane, "@ide_role", action.paneRole ?? "shell");
-        setPaneOption(action.targetPane, "@ide_name", action.title ?? "");
-        setPaneOption(action.targetPane, "@ide_type", action.paneType ?? "shell");
+        // Stamp semantic identity before compatibility metadata. `%pane_id` remains
+        // a live tmux address only; this durable option is what workspace restore
+        // correlates across app and tmux-server restarts.
+        for (const [option, value] of paneIdentityOptions(action)) {
+            setPaneOption(action.targetPane, option, value);
+        }
         // Lock agent pane titles so Claude Code can't overwrite them
         if (action.paneRole === "lead" || action.paneRole === "teammate") {
             setPaneOption(action.targetPane, "allow-rename", "off");
@@ -232,10 +244,10 @@ export async function launch(targetDir, { json = false, attach = true, sessionNa
     // tolerate its absence (daemon may still be coming up, or running
     // sessionless). Print only when we have a real port to advertise.
     try {
-        const { readCanonicalDaemonInfo } = await import("./lib/canonical-daemon.js");
+        const { canonicalDaemonUrl, readCanonicalDaemonInfo } = await import("./lib/canonical-daemon.js");
         const info = readCanonicalDaemonInfo();
         if (info) {
-            console.log(`Command center: http://${info.bindHostname}:${info.port}/`);
+            console.log(`Command center: ${canonicalDaemonUrl("http", info.bindHostname, info.port)}/`);
         }
     }
     catch {