@modootoday/pmcp 0.15.0 → 0.16.1

package/dist/cli.js

@@ -1837,11 +1837,11 @@ function dockerPolicy(value) {
   for (const [runtime2, value2] of entries) {
     if (!Object.hasOwn(runtimeExecutables, runtime2))
       throw new Error("unsupported_docker_runtime");
-    const command2 = strings2(value2, "docker_runtime_command");
-    const executable = command2[0];
-    if (!isAbsolute10(executable) || posix5.normalize(executable) !== executable || command2.some((argument) => /[\r\n\x1b]/.test(argument)))
+    const command3 = strings2(value2, "docker_runtime_command");
+    const executable = command3[0];
+    if (!isAbsolute10(executable) || posix5.normalize(executable) !== executable || command3.some((argument) => /[\r\n\x1b]/.test(argument)))
       throw new Error("invalid_docker_runtime_command");
-    parsed[runtime2] = command2;
+    parsed[runtime2] = command3;
   }
   return {
     schemaVersion: 1,
@@ -2962,14 +2962,14 @@ function bridgeName(nonce) {
 function containerEntrypoint(policy, runtime2, nonce, privateProfile) {
   const native2 = policy.commands[runtime2];
   if (!native2) throw new Error("docker_runtime_command_not_granted");
-  const command2 = policy.egress?.bridgeExecutable ? [
+  const command3 = policy.egress?.bridgeExecutable ? [
     policy.egress.bridgeExecutable,
     `/state/${bridgeName(nonce)}`,
     "--",
     ...native2
   ] : native2;
   const profile = selectedProfile(policy, privateProfile, runtime2);
-  if (!profile) return command2;
+  if (!profile) return command3;
   return [
     profile.lockExecutable,
     "--exclusive",
@@ -2978,7 +2978,7 @@ function containerEntrypoint(policy, runtime2, nonce, privateProfile) {
     "--conflict-exit-code",
     "73",
     `/state/${privateProfileLock}`,
-    ...command2
+    ...command3
   ];
 }
 var init_entrypoint = __esm({
@@ -5254,6 +5254,79 @@ var init_runtime2 = __esm({
   }
 });
 
+// src/tui/startup/diagnostics.ts
+function remediation(tools, userManagerAvailable) {
+  const steps = [];
+  if (tools.platform !== "linux")
+    steps.push(
+      "Use a qualified Linux host for the terminal workspace. Other PMCP CLI features do not require this host profile."
+    );
+  const missing = ["tmux", "flock", "systemctl", "systemdRun"].filter(
+    (name) => !tools[name]
+  );
+  if (missing.length)
+    steps.push(
+      `Install the missing tmux, util-linux or systemd tools for your distribution and add them to PATH: ${missing.join(", ")}.`
+    );
+  if (!tools.nodeSupported)
+    steps.push(
+      "Select Node.js 22 or later through your existing version manager and check node --version in this terminal."
+    );
+  if (tools.supported && !userManagerAvailable)
+    steps.push(
+      "Check systemctl --user status in your login session and restore access to its user manager before launching. Doctor does not start or repair services."
+    );
+  return steps;
+}
+function inspectTerminalHost() {
+  const tools = dependencies();
+  let userManagerAvailable = false;
+  let reason;
+  try {
+    if (!tools.supported) throw new Error("tui_dependencies_unavailable");
+    assertNativeHost();
+    userManagerAvailable = true;
+  } catch (error) {
+    reason = error instanceof Error ? error.message : "native_host_unavailable";
+  }
+  const runtimes = Object.entries(runtimeExecutables).map(
+    ([id2, executable]) => {
+      const path = locateExecutable(executable);
+      return {
+        id: id2,
+        executable,
+        installed: Boolean(path),
+        ...path ? { path } : {},
+        nativeAcceptance: "not-assessed",
+        authentication: "not-inspected"
+      };
+    }
+  );
+  return {
+    schemaVersion: 1,
+    ok: true,
+    ...tools,
+    supported: tools.supported && userManagerAvailable,
+    userManagerAvailable,
+    ...reason ? { reason } : {},
+    runtimes,
+    qualification: "Prerequisite availability only; native behavior and cgroup delegation require separate qualification.",
+    remediation: remediation(tools, userManagerAvailable),
+    nextCommands: ["pmcp tui plan", "pmcp tui recovery"],
+    providerInvoked: false,
+    authenticationInspected: false
+  };
+}
+var init_diagnostics = __esm({
+  "src/tui/startup/diagnostics.ts"() {
+    "use strict";
+    init_runtime2();
+    init_admission2();
+    init_registry();
+    init_executable();
+  }
+});
+
 // src/tui/state/store.ts
 import { randomUUID as randomUUID13 } from "crypto";
 import {
@@ -5592,13 +5665,19 @@ var init_feedback = __esm({
     init_store3();
     init_store2();
     hints = {
-      startup_requires_recovery: "Inspect the saved group with pmcp tui plan and pmcp harness recovery inspect. No runtime was restarted.",
+      startup_requires_recovery: "Run pmcp tui recovery for saved ownership and exact inspection commands. No runtime was restarted.",
       startup_group_paused: "The saved group is paused. Resume it explicitly through the harness CLI before reopening.",
       startup_main_unavailable: "Inspect the saved main and recovery state. Stop the old group explicitly before using pmcp tui --new.",
       startup_busy: "Another workspace launch is running. Wait and retry.",
       startup_runtime_conflict: "The saved main uses another runtime. Stop the old group before creating a new workspace.",
       workspace_already_running: "Reopen the existing workspace, or stop its exact owned group before using --new.",
       runtime_executable_unavailable: "Install the selected native CLI on PATH, or choose an installed runtime with --runtime.",
+      view_client_unavailable: "Open the view before using the worker menu, or run pmcp tui start-worker with --view and --runtime.",
+      runtime_not_granted: "Choose a runtime granted by this owned group. Inspect the group before creating another workspace.",
+      runtime_capacity_exceeded: "Stop an exact owned worker before adding another, or use the main session alone.",
+      aggregate_memory_budget_exceeded: "Use fewer sessions or start a worker with an explicit smaller --memory-mb reservation.",
+      group_not_ready: "Inspect the group and resume a paused group explicitly before adding a worker.",
+      startup_group_not_ready: "Inspect the group and resume a paused group explicitly before adding a worker.",
       control_connection_lost: "The native writer or lease disappeared. Inspect and release control before reconnecting.",
       control_busy: "Another controller holds the lease. Release it explicitly before retrying.",
       native_writer_active: "A native writer is still attached. Detach that writer before retrying.",
@@ -5619,6 +5698,20 @@ var init_feedback = __esm({
   }
 });
 
+// src/tui/presentation/target.ts
+function targetStatus(view) {
+  const role = view.target === view.mainId ? "MAIN" : "WORKER";
+  const phase2 = view.phase === "read-only" ? "OBSERVE" : phaseLabel(view.phase);
+  const input = view.phase === "controlled" ? "INPUT ON" : "INPUT OFF";
+  return `${role} ${view.target.slice(0, 8)} | ${phase2} | ${input}`;
+}
+var init_target = __esm({
+  "src/tui/presentation/target.ts"() {
+    "use strict";
+    init_feedback();
+  }
+});
+
 // src/tui/adapters/tmux/bindings.ts
 function callback(view, file2, action, args = []) {
   return [
@@ -5645,7 +5738,8 @@ function bindKeys(connection, view, file2) {
     ["b", "mailbox"],
     ["d", "detach"],
     ["!", "dismiss"],
-    ["g", "management"]
+    ["g", "management"],
+    ["n", "worker-menu"]
   ])
     connection.command([
       "bind-key",
@@ -5666,7 +5760,7 @@ function bindKeys(connection, view, file2) {
     "bind-key",
     "?",
     "display-message",
-    "m main; w/1-4 worker; c control; r release; h history; b mailbox; d detach; ! dismiss error; double Ctrl-g forwards native Ctrl-g"
+    "m main; n add worker; w/1-4 worker; c control; r release; h history; b mailbox; d detach; ! dismiss error; double Ctrl-g forwards native Ctrl-g"
   ]);
   connection.command([
     "set-hook",
@@ -5694,7 +5788,7 @@ var init_view = __esm({
   "src/tui/adapters/tmux/view.ts"() {
     "use strict";
     init_command();
-    init_feedback();
+    init_target();
     init_connection2();
     init_bindings();
     TmuxView = class {
@@ -5880,7 +5974,7 @@ var init_view = __esm({
           "set-option",
           "-g",
           "status-right",
-          `${view.target === view.mainId ? "main" : "worker"} | ${phaseLabel(view.phase)}${failure2} | Ctrl-g ?`
+          `${targetStatus(view)}${failure2} | Ctrl-g ?`
         ]);
       }
       input(pane, enabled) {
@@ -5903,6 +5997,32 @@ var init_view = __esm({
       clients() {
         return this.connection.command(["list-clients", "-F", "#{client_pid}"]);
       }
+      workerMenu(view) {
+        const pane = view.workerPane ?? view.mainPane;
+        this.connection.assertOwned(pane);
+        const popup = [
+          "tmux",
+          "-S",
+          this.connection.socket,
+          "display-popup",
+          "-E",
+          "-t",
+          pane,
+          "-w",
+          "90%",
+          "-h",
+          "80%",
+          this.shell([
+            view.node,
+            view.worker,
+            "worker-menu",
+            "--view",
+            this.stateFile,
+            "--callback"
+          ])
+        ];
+        this.connection.command(["run-shell", "-b", popup.map(quote2).join(" ")]);
+      }
       copy(pane) {
         this.connection.assertOwned(pane);
         this.connection.command(["copy-mode", "-t", pane]);
@@ -6465,6 +6585,11 @@ var init_operations = __esm({
       close: closeView,
       check: checkControl,
       dismiss: ({ view, file: file2 }) => dismissFailure(file2, view),
+      "worker-menu": async (context) => {
+        if (!context.renderer.clients()) throw new Error("view_client_unavailable");
+        await releaseControl(context);
+        context.renderer.workerMenu(context.view);
+      },
       management: async (context) => {
         await releaseControl(context);
         if (context.view.managementWindow) {
@@ -6488,10 +6613,9 @@ __export(invoke_exports2, {
   invokeTui: () => invokeTui
 });
 async function invokeTui(invocation2) {
-  if (invocation2.action === "launch" || invocation2.action === "plan")
+  if (["launch", "plan", "recovery", "start-worker"].includes(invocation2.action))
     throw new Error("startup_requires_cli_context");
-  if (invocation2.action === "doctor")
-    return { schemaVersion: 1, ok: true, ...dependencies() };
+  if (invocation2.action === "doctor") return inspectTerminalHost();
   if (invocation2.action === "create") return createView(invocation2.create);
   if (invocation2.action === "inspect")
     return operate("inspect", invocation2.viewFile);
@@ -6529,7 +6653,7 @@ function failedInvocation(action, error) {
 var init_invoke2 = __esm({
   "src/tui/application/invoke.ts"() {
     "use strict";
-    init_runtime2();
+    init_diagnostics();
     init_lock();
     init_create();
     init_operations();
@@ -6538,6 +6662,31 @@ var init_invoke2 = __esm({
   }
 });
 
+// src/tui/application/worker-start.ts
+var worker_start_exports = {};
+__export(worker_start_exports, {
+  startViewWorker: () => startViewWorker
+});
+async function startViewWorker(file2, runtime2, memoryMb) {
+  const { view, common: common2 } = openView(file2);
+  if (view.state !== "open") throw new Error("view_closed");
+  const observed = await common2.snapshot();
+  if (observed.group.state !== "ready") throw new Error("group_not_ready");
+  const main2 = observed.sessions.find(
+    (session) => session.id === view.mainId && session.role === "main"
+  );
+  if (!main2?.alive) throw new Error("startup_main_unavailable");
+  return common2.call("session", "start", {
+    input: { role: "worker", runtime: runtime2, memoryMb: memoryMb ?? main2.memoryMb }
+  });
+}
+var init_worker_start = __esm({
+  "src/tui/application/worker-start.ts"() {
+    "use strict";
+    init_context2();
+  }
+});
+
 // src/tui/startup/config.ts
 import { realpathSync as realpathSync17 } from "fs";
 import { resolve as resolve19 } from "path";
@@ -6664,6 +6813,160 @@ var init_state = __esm({
   }
 });
 
+// src/tui/startup/worker.ts
+var worker_exports = {};
+__export(worker_exports, {
+  startWorkspaceWorker: () => startWorkspaceWorker
+});
+async function startWorkspaceWorker(request3, runtime2, memoryMb) {
+  if (!Object.hasOwn(runtimeExecutables, runtime2))
+    throw new Error("unsupported_runtime");
+  const settings2 = startupSettings({
+    cwd: request3.cwd,
+    config: request3.config
+  });
+  const state = readStartup(
+    startupFile(settings2.projectRoot),
+    settings2.projectRoot
+  );
+  if (!state || state.phase !== "ready" || !state.groupFile || !state.generation)
+    throw new Error("startup_requires_recovery");
+  const store = new GroupStore(state.groupFile);
+  const group = store.state.group;
+  if (group.projectRoot !== settings2.projectRoot)
+    throw new Error("startup_project_mismatch");
+  if (group.generation !== state.generation)
+    throw new Error("stale_group_generation");
+  if (group.state === "paused") throw new Error("startup_group_paused");
+  if (group.state !== "ready") throw new Error("startup_group_not_ready");
+  if (group.profile === "native" && !locateExecutable(runtimeExecutables[runtime2], request3.cwd))
+    throw new Error("runtime_executable_unavailable");
+  const observed = await invoke({
+    family: "session",
+    action: "list",
+    groupFile: store.path
+  });
+  if (observed.ok !== true) return observed;
+  const sessions = observed.sessions;
+  if (!sessions.some((session) => session.role === "main" && session.alive))
+    throw new Error("startup_main_unavailable");
+  return invoke({
+    family: "session",
+    action: "start",
+    groupFile: store.path,
+    generation: group.generation,
+    input: {
+      runtime: runtime2,
+      role: "worker",
+      memoryMb: memoryMb ?? settings2.sessionMemoryMb
+    }
+  });
+}
+var init_worker = __esm({
+  "src/tui/startup/worker.ts"() {
+    "use strict";
+    init_invoke();
+    init_store2();
+    init_registry();
+    init_executable();
+    init_config3();
+    init_state();
+  }
+});
+
+// src/tui/startup/recovery.ts
+var recovery_exports = {};
+__export(recovery_exports, {
+  inspectStartupRecovery: () => inspectStartupRecovery
+});
+function command2(args) {
+  return ["pmcp", ...args].map(quote2).join(" ");
+}
+function inspectStartupRecovery(request3) {
+  const settings2 = startupSettings(request3);
+  const checkpoint = startupFile(settings2.projectRoot);
+  const state = readStartup(checkpoint, settings2.projectRoot);
+  const config = settings2.configFile ? ["--config", settings2.configFile] : [];
+  const common2 = {
+    schemaVersion: 1,
+    ok: true,
+    checkpoint,
+    projectRoot: settings2.projectRoot,
+    providerInvoked: false,
+    runtimeRestarted: false,
+    inputReplayed: false,
+    observedNativeProcesses: false
+  };
+  if (!state)
+    return {
+      ...common2,
+      status: "not-started",
+      hint: "No saved workspace exists. Start explicitly from an interactive terminal.",
+      commands: [command2(["tui", ...config])]
+    };
+  if (!state.groupFile || !state.generation)
+    return {
+      ...common2,
+      status: "manual-inspection",
+      phase: state.phase,
+      hint: "Creation stopped before a group reference was saved. Preserve this checkpoint and inspect owned launch evidence before changing it. No group ownership can be inferred from a matching project path.",
+      commands: []
+    };
+  const store = new GroupStore(state.groupFile);
+  const group = store.state.group;
+  if (group.projectRoot !== settings2.projectRoot)
+    throw new Error("startup_project_mismatch");
+  if (group.generation !== state.generation)
+    throw new Error("stale_group_generation");
+  const target2 = ["--group-file", store.path];
+  const generation = ["--generation", group.generation];
+  const inspect = command2([
+    "harness",
+    "recovery",
+    "inspect",
+    ...target2,
+    "--include-starts"
+  ]);
+  const status = group.state === "ready" ? state.phase : group.state;
+  const commands = [inspect];
+  let hint = "Inspect actual processes and outstanding starts before any recovery action.";
+  if (group.state === "paused") {
+    hint = "The group is paused. Keep it paused until you explicitly decide to resume it.";
+    commands.push(
+      command2(["harness", "group", "resume", ...target2, ...generation])
+    );
+  }
+  if (group.state === "stopped") {
+    hint = "The saved group is stopped. An explicitly confirmed fresh launch can create a replacement.";
+    commands.push(command2(["tui", "--new", ...config]));
+  }
+  if (group.state === "ready" && !["ready", "view-pending"].includes(state.phase)) {
+    hint = "Startup is incomplete. Inspect pending starts; stop the exact owned group before an explicit fresh launch.";
+    commands.push(
+      command2(["harness", "group", "stop", ...target2, ...generation])
+    );
+  }
+  return {
+    ...common2,
+    status,
+    phase: state.phase,
+    groupFile: store.path,
+    generation: group.generation,
+    hint,
+    commands,
+    commandsRequireExplicitAction: true
+  };
+}
+var init_recovery2 = __esm({
+  "src/tui/startup/recovery.ts"() {
+    "use strict";
+    init_store2();
+    init_command();
+    init_config3();
+    init_state();
+  }
+});
+
 // src/tui/startup/host.ts
 var host_exports = {};
 __export(host_exports, {
@@ -6767,13 +7070,48 @@ var init_lock2 = __esm({
   }
 });
 
+// src/tui/presentation/runtime-choice.ts
+import { createInterface as createInterface2 } from "readline/promises";
+async function chooseRuntime(prompt, choices, preferred) {
+  if (!choices.length) throw new Error("runtime_executable_unavailable");
+  const fallback = Math.max(choices.indexOf(preferred), 0);
+  process.stderr.write(
+    `${choices.map((runtime2, index) => `${index + 1}. ${runtime2}`).join("\n")}
+`
+  );
+  while (true) {
+    const answer = (await prompt.question(
+      `Runtime [1-${choices.length}, Enter=${fallback + 1}, q=cancel] `
+    )).trim();
+    if (answer === "q") return void 0;
+    if (answer === "") return choices[fallback];
+    if (!/^\d+$/.test(answer)) continue;
+    const index = Number(answer) - 1;
+    if (Number.isSafeInteger(index) && index >= 0 && index < choices.length)
+      return choices[index];
+  }
+}
+async function confirmRuntimeStart(prompt, runtime2) {
+  const answer = await prompt.question(
+    `Start ${runtime2}? [Enter=start, q=cancel] `
+  );
+  return answer.trim() === "";
+}
+function terminalPrompt() {
+  return createInterface2({ input: process.stdin, output: process.stderr });
+}
+var init_runtime_choice = __esm({
+  "src/tui/presentation/runtime-choice.ts"() {
+    "use strict";
+  }
+});
+
 // src/tui/startup/entry.ts
 var entry_exports = {};
 __export(entry_exports, {
   launchStartup: () => launchStartup,
   planStartup: () => planStartup
 });
-import { createInterface as createInterface2 } from "readline/promises";
 function planStartup(request3) {
   const settings2 = startupSettings(request3);
   const state = readStartup(
@@ -6795,26 +7133,41 @@ function planStartup(request3) {
 }
 async function launchStartup(request3, confirmed) {
   requireTerminal();
-  const settings2 = startupSettings(request3);
+  let settings2 = startupSettings(request3);
   const state = readStartup(
     startupFile(settings2.projectRoot),
     settings2.projectRoot
   );
   const starting = (!state || request3.fresh) && !settings2.groupFile;
   if (starting) {
+    if (!confirmed) {
+      const prompt = terminalPrompt();
+      try {
+        let runtime2 = settings2.runtime;
+        process.stderr.write(`PMCP MAIN | ${settings2.projectRoot}
+`);
+        if (!request3.runtime) {
+          const installed = settings2.allowedRuntimes.filter(
+            (id2) => locateExecutable(runtimeExecutables[id2], request3.cwd)
+          );
+          const selected = await chooseRuntime(prompt, installed, runtime2);
+          if (!selected) return cancelledStart();
+          runtime2 = selected;
+        }
+        if (!await confirmRuntimeStart(prompt, runtime2))
+          return cancelledStart();
+        request3 = { ...request3, runtime: runtime2 };
+        settings2 = startupSettings(request3);
+      } finally {
+        prompt.close();
+      }
+    }
     if (!locateExecutable(runtimeExecutables[settings2.runtime], request3.cwd))
       throw new Error("runtime_executable_unavailable");
     process.stderr.write(
       `PMCP main: ${settings2.runtime} | ${settings2.projectRoot}
 `
     );
-    if (!confirmed && !await confirmStart(settings2.runtime))
-      return {
-        schemaVersion: 1,
-        ok: true,
-        cancelled: true,
-        providerInvoked: false
-      };
   }
   const prepared = serializedStartup(request3);
   if (prepared.ok !== true) return prepared;
@@ -6824,19 +7177,13 @@ async function launchStartup(request3, confirmed) {
     input: {}
   });
 }
-async function confirmStart(runtime2) {
-  const prompt = createInterface2({
-    input: process.stdin,
-    output: process.stderr
-  });
-  try {
-    const answer = await prompt.question(
-      `Start ${runtime2}? [Enter=start, q=cancel] `
-    );
-    return answer.trim() === "";
-  } finally {
-    prompt.close();
-  }
+function cancelledStart() {
+  return {
+    schemaVersion: 1,
+    ok: true,
+    cancelled: true,
+    providerInvoked: false
+  };
 }
 var init_entry2 = __esm({
   "src/tui/startup/entry.ts"() {
@@ -6848,6 +7195,7 @@ var init_entry2 = __esm({
     init_state();
     init_host();
     init_lock2();
+    init_runtime_choice();
   }
 });
 
@@ -6904,15 +7252,15 @@ function one(args, name) {
 function many(args, name) {
   return args.options.get(name) ?? [];
 }
-function printCommandHelp(ui, command2) {
-  ui.heading(`pmcp ${command2.name}`);
-  ui.line(`  ${command2.describe}`);
+function printCommandHelp(ui, command3) {
+  ui.heading(`pmcp ${command3.name}`);
+  ui.line(`  ${command3.describe}`);
   ui.line();
-  ui.line(`  ${ui.paint(command2.usage, "dim")}`);
-  if (command2.options && command2.options.length > 0) {
+  ui.line(`  ${ui.paint(command3.usage, "dim")}`);
+  if (command3.options && command3.options.length > 0) {
     ui.line();
     ui.table(
-      command2.options.map((option) => [
+      command3.options.map((option) => [
         `--${option.name}${option.placeholder ? ` ${option.placeholder}` : ""}`,
         option.describe
       ])
@@ -6923,7 +7271,7 @@ function printCommandHelp(ui, command2) {
 function printHelp(ui, commands, notImplemented) {
   ui.heading("pmcp \u2014 the skills your installed packages ship");
   ui.line();
-  ui.table(commands.map((command2) => [command2.name, command2.describe]));
+  ui.table(commands.map((command3) => [command3.name, command3.describe]));
   ui.line();
   ui.line(
     "  With no command, pmcp opens a terminal workspace on a supported TTY."
@@ -7038,7 +7386,7 @@ init_entry();
 
 // src/intent.ts
 function normaliseIntent(intent) {
-  return intent.toLowerCase().replaceAll(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/u).filter(Boolean).join(" ");
+  return intent.normalize("NFC").toLowerCase().replaceAll(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/u).filter(Boolean).join(" ");
 }
 
 // src/cache.ts
@@ -9511,7 +9859,7 @@ function registerMailboxTools(server, service) {
 
 // src/mcp.ts
 var SERVER_NAME = "pmcp";
-var SERVER_VERSION = "0.15.0";
+var SERVER_VERSION = "0.16.1";
 function registerSkillTools(server, tools) {
   registerCatalogTool(server, tools);
   registerFindTool(server, tools);
@@ -12131,8 +12479,8 @@ var denied = () => ({
   decision: "deny",
   reason: "Shell guard failed validation or execution"
 });
-function guardPath(root, command2) {
-  const script = command2[0]?.startsWith(".agents/guards/") ? command2[0] : command2[1];
+function guardPath(root, command3) {
+  const script = command3[0]?.startsWith(".agents/guards/") ? command3[0] : command3[1];
   if (!script?.startsWith(".agents/guards/")) {
     throw new Error("Hook command must execute a script under .agents/guards/");
   }
@@ -12190,10 +12538,10 @@ function evaluateShellHook(root, policy, tool, payload) {
     if (!shellNames[tool].includes(name)) {
       return { decision: "allow" };
     }
-    const command2 = scalar(
+    const command3 = scalar(
       input[tool === "antigravity" ? "CommandLine" : "command"]
     );
-    if (command2 === void 0 || command2.length > 65536) {
+    if (command3 === void 0 || command3.length > 65536) {
       return denied();
     }
     const cwd = scalar(input["Cwd"]) ?? scalar(value["cwd"]) ?? root;
@@ -12214,7 +12562,7 @@ function evaluateShellHook(root, policy, tool, payload) {
       input: JSON.stringify({
         runtime: tool,
         event: "before_shell",
-        command: command2,
+        command: command3,
         cwd
       }),
       encoding: "utf8",
@@ -12402,11 +12750,11 @@ function hookOutputs(spec) {
           continue;
         }
         const target2 = native[tool];
-        const command2 = `d="$PWD"; while [ ! -f "$d/pmcp.toml" ]; do [ "$d" = / ] && exit 1; d=$(dirname "$d"); done; exec node "$d/${ADAPTER}" --pmcp-shell-hook ${tool} "$d/${policyFile}" ${integrity2}`;
+        const command3 = `d="$PWD"; while [ ! -f "$d/pmcp.toml" ]; do [ "$d" = / ] && exit 1; d=$(dirname "$d"); done; exec node "$d/${ADAPTER}" --pmcp-shell-hook ${tool} "$d/${policyFile}" ${integrity2}`;
         const timeout = tool === "gemini" ? hook.timeoutMs + 2e3 : Math.ceil(hook.timeoutMs / 1e3) + 2;
         const value = {
           matcher: target2.matcher,
-          hooks: [{ type: "command", command: command2, timeout }]
+          hooks: [{ type: "command", command: command3, timeout }]
         };
         const path = `${target2.file}#${target2.key.join(".")}`;
         const entry2 = desired.get(path) ?? {
@@ -13120,13 +13468,13 @@ function readHooks(path, root, raw) {
       return fail2("unknown shell entry field");
     }
     const name = entry2["name"];
-    const command2 = entry2["command"];
+    const command3 = entry2["command"];
     const targets = entry2["targets"];
     const timeoutMs = entry2["timeout_ms"] ?? 15e3;
     if (typeof name !== "string" || !/^[a-z0-9][a-z0-9-]*$/u.test(name) || names.has(name)) {
       return fail2("shell names must be unique lowercase names");
     }
-    if (!Array.isArray(command2) || command2.length === 0 || !command2.every(
+    if (!Array.isArray(command3) || command3.length === 0 || !command3.every(
       (part) => typeof part === "string" && part.length > 0 && !part.includes("\0")
     )) {
       return fail2("command must be a nonempty argument list");
@@ -13140,7 +13488,7 @@ function readHooks(path, root, raw) {
       return fail2("timeout_ms must be an integer from 100 to 60000");
     }
     try {
-      guardPath(root, command2);
+      guardPath(root, command3);
     } catch (error) {
       return fail2(
         error instanceof Error ? error.message : "invalid guard path"
@@ -13149,7 +13497,7 @@ function readHooks(path, root, raw) {
     names.add(name);
     return {
       name,
-      command: command2,
+      command: command3,
       targets,
       timeoutMs
     };
@@ -13372,13 +13720,13 @@ function readMcp(path, value) {
         fail(path, where, `unknown field ${key}`);
       }
     }
-    const command2 = entry2["command"];
+    const command3 = entry2["command"];
     const url = entry2["url"];
-    if (command2 === void 0 === (url === void 0)) {
+    if (command3 === void 0 === (url === void 0)) {
       fail(path, where, "provide exactly one of command or url");
     }
     for (const [key, item] of [
-      ["command", command2],
+      ["command", command3],
       ["url", url],
       ["cwd", entry2["cwd"]]
     ]) {
@@ -13476,7 +13824,7 @@ function readMcp(path, value) {
       fail(path, where, "mailbox must be a boolean");
     }
     servers[alias] = {
-      ...typeof command2 === "string" ? { command: command2 } : { url },
+      ...typeof command3 === "string" ? { command: command3 } : { url },
       args: list(path, `${where} args`, entry2["args"], false),
       env,
       ...envVars.length > 0 ? { envVars } : {},
@@ -13879,8 +14227,8 @@ import { spawnSync as spawnSync3 } from "child_process";
 import { existsSync as existsSync21, readFileSync as readFileSync28 } from "fs";
 import { join as join25 } from "path";
 import { parse as parse8 } from "smol-toml";
-var spawnRunner = (command2, args, cwd, env) => {
-  const result = spawnSync3(command2, [...args], {
+var spawnRunner = (command3, args, cwd, env) => {
+  const result = spawnSync3(command3, [...args], {
     cwd,
     ...env ? { env: { ...process.env, ...env } } : {},
     encoding: "utf8",
@@ -15137,6 +15485,11 @@ var tuiOptions = [
   },
   { name: "rows", describe: "Terminal rows (12\u20131000)", placeholder: "<count>" },
   { name: "index", describe: "Worker dock index", placeholder: "<count>" },
+  {
+    name: "memory-mb",
+    describe: "Worker memory reservation",
+    placeholder: "<count>"
+  },
   {
     name: "confirm-session",
     describe: "Exact target ID for stop",
@@ -15149,7 +15502,7 @@ var tuiOptions = [
   },
   {
     name: "runtime",
-    describe: "Main native runtime ID for launch",
+    describe: "Native runtime ID for main launch or worker start",
     placeholder: "<runtime>"
   },
   {
@@ -15171,6 +15524,8 @@ var tuiOptions = [
 var allowed2 = {
   launch: ["config", "runtime", "yes", "new"],
   plan: ["config", "runtime"],
+  recovery: ["config"],
+  "start-worker": ["config", "view", "runtime", "memory-mb"],
   doctor: [],
   create: ["group-file", "columns", "rows", "config", "actor-file"],
   inspect: ["view"],
@@ -15188,6 +15543,7 @@ var allowed2 = {
   close: ["view"],
   dismiss: ["view"],
   management: ["view"],
+  "worker-menu": ["view"],
   check: ["view"]
 };
 function parseTui(args) {
@@ -15212,7 +15568,23 @@ function parseTui(args) {
     return Number(value);
   };
   if (action === "doctor") return { action, input: {} };
-  if (action === "launch" || action === "plan")
+  if (action === "start-worker") {
+    const config = one(args, "config");
+    const viewFile = one(args, "view");
+    if (config && viewFile)
+      throw new ArgumentError("Choose --config or --view for worker start");
+    return {
+      action,
+      viewFile,
+      input: {},
+      startup: {
+        config,
+        runtime: required2("runtime"),
+        memoryMb: number("memory-mb")
+      }
+    };
+  }
+  if (action === "launch" || action === "plan" || action === "recovery")
     return {
       action,
       input: {},
@@ -15263,14 +15635,36 @@ function parseTui(args) {
 var tuiCommand = {
   name: "tui",
   describe: "Open a native terminal workspace with optional configuration",
-  usage: "pmcp tui [--config <file>] [--runtime <id>] | plan | doctor | operation --view <file>",
+  usage: "pmcp tui [--config <file>] [--runtime <id>] | plan | recovery | doctor | start-worker --runtime <id> | operation --view <file>",
   options: tuiOptions,
   async run(context) {
     const invocation2 = parseTui(context.args);
     const { invokeTui: invokeTui2, failedInvocation: failedInvocation2 } = await Promise.resolve().then(() => (init_invoke2(), invoke_exports2));
     try {
       let receipt;
-      if (invocation2.action === "launch" || invocation2.action === "plan") {
+      if (invocation2.action === "start-worker") {
+        if (invocation2.viewFile) {
+          const { startViewWorker: startViewWorker2 } = await Promise.resolve().then(() => (init_worker_start(), worker_start_exports));
+          receipt = await startViewWorker2(
+            invocation2.viewFile,
+            invocation2.startup.runtime,
+            invocation2.startup?.memoryMb
+          );
+        } else {
+          const { startWorkspaceWorker: startWorkspaceWorker2 } = await Promise.resolve().then(() => (init_worker(), worker_exports));
+          receipt = await startWorkspaceWorker2(
+            { config: invocation2.startup?.config, cwd: context.cwd },
+            invocation2.startup.runtime,
+            invocation2.startup?.memoryMb
+          );
+        }
+      } else if (invocation2.action === "recovery") {
+        const { inspectStartupRecovery: inspectStartupRecovery2 } = await Promise.resolve().then(() => (init_recovery2(), recovery_exports));
+        receipt = inspectStartupRecovery2({
+          ...invocation2.startup,
+          cwd: context.cwd
+        });
+      } else if (invocation2.action === "launch" || invocation2.action === "plan") {
         const { launchStartup: launchStartup2, planStartup: planStartup2 } = await Promise.resolve().then(() => (init_entry2(), entry_exports));
         const request3 = { ...invocation2.startup, cwd: context.cwd };
         receipt = invocation2.action === "plan" ? planStartup2(request3) : await launchStartup2(
@@ -15525,7 +15919,7 @@ function dispatch(argv, options2 = {}) {
     return defaultEntry(options2, { ui, env, cwd });
   }
   if (verb === "--help" || verb === "-h" || verb === "help") {
-    const named2 = COMMANDS.find((command3) => command3.name === rest[0]);
+    const named2 = COMMANDS.find((command4) => command4.name === rest[0]);
     if (named2) printCommandHelp(ui, named2);
     else printHelp(ui, COMMANDS, PLANNED);
     return 0;
@@ -15538,8 +15932,8 @@ function dispatch(argv, options2 = {}) {
   if (verb.startsWith("-")) {
     return run(serveCommand, rest0, { ui, env, cwd });
   }
-  const command2 = COMMANDS.find((candidate2) => candidate2.name === verb);
-  if (command2 === void 0) {
+  const command3 = COMMANDS.find((candidate2) => candidate2.name === verb);
+  if (command3 === void 0) {
     if (PLANNED.includes(verb))
       ui.error(`"${verb}" is designed but not implemented yet`);
     else ui.error(`unknown command "${verb}"`);
@@ -15547,12 +15941,12 @@ function dispatch(argv, options2 = {}) {
     return 2;
   }
   if (rest.includes("--help") || rest.includes("-h")) {
-    printCommandHelp(ui, command2);
+    printCommandHelp(ui, command3);
     return 0;
   }
-  return run(command2, rest, { ui, env, cwd });
+  return run(command3, rest, { ui, env, cwd });
 }
-var VERSION = "0.15.0";
+var VERSION = "0.16.1";
 async function defaultEntry(options2, context) {
   const terminal = options2.terminal ?? {
     stdin: process.stdin.isTTY === true,
@@ -15576,16 +15970,16 @@ async function defaultEntry(options2, context) {
   printHelp(context.ui, COMMANDS, PLANNED);
   return 0;
 }
-async function run(command2, argv, context) {
+async function run(command3, argv, context) {
   try {
-    return await command2.run({
+    return await command3.run({
       ...context,
-      args: parseArgs(argv, command2.options)
+      args: parseArgs(argv, command3.options)
     });
   } catch (error) {
     if (error instanceof ArgumentError) {
       context.ui.error(error.message);
-      printCommandHelp(context.ui, command2);
+      printCommandHelp(context.ui, command3);
       return 2;
     }
     context.ui.error(error instanceof Error ? error.message : "command failed");