tmux-ide 2.7.0 → 2.9.0-beta.5

package/packages/daemon/src/cli.ts

@@ -11,14 +11,15 @@ import { status } from "./status.ts";
 import { inspect } from "./inspect.ts";
 import { validate } from "./validate.ts";
 import { detect } from "./detect.ts";
+import { migrate } from "./migrate.ts";
 import { config } from "./config.ts";
 import { send } from "./send.ts";
 import { IdeError, TmuxError } from "./lib/errors.ts";
 import { printCommandError } from "./lib/output.ts";
-import { getSessionName } from "./lib/yaml-io.ts";
+import { resolveProjectConfigContext } from "./lib/config-context.ts";
 import { attachSession } from "@tmux-ide/tmux-bridge";
 import { tryDispatchAction } from "./lib/cli-action-bridge.ts";
-import { startEmbeddedDaemon, type EmbeddedDaemonHandle } from "./index.ts";
+import { runHeadlessDaemon } from "./lib/headless-daemon.ts";
 import type { ActionResult } from "./command-center/actions/contract.ts";
 
 /**
@@ -39,6 +40,7 @@ interface CliFlags {
   command?: string;
   size?: string;
   write?: boolean;
+  "dry-run"?: boolean;
   template?: string;
   name?: string;
   verbose?: boolean;
@@ -87,6 +89,7 @@ export async function main(): Promise<void> {
       command: { type: "string" },
       size: { type: "string" },
       write: { type: "boolean" },
+      "dry-run": { type: "boolean" },
       template: { type: "string" },
       name: { type: "string" },
       verbose: { type: "boolean", default: false },
@@ -139,6 +142,7 @@ export async function main(): Promise<void> {
     "inspect",
     "validate",
     "detect",
+    "migrate",
     "config",
     "setup",
     "send",
@@ -181,13 +185,13 @@ export async function main(): Promise<void> {
     console.log(`${bold("tmux-ide")} — Terminal IDE powered by tmux
 
 ${bold("Usage:")}
-  ${cyan("tmux-ide")}                    ${dim("Launch IDE from ide.yml")}
+  ${cyan("tmux-ide")}                    ${dim("Launch IDE from workspace config")}
   ${cyan("tmux-ide --headless")}         ${dim("Start the canonical daemon without the app")}
   ${cyan("tmux-ide <path>")}             ${dim("Launch from a specific directory")}
   ${cyan("tmux-ide setup")}              ${dim("Interactive TUI setup wizard")}
   ${cyan("tmux-ide setup --edit")}       ${dim("Open config tree editor")}
   ${cyan("tmux-ide settings")}           ${dim("Interactive TUI config manager")}
-  ${cyan("tmux-ide init")} [--template]  ${dim("Scaffold a new ide.yml (auto-detects stack)")}
+  ${cyan("tmux-ide init")} [--template]  ${dim("Scaffold .tmux-ide/workspace.yml (auto-detects stack)")}
   ${cyan("tmux-ide stop")}               ${dim("Kill the current IDE session")}
   ${cyan("tmux-ide restart")}            ${dim("Stop and relaunch the IDE session")}
   ${cyan("tmux-ide attach")}             ${dim("Reattach to a running session")}
@@ -195,16 +199,16 @@ ${bold("Usage:")}
   ${cyan("tmux-ide status")} [--json]    ${dim("Show session status")}
   ${cyan("tmux-ide inspect")} [--json]   ${dim("Show effective config and runtime state")}
   ${cyan("tmux-ide doctor")}             ${dim("Check system requirements")}
-  ${cyan("tmux-ide validate")} [--json]  ${dim("Validate ide.yml")}
+  ${cyan("tmux-ide validate")} [--json]  ${dim("Validate workspace config")}
   ${cyan("tmux-ide detect")} [--json]    ${dim("Detect project stack")}
-  ${cyan("tmux-ide detect --write")}     ${dim("Detect and write ide.yml")}
+  ${cyan("tmux-ide detect --write")}     ${dim("Detect and write .tmux-ide/workspace.yml")}
+  ${cyan("tmux-ide migrate --dry-run")} [--json]  ${dim("Preview ide.yml migration")}
+  ${cyan("tmux-ide migrate --write")} [--json]    ${dim("Create .tmux-ide/workspace.yml")}
   ${cyan("tmux-ide config")} [--json]    ${dim("Dump config as JSON")}
   ${cyan("tmux-ide config set")} <path> <value>
   ${cyan("tmux-ide config add-pane")} --row <N> --title <T> [--command <C>]
   ${cyan("tmux-ide config remove-pane")} --row <N> --pane <M>
   ${cyan("tmux-ide config add-row")} [--size <percent>]
-  ${cyan("tmux-ide config enable-team")} [--name <N>]   ${dim("Enable agent teams")}
-  ${cyan("tmux-ide config disable-team")}               ${dim("Disable agent teams")}
 
 ${bold("Pane Messaging:")}
   ${cyan("tmux-ide send")} <target> <message>     ${dim("Send message to a pane")}
@@ -219,14 +223,16 @@ ${bold("Flags:")}
   ${cyan("--json")}                      ${dim("Output as JSON (all commands)")}
   ${cyan("--headless")}                  ${dim("Run the canonical daemon in this process")}
   ${cyan("--template <name>")}           ${dim("Use specific template for init")}
-  ${cyan("--write")}                     ${dim("Write detected config to ide.yml")}
+  ${cyan("--write")}                     ${dim("Write detected config to .tmux-ide/workspace.yml")}
+  ${cyan("--dry-run")}                   ${dim("Preview migration without writing")}
   ${cyan("--verbose")}                   ${dim("Log all tmux commands (or set TMUX_IDE_DEBUG=1)")}
   ${cyan("-h, --help")}                  ${dim("Show usage")}
       ${cyan("-v, --version")}               ${dim("Show version number")}`);
   }
 
-  function resolveProjectName(targetDir: string | undefined): string {
-    return getSessionName(resolve(targetDir ?? ".")).name;
+  async function resolveProjectName(targetDir: string | undefined): Promise<string> {
+    const dir = resolve(targetDir ?? ".");
+    return (await resolveProjectConfigContext(dir)).sessionName;
   }
 
   async function dispatchProjectLaunch(
@@ -285,35 +291,27 @@ ${bold("Flags:")}
     return result;
   }
 
-  async function runHeadlessDaemon(): Promise<void> {
-    let handle: EmbeddedDaemonHandle | null = null;
-    let stopping = false;
-    const stop = async () => {
-      if (stopping) return;
-      stopping = true;
-      if (handle) await handle.stop();
-    };
-    process.on("SIGINT", () => {
-      void stop().finally(() => process.exit(0));
-    });
-    process.on("SIGTERM", () => {
-      void stop().finally(() => process.exit(0));
-    });
-
-    handle = await startEmbeddedDaemon({ bindHostname: "127.0.0.1" });
-    console.log(`Canonical daemon: ${handle.apiBaseUrl}`);
-    await new Promise<void>(() => undefined);
-  }
-
   try {
     if (values.headless) {
-      await runHeadlessDaemon();
+      if (positionals.length > 0) {
+        throw new IdeError("--headless cannot be combined with a command or project path", {
+          code: "USAGE",
+          exitCode: 2,
+        });
+      }
+      const pkg = await import("../../../package.json");
+      const outcome = await runHeadlessDaemon({
+        port: values.port,
+        json,
+        expectedVersion: pkg.default.version,
+      });
+      if (outcome === "stopped") process.exit(0);
     } else
       switch (command) {
         case "start":
           {
             const cwd = resolve(startTargetDir ?? ".");
-            const projectName = resolveProjectName(startTargetDir);
+            const projectName = await resolveProjectName(startTargetDir);
             const result = await dispatchProjectLaunch(projectName, cwd);
             if (json) {
               console.log(JSON.stringify(result));
@@ -333,7 +331,7 @@ ${bold("Flags:")}
         case "stop":
           {
             const cwd = resolve(positionals[1] ?? ".");
-            const projectName = resolveProjectName(positionals[1]);
+            const projectName = await resolveProjectName(positionals[1]);
             const result = await dispatchProjectStop(projectName, cwd);
             if (json) console.log(JSON.stringify(result));
             else
@@ -346,7 +344,7 @@ ${bold("Flags:")}
         case "attach":
           {
             const cwd = resolve(positionals[1] ?? ".");
-            const projectName = resolveProjectName(positionals[1]);
+            const projectName = await resolveProjectName(positionals[1]);
             const result = await dispatchProjectOpenTerminal(projectName, cwd);
             if (json) console.log(JSON.stringify(result));
             attachSession(result.sessionName);
@@ -356,7 +354,7 @@ ${bold("Flags:")}
         case "restart":
           {
             const cwd = resolve(positionals[1] ?? ".");
-            const projectName = resolveProjectName(positionals[1]);
+            const projectName = await resolveProjectName(positionals[1]);
             const result = await dispatchProjectRestart(projectName, cwd);
             if (json) console.log(JSON.stringify(result));
             else console.log(`Restarted "${result.sessionName}".`);
@@ -388,6 +386,10 @@ ${bold("Flags:")}
           await detect(positionals[1], { json, write: values.write });
           break;
 
+        case "migrate":
+          await migrate(positionals[1], { json, dryRun: values["dry-run"], write: values.write });
+          break;
+
         case "config": {
           const sub = positionals[1];
           let action = "dump";

package/packages/daemon/src/command-center/actions/command-definitions.ts

@@ -0,0 +1,91 @@
+import {
+  ACTION_NAMES,
+  ActionContractsZ,
+  COMMAND_PROTOCOL_VERSION,
+  type ActionName,
+  type CommandDescriptor,
+} from "@tmux-ide/contracts";
+import type { ZodType } from "zod";
+import { CommandRegistry, type CommandDefinition } from "../../lib/command-registry.ts";
+
+interface ActionCommandMetadata {
+  label: string;
+  category: string;
+  dangerous?: boolean;
+}
+
+const ACTION_COMMAND_METADATA: Record<ActionName, ActionCommandMetadata> = {
+  "project.openTerminal": { label: "Open project terminal", category: "project" },
+  "project.launch": { label: "Launch project", category: "project" },
+  "project.stop": { label: "Stop project", category: "project", dangerous: true },
+  "project.restart": { label: "Restart project", category: "project", dangerous: true },
+  "project.activate": { label: "Activate project", category: "project" },
+  "terminal.respawn": { label: "Respawn terminal", category: "terminal" },
+  "terminal.stop": { label: "Stop terminal", category: "terminal", dangerous: true },
+  "config.set": { label: "Set configuration value", category: "configuration" },
+  "config.addPane": { label: "Add configuration pane", category: "configuration" },
+  "config.removePane": {
+    label: "Remove configuration pane",
+    category: "configuration",
+    dangerous: true,
+  },
+  "config.addRow": { label: "Add configuration row", category: "configuration" },
+  "config.enableTeam": { label: "Enable legacy team configuration", category: "compatibility" },
+  "config.disableTeam": {
+    label: "Disable legacy team configuration",
+    category: "compatibility",
+  },
+  "app.setRemoteAccess": { label: "Set remote access", category: "application" },
+  "daemon.shutdown": { label: "Shut down daemon", category: "daemon", dangerous: true },
+  "workspace.pane.create": { label: "Create workspace pane", category: "workspace" },
+  "workspace.open": { label: "Open config-free workspace", category: "workspace" },
+  "workspace.open.prepare": { label: "Prepare workspace handoff", category: "workspace" },
+  "workspace.session.create": { label: "Create session", category: "workspace" },
+  "fleet.agent.mutate": { label: "Manage fleet agent", category: "workspace" },
+  "fleet.agent.provision": { label: "Create fleet agent", category: "workspace" },
+  "workspace.open.commit": { label: "Commit workspace handoff", category: "workspace" },
+  "workspace.open.cancel": { label: "Cancel workspace handoff", category: "workspace" },
+  "workspace.promote": { label: "Promote live session to workspace", category: "workspace" },
+  "workspace.app-window.mutate": { label: "Mutate application window", category: "workspace" },
+  "workspace.window.split": { label: "Split pane", category: "workspace" },
+  "workspace.window.kill": { label: "Close window", category: "workspace", dangerous: true },
+  "workspace.pane.kill": { label: "Close pane", category: "workspace", dangerous: true },
+  "workspace.session.kill": { label: "Close session", category: "workspace", dangerous: true },
+  "workspace.rename": { label: "Rename session, window, or pane", category: "workspace" },
+  "workspace.pane.zoom.toggle": { label: "Toggle pane zoom", category: "workspace" },
+  "workspace.pane.select": { label: "Focus pane", category: "workspace" },
+  "workspace.pane.send": { label: "Send pane input", category: "workspace" },
+  "workspace.pane.swap": { label: "Swap panes", category: "workspace" },
+  "workspace.pane.resize": { label: "Resize pane", category: "workspace" },
+};
+
+function actionDescriptor(name: ActionName): CommandDescriptor {
+  const metadata = ACTION_COMMAND_METADATA[name];
+  return Object.freeze({
+    version: COMMAND_PROTOCOL_VERSION,
+    id: name,
+    owner: "daemon",
+    label: metadata.label,
+    category: metadata.category,
+    schemas: Object.freeze({
+      input: `${name}.input.v1`,
+      result: `${name}.result.v1`,
+    }),
+    dangerous: metadata.dangerous === true,
+    // Existing HTTP/CLI compatibility paths do not add interactive prompts.
+    confirmation: "none",
+  });
+}
+
+/** Every existing action adapted to the shared, handler-free command catalog. */
+export const DAEMON_ACTION_COMMAND_DEFINITIONS: readonly CommandDefinition[] = Object.freeze(
+  ACTION_NAMES.map((name) =>
+    Object.freeze({
+      descriptor: actionDescriptor(name),
+      inputSchema: ActionContractsZ[name].input as ZodType<unknown>,
+      resultSchema: ActionContractsZ[name].result as ZodType<unknown>,
+    }),
+  ),
+);
+
+export const daemonActionCommandRegistry = new CommandRegistry(DAEMON_ACTION_COMMAND_DEFINITIONS);

package/packages/daemon/src/command-center/actions/dispatcher.ts

@@ -18,14 +18,68 @@
 
 import type { Context } from "hono";
 import { ZodError } from "zod";
-import { isActionName, type ActionErrorEnvelope, type ActionName } from "./contract.ts";
+import {
+  COMMAND_PROTOCOL_VERSION,
+  isActionName,
+  type ActionErrorEnvelope,
+  type ActionName,
+} from "./contract.ts";
 import { ActionError, wrapInternalError } from "./errors.ts";
+import { PANE_SOURCE_CREDENTIAL_HEADER } from "../../lib/pane-source-credentials.ts";
 import { getLooseActionEntry } from "./registry.ts";
-import { broadcastActionComplete } from "../ws-events.ts";
+import {
+  broadcastActionComplete,
+  broadcastResourceChanged,
+  broadcastWorkspacePromotionCompleted,
+  type ResourceChangedBroadcast,
+} from "../ws-events.ts";
+import {
+  AppWindowMutationResultSchemaZ,
+  FleetAgentMutateResultSchemaZ,
+  FleetAgentProvisionResultSchemaZ,
+  WorkspaceSessionCreateResultSchemaZ,
+  WorkspaceMultiplexerMutationResultSchemaZ,
+  WorkspaceOpenMutationResultSchemaZ,
+  WorkspacePaneCreateMutationResultSchemaZ,
+  WorkspacePromoteMutationResultSchemaZ,
+} from "@tmux-ide/contracts";
+import { daemonActionCommandRegistry } from "./command-definitions.ts";
+import type { WorkspacePaneCreationBackend } from "./handlers/workspace-pane-create.ts";
+import type { WorkspaceMultiplexerBackend } from "./handlers/workspace-multiplexer.ts";
+import type { WorkspaceOpenBackend } from "./handlers/workspace-open.ts";
+import type { FleetLifecycleBackend } from "./handlers/fleet-lifecycle.ts";
+import type { WorkspacePromotionBackend } from "./handlers/workspace-promote.ts";
+import type { AppWindowMutationBackend } from "./handlers/app-window-mutate.ts";
+import { isSemanticMultiplexerActionName } from "./semantic-multiplexer-actions.ts";
 
 export interface DispatcherDeps {
   /** Override the WS broadcaster (tests / non-default daemons). */
   broadcast?: (name: string, result: unknown) => void;
+  /** Override the typed promotion-completed receipt broadcaster (tests). */
+  broadcastPromotionCompleted?: (workspaceName: string, outcome: "promoted" | "replayed") => void;
+  /** Override the scoped replayable invalidation broadcaster (tests). */
+  broadcastResourceChanged?: (change: ResourceChangedBroadcast, daemonInstanceId: string) => void;
+  /** Trusted daemon generation; never accepted from an HTTP request body. */
+  daemonInstanceId?: string;
+  /** Instance-owned privileged mutation authority; never module-global. */
+  workspacePaneCreationBackend?: WorkspacePaneCreationBackend;
+  /** Instance-owned config-free admission authority; never renderer-authored. */
+  workspaceOpenBackend?: WorkspaceOpenBackend;
+  workspaceOpenHandoffBackend?: import("./handlers/workspace-open.ts").WorkspaceOpenHandoffBackend;
+  fleetLifecycleBackend?: FleetLifecycleBackend;
+  /** Instance-owned session-promotion admission authority; never renderer-authored. */
+  workspacePromotionBackend?: WorkspacePromotionBackend;
+  /** Instance-owned AppWindow authority; renderer never supplies its envelope. */
+  appWindowMutationBackend?: AppWindowMutationBackend;
+  /** Instance-owned multiplexer verb authority; never module-global. */
+  workspaceMultiplexerBackend?: WorkspaceMultiplexerBackend;
+}
+
+const ownerAuthorizedContexts = new WeakSet<object>();
+
+/** Stamp set only by the owner-auth middleware after bearer verification. */
+export function markActionOwnerAuthorized(context: object): void {
+  ownerAuthorizedContexts.add(context);
 }
 
 interface DispatchOk {
@@ -33,6 +87,138 @@ interface DispatchOk {
   result: unknown;
 }
 
+export function shouldBroadcastGenericActionComplete(
+  actionName: ActionName,
+  result: unknown,
+  unchangedAppWindowMutation: boolean,
+): boolean {
+  if (unchangedAppWindowMutation) return false;
+  return !(
+    isSemanticMultiplexerActionName(actionName) &&
+    WorkspaceMultiplexerMutationResultSchemaZ.safeParse(result).success
+  );
+}
+
+function resourceChangesForAction(
+  actionName: ActionName,
+  result: unknown,
+): readonly ResourceChangedBroadcast[] {
+  if (actionName === "workspace.session.create") {
+    const mutation = WorkspaceSessionCreateResultSchemaZ.safeParse(result);
+    if (!mutation.success || mutation.data.outcome === "replayed") return [];
+    return [
+      {
+        workspaceName: null,
+        resource: "workspace-catalog",
+        causeOperationId: mutation.data.operationId,
+      },
+      {
+        workspaceName: null,
+        resource: "fleet-catalog",
+        causeOperationId: mutation.data.operationId,
+      },
+    ];
+  }
+  if (actionName === "fleet.agent.mutate") {
+    const mutation = FleetAgentMutateResultSchemaZ.safeParse(result);
+    if (!mutation.success || mutation.data.outcome === "replayed") return [];
+    return [
+      {
+        workspaceName: null,
+        resource: "fleet-catalog",
+        causeOperationId: mutation.data.operationId,
+      },
+    ];
+  }
+  if (actionName === "fleet.agent.provision") {
+    const mutation = FleetAgentProvisionResultSchemaZ.safeParse(result);
+    if (!mutation.success || mutation.data.outcome === "replayed") return [];
+    return [
+      {
+        workspaceName: null,
+        resource: "workspace-catalog",
+        causeOperationId: mutation.data.operationId,
+      },
+      {
+        workspaceName: null,
+        resource: "fleet-catalog",
+        causeOperationId: mutation.data.operationId,
+      },
+    ];
+  }
+  if (actionName === "workspace.app-window.mutate") {
+    const mutation = AppWindowMutationResultSchemaZ.safeParse(result);
+    if (!mutation.success || mutation.data.outcome !== "applied") return [];
+    return [
+      {
+        workspaceName: mutation.data.workspaceName,
+        resource: "application-shell",
+        revision: mutation.data.documentRevision,
+        causeOperationId: mutation.data.operationId,
+      },
+      {
+        workspaceName: mutation.data.workspaceName,
+        resource: "workspace-missions",
+        causeOperationId: mutation.data.operationId,
+      },
+    ];
+  }
+  if (actionName === "workspace.pane.create") {
+    const mutation = WorkspacePaneCreateMutationResultSchemaZ.safeParse(result);
+    if (!mutation.success || mutation.data.outcome !== "created") return [];
+    return [
+      {
+        workspaceName: mutation.data.resource.workspaceName,
+        resource: "application-shell",
+        causeOperationId: mutation.data.operationId,
+      },
+      {
+        workspaceName: mutation.data.resource.workspaceName,
+        resource: "workspace-missions",
+        causeOperationId: mutation.data.operationId,
+      },
+      {
+        workspaceName: null,
+        resource: "fleet-catalog",
+        causeOperationId: mutation.data.operationId,
+      },
+    ];
+  }
+  if (actionName === "workspace.open") {
+    const mutation = WorkspaceOpenMutationResultSchemaZ.safeParse(result);
+    if (!mutation.success || mutation.data.outcome === "replayed") return [];
+    const base = {
+      workspaceName: mutation.data.resource.workspaceName,
+      causeOperationId: mutation.data.operationId,
+    } as const;
+    return [
+      { ...base, workspaceName: null, resource: "workspace-catalog" },
+      { ...base, resource: "application-shell" },
+      { ...base, resource: "workspace-missions" },
+      { ...base, workspaceName: null, resource: "fleet-catalog" },
+    ];
+  }
+  if (actionName === "workspace.promote") {
+    const mutation = WorkspacePromoteMutationResultSchemaZ.safeParse(result);
+    if (!mutation.success || mutation.data.outcome !== "promoted") return [];
+    const base = {
+      workspaceName: mutation.data.resource.workspaceName,
+      causeOperationId: mutation.data.operationId,
+    } as const;
+    return [
+      { ...base, workspaceName: null, resource: "workspace-catalog" },
+      { ...base, resource: "application-shell" },
+      { ...base, resource: "workspace-missions" },
+      { ...base, workspaceName: null, resource: "fleet-catalog" },
+    ];
+  }
+  // Semantic multiplexer actions already publish from the observed-completion
+  // owner used by every HTTP/TUI/SDK transport. Repeating them here advances
+  // the resource revision twice for one operation.
+  if (isSemanticMultiplexerActionName(actionName)) return [];
+  return [];
+}
+
 function errorEnvelope(err: ActionError): ActionErrorEnvelope {
   return { ok: false, error: err.toEnvelope() };
 }
@@ -69,6 +255,9 @@ function outputZodErrorEnvelope(err: ZodError): ActionErrorEnvelope {
  */
 export function createActionDispatcher(deps: DispatcherDeps = {}) {
   const broadcast = deps.broadcast ?? broadcastActionComplete;
+  const broadcastPromotionCompleted =
+    deps.broadcastPromotionCompleted ?? broadcastWorkspacePromotionCompleted;
+  const broadcastResource = deps.broadcastResourceChanged ?? broadcastResourceChanged;
 
   return async function dispatcher(c: Context): Promise<Response> {
     const name = c.req.param("name");
@@ -106,30 +295,122 @@ export function createActionDispatcher(deps: DispatcherDeps = {}) {
     const actionName: ActionName = name;
     const entry = getLooseActionEntry(actionName);
 
+    // Preserve the public v2 action contract exactly: HTTP request bodies are
+    // validated by the action schema before they are adapted to commands. In
+    // particular, null/array/scalar bodies must keep the action schema's issue
+    // paths rather than gaining a command-envelope `args` prefix.
     const inputParsed = entry.inputSchema.safeParse(body);
     if (!inputParsed.success) {
       return c.json(zodErrorEnvelope(inputParsed.error) satisfies ActionErrorEnvelope, 200);
     }
 
+    const commandResolution = daemonActionCommandRegistry.resolve(
+      {
+        version: COMMAND_PROTOCOL_VERSION,
+        id: actionName,
+        source: { kind: "http" },
+        args: inputParsed.data,
+      },
+      undefined,
+    );
+    if (!commandResolution.ok) {
+      // The command adapter uses the same schema object as the action entry,
+      // so this is an internal registry drift rather than a client failure.
+      console.error("[actions] command adapter rejected action-schema-validated input", {
+        actionName,
+        error: commandResolution.error,
+      });
+      return c.json(
+        {
+          ok: false,
+          error: {
+            code: "internal",
+            message: "Action command adapter rejected validated input",
+          },
+        } satisfies ActionErrorEnvelope,
+        200,
+      );
+    }
+
+    const operationId = c.req.header("X-Tmux-Ide-Operation-Id");
+    const context = {
+      operationId,
+      daemonInstanceId: deps.daemonInstanceId,
+      hostClientId: c.req.header("X-Tmux-Ide-Host-Client-Id"),
+      sourcePaneCredential: c.req.header(PANE_SOURCE_CREDENTIAL_HEADER),
+      ownerAuthorized: ownerAuthorizedContexts.has(c),
+      workspacePaneCreationBackend: deps.workspacePaneCreationBackend,
+      workspaceOpenBackend: deps.workspaceOpenBackend,
+      workspaceOpenHandoffBackend: deps.workspaceOpenHandoffBackend,
+      fleetLifecycleBackend: deps.fleetLifecycleBackend,
+      workspacePromotionBackend: deps.workspacePromotionBackend,
+      appWindowMutationBackend: deps.appWindowMutationBackend,
+      workspaceMultiplexerBackend: deps.workspaceMultiplexerBackend,
+    };
     let result: unknown;
     try {
-      result = await entry.handler(inputParsed.data);
+      result = entry.handlerWithContext
+        ? await entry.handlerWithContext(commandResolution.command.input, context)
+        : await entry.handler(commandResolution.command.input);
     } catch (err) {
       const wrapped = wrapInternalError(err);
       return c.json(errorEnvelope(wrapped) satisfies ActionErrorEnvelope, 200);
     }
 
-    const outputParsed = entry.resultSchema.safeParse(result);
+    const outputParsed = (commandResolution.command.resultSchema ?? entry.resultSchema).safeParse(
+      result,
+    );
     if (!outputParsed.success) {
       return c.json(outputZodErrorEnvelope(outputParsed.error) satisfies ActionErrorEnvelope, 200);
     }
 
-    // Fire-and-forget: subscribers learn about the success via the WS bus.
-    try {
-      broadcast(actionName, outputParsed.data);
-    } catch (err) {
-      // Broadcast failure must not turn a successful action into a failure.
-      console.error("[actions] broadcast failed:", err);
+    const unchangedAppWindowMutation =
+      actionName === "workspace.app-window.mutate" &&
+      typeof outputParsed.data === "object" &&
+      outputParsed.data !== null &&
+      "outcome" in outputParsed.data &&
+      outputParsed.data.outcome === "unchanged";
+    if (
+      shouldBroadcastGenericActionComplete(
+        actionName,
+        outputParsed.data,
+        unchangedAppWindowMutation,
+      )
+    ) {
+      // Fire-and-forget: subscribers learn about durable state changes via WS.
+      try {
+        broadcast(actionName, outputParsed.data);
+      } catch (err) {
+        // Broadcast failure must not turn a successful action into a failure.
+        console.error("[actions] broadcast failed:", err);
+      }
+    }
+
+    if (deps.daemonInstanceId) {
+      for (const change of resourceChangesForAction(actionName, outputParsed.data)) {
+        try {
+          broadcastResource(change, deps.daemonInstanceId);
+        } catch (err) {
+          console.error("[actions] resource invalidation broadcast failed:", err);
+        }
+      }
+    }
+
+    if (actionName === "workspace.promote") {
+      // Typed completion receipt alongside the generic action.complete frame.
+      // Re-narrowing through the result schema (already validated above) keeps
+      // this cast-free; a mismatch is an internal drift worth logging, not a
+      // client failure.
+      const promoted = WorkspacePromoteMutationResultSchemaZ.safeParse(outputParsed.data);
+      if (promoted.success) {
+        try {
+          broadcastPromotionCompleted(promoted.data.resource.workspaceName, promoted.data.outcome);
+        } catch (err) {
+          console.error("[actions] promotion receipt broadcast failed:", err);
+        }
+      } else {
+        console.error("[actions] workspace.promote result did not match the mutation schema");
+      }
     }
 
     return c.json({ ok: true, result: outputParsed.data } satisfies DispatchOk, 200);