@modootoday/pmcp 0.14.1 → 0.16.0

package/dist/cli.js

@@ -9,6 +9,23 @@ var __export = (target2, all) => {
     __defProp(target2, name, { get: all[name], enumerable: true });
 };
 
+// src/cli/entry.ts
+function interactiveEntry(terminal) {
+  if (!terminal.stdin || !terminal.stdout) return false;
+  if (!terminal.term || terminal.term === "dumb") return false;
+  return !terminal.ci || terminal.ci === "false" || terminal.ci === "0";
+}
+function entryMode(terminal) {
+  if (!terminal.stdin || !terminal.stdout) return "server";
+  if (!interactiveEntry(terminal)) return "help";
+  return "terminal";
+}
+var init_entry = __esm({
+  "src/cli/entry.ts"() {
+    "use strict";
+  }
+});
+
 // src/storage/sqlite.ts
 async function openSqlite(path, options2 = {}) {
   const provider = process.versions.bun ? "bun:sqlite" : "node:sqlite";
@@ -245,6 +262,7 @@ function findConfig(start2) {
   for (; ; ) {
     const candidate2 = join4(dir, CONFIG_FILE);
     if (existsSync4(candidate2)) return candidate2;
+    if (existsSync4(join4(dir, ".git"))) return null;
     const parent = dirname3(dir);
     if (parent === dir) return null;
     dir = parent;
@@ -453,8 +471,6 @@ var init_types = __esm({
         this.retryable = retryable;
         this.name = "MailboxError";
       }
-      code;
-      retryable;
     };
   }
 });
@@ -1819,11 +1835,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,
@@ -1920,47 +1936,47 @@ var init_validation2 = __esm({
 });
 
 // src/harness/groups/store.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import {
-  closeSync as closeSync3,
+  closeSync as closeSync4,
   constants as constants3,
   fstatSync as fstatSync2,
-  fsyncSync,
-  openSync as openSync3,
-  readFileSync as readFileSync33,
-  realpathSync as realpathSync4,
-  renameSync as renameSync3,
+  fsyncSync as fsyncSync2,
+  openSync as openSync4,
+  readFileSync as readFileSync34,
+  realpathSync as realpathSync6,
+  renameSync as renameSync4,
   writeFileSync as writeFileSync9
 } from "fs";
-import { dirname as dirname19, join as join27 } from "path";
+import { dirname as dirname21, join as join29 } from "path";
 function privateJson(path, value) {
-  const temporary = `${path}.${randomUUID4()}.new`;
-  const descriptor = openSync3(temporary, "wx", 384);
+  const temporary = `${path}.${randomUUID5()}.new`;
+  const descriptor = openSync4(temporary, "wx", 384);
   try {
     writeFileSync9(descriptor, `${JSON.stringify(value, null, 2)}
 `);
-    fsyncSync(descriptor);
+    fsyncSync2(descriptor);
   } finally {
-    closeSync3(descriptor);
+    closeSync4(descriptor);
   }
-  renameSync3(temporary, path);
-  const directory = openSync3(dirname19(path), "r");
+  renameSync4(temporary, path);
+  const directory = openSync4(dirname21(path), "r");
   try {
-    fsyncSync(directory);
+    fsyncSync2(directory);
   } finally {
-    closeSync3(directory);
+    closeSync4(directory);
   }
 }
 function readPrivateJson2(path) {
-  const descriptor = openSync3(path, constants3.O_RDONLY | constants3.O_NOFOLLOW);
+  const descriptor = openSync4(path, constants3.O_RDONLY | constants3.O_NOFOLLOW);
   try {
     const stat = fstatSync2(descriptor);
     if (!stat.isFile() || (stat.mode & 63) !== 0 || stat.size > 2097152)
       throw new Error("unsafe_state_file");
     if (stat.uid !== process.getuid?.()) throw new Error("foreign_state_file");
-    return JSON.parse(readFileSync33(descriptor, "utf8"));
+    return JSON.parse(readFileSync34(descriptor, "utf8"));
   } finally {
-    closeSync3(descriptor);
+    closeSync4(descriptor);
   }
 }
 var GroupStore;
@@ -1973,10 +1989,10 @@ var init_store2 = __esm({
       path;
       state;
       constructor(path) {
-        this.path = realpathSync4(path);
+        this.path = realpathSync6(path);
         this.state = validateState(readPrivateJson2(path));
         const metadata2 = object8(
-          readPrivateJson2(join27(dirname19(this.path), "harness.json"))
+          readPrivateJson2(join29(dirname21(this.path), "harness.json"))
         );
         if (this.state.group.schemaVersion !== 1 || this.state.group.owner !== metadata2.owner) {
           throw new Error("foreign_group");
@@ -1997,13 +2013,13 @@ var init_store2 = __esm({
 
 // src/harness/adapters/process/serialized.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { randomUUID as randomUUID5 } from "crypto";
-import { existsSync as existsSync22, unlinkSync as unlinkSync2 } from "fs";
-import { dirname as dirname20, join as join28 } from "path";
+import { randomUUID as randomUUID6 } from "crypto";
+import { existsSync as existsSync25, unlinkSync as unlinkSync2 } from "fs";
+import { dirname as dirname22, join as join30 } from "path";
 function serialized(operation) {
   const store = new GroupStore(text(operation.groupFile, "group_file"));
-  const directory = dirname20(store.path);
-  const operationFile = join28(directory, `operation-${randomUUID5()}.json`);
+  const directory = dirname22(store.path);
+  const operationFile = join30(directory, `operation-${randomUUID6()}.json`);
   privateJson(operationFile, operation);
   const worker = artifact("worker");
   try {
@@ -2015,7 +2031,7 @@ function serialized(operation) {
         "--no-fork",
         "--conflict-exit-code",
         "73",
-        join28(directory, "group-control.lock"),
+        join30(directory, "group-control.lock"),
         process.execPath,
         worker,
         operationFile
@@ -2031,7 +2047,7 @@ function serialized(operation) {
     if (!result.stdout.trim()) throw new Error("worker_receipt_missing");
     return JSON.parse(result.stdout);
   } finally {
-    if (existsSync22(operationFile)) unlinkSync2(operationFile);
+    if (existsSync25(operationFile)) unlinkSync2(operationFile);
   }
 }
 var init_serialized = __esm({
@@ -2111,11 +2127,11 @@ var init_command = __esm({
 });
 
 // src/harness/adapters/process/identity.ts
-import { readFileSync as readFileSync34 } from "fs";
+import { readFileSync as readFileSync35 } from "fs";
 function processIdentity(pid) {
   if (!Number.isSafeInteger(pid) || pid < 1)
     throw new Error("invalid_process_id");
-  const stat = readFileSync34(`/proc/${pid}/stat`, "utf8");
+  const stat = readFileSync35(`/proc/${pid}/stat`, "utf8");
   const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
   if (!/^\d+$/.test(fields[19] ?? ""))
     throw new Error("process_identity_unknown");
@@ -2285,7 +2301,6 @@ var init_connection = __esm({
       constructor(records2) {
         this.records = records2;
       }
-      records;
       tmux(args, options2 = {}) {
         return command(
           "tmux",
@@ -2345,19 +2360,19 @@ var init_connection = __esm({
 });
 
 // src/harness/adapters/tmux/records.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 import {
-  lstatSync as lstatSync5,
+  lstatSync as lstatSync6,
   mkdirSync as mkdirSync9,
   readdirSync as readdirSync10,
-  realpathSync as realpathSync5,
+  realpathSync as realpathSync7,
   writeFileSync as writeFileSync10
 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join29 } from "path";
+import { join as join31 } from "path";
 function stateDirectory() {
-  return join29(
-    process.env.XDG_STATE_HOME ?? join29(homedir7(), ".local/state"),
+  return join31(
+    process.env.XDG_STATE_HOME ?? join31(homedir7(), ".local/state"),
     "pmcp/harness"
   );
 }
@@ -2384,15 +2399,15 @@ var init_records = __esm({
       configPath;
       owner;
       constructor(directory) {
-        const stat = lstatSync5(directory);
+        const stat = lstatSync6(directory);
         if (!stat.isDirectory() || stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0)
           throw new Error("unsafe_group_directory");
-        this.directory = realpathSync5(directory);
-        this.socket = join29(this.directory, "s");
+        this.directory = realpathSync7(directory);
+        this.socket = join31(this.directory, "s");
         if (Buffer.byteLength(this.socket) > 100)
           throw new Error("socket_path_too_long");
-        this.metadataPath = join29(this.directory, "harness.json");
-        this.configPath = join29(this.directory, "tmux.conf");
+        this.metadataPath = join31(this.directory, "harness.json");
+        this.configPath = join31(this.directory, "tmux.conf");
         this.owner = text(
           object8(readPrivateJson2(this.metadataPath)).owner,
           "owner"
@@ -2402,17 +2417,17 @@ var init_records = __esm({
       static create() {
         const root = stateDirectory();
         mkdirSync9(root, { recursive: true, mode: 448 });
-        const directory = join29(root, randomUUID6().slice(0, 16));
-        if (Buffer.byteLength(join29(directory, "s")) > 100)
+        const directory = join31(root, randomUUID7().slice(0, 16));
+        if (Buffer.byteLength(join31(directory, "s")) > 100)
           throw new Error("socket_path_too_long");
         mkdirSync9(directory, { mode: 448 });
-        mkdirSync9(join29(directory, "sessions"), { mode: 448 });
-        privateJson(join29(directory, "harness.json"), {
-          owner: randomUUID6(),
+        mkdirSync9(join31(directory, "sessions"), { mode: 448 });
+        privateJson(join31(directory, "harness.json"), {
+          owner: randomUUID7(),
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         });
         writeFileSync10(
-          join29(directory, "tmux.conf"),
+          join31(directory, "tmux.conf"),
           [
             "set -g remain-on-exit on",
             "set -g history-limit 2000",
@@ -2428,7 +2443,7 @@ var init_records = __esm({
       }
       path(id2) {
         runtimeUnit(id2);
-        return join29(this.directory, "sessions", `${id2}.json`);
+        return join31(this.directory, "sessions", `${id2}.json`);
       }
       read(id2) {
         const record = object8(readPrivateJson2(this.path(id2)));
@@ -2450,7 +2465,7 @@ var init_records = __esm({
         return record;
       }
       all() {
-        return readdirSync10(join29(this.directory, "sessions")).filter((name) => name.endsWith(".json")).map((name) => this.read(name.slice(0, -5)));
+        return readdirSync10(join31(this.directory, "sessions")).filter((name) => name.endsWith(".json")).map((name) => this.read(name.slice(0, -5)));
       }
       save(record) {
         privateJson(this.path(record.id), record);
@@ -2532,8 +2547,8 @@ var init_launch_identity = __esm({
 
 // src/harness/launch/journal.ts
 import { createHash as createHash16 } from "crypto";
-import { existsSync as existsSync23, readdirSync as readdirSync11 } from "fs";
-import { join as join30 } from "path";
+import { existsSync as existsSync26, readdirSync as readdirSync11 } from "fs";
+import { join as join32 } from "path";
 function launchJournals(records2) {
   return readdirSync11(records2.directory).filter((name) => name.endsWith(".intent.json")).map((name) => new LaunchJournal(records2, name.slice(0, -12)));
 }
@@ -2541,7 +2556,7 @@ function pendingLaunches(records2) {
   return launchJournals(records2).filter((journal) => {
     const aborted = journal.abortRecord();
     if (aborted) return aborted.state !== "stopped";
-    if (!existsSync23(journal.path("committed"))) return true;
+    if (!existsSync26(journal.path("committed"))) return true;
     journal.assertCommitted();
     return false;
   });
@@ -2563,12 +2578,10 @@ var init_journal = __esm({
         this.id = id2;
         runtimeUnit(id2);
       }
-      records;
-      id;
       path(kind2) {
         if (!["intent", "proof", "grant", "committed", "aborted"].includes(kind2))
           throw new Error("invalid_launch_artifact");
-        return join30(this.records.directory, `${this.id}.${kind2}.json`);
+        return join32(this.records.directory, `${this.id}.${kind2}.json`);
       }
       intent() {
         const value = object8(readPrivateJson2(this.path("intent")));
@@ -2597,13 +2610,13 @@ var init_journal = __esm({
             throw new Error("invalid_docker_bridge_digest");
           if (!bridge && creation.bridgeSha256 !== void 0)
             throw new Error("ungranted_docker_bridge_digest");
-          const policy = new GroupStore(join30(this.records.directory, "group.json")).state.group.dockerPolicy;
+          const policy = new GroupStore(join32(this.records.directory, "group.json")).state.group.dockerPolicy;
           const profile = selectedProfile(
             policy,
             creation.privateProfile,
             text(value.runtime, "runtime")
           );
-          const expectedState = profile?.directory ?? join30(
+          const expectedState = profile?.directory ?? join32(
             this.records.directory,
             "containers",
             text(value.nonce, "nonce"),
@@ -2649,7 +2662,7 @@ var init_journal = __esm({
       }
       assertRegistered() {
         const intent = this.intent();
-        const group = new GroupStore(join30(this.records.directory, "group.json")).state.group;
+        const group = new GroupStore(join32(this.records.directory, "group.json")).state.group;
         if (group.id !== intent.groupId || group.generation !== intent.generation)
           throw new Error("launch_group_generation_mismatch");
         if (intent.dockerCreation && JSON.stringify(intent.dockerCreation.egress) !== JSON.stringify(group.dockerPolicy?.egress))
@@ -2665,12 +2678,12 @@ var init_journal = __esm({
           throw new Error("launch_record_mismatch");
       }
       authorize() {
-        if (existsSync23(this.path("aborted"))) throw new Error("launch_was_aborted");
+        if (existsSync26(this.path("aborted"))) throw new Error("launch_was_aborted");
         this.assertRegistered();
         privateJson(this.path("grant"), this.grant());
       }
       assertGrant() {
-        if (existsSync23(this.path("aborted"))) throw new Error("launch_was_aborted");
+        if (existsSync26(this.path("aborted"))) throw new Error("launch_was_aborted");
         const grant = object8(readPrivateJson2(this.path("grant")));
         if (JSON.stringify(grant) !== JSON.stringify(this.grant()))
           throw new Error("launch_grant_mismatch");
@@ -2687,7 +2700,7 @@ var init_journal = __esm({
           throw new Error("launch_commit_mismatch");
       }
       abortRecord() {
-        if (!existsSync23(this.path("aborted"))) return;
+        if (!existsSync26(this.path("aborted"))) return;
         const value = object8(readPrivateJson2(this.path("aborted")));
         if (value.id !== this.id || value.owner !== this.records.owner || !["stopping", "stopped"].includes(String(value.state)))
           throw new Error("foreign_launch_abort");
@@ -2734,30 +2747,30 @@ var init_lifecycle = __esm({
 // src/harness/adapters/docker/private-profile.ts
 import { homedir as homedir8 } from "os";
 import {
-  closeSync as closeSync4,
+  closeSync as closeSync5,
   constants as constants4,
-  existsSync as existsSync24,
+  existsSync as existsSync27,
   fstatSync as fstatSync3,
-  lstatSync as lstatSync6,
-  openSync as openSync4,
-  realpathSync as realpathSync6,
+  lstatSync as lstatSync7,
+  openSync as openSync5,
+  realpathSync as realpathSync8,
   statfsSync
 } from "fs";
-import { join as join31, relative as relative11 } from "path";
+import { join as join33, relative as relative11 } from "path";
 function overlap(left, right) {
   const scope = relative11(left, right);
   return scope === "" || scope !== ".." && !scope.startsWith("../");
 }
 function profileIdentity(directory, projectRoot) {
-  if (directory === "/" || directory === realpathSync6(homedir8()) || overlap(directory, projectRoot) || overlap(projectRoot, directory) || realpathSync6(directory) !== directory)
+  if (directory === "/" || directory === realpathSync8(homedir8()) || overlap(directory, projectRoot) || overlap(projectRoot, directory) || realpathSync8(directory) !== directory)
     throw new Error("private_profile_scope_not_admitted");
-  const stat = lstatSync6(directory);
+  const stat = lstatSync7(directory);
   if (!stat.isDirectory() || stat.uid !== process.getuid?.() || (stat.mode & 511) !== 448)
     throw new Error("unsafe_private_profile_directory");
   if ([26985, 4283649346, 4266872130].includes(statfsSync(directory).type))
     throw new Error("remote_private_profile_not_admitted");
-  const lock = openSync4(
-    join31(directory, privateProfileLock),
+  const lock = openSync5(
+    join33(directory, privateProfileLock),
     constants4.O_RDONLY | constants4.O_NOFOLLOW
   );
   try {
@@ -2766,18 +2779,18 @@ function profileIdentity(directory, projectRoot) {
       throw new Error("unsafe_private_profile_lock");
     return `${stat.dev}:${stat.ino}:${value.dev}:${value.ino}`;
   } finally {
-    closeSync4(lock);
+    closeSync5(lock);
   }
 }
 function captureProfile(grant, projectRoot) {
-  const directory = realpathSync6(grant.directory);
-  if (directory !== grant.directory || overlap(directory, projectRoot) || overlap(projectRoot, directory) || directory === "/" || directory === realpathSync6(homedir8()))
+  const directory = realpathSync8(grant.directory);
+  if (directory !== grant.directory || overlap(directory, projectRoot) || overlap(projectRoot, directory) || directory === "/" || directory === realpathSync8(homedir8()))
     throw new Error("private_profile_scope_not_admitted");
-  const stat = lstatSync6(directory);
+  const stat = lstatSync7(directory);
   if (!stat.isDirectory() || stat.uid !== process.getuid?.() || (stat.mode & 511) !== 448)
     throw new Error("unsafe_private_profile_directory");
-  const lock = join31(directory, privateProfileLock);
-  if (!existsSync24(lock)) closeSync4(openSync4(lock, "wx", 384));
+  const lock = join33(directory, privateProfileLock);
+  if (!existsSync27(lock)) closeSync5(openSync5(lock, "wx", 384));
   const identity = profileIdentity(directory, projectRoot);
   if (grant.identity && grant.identity !== identity)
     throw new Error("private_profile_identity_changed");
@@ -2795,7 +2808,7 @@ function assertProfileAvailable(grant, projectRoot) {
       "--nonblock",
       "--conflict-exit-code",
       "73",
-      join31(grant.directory, privateProfileLock),
+      join33(grant.directory, privateProfileLock),
       "true"
     ]);
   } catch (error) {
@@ -2815,7 +2828,7 @@ var init_private_profile = __esm({
 
 // src/harness/adapters/docker/profile.ts
 import { homedir as homedir9 } from "os";
-import { lstatSync as lstatSync7, realpathSync as realpathSync7 } from "fs";
+import { lstatSync as lstatSync8, realpathSync as realpathSync9 } from "fs";
 import { relative as relative12 } from "path";
 function assertLocalDocker() {
   if (process.env.DOCKER_HOST)
@@ -2832,12 +2845,12 @@ function assertLocalDocker() {
     throw new Error("remote_docker_context_not_admitted");
 }
 function loadDockerPolicy(path, projectRoot, runtimes) {
-  if (projectRoot === "/" || projectRoot === realpathSync7(homedir9()))
+  if (projectRoot === "/" || projectRoot === realpathSync9(homedir9()))
     throw new Error("docker_project_root_too_broad");
   const inputPath = text(path, "docker_policy_file");
-  if (lstatSync7(inputPath).isSymbolicLink())
+  if (lstatSync8(inputPath).isSymbolicLink())
     throw new Error("symlink_docker_policy_not_admitted");
-  const source2 = realpathSync7(inputPath);
+  const source2 = realpathSync9(inputPath);
   const scope = relative12(projectRoot, source2);
   if (scope === ".." || scope.startsWith("../"))
     throw new Error("docker_policy_outside_project");
@@ -2871,16 +2884,16 @@ var init_profile = __esm({
 });
 
 // src/harness/adapters/docker/mounts.ts
-import { lstatSync as lstatSync8, realpathSync as realpathSync8 } from "fs";
-import { join as join32 } from "path";
+import { lstatSync as lstatSync9, realpathSync as realpathSync10 } from "fs";
+import { join as join34 } from "path";
 function assertContainerMounts(actual, statePath, projectRoot, directory, nonce, policy, privateProfile, runtime2) {
   const state = text(statePath, "container_state_directory");
   const profile = selectedProfile(policy, privateProfile, runtime2 ?? "");
   if (profile) assertProfileIdentity(profile, projectRoot);
-  const expected = profile?.directory ?? join32(directory, "containers", nonce, "profile");
-  if (state !== expected || realpathSync8(state) !== expected)
+  const expected = profile?.directory ?? join34(directory, "containers", nonce, "profile");
+  if (state !== expected || realpathSync10(state) !== expected)
     throw new Error("foreign_container_state_directory");
-  const stat = lstatSync8(state);
+  const stat = lstatSync9(state);
   if (!stat.isDirectory() || stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0)
     throw new Error("unsafe_container_state_directory");
   if (!Array.isArray(actual.Mounts) || actual.Mounts.length !== 2)
@@ -2944,14 +2957,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",
@@ -2960,7 +2973,7 @@ function containerEntrypoint(policy, runtime2, nonce, privateProfile) {
     "--conflict-exit-code",
     "73",
     `/state/${privateProfileLock}`,
-    ...command2
+    ...command3
   ];
 }
 var init_entrypoint = __esm({
@@ -2972,17 +2985,17 @@ var init_entrypoint = __esm({
 });
 
 // src/harness/adapters/docker/admission.ts
-import { lstatSync as lstatSync9, realpathSync as realpathSync9 } from "fs";
-import { join as join33, relative as relative13 } from "path";
+import { lstatSync as lstatSync10, realpathSync as realpathSync11 } from "fs";
+import { join as join35, relative as relative13 } from "path";
 function admitResource(path, group, role, directory, memoryMb, runtime2) {
   if (group.profile !== "docker" || !group.dockerPolicy)
     throw new Error("container_requires_docker_profile");
   const { projectRoot } = group;
   assertLocalDocker();
   const inputPath = text(path, "container_file");
-  if (lstatSync9(inputPath).isSymbolicLink())
+  if (lstatSync10(inputPath).isSymbolicLink())
     throw new Error("symlink_container_file_not_admitted");
-  const source2 = realpathSync9(inputPath);
+  const source2 = realpathSync11(inputPath);
   const scope = relative13(projectRoot, source2);
   if (scope === ".." || scope.startsWith("../"))
     throw new Error("container_file_outside_project");
@@ -3029,7 +3042,7 @@ function admitClaim(value, group, role, directory, memoryMb, runtime2, cwd = gro
     )
   ))
     throw new Error("container_runtime_image_not_granted");
-  if (config.WorkingDir !== join33("/workspace", relative13(projectRoot, cwd)))
+  if (config.WorkingDir !== join35("/workspace", relative13(projectRoot, cwd)))
     throw new Error("container_cwd_not_granted");
   assertContainerMounts(
     actual,
@@ -3165,20 +3178,20 @@ var init_engine = __esm({
 // src/harness/adapters/docker/bridge-artifact.ts
 import { createHash as createHash17 } from "crypto";
 import {
-  closeSync as closeSync5,
+  closeSync as closeSync6,
   constants as constants5,
   fstatSync as fstatSync4,
-  fsyncSync as fsyncSync2,
-  openSync as openSync5,
-  readFileSync as readFileSync35,
+  fsyncSync as fsyncSync3,
+  openSync as openSync6,
+  readFileSync as readFileSync36,
   writeFileSync as writeFileSync11
 } from "fs";
-import { join as join34 } from "path";
+import { join as join36 } from "path";
 function source() {
   const path = artifact("egress-bridge");
   if (!path.endsWith(".js"))
     throw new Error("docker_bridge_requires_compiled_cli");
-  return readFileSync35(path);
+  return readFileSync36(path);
 }
 function digest(value) {
   return createHash17("sha256").update(value).digest("hex");
@@ -3191,30 +3204,30 @@ function prepareBridge(creation) {
   const content = source();
   if (digest(content) !== creation.bridgeSha256)
     throw new Error("docker_bridge_source_changed");
-  const descriptor = openSync5(
-    join34(creation.state, bridgeName(creation.nonce)),
+  const descriptor = openSync6(
+    join36(creation.state, bridgeName(creation.nonce)),
     "wx",
     384
   );
   try {
     writeFileSync11(descriptor, content);
-    fsyncSync2(descriptor);
+    fsyncSync3(descriptor);
   } finally {
-    closeSync5(descriptor);
+    closeSync6(descriptor);
   }
 }
 function assertBridge(creation) {
   if (!creation.egress?.bridgeExecutable) return;
-  const descriptor = openSync5(
-    join34(creation.state, bridgeName(creation.nonce)),
+  const descriptor = openSync6(
+    join36(creation.state, bridgeName(creation.nonce)),
     constants5.O_RDONLY | constants5.O_NOFOLLOW
   );
   try {
     const stat = fstatSync4(descriptor);
-    if (!stat.isFile() || stat.uid !== process.getuid?.() || stat.nlink !== 1 || (stat.mode & 63) !== 0 || stat.size > 2097152 || digest(readFileSync35(descriptor)) !== creation.bridgeSha256)
+    if (!stat.isFile() || stat.uid !== process.getuid?.() || stat.nlink !== 1 || (stat.mode & 63) !== 0 || stat.size > 2097152 || digest(readFileSync36(descriptor)) !== creation.bridgeSha256)
       throw new Error("docker_bridge_artifact_changed");
   } finally {
-    closeSync5(descriptor);
+    closeSync6(descriptor);
   }
 }
 var init_bridge_artifact = __esm({
@@ -3226,7 +3239,7 @@ var init_bridge_artifact = __esm({
 });
 
 // src/harness/adapters/docker/creation-plan.ts
-import { join as join35, relative as relative14 } from "path";
+import { join as join37, relative as relative14 } from "path";
 function creationPlan(group, directory, id2, nonce, role, runtime2, cwd, preparation) {
   if (group.profile !== "docker" || !group.dockerPolicy)
     throw new Error("container_requires_docker_profile");
@@ -3243,7 +3256,7 @@ function creationPlan(group, directory, id2, nonce, role, runtime2, cwd, prepara
     throw new Error("invalid_container_image_environment");
   const profile = selectedProfile(policy, preparation.privateProfile, runtime2);
   if (profile) assertProfileAvailable(profile, group.projectRoot);
-  const state = profile?.directory ?? join35(directory, "containers", nonce, "profile");
+  const state = profile?.directory ?? join37(directory, "containers", nonce, "profile");
   return {
     name: containerName(group.owner, id2),
     nonce,
@@ -3260,7 +3273,7 @@ function creationPlan(group, directory, id2, nonce, role, runtime2, cwd, prepara
         preparation.privateProfile
       ),
       Cmd: preparation.args.length ? preparation.args : null,
-      WorkingDir: join35("/workspace", relative14(group.projectRoot, cwd)),
+      WorkingDir: join37("/workspace", relative14(group.projectRoot, cwd)),
       User: `${process.getuid?.()}:${process.getgid?.()}`,
       Env: [
         ...environment2.filter(
@@ -3359,12 +3372,12 @@ var init_creation_plan = __esm({
 
 // src/harness/adapters/docker/creation.ts
 import { mkdirSync as mkdirSync10 } from "fs";
-import { join as join36 } from "path";
+import { join as join38 } from "path";
 async function prepareCreation(journal) {
   const intent = journal.intent();
   const creation = intent.dockerCreation;
   if (!creation) throw new Error("container_creation_missing");
-  const group = new GroupStore(join36(journal.records.directory, "group.json")).state.group;
+  const group = new GroupStore(join38(journal.records.directory, "group.json")).state.group;
   const profile = selectedProfile(
     group.dockerPolicy,
     creation.privateProfile,
@@ -3378,7 +3391,7 @@ async function prepareCreation(journal) {
     creation.name,
     creation.configuration
   );
-  const current = new GroupStore(join36(journal.records.directory, "group.json")).state.group;
+  const current = new GroupStore(join38(journal.records.directory, "group.json")).state.group;
   if (current.id !== intent.groupId || current.generation !== intent.generation)
     throw new Error("launch_group_generation_mismatch");
   const resource = {
@@ -3446,7 +3459,7 @@ function findCreation(journal) {
   assertResourceOwner(resource, actual);
   assertCreationConfiguration(actual, creation);
   if (!intent.resource) {
-    const group = new GroupStore(join36(journal.records.directory, "group.json")).state.group;
+    const group = new GroupStore(join38(journal.records.directory, "group.json")).state.group;
     return {
       ...admitClaim(
         { ...resource, runtime: intent.runtime, state: creation.state },
@@ -3483,7 +3496,7 @@ var init_creation = __esm({
 });
 
 // src/harness/launch/recovery.ts
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 function abortLaunch(connection, journal) {
   const intent = journal.intent();
   if (!controllerExited(intent.controllerIdentity))
@@ -3500,7 +3513,7 @@ function abortLaunch(connection, journal) {
       inputReplayed: false
     };
   }
-  if (!existsSync25(journal.path("proof"))) {
+  if (!existsSync28(journal.path("proof"))) {
     const paneUnknown = connection.alive() && (!intent.dockerCreation || connection.tmux(["list-sessions", "-F", "#{session_name}"]).trim().split("\n").includes(`pmcp-${intent.id}`));
     if (paneUnknown || unitActive(intent.unit))
       throw new Error("launch_identity_unknown");
@@ -3527,7 +3540,7 @@ function abortLaunch(connection, journal) {
     assertProof(connection, proof);
     connection.tmux(["kill-pane", "-t", proof.session.paneId]);
   }
-  if (existsSync25(journal.records.path(intent.id)))
+  if (existsSync28(journal.records.path(intent.id)))
     journal.records.save({
       ...proof.session,
       stoppedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -3553,10 +3566,10 @@ var init_recovery = __esm({
 });
 
 // src/harness/adapters/tmux/lifecycle.ts
-import { randomUUID as randomUUID7 } from "crypto";
-import { existsSync as existsSync26 } from "fs";
+import { randomUUID as randomUUID8 } from "crypto";
+import { existsSync as existsSync29 } from "fs";
 import { setTimeout as setTimeout2 } from "timers/promises";
-import { join as join37 } from "path";
+import { join as join39 } from "path";
 async function start(connection, spec) {
   const records2 = connection.records;
   if (spec.budgetSlice !== budgetSlice(records2.owner))
@@ -3566,11 +3579,11 @@ async function start(connection, spec) {
   runtimeUnit(spec.generation);
   if (spec.role !== "main" && spec.role !== "worker")
     throw new Error("invalid_launch_role");
-  const id2 = randomUUID7();
-  const nonce = randomUUID7();
+  const id2 = randomUUID8();
+  const nonce = randomUUID8();
   const journal = new LaunchJournal(records2, id2);
   const dockerCreation = spec.dockerPreparation ? creationPlan(
-    new GroupStore(join37(records2.directory, "group.json")).state.group,
+    new GroupStore(join39(records2.directory, "group.json")).state.group,
     records2.directory,
     id2,
     nonce,
@@ -3630,7 +3643,7 @@ async function start(connection, spec) {
     `exec ${argv.map(quote2).join(" ")}`
   ]);
   const deadline = Date.now() + 5e3;
-  while (!existsSync26(journal.path("proof"))) {
+  while (!existsSync29(journal.path("proof"))) {
     if (Date.now() >= deadline) throw new Error("launch_proof_timeout");
     await setTimeout2(25);
   }
@@ -3641,7 +3654,7 @@ async function start(connection, spec) {
 }
 function stop(connection, id2) {
   const journal = new LaunchJournal(connection.records, id2);
-  if (existsSync26(journal.path("intent"))) {
+  if (existsSync29(journal.path("intent"))) {
     abortLaunch(connection, journal);
     return;
   }
@@ -3668,7 +3681,7 @@ function cleanup(connection) {
   }
   for (const record of records2) {
     if (record.resource) stopResource(record.resource);
-    if (record.stoppedAt || !existsSync26(
+    if (record.stoppedAt || !existsSync29(
       new LaunchJournal(connection.records, record.id).path("intent")
     )) {
       stopUnit(record.unit);
@@ -3698,9 +3711,9 @@ var init_lifecycle2 = __esm({
 });
 
 // src/harness/adapters/tmux/input.ts
-import { randomUUID as randomUUID8 } from "crypto";
-import { closeSync as closeSync6, openSync as openSync6, unlinkSync as unlinkSync3, writeFileSync as writeFileSync12 } from "fs";
-import { join as join38 } from "path";
+import { randomUUID as randomUUID9 } from "crypto";
+import { closeSync as closeSync7, openSync as openSync7, unlinkSync as unlinkSync3, writeFileSync as writeFileSync12 } from "fs";
+import { join as join40 } from "path";
 function validateText(text3) {
   if (typeof text3 !== "string" || Buffer.byteLength(text3) > 16384)
     throw new Error("invalid_text");
@@ -3731,9 +3744,9 @@ function write(connection, id2, text3, submit) {
   validateText(text3);
   const session = connection.inspect(id2);
   if (!session.alive) throw new Error("runtime_exited");
-  const lock = join38(connection.records.directory, `${id2}.input.lock`);
-  const descriptor = openSync6(lock, "wx", 384);
-  const buffer = `pmcp-${randomUUID8()}`;
+  const lock = join40(connection.records.directory, `${id2}.input.lock`);
+  const descriptor = openSync7(lock, "wx", 384);
+  const buffer = `pmcp-${randomUUID9()}`;
   try {
     writeFileSync12(
       descriptor,
@@ -3773,7 +3786,7 @@ function write(connection, id2, text3, submit) {
       connection.tmux(["delete-buffer", "-b", buffer]);
     } catch {
     }
-    closeSync6(descriptor);
+    closeSync7(descriptor);
     unlinkSync3(lock);
   }
 }
@@ -3849,7 +3862,6 @@ var init_backend = __esm({
         this.runDirectory = recordStore.directory;
         this.metadataPath = recordStore.metadataPath;
       }
-      recordStore;
       connection;
       owner;
       socket;
@@ -3890,10 +3902,10 @@ var init_backend = __esm({
 });
 
 // src/harness/adapters/systemd/budget.ts
-import { join as join39 } from "path";
+import { join as join41 } from "path";
 async function budgetOperation(directory, operation) {
   const backend = openBackend(directory);
-  const path = join39(directory, "runtime-policy.json");
+  const path = join41(directory, "runtime-policy.json");
   const metadata2 = object8(readPrivateJson2(backend.metadataPath));
   const slice = budgetSlice(backend.owner);
   if (operation.action === "configure") {
@@ -3994,7 +4006,7 @@ var init_budget = __esm({
 
 // src/harness/adapters/systemd/configure.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { join as join40 } from "path";
+import { join as join42 } from "path";
 function configureBudget(context, input) {
   const { store, backend } = context;
   assertOwnedRecords(backend);
@@ -4016,7 +4028,7 @@ function configureBudget(context, input) {
     throw new Error("capacity_below_active_sessions");
   if (active.reduce((total, session) => total + session.memoryMb, 0) > memoryMb)
     throw new Error("budget_below_reserved_memory");
-  const path = join40(backend.runDirectory, "runtime-policy.json");
+  const path = join42(backend.runDirectory, "runtime-policy.json");
   const policy = object8(readPrivateJson2(path));
   const metadata2 = object8(readPrivateJson2(backend.metadataPath));
   const slice = budgetSlice(backend.owner);
@@ -4054,11 +4066,11 @@ var init_configure = __esm({
 
 // src/harness/adapters/process/executable.ts
 import { accessSync, constants as constants6, statSync as statSync16 } from "fs";
-import { delimiter, resolve as resolve19 } from "path";
+import { delimiter, resolve as resolve18 } from "path";
 function locateExecutable(binary, cwd = process.cwd()) {
   for (const directory of (process.env.PATH ?? "").split(delimiter)) {
     if (!directory) continue;
-    const path = resolve19(cwd, directory, binary);
+    const path = resolve18(cwd, directory, binary);
     try {
       if (!statSync16(path).isFile()) continue;
       accessSync(path, constants6.X_OK);
@@ -4110,11 +4122,11 @@ var init_admission2 = __esm({
 });
 
 // src/harness/groups/service.ts
-import { randomUUID as randomUUID9 } from "crypto";
-import { realpathSync as realpathSync10, statSync as statSync17, unlinkSync as unlinkSync4 } from "fs";
-import { join as join41 } from "path";
+import { randomUUID as randomUUID10 } from "crypto";
+import { realpathSync as realpathSync12, statSync as statSync17, unlinkSync as unlinkSync4 } from "fs";
+import { join as join43 } from "path";
 async function createGroup(input) {
-  const projectRoot = realpathSync10(text(input.projectRoot, "project_root"));
+  const projectRoot = realpathSync12(text(input.projectRoot, "project_root"));
   if (!statSync17(projectRoot).isDirectory())
     throw new Error("invalid_project_root");
   const allowedRuntimes = strings2(input.allowedRuntimes, "allowed_runtimes");
@@ -4134,8 +4146,8 @@ async function createGroup(input) {
   const group = {
     schemaVersion: 1,
     owner: backend.owner,
-    id: randomUUID9(),
-    generation: randomUUID9(),
+    id: randomUUID10(),
+    generation: randomUUID10(),
     projectRoot,
     allowedRuntimes,
     profile,
@@ -4145,7 +4157,7 @@ async function createGroup(input) {
     sessions: [],
     ...dockerPolicy2 ? { dockerPolicy: dockerPolicy2 } : {}
   };
-  const groupFile = join41(backend.runDirectory, "group.json");
+  const groupFile = join43(backend.runDirectory, "group.json");
   privateJson(groupFile, { group, leases: [], deliveries: [] });
   try {
     await budgetOperation(backend.runDirectory, {
@@ -4158,7 +4170,7 @@ async function createGroup(input) {
       await budgetOperation(backend.runDirectory, { action: "cleanup" });
       unlinkSync4(groupFile);
     } catch (cleanupError) {
-      privateJson(join41(backend.runDirectory, "initialization-failure.json"), {
+      privateJson(join43(backend.runDirectory, "initialization-failure.json"), {
         error: String(error),
         cleanupError: String(cleanupError),
         recoveryRequired: true
@@ -4220,16 +4232,16 @@ var init_service2 = __esm({
 });
 
 // src/harness/groups/catalog.ts
-import { existsSync as existsSync27, readdirSync as readdirSync12 } from "fs";
-import { join as join42 } from "path";
+import { existsSync as existsSync30, readdirSync as readdirSync12 } from "fs";
+import { join as join44 } from "path";
 function listGroups() {
   const directory = stateDirectory();
-  if (!existsSync27(directory)) return { groups: [] };
+  if (!existsSync30(directory)) return { groups: [] };
   const groups2 = [];
   for (const entry2 of readdirSync12(directory, { withFileTypes: true })) {
     if (!entry2.isDirectory()) continue;
-    const path = join42(directory, entry2.name, "group.json");
-    if (!existsSync27(path)) continue;
+    const path = join44(directory, entry2.name, "group.json");
+    if (!existsSync30(path)) continue;
     try {
       const store = new GroupStore(path);
       groups2.push({ groupFile: store.path, group: store.state.group });
@@ -4288,10 +4300,10 @@ var init_service3 = __esm({
 });
 
 // src/harness/application/context.ts
-import { dirname as dirname21 } from "path";
+import { dirname as dirname23 } from "path";
 function openGroup(path) {
   const store = new GroupStore(path);
-  const backend = openBackend(dirname21(store.path));
+  const backend = openBackend(dirname23(store.path));
   if (store.state.group.owner !== backend.owner)
     throw new Error("foreign_group");
   return { store, backend };
@@ -4425,8 +4437,8 @@ var init_watch = __esm({
 });
 
 // src/harness/control/leases.ts
-import { randomUUID as randomUUID10 } from "crypto";
-import { join as join43 } from "path";
+import { randomUUID as randomUUID11 } from "crypto";
+import { join as join45 } from "path";
 function resolveLease(context, file2, allowExpired = false) {
   const credential2 = object8(readPrivateJson2(file2));
   const lease = context.store.state.leases.find(
@@ -4458,7 +4470,7 @@ function acquireControl(context, sessionId, controller, mode) {
   if (mode !== "cli" && mode !== "native")
     throw new Error("invalid_control_mode");
   const lease = {
-    token: randomUUID10(),
+    token: randomUUID11(),
     sessionId,
     generation: store.state.group.generation,
     controller: id(controller, "controller"),
@@ -4470,7 +4482,7 @@ function acquireControl(context, sessionId, controller, mode) {
   );
   store.state.leases.push(lease);
   store.save();
-  const leaseFile = join43(backend.runDirectory, `lease-${randomUUID10()}.json`);
+  const leaseFile = join45(backend.runDirectory, `lease-${randomUUID11()}.json`);
   privateJson(leaseFile, { token: lease.token });
   return { sessionId, controller, mode, expiresAt: lease.expiresAt, leaseFile };
 }
@@ -4617,18 +4629,18 @@ var init_service5 = __esm({
 });
 
 // src/harness/adapters/process/recover-lock.ts
-import { existsSync as existsSync28, lstatSync as lstatSync10, unlinkSync as unlinkSync5 } from "fs";
-import { join as join44 } from "path";
+import { existsSync as existsSync31, lstatSync as lstatSync11, unlinkSync as unlinkSync5 } from "fs";
+import { join as join46 } from "path";
 function recoverInputLock(backend, sessionId) {
   backend.inspect(sessionId);
-  const path = join44(backend.runDirectory, `${sessionId}.input.lock`);
-  if (!existsSync28(path)) return;
-  const before = lstatSync10(path);
+  const path = join46(backend.runDirectory, `${sessionId}.input.lock`);
+  if (!existsSync31(path)) return;
+  const before = lstatSync11(path);
   const record = object8(readPrivateJson2(path));
   if (record.id !== sessionId) throw new Error("foreign_writer_lock");
   if (!controllerExited(text(record.controller, "controller_identity")))
     throw new Error("writer_still_alive");
-  if (lstatSync10(path).ino !== before.ino)
+  if (lstatSync11(path).ino !== before.ino)
     throw new Error("writer_lock_changed");
   unlinkSync5(path);
 }
@@ -4642,7 +4654,7 @@ var init_recover_lock = __esm({
 });
 
 // src/harness/launch/service.ts
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync32 } from "fs";
 function assertLaunchAdmission(records2) {
   for (const journal of launchJournals(records2)) {
     if (journal.abortRecord()?.state === "stopped" && unitActive(journal.intent().unit))
@@ -4667,12 +4679,12 @@ function inspectPendingStarts(context) {
     role: journal.intent().role,
     runtime: journal.intent().runtime,
     controllerExited: controllerExited(journal.intent().controllerIdentity),
-    proofPresent: existsSync29(journal.path("proof")),
-    recordPresent: existsSync29(journal.records.path(journal.id)),
+    proofPresent: existsSync32(journal.path("proof")),
+    recordPresent: existsSync32(journal.records.path(journal.id)),
     registered: context.store.state.group.sessions.some(
       (session) => session.id === journal.id
     ),
-    authorizationPresent: existsSync29(journal.path("grant")),
+    authorizationPresent: existsSync32(journal.path("grant")),
     processingConfirmed: false,
     inputReplayed: false
   }));
@@ -4690,7 +4702,7 @@ var init_service6 = __esm({
 });
 
 // src/harness/sessions/service.ts
-import { realpathSync as realpathSync11 } from "fs";
+import { realpathSync as realpathSync13 } from "fs";
 import { relative as relative15 } from "path";
 async function startSession(context, input) {
   const { store, backend } = context;
@@ -4724,7 +4736,7 @@ async function startSession(context, input) {
     );
     if (!backend.inspect(main2.id).alive) throw new Error("main_unavailable");
   }
-  const cwd = realpathSync11(text(input.cwd ?? group.projectRoot, "cwd"));
+  const cwd = realpathSync13(text(input.cwd ?? group.projectRoot, "cwd"));
   const scope = relative15(group.projectRoot, cwd);
   if (scope === ".." || scope.startsWith("../"))
     throw new Error("cwd_outside_project");
@@ -4832,7 +4844,7 @@ var init_service7 = __esm({
 });
 
 // src/harness/recovery/service.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 function inspectRecovery(context, includeStarts = false) {
   const pendingStarts = includeStarts ? inspectPendingStarts(context) : [];
   return {
@@ -4915,7 +4927,7 @@ async function replaceMain(context, input) {
     if (observation.alive) throw new Error("main_still_alive");
     previous.stopped = true;
   }
-  store.state.group.generation = randomUUID11();
+  store.state.group.generation = randomUUID12();
   store.state.leases = [];
   store.save();
   const result = await startSession(context, { ...input, role: "main" });
@@ -5187,9 +5199,9 @@ var init_invoke = __esm({
 });
 
 // src/tui/adapters/process/runtime.ts
-import { dirname as dirname22, join as join45 } from "path";
+import { dirname as dirname24, join as join47 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { existsSync as existsSync30, realpathSync as realpathSync12 } from "fs";
+import { existsSync as existsSync33, realpathSync as realpathSync14 } from "fs";
 function dependencies() {
   const tmux = locateExecutable("tmux");
   const flock = locateExecutable("flock");
@@ -5222,10 +5234,10 @@ function runtime() {
   if (!available.supported || !available.node)
     throw new Error("tui_dependencies_unavailable");
   const current = fileURLToPath4(import.meta.url);
-  const directory = dirname22(current);
-  const bundled = join45(directory, "tui-worker.js");
-  if (!existsSync30(bundled)) throw new Error("tui_build_required");
-  return { node: realpathSync12(available.node), worker: bundled };
+  const directory = dirname24(current);
+  const bundled = join47(directory, "tui-worker.js");
+  if (!existsSync33(bundled)) throw new Error("tui_build_required");
+  return { node: realpathSync14(available.node), worker: bundled };
 }
 var init_runtime2 = __esm({
   "src/tui/adapters/process/runtime.ts"() {
@@ -5236,35 +5248,108 @@ 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 randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 import {
-  existsSync as existsSync31,
-  lstatSync as lstatSync11,
+  existsSync as existsSync34,
+  lstatSync as lstatSync12,
   mkdirSync as mkdirSync11,
-  realpathSync as realpathSync13,
+  realpathSync as realpathSync15,
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync13
 } from "fs";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname23, join as join46 } from "path";
+import { dirname as dirname25, join as join48 } from "path";
 function createDirectory() {
-  const root = join46(
-    process.env.XDG_STATE_HOME ?? join46(homedir10(), ".local/state"),
+  const root = join48(
+    process.env.XDG_STATE_HOME ?? join48(homedir10(), ".local/state"),
     "pmcp/tui"
   );
   mkdirSync11(root, { recursive: true, mode: 448 });
-  const directory = join46(realpathSync13(root), randomUUID12().slice(0, 16));
-  if (Buffer.byteLength(join46(directory, "s")) > 100)
+  const directory = join48(realpathSync15(root), randomUUID13().slice(0, 16));
+  if (Buffer.byteLength(join48(directory, "s")) > 100)
     throw new Error("socket_path_too_long");
   mkdirSync11(directory, { mode: 448 });
-  const owner = randomUUID12();
-  privateJson(join46(directory, "owner.json"), {
+  const owner = randomUUID13();
+  privateJson(join48(directory, "owner.json"), {
     owner,
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   writeFileSync13(
-    join46(directory, "tmux.conf"),
+    join48(directory, "tmux.conf"),
     [
       "set -g remain-on-exit on",
       "set -g history-limit 2000",
@@ -5279,13 +5364,13 @@ function createDirectory() {
   return { directory, owner };
 }
 function readView(path) {
-  const file2 = realpathSync13(path);
-  const directory = dirname23(file2);
-  const stat = lstatSync11(directory);
+  const file2 = realpathSync15(path);
+  const directory = dirname25(file2);
+  const stat = lstatSync12(directory);
   if (!stat.isDirectory() || stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0)
     throw new Error("unsafe_view_directory");
   const value = object8(readPrivateJson2(file2));
-  const metadata2 = object8(readPrivateJson2(join46(directory, "owner.json")));
+  const metadata2 = object8(readPrivateJson2(join48(directory, "owner.json")));
   if (value.schemaVersion !== 1 || value.directory !== directory || value.owner !== metadata2.owner)
     throw new Error("foreign_view_owner");
   for (const key of [
@@ -5322,8 +5407,8 @@ function readView(path) {
       throw new Error("invalid_view_identity");
   }
   const view = value;
-  const fallback = join46(directory, "callback-failure.json");
-  if (existsSync31(fallback)) {
+  const fallback = join48(directory, "callback-failure.json");
+  if (existsSync34(fallback)) {
     const recorded = object8(readPrivateJson2(fallback));
     const failure2 = object8(recorded.failure);
     if (recorded.owner !== view.owner || typeof failure2.code !== "string" || !/^[a-z][a-z0-9_]{0,79}$/.test(failure2.code))
@@ -5334,8 +5419,8 @@ function readView(path) {
   return { file: file2, view };
 }
 function dismissFailure(file2, view) {
-  const fallback = join46(view.directory, "callback-failure.json");
-  if (existsSync31(fallback)) unlinkSync6(fallback);
+  const fallback = join48(view.directory, "callback-failure.json");
+  if (existsSync34(fallback)) unlinkSync6(fallback);
   delete view.failure;
   saveView(file2, view);
 }
@@ -5397,7 +5482,7 @@ var init_lock = __esm({
 });
 
 // src/tui/adapters/process/budget.ts
-import { readFileSync as readFileSync36 } from "fs";
+import { readFileSync as readFileSync37 } from "fs";
 function viewUnit(owner) {
   if (!/^[a-f0-9]{8}(-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(owner))
     throw new Error("invalid_view_owner");
@@ -5425,7 +5510,7 @@ function startPresentation(owner, args, env) {
   );
 }
 function assertPresentationBudget(owner, pid) {
-  if (!readFileSync36(`/proc/${pid}/cgroup`, "utf8").includes(
+  if (!readFileSync37(`/proc/${pid}/cgroup`, "utf8").includes(
     `/${viewUnit(owner)}
 `
   ))
@@ -5440,7 +5525,7 @@ var init_budget2 = __esm({
 
 // src/tui/adapters/tmux/connection.ts
 import { spawn as spawn3 } from "child_process";
-import { join as join47 } from "path";
+import { join as join49 } from "path";
 var ViewConnection;
 var init_connection2 = __esm({
   "src/tui/adapters/tmux/connection.ts"() {
@@ -5453,11 +5538,8 @@ var init_connection2 = __esm({
         this.directory = directory;
         this.owner = owner;
         this.identity = identity;
-        this.socket = join47(directory, "s");
+        this.socket = join49(directory, "s");
       }
-      directory;
-      owner;
-      identity;
       socket;
       raw(args) {
         const env = { ...process.env };
@@ -5466,14 +5548,14 @@ var init_connection2 = __esm({
           "-S",
           this.socket,
           "-f",
-          join47(this.directory, "tmux.conf"),
+          join49(this.directory, "tmux.conf"),
           ...args
         ];
         if (args[0] === "new-session" && !this.identity)
           return startPresentation(this.owner, options2, env).trim();
         return command(
           "tmux",
-          ["-S", this.socket, "-f", join47(this.directory, "tmux.conf"), ...args],
+          ["-S", this.socket, "-f", join49(this.directory, "tmux.conf"), ...args],
           { env }
         ).trim();
       }
@@ -5537,7 +5619,7 @@ var init_connection2 = __esm({
 });
 
 // src/tui/application/feedback.ts
-import { join as join48 } from "path";
+import { join as join50 } from "path";
 function describeFailure(action, error) {
   const message = error instanceof Error ? error.message : "view_action_failed";
   const code = error instanceof RangeError ? "terminal_size_invalid" : failureCode(message);
@@ -5574,6 +5656,19 @@ var init_feedback = __esm({
     init_store3();
     init_store2();
     hints = {
+      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.",
@@ -5594,6 +5689,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 [
@@ -5620,7 +5729,8 @@ function bindKeys(connection, view, file2) {
     ["b", "mailbox"],
     ["d", "detach"],
     ["!", "dismiss"],
-    ["g", "management"]
+    ["g", "management"],
+    ["n", "worker-menu"]
   ])
     connection.command([
       "bind-key",
@@ -5641,7 +5751,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",
@@ -5669,7 +5779,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 {
@@ -5682,8 +5792,6 @@ var init_view = __esm({
           view.serverIdentity
         );
       }
-      view;
-      stateFile;
       connection;
       shell(argv) {
         return `exec ${argv.map(quote2).join(" ")}`;
@@ -5855,7 +5963,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) {
@@ -5878,6 +5986,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]);
@@ -5901,7 +6035,6 @@ var init_common = __esm({
       constructor(view) {
         this.view = view;
       }
-      view;
       async call(family, action, input = {}) {
         const group = new GroupStore(this.view.groupFile).state.group;
         if (group.owner !== this.view.groupOwner) throw new Error("foreign_group");
@@ -5935,16 +6068,16 @@ var init_common = __esm({
 });
 
 // src/tui/application/create.ts
-import { join as join49 } from "path";
-import { realpathSync as realpathSync14 } from "fs";
+import { join as join51 } from "path";
+import { realpathSync as realpathSync16 } from "fs";
 async function createView(input) {
   const plan2 = planLayout(input.columns, input.rows);
   const helpers = runtime();
   const mailbox = input.mailbox ? {
-    config: realpathSync14(input.mailbox.config),
-    actorFile: realpathSync14(input.mailbox.actorFile)
+    config: realpathSync16(input.mailbox.config),
+    actorFile: realpathSync16(input.mailbox.actorFile)
   } : void 0;
-  const groupFile = realpathSync14(input.groupFile);
+  const groupFile = realpathSync16(input.groupFile);
   const group = new GroupStore(groupFile).state.group;
   const common2 = new CommonHarness({
     groupFile,
@@ -5957,7 +6090,7 @@ async function createView(input) {
   );
   if (!main2) throw new Error("view_requires_live_main");
   const { directory, owner } = createDirectory();
-  const file2 = join49(directory, "view.json");
+  const file2 = join51(directory, "view.json");
   const connection = new ViewConnection(directory, owner);
   const argv = [helpers.node, helpers.worker, "attach", file2, main2.id];
   const result = connection.raw([
@@ -6185,7 +6318,7 @@ var init_navigation = __esm({
 });
 
 // src/tui/application/history.ts
-import { join as join50 } from "path";
+import { join as join52 } from "path";
 async function observeHistory(context) {
   const { view, renderer, common: common2, file: file2 } = context;
   await releaseControl(context);
@@ -6193,7 +6326,7 @@ async function observeHistory(context) {
     sessionId: view.target,
     input: { lines: 2e3, maxBytes: 65536 }
   });
-  privateJson(join50(view.directory, "history.json"), {
+  privateJson(join52(view.directory, "history.json"), {
     sessionId: view.target,
     content: history.content,
     truncated: history.truncated
@@ -6269,8 +6402,8 @@ var init_mailbox = __esm({
 });
 
 // src/tui/application/lifecycle.ts
-import { existsSync as existsSync32, unlinkSync as unlinkSync7 } from "fs";
-import { join as join51 } from "path";
+import { existsSync as existsSync35, unlinkSync as unlinkSync7 } from "fs";
+import { join as join53 } from "path";
 function resizeView({ view, renderer, input }) {
   renderer.resize(view, planLayout(input.columns, input.rows));
 }
@@ -6285,8 +6418,8 @@ async function stopTarget(context) {
 async function closeView(context) {
   await returnToMain(context);
   context.renderer.connection.cleanup();
-  const history = join51(context.view.directory, "history.json");
-  if (existsSync32(history)) unlinkSync7(history);
+  const history = join53(context.view.directory, "history.json");
+  if (existsSync35(history)) unlinkSync7(history);
   context.view.state = "closed";
   saveView(context.file, context.view);
 }
@@ -6440,6 +6573,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) {
@@ -6463,8 +6601,9 @@ __export(invoke_exports2, {
   invokeTui: () => invokeTui
 });
 async function invokeTui(invocation2) {
-  if (invocation2.action === "doctor")
-    return { schemaVersion: 1, ok: true, ...dependencies() };
+  if (["launch", "plan", "recovery", "start-worker"].includes(invocation2.action))
+    throw new Error("startup_requires_cli_context");
+  if (invocation2.action === "doctor") return inspectTerminalHost();
   if (invocation2.action === "create") return createView(invocation2.create);
   if (invocation2.action === "inspect")
     return operate("inspect", invocation2.viewFile);
@@ -6502,7 +6641,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();
@@ -6511,6 +6650,543 @@ 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";
+function startupSettings(request3) {
+  const path = request3.config ? resolve19(request3.cwd, request3.config) : findConfig(request3.cwd);
+  const config = path ? readConfig(path) : void 0;
+  const source2 = config?.raw.tui;
+  const fail2 = (message) => {
+    throw new ConfigError(path ?? "pmcp.toml", `[tui] ${message}`);
+  };
+  if (source2 !== void 0 && (source2 === null || typeof source2 !== "object" || Array.isArray(source2)))
+    fail2("must be a table");
+  const values = source2 ?? {};
+  const allowed3 = /* @__PURE__ */ new Set([
+    "runtime",
+    "memory_mb",
+    "session_memory_mb",
+    "max_active",
+    "group_file"
+  ]);
+  for (const key of Object.keys(values)) {
+    if (!allowed3.has(key)) fail2(`unknown key ${key}`);
+  }
+  const string = (key) => {
+    const value = values[key];
+    if (value === void 0) return void 0;
+    if (typeof value !== "string" || !value.trim())
+      fail2(`${key} must be a non-empty string`);
+    return value;
+  };
+  const integer2 = (key, fallback, min, max) => {
+    const value = values[key] ?? fallback;
+    if (typeof value !== "number" || !Number.isSafeInteger(value))
+      fail2(`${key} must be an integer`);
+    if (Number(value) < min || Number(value) > max)
+      fail2(`${key} must be between ${min} and ${max}`);
+    return Number(value);
+  };
+  const configuredRuntime = string("runtime");
+  if (configuredRuntime !== void 0 && configuredRuntime !== "auto" && !Object.hasOwn(runtimeExecutables, configuredRuntime))
+    fail2("runtime must be auto or a supported runtime ID");
+  const available = preference.filter(
+    (runtime3) => locateExecutable(runtimeExecutables[runtime3], request3.cwd)
+  );
+  let runtime2 = request3.runtime ?? configuredRuntime ?? "auto";
+  if (runtime2 === "auto") runtime2 = available[0] ?? "codex-cli";
+  if (!Object.hasOwn(runtimeExecutables, runtime2))
+    fail2("runtime must be a supported runtime ID");
+  const memoryMb = integer2("memory_mb", 2048, 128, 4096);
+  const sessionMemoryMb = integer2("session_memory_mb", 768, 32, 1536);
+  if (sessionMemoryMb > memoryMb)
+    fail2("session memory exceeds the group budget");
+  const groupFile = string("group_file");
+  return {
+    projectRoot: realpathSync17(config?.dir ?? request3.cwd),
+    ...config ? { configFile: config.path } : {},
+    runtime: runtime2,
+    allowedRuntimes: [.../* @__PURE__ */ new Set([...available, runtime2])],
+    memoryMb,
+    sessionMemoryMb,
+    maxActive: integer2("max_active", 2, 1, 5),
+    ...groupFile ? { groupFile: resolve19(config?.dir ?? request3.cwd, groupFile) } : {}
+  };
+}
+var preference;
+var init_config3 = __esm({
+  "src/tui/startup/config.ts"() {
+    "use strict";
+    init_config();
+    init_registry();
+    init_executable();
+    preference = [
+      "codex-cli",
+      "gemini-cli",
+      "antigravity",
+      "grok-cli",
+      "claude-code"
+    ];
+  }
+});
+
+// src/tui/startup/state.ts
+import { createHash as createHash19 } from "crypto";
+import { existsSync as existsSync36, lstatSync as lstatSync13, mkdirSync as mkdirSync12 } from "fs";
+import { homedir as homedir11 } from "os";
+import { dirname as dirname26, join as join54 } from "path";
+function startupFile(projectRoot) {
+  const root = join54(
+    process.env.XDG_STATE_HOME ?? join54(homedir11(), ".local/state"),
+    "pmcp/launcher"
+  );
+  const key = createHash19("sha256").update(projectRoot).digest("hex");
+  return join54(root, `${key}.json`);
+}
+function ensureStartupDirectory(file2) {
+  const directory = dirname26(file2);
+  mkdirSync12(directory, { recursive: true, mode: 448 });
+  const stat = lstatSync13(directory);
+  if (!stat.isDirectory() || stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0)
+    throw new Error("unsafe_startup_directory");
+}
+function readStartup(file2, projectRoot) {
+  if (!existsSync36(file2)) return null;
+  const value = object8(readPrivateJson2(file2));
+  if (value.schemaVersion !== 1 || value.projectRoot !== projectRoot)
+    throw new Error("foreign_startup_state");
+  if (!["creating", "starting", "view-pending", "ready"].includes(
+    String(value.phase)
+  ))
+    throw new Error("invalid_startup_state");
+  text(value.runtime, "runtime");
+  if (value.phase !== "creating") {
+    text(value.groupFile, "group_file");
+    text(value.generation, "generation");
+  }
+  if (value.phase === "ready") text(value.viewFile, "view_file");
+  return value;
+}
+var init_state = __esm({
+  "src/tui/startup/state.ts"() {
+    "use strict";
+    init_store2();
+    init_validation();
+  }
+});
+
+// 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, {
+  requireTerminal: () => requireTerminal,
+  terminalSupport: () => terminalSupport
+});
+function terminalSupport() {
+  try {
+    if (!dependencies().supported)
+      throw new Error("tui_dependencies_unavailable");
+    assertNativeHost();
+    planLayout(process.stdout.columns ?? 0, process.stdout.rows ?? 0);
+    return { supported: true };
+  } catch (error) {
+    return {
+      supported: false,
+      reason: error instanceof Error ? error.message : "terminal_unavailable"
+    };
+  }
+}
+function requireTerminal() {
+  if (!interactiveEntry({
+    stdin: process.stdin.isTTY === true,
+    stdout: process.stdout.isTTY === true,
+    term: process.env.TERM,
+    ci: process.env.CI
+  }))
+    throw new Error("terminal_required");
+  const support = terminalSupport();
+  if (!support.supported) throw new Error(support.reason);
+}
+var init_host = __esm({
+  "src/tui/startup/host.ts"() {
+    "use strict";
+    init_entry();
+    init_layout();
+    init_admission2();
+    init_runtime2();
+  }
+});
+
+// src/tui/startup/lock.ts
+import { spawnSync as spawnSync6 } from "child_process";
+import { closeSync as closeSync8, constants as constants7, fstatSync as fstatSync5, openSync as openSync8 } from "fs";
+function serializedStartup(request3) {
+  const settings2 = startupSettings(request3);
+  const file2 = startupFile(settings2.projectRoot);
+  ensureStartupDirectory(file2);
+  const lock = `${file2}.lock`;
+  const descriptor = openSync8(
+    lock,
+    constants7.O_CREAT | constants7.O_WRONLY | constants7.O_NOFOLLOW,
+    384
+  );
+  try {
+    const stat = fstatSync5(descriptor);
+    if (!stat.isFile() || stat.uid !== process.getuid?.() || (stat.mode & 63) !== 0)
+      throw new Error("unsafe_startup_lock");
+  } finally {
+    closeSync8(descriptor);
+  }
+  const helpers = runtime();
+  const encoded = Buffer.from(JSON.stringify(request3)).toString("base64url");
+  const child = spawnSync6(
+    "flock",
+    [
+      "--wait",
+      "10",
+      "--close",
+      "--conflict-exit-code",
+      "73",
+      lock,
+      helpers.node,
+      helpers.worker,
+      "startup",
+      encoded
+    ],
+    {
+      encoding: "utf8",
+      timeout: 6e4,
+      maxBuffer: 256 * 1024,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        PMCP_TUI_COLUMNS: String(process.stdout.columns),
+        PMCP_TUI_ROWS: String(process.stdout.rows)
+      }
+    }
+  );
+  if (child.status === 73) throw new Error("startup_busy");
+  if (child.error || !child.stdout.trim())
+    throw new Error("startup_requires_recovery");
+  return JSON.parse(child.stdout);
+}
+var init_lock2 = __esm({
+  "src/tui/startup/lock.ts"() {
+    "use strict";
+    init_runtime2();
+    init_state();
+    init_config3();
+  }
+});
+
+// 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
+});
+function planStartup(request3) {
+  const settings2 = startupSettings(request3);
+  const state = readStartup(
+    startupFile(settings2.projectRoot),
+    settings2.projectRoot
+  );
+  return {
+    schemaVersion: 1,
+    ok: true,
+    settings: settings2,
+    savedWorkspace: state,
+    willStartRuntime: !state && !settings2.groupFile,
+    runtimeExecutable: locateExecutable(
+      runtimeExecutables[settings2.runtime],
+      request3.cwd
+    ),
+    providerInvoked: false
+  };
+}
+async function launchStartup(request3, confirmed) {
+  requireTerminal();
+  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}
+`
+    );
+  }
+  const prepared = serializedStartup(request3);
+  if (prepared.ok !== true) return prepared;
+  return invokeTui({
+    action: "open",
+    viewFile: String(prepared.viewFile),
+    input: {}
+  });
+}
+function cancelledStart() {
+  return {
+    schemaVersion: 1,
+    ok: true,
+    cancelled: true,
+    providerInvoked: false
+  };
+}
+var init_entry2 = __esm({
+  "src/tui/startup/entry.ts"() {
+    "use strict";
+    init_executable();
+    init_registry();
+    init_invoke2();
+    init_config3();
+    init_state();
+    init_host();
+    init_lock2();
+    init_runtime_choice();
+  }
+});
+
 // src/cli/command.ts
 var ArgumentError = class extends Error {
   constructor(message) {
@@ -6564,15 +7240,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
       ])
@@ -6583,9 +7259,14 @@ 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 runs the MCP server on stdio.");
+  ui.line(
+    "  With no command, pmcp opens a terminal workspace on a supported TTY."
+  );
+  ui.line(
+    "  Piped launches retain MCP stdio. Use pmcp serve explicitly for MCP."
+  );
   ui.line();
   ui.table([
     ["-q, --quiet", "only errors"],
@@ -6688,6 +7369,9 @@ var Ui = class {
   }
 };
 
+// src/commands/index.ts
+init_entry();
+
 // src/intent.ts
 function normaliseIntent(intent) {
   return intent.toLowerCase().replaceAll(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/u).filter(Boolean).join(" ");
@@ -9163,7 +9847,7 @@ function registerMailboxTools(server, service) {
 
 // src/mcp.ts
 var SERVER_NAME = "pmcp";
-var SERVER_VERSION = "0.14.1";
+var SERVER_VERSION = "0.16.0";
 function registerSkillTools(server, tools) {
   registerCatalogTool(server, tools);
   registerFindTool(server, tools);
@@ -9351,7 +10035,7 @@ async function prepareSearch(catalog, options2) {
 // src/commands/serve.ts
 var serveCommand = {
   name: "serve",
-  describe: "Run the MCP server on stdio (the default with no command)",
+  describe: "Run the MCP server on stdio (also the default for piped launches)",
   usage: "pmcp serve [--root <dir>] [--scope <prefix>] [--marketplace <dir>] [--package <dir>] [--workspace <dir>] [--config <file> | --no-config] [--prompts]",
   options: [
     ...CATALOG_OPTIONS,
@@ -9812,6 +10496,10 @@ function installedPackageDirectory(project2, name) {
   for (; ; ) {
     const candidate2 = join11(directory, "node_modules", name);
     if (existsSync10(join11(candidate2, "package.json"))) return candidate2;
+    if (existsSync10(join11(directory, ".git")))
+      throw new Error(
+        "Installed package manifest was not found in this repository"
+      );
     const parent = dirname11(directory);
     if (parent === directory)
       throw new Error("Installed package manifest was not found");
@@ -9829,6 +10517,8 @@ function locate(name, project2) {
       );
     } catch (error) {
       if (!absent(error)) return { name, reason: "unreadable_manifest" };
+      if (existsSync10(join11(directory, ".git")))
+        return { name, reason: "not_installed" };
       const parent = dirname11(directory);
       if (parent === directory) return { name, reason: "not_installed" };
       directory = parent;
@@ -9885,30 +10575,77 @@ function readInstalledDependencies(projectDirectory) {
 }
 
 // src/install/plan.ts
-import { createHash as createHash7 } from "crypto";
-import { existsSync as existsSync11, readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname12, join as join12, relative as relative6, resolve as resolve9, sep as sep5 } from "path";
 import semver from "semver";
-function matchingSkills(catalog, inventory) {
-  const matches2 = [];
-  for (const dependency of inventory.dependencies) {
-    for (const entry2 of catalog.entries) {
-      const target2 = entry2.targets.find(
-        (target3) => target3.packageName === dependency.name
+
+// src/install/manager.ts
+import { existsSync as existsSync11 } from "fs";
+import { join as join12, relative as relative6, sep as sep5 } from "path";
+function installationCommand(context, specs) {
+  if (context.manager === "npm") {
+    const args2 = [
+      "install",
+      "--save-dev",
+      "--save-exact",
+      "--ignore-scripts",
+      "--no-audit",
+      "--no-fund"
+    ];
+    if (context.project !== context.root)
+      args2.push(
+        `--workspace=${relative6(context.root, context.project).split(sep5).join("/")}`
       );
-      if (target2 && semver.satisfies(dependency.version, target2.range)) {
-        matches2.push({
-          targetName: dependency.name,
-          targetVersion: dependency.version,
-          verified: target2.verifiedVersions.includes(dependency.version),
-          entry: entry2
-        });
+    return { executable: "npm", args: [...args2, ...specs], cwd: context.root };
+  }
+  const args = context.manager === "pnpm" ? ["add", "--save-dev", "--save-exact", "--ignore-scripts"] : ["add", "--dev", "--exact", "--ignore-scripts"];
+  if (context.manager === "pnpm" && context.project === context.root && existsSync11(join12(context.root, "pnpm-workspace.yaml")))
+    args.push("--workspace-root");
+  return {
+    executable: context.manager,
+    args: [...args, ...specs],
+    cwd: context.project
+  };
+}
+function integrityArguments(manager, spec) {
+  const verb = manager === "bun" ? "info" : "view";
+  return [verb, spec, "dist.integrity", "--json"];
+}
+
+// src/install/context.ts
+import { createHash as createHash7 } from "crypto";
+import { existsSync as existsSync13, readFileSync as readFileSync15, realpathSync as realpathSync4 } from "fs";
+import { dirname as dirname12, join as join14 } from "path";
+
+// src/install/workspace.ts
+import { existsSync as existsSync12, readFileSync as readFileSync14, realpathSync as realpathSync3 } from "fs";
+import { join as join13 } from "path";
+import { parse as parse3 } from "yaml";
+function workspaceContains(root, project2) {
+  const file2 = join13(root, "pnpm-workspace.yaml");
+  if (!existsSync12(file2)) return workspacePackageDirs(root).includes(project2);
+  const value = parse3(readFileSync14(file2, "utf8"));
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("invalid pnpm workspace configuration");
+  const patterns = value.packages ?? [];
+  if (!Array.isArray(patterns) || patterns.some((item) => typeof item !== "string"))
+    throw new Error("pnpm workspace packages must be string patterns");
+  const included = /* @__PURE__ */ new Set([root]);
+  const excluded = /* @__PURE__ */ new Set();
+  for (const raw of patterns) {
+    const negated = raw.startsWith("!");
+    const pattern = negated ? raw.slice(1) : raw;
+    if (!pattern || pattern.split("/").includes("..") || pattern.startsWith("/"))
+      throw new Error("workspace patterns must stay inside the workspace");
+    for (const alternative of expandBraces(pattern)) {
+      for (const match of globDirs(root, alternative)) {
+        (negated ? excluded : included).add(realpathSync3(match));
       }
     }
   }
-  return matches2;
+  return project2 === root || included.has(project2) && !excluded.has(project2);
 }
-var LOCKS = [
+
+// src/install/context.ts
+var locks = [
   "package-lock.json",
   "npm-shrinkwrap.json",
   "bun.lock",
@@ -9921,7 +10658,7 @@ function fingerprint(files) {
   for (const file2 of files) {
     hash2.update(file2).update("\0");
     try {
-      hash2.update(readFileSync14(file2));
+      hash2.update(readFileSync15(file2));
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
       hash2.update("absent");
@@ -9932,65 +10669,71 @@ function fingerprint(files) {
 }
 function manifestAt(directory) {
   const value = JSON.parse(
-    readFileSync14(join12(directory, "package.json"), "utf8")
+    readFileSync15(join14(directory, "package.json"), "utf8")
   );
   if (!value || typeof value !== "object" || Array.isArray(value))
     throw new Error("invalid project manifest");
   return value;
 }
-function installContext(directory) {
-  const project2 = resolve9(directory);
-  const manifest2 = manifestAt(project2);
-  let root = project2;
+function managerForLock(file2) {
+  if (file2.startsWith("bun.")) return "bun";
+  if (file2 === "pnpm-lock.yaml") return "pnpm";
+  if (file2 === "package-lock.json" || file2 === "npm-shrinkwrap.json")
+    return "npm";
+  return "unsupported";
+}
+function workspaceRoot(project2) {
   let ancestor = project2;
   for (; ; ) {
-    if (ancestor !== project2 && existsSync11(join12(ancestor, "package.json"))) {
+    if (ancestor !== project2 && existsSync13(join14(ancestor, "package.json"))) {
       const candidate2 = manifestAt(ancestor);
-      if (candidate2.workspaces !== void 0) {
-        root = ancestor;
-        break;
+      if (candidate2.workspaces !== void 0 || existsSync13(join14(ancestor, "pnpm-workspace.yaml"))) {
+        if (!workspaceContains(ancestor, project2))
+          throw new Error("project is excluded from the ancestor workspace");
+        return ancestor;
       }
-      if (LOCKS.some((file2) => existsSync11(join12(ancestor, file2)))) break;
+      if (locks.some((file2) => existsSync13(join14(ancestor, file2))))
+        return project2;
     }
-    if (existsSync11(join12(ancestor, ".git")) || dirname12(ancestor) === ancestor)
-      break;
+    if (existsSync13(join14(ancestor, ".git")) || dirname12(ancestor) === ancestor)
+      return project2;
     ancestor = dirname12(ancestor);
   }
+}
+function installContext(directory) {
+  const project2 = realpathSync4(directory);
+  const manifest2 = manifestAt(project2);
+  const root = workspaceRoot(project2);
   const owner = manifestAt(root);
-  const lockNames = LOCKS.filter((file2) => existsSync11(join12(root, file2)));
-  const lockManagers = new Set(
-    lockNames.map((file2) => {
-      if (file2.startsWith("bun.")) return "bun";
-      if (file2 === "package-lock.json" || file2 === "npm-shrinkwrap.json")
-        return "npm";
-      return "unsupported";
-    })
-  );
+  const lockNames = locks.filter((file2) => existsSync13(join14(root, file2)));
+  const lockManagers = new Set(lockNames.map(managerForLock));
   if (lockManagers.size > 1 || lockManagers.has("unsupported"))
     throw new Error("conflicting or unsupported package manager lockfiles");
   const declared = owner.packageManager?.match(
-    /^(npm|bun)@\d+\.\d+\.\d+(?:[-+].+)?$/u
+    /^(npm|bun|pnpm)@\d+\.\d+\.\d+(?:[-+].+)?$/u
   )?.[1];
   if (owner.packageManager !== void 0 && !declared)
-    throw new Error("only npm and Bun projects are supported");
+    throw new Error("only npm, Bun and pnpm projects are supported");
   const locked = [...lockManagers][0];
   if (declared && locked && declared !== locked)
     throw new Error("packageManager and lockfile disagree");
   const manager = declared ?? locked;
-  if (manager !== "npm" && manager !== "bun")
+  if (manager !== "npm" && manager !== "bun" && manager !== "pnpm")
     throw new Error(
       "declare packageManager or install project dependencies first"
     );
-  if (root !== project2 && LOCKS.some((file2) => existsSync11(join12(project2, file2)))) {
+  if (root !== project2 && locks.some((file2) => existsSync13(join14(project2, file2))))
     throw new Error(
       "nested project has its own lockfile; resolve the workspace boundary first"
     );
-  }
   const files = [
     .../* @__PURE__ */ new Set([
-      join12(root, "package.json"),
-      join12(project2, "package.json"),
-      ...LOCKS.map((file2) => join12(root, file2))
+      join14(root, "package.json"),
+      join14(project2, "package.json"),
+      join14(root, "pnpm-workspace.yaml"),
+      join14(root, ".npmrc"),
+      join14(project2, ".npmrc"),
+      ...locks.map((file2) => join14(root, file2))
     ])
   ];
   return {
@@ -10002,6 +10745,27 @@ function installContext(directory) {
     fingerprint: fingerprint(files)
   };
 }
+
+// src/install/plan.ts
+function matchingSkills(catalog, inventory) {
+  const matches2 = [];
+  for (const dependency of inventory.dependencies) {
+    for (const entry2 of catalog.entries) {
+      const target2 = entry2.targets.find(
+        (target3) => target3.packageName === dependency.name
+      );
+      if (target2 && semver.satisfies(dependency.version, target2.range)) {
+        matches2.push({
+          targetName: dependency.name,
+          targetVersion: dependency.version,
+          verified: target2.verifiedVersions.includes(dependency.version),
+          entry: entry2
+        });
+      }
+    }
+  }
+  return matches2;
+}
 function planInstall(options2) {
   if (options2.inventory.issues.length)
     throw new Error(
@@ -10066,49 +10830,27 @@ function planInstall(options2) {
   const specs = deliveries.map(
     (entry2) => `${entry2.packageName}@${entry2.version}`
   );
-  let args;
-  if (context.manager === "npm") {
-    args = [
-      "install",
-      "--save-dev",
-      "--save-exact",
-      "--ignore-scripts",
-      "--no-audit",
-      "--no-fund"
-    ];
-    if (context.project !== context.root)
-      args.push(
-        `--workspace=${relative6(context.root, context.project).split(sep5).join("/")}`
-      );
-  } else {
-    args = ["add", "--dev", "--exact", "--ignore-scripts"];
-  }
-  args.push(...specs);
   return {
     catalogRevision: catalog.revision,
     context,
     changes: deliveries,
     recalled,
-    command: {
-      executable: context.manager,
-      args,
-      cwd: context.manager === "npm" ? context.root : context.project
-    }
+    command: installationCommand(context, specs)
   };
 }
 
 // src/commands/remote-options.ts
-import { join as join14, resolve as resolve10 } from "path";
-import { readFileSync as readFileSync17 } from "fs";
+import { dirname as dirname13, join as join16, resolve as resolve9 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync18 } from "fs";
 
 // src/remote/catalog.ts
-import { readFileSync as readFileSync16, statSync as statSync8 } from "fs";
+import { readFileSync as readFileSync17, statSync as statSync8 } from "fs";
 import semver2 from "semver";
 import { z as z13 } from "zod";
 
 // src/remote/catalog-cache.ts
-import { mkdirSync as mkdirSync5, readFileSync as readFileSync15, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "fs";
-import { join as join13 } from "path";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync16, renameSync as renameSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join15 } from "path";
 var MAX_CACHE_BYTES = 8 * 1024 * 1024;
 function memoryCatalogCache() {
   const held = /* @__PURE__ */ new Map();
@@ -10120,11 +10862,11 @@ function memoryCatalogCache() {
   };
 }
 function fileCatalogCache(dir) {
-  const path = join13(dir, "catalog-cache.json");
+  const path = join15(dir, "catalog-cache.json");
   return {
     read(origin) {
       try {
-        const raw = readFileSync15(path, "utf8");
+        const raw = readFileSync16(path, "utf8");
         if (raw.length > MAX_CACHE_BYTES) return null;
         const held = JSON.parse(raw);
         if (typeof held !== "object" || held === null) return null;
@@ -10247,7 +10989,7 @@ function readCatalogFile(path) {
   const stat = statSync8(path);
   if (!stat.isFile() || stat.size > MAX_CATALOG_BYTES)
     throw new Error("catalog file exceeds the supported size");
-  const bytes = readFileSync16(path);
+  const bytes = readFileSync17(path);
   if (bytes.byteLength > MAX_CATALOG_BYTES)
     throw new Error("catalog file exceeds the supported size");
   return parseCatalog(JSON.parse(bytes.toString("utf8")));
@@ -10349,7 +11091,17 @@ function catalogProvider(context) {
   return given ?? (api2 ? "hosted" : "public");
 }
 function projectFrom(context) {
-  return resolve10(context.cwd, one(context.args, "project") ?? ".");
+  const explicit = one(context.args, "project");
+  if (explicit) return resolve9(context.cwd, explicit);
+  let directory = resolve9(context.cwd);
+  for (; ; ) {
+    if (existsSync14(join16(directory, "package.json"))) return directory;
+    if (existsSync14(join16(directory, ".git")) || dirname13(directory) === directory)
+      throw new ArgumentError(
+        "No project package.json found; provide --project"
+      );
+    directory = dirname13(directory);
+  }
 }
 function apiOrigin(context) {
   return one(context.args, "api") ?? context.env["PMCP_API_ORIGIN"] ?? DEFAULT_API_ORIGIN;
@@ -10360,11 +11112,11 @@ async function remoteCatalog(context) {
   if (file2) {
     if (one(context.args, "api"))
       throw new Error("choose --catalog or --api, not both");
-    return readCatalogFile(resolve10(context.cwd, file2));
+    return readCatalogFile(resolve9(context.cwd, file2));
   }
   if (provider === "public") {
     const catalog = JSON.parse(
-      readFileSync17(join14(publicMarketplaceRoot(), "docs/catalog.json"), "utf8")
+      readFileSync18(join16(publicMarketplaceRoot(), "docs/catalog.json"), "utf8")
     );
     return parseCatalog({
       schemaVersion: 1,
@@ -10517,7 +11269,7 @@ function createPackageManagerRunner(userConfig, baseEnv = process.env, verifiedI
       const alreadyVerified = verifiedIntegrity?.get(packageSpec);
       if (alreadyVerified) return alreadyVerified;
       const { manager, project: project2 } = plan2.context;
-      const args = manager === "npm" ? ["view", packageSpec, "dist.integrity", "--json"] : ["info", packageSpec, "dist.integrity", "--json"];
+      const args = integrityArguments(manager, packageSpec);
       const result = spawnSync(manager, args, {
         cwd: project2,
         env: environment(userConfig, baseEnv),
@@ -10592,8 +11344,8 @@ function applyInstallPlan(plan2, runner = packageManagerRunner) {
 
 // src/install/verify-content.ts
 import { createHash as createHash8 } from "crypto";
-import { readdirSync as readdirSync5, readFileSync as readFileSync18, statSync as statSync9 } from "fs";
-import { join as join15, relative as relative7, resolve as resolve11, sep as sep6 } from "path";
+import { readdirSync as readdirSync5, readFileSync as readFileSync19, statSync as statSync9 } from "fs";
+import { join as join17, relative as relative7, resolve as resolve10, sep as sep6 } from "path";
 var SKILL = "SKILL.md";
 var SKIP = /* @__PURE__ */ new Set(["node_modules", ".git", ".cache"]);
 function skillFiles2(root) {
@@ -10607,7 +11359,7 @@ function skillFiles2(root) {
     }
     for (const name of entries) {
       if (SKIP.has(name)) continue;
-      const path = join15(dir, name);
+      const path = join17(dir, name);
       let stats;
       try {
         stats = statSync9(path);
@@ -10618,7 +11370,7 @@ function skillFiles2(root) {
       else if (name === SKILL)
         found.set(
           relative7(root, path).split(sep6).join("/"),
-          readFileSync18(path, "utf8")
+          readFileSync19(path, "utf8")
         );
     }
   };
@@ -10634,11 +11386,11 @@ function contentDigest(files) {
   return `sha256:${hash2.digest("hex")}`;
 }
 function verifyInstalledContent(project2, packageName2, expected) {
-  let root = resolve11(project2, "node_modules", ...packageName2.split("/"));
+  let root = resolve10(project2, "node_modules", ...packageName2.split("/"));
   try {
     root = installedPackageDirectory(project2, packageName2);
   } catch {
-    root = resolve11(project2, "node_modules", ...packageName2.split("/"));
+    root = resolve10(project2, "node_modules", ...packageName2.split("/"));
   }
   const files = skillFiles2(root);
   const actual = contentDigest(files);
@@ -10652,8 +11404,8 @@ function verifyInstalledContent(project2, packageName2, expected) {
 }
 
 // src/install/public.ts
-import { lstatSync, readFileSync as readFileSync19, readdirSync as readdirSync6 } from "fs";
-import { join as join16 } from "path";
+import { lstatSync, readFileSync as readFileSync20, readdirSync as readdirSync6 } from "fs";
+import { join as join18 } from "path";
 
 // src/install/archive.ts
 import { createHash as createHash9 } from "crypto";
@@ -10820,7 +11572,7 @@ function verifyPublicDelivery(project2, delivery) {
       for (const entry2 of readdirSync6(directory, { withFileTypes: true })) {
         const path = prefix ? `${prefix}/${entry2.name}` : entry2.name;
         if (entry2.isDirectory()) {
-          walk(join16(directory, entry2.name), path);
+          walk(join18(directory, entry2.name), path);
           continue;
         }
         if (!entry2.isFile() || !expected.has(path))
@@ -10831,8 +11583,8 @@ function verifyPublicDelivery(project2, delivery) {
     };
     walk(root);
     for (const [path, bytes] of files) {
-      const destination = join16(root, path.slice("package/".length));
-      if (!lstatSync(destination).isFile() || !readFileSync19(destination).equals(bytes))
+      const destination = join18(root, path.slice("package/".length));
+      if (!lstatSync(destination).isFile() || !readFileSync20(destination).equals(bytes))
         throw new Error(
           "Installed public package differs from its verified archive; inspect the project before retrying"
         );
@@ -10843,7 +11595,7 @@ function verifyPublicDelivery(project2, delivery) {
 // src/remote/distribution.ts
 import { chmodSync as chmodSync4, mkdtempSync, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir } from "os";
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 function api(origin, path) {
   const base = new URL(catalogEndpoint(origin));
   base.pathname = path;
@@ -10983,9 +11735,9 @@ async function revokeDistributionCredential(accessToken, id2, origin = DEFAULT_A
   }
 }
 function temporaryRegistryConfig(value) {
-  const directory = mkdtempSync(join17(tmpdir(), "pmcp-registry-"));
+  const directory = mkdtempSync(join19(tmpdir(), "pmcp-registry-"));
   chmodSync4(directory, 448);
-  const path = join17(directory, ".npmrc");
+  const path = join19(directory, ".npmrc");
   const registry = new URL(value.registry);
   const auth = `//${registry.host}${registry.pathname}:_authToken=${value.token}`;
   writeFileSync3(path, `${value.scope}:registry=${registry.href}
@@ -11238,36 +11990,34 @@ import { homedir as homedir6 } from "os";
 // src/project/apply.ts
 import { createHash as createHash13 } from "crypto";
 import {
-  existsSync as existsSync17,
-  lstatSync as lstatSync4,
+  existsSync as existsSync20,
+  lstatSync as lstatSync5,
   mkdirSync as mkdirSync7,
-  readFileSync as readFileSync24,
+  readFileSync as readFileSync25,
   readdirSync as readdirSync9,
   readlinkSync as readlinkSync2,
-  rmSync as rmSync4,
-  symlinkSync,
-  writeFileSync as writeFileSync5
+  rmSync as rmSync5
 } from "fs";
-import { dirname as dirname16, join as join22, posix as posix2 } from "path";
-import { parse as parse4 } from "smol-toml";
+import { dirname as dirname18, join as join24, posix as posix2 } from "path";
+import { parse as parse5 } from "smol-toml";
 
 // src/project/backup.ts
 import { createHash as createHash10 } from "crypto";
 import {
-  existsSync as existsSync13,
+  existsSync as existsSync16,
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync6,
   mkdtempSync as mkdtempSync2,
-  readFileSync as readFileSync20,
+  readFileSync as readFileSync21,
   writeFileSync as writeFileSync4
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { dirname as dirname14, isAbsolute as isAbsolute4, join as join19, relative as relative8, resolve as resolve12 } from "path";
+import { dirname as dirname15, isAbsolute as isAbsolute4, join as join21, relative as relative8, resolve as resolve11 } from "path";
 
 // src/project/package-rules.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync12, lstatSync as lstatSync2, readdirSync as readdirSync7, readlinkSync } from "fs";
-import { dirname as dirname13, join as join18, posix } from "path";
+import { existsSync as existsSync15, lstatSync as lstatSync2, readdirSync as readdirSync7, readlinkSync } from "fs";
+import { dirname as dirname14, join as join20, posix } from "path";
 var ProjectError = class extends Error {
   constructor(message) {
     super(message);
@@ -11312,11 +12062,11 @@ function linkTarget(abs) {
 }
 function legacyLinks(root) {
   const found = /* @__PURE__ */ new Map();
-  const dir = join18(root, RULES_DIR);
-  if (!existsSync12(dir)) return found;
+  const dir = join20(root, RULES_DIR);
+  if (!existsSync15(dir)) return found;
   for (const entry2 of readdirSync7(dir).sort()) {
     if (!entry2.endsWith(".md")) continue;
-    const target2 = linkTarget(join18(dir, entry2));
+    const target2 = linkTarget(join20(dir, entry2));
     if (target2 === null || !target2.startsWith("../../")) continue;
     found.set(entry2.slice(0, -3), target2.slice("../../".length));
   }
@@ -11336,14 +12086,14 @@ function packageRuleOutputs(root, spec, owned) {
   const legacyByDir = /* @__PURE__ */ new Map();
   for (const [name, target2] of legacy) {
     if (!byTarget.has(target2)) byTarget.set(target2, name);
-    const dir = dirname13(target2);
+    const dir = dirname14(target2);
     if (!legacyByDir.has(dir)) legacyByDir.set(dir, name);
   }
   const outputs = [];
   const taken = /* @__PURE__ */ new Map();
   for (const file2 of files) {
     const pkg = file2.slice(0, -suffix.length);
-    const name = byTarget.get(file2) ?? legacyByDir.get(dirname13(file2)) ?? deriveName(pkg, spec.strip);
+    const name = byTarget.get(file2) ?? legacyByDir.get(dirname14(file2)) ?? deriveName(pkg, spec.strip);
     const other = taken.get(name);
     if (other !== void 0) {
       throw new ProjectError(
@@ -11362,8 +12112,8 @@ function packageRuleOutputs(root, spec, owned) {
 
 // src/project/backup.ts
 function backupFiles(root, paths) {
-  const base = join19(homedir3(), ".cache/pmcp/project-backups");
-  const inside = relative8(resolve12(root), resolve12(base));
+  const base = join21(homedir3(), ".cache/pmcp/project-backups");
+  const inside = relative8(resolve11(root), resolve11(base));
   if (!isAbsolute4(inside) && inside !== ".." && !inside.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`)) {
     throw new ProjectError("Project backups must be outside the project");
   }
@@ -11378,12 +12128,12 @@ function backupFiles(root, paths) {
     );
   }
   const snapshots = [...new Set(paths)].map((path) => {
-    const absolute2 = resolve12(root, path);
-    const within = relative8(resolve12(root), absolute2);
+    const absolute2 = resolve11(root, path);
+    const within = relative8(resolve11(root), absolute2);
     if (isAbsolute4(within) || within === ".." || within.startsWith("../") || within.startsWith("..\\")) {
       throw new ProjectError("Backup paths must stay inside the project");
     }
-    if (!existsSync13(absolute2)) {
+    if (!existsSync16(absolute2)) {
       return { path, contents: null };
     }
     const stat = lstatSync3(absolute2);
@@ -11392,15 +12142,15 @@ function backupFiles(root, paths) {
         `Refusing to back up a nonregular config file: ${path}`
       );
     }
-    return { path, contents: readFileSync20(absolute2) };
+    return { path, contents: readFileSync21(absolute2) };
   });
-  const destination = mkdtempSync2(join19(base, "project-"));
+  const destination = mkdtempSync2(join21(base, "project-"));
   const entries = snapshots.map(({ path, contents }) => {
     if (contents === null) {
       return { path, present: false };
     }
-    const output = join19(destination, "files", path);
-    mkdirSync6(dirname14(output), { recursive: true, mode: 448 });
+    const output = join21(destination, "files", path);
+    mkdirSync6(dirname15(output), { recursive: true, mode: 448 });
     writeFileSync4(output, contents, { mode: 384 });
     return {
       path,
@@ -11409,11 +12159,11 @@ function backupFiles(root, paths) {
     };
   });
   writeFileSync4(
-    join19(destination, "receipt.json"),
+    join21(destination, "receipt.json"),
     JSON.stringify(
       {
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        projectRoot: resolve12(root),
+        projectRoot: resolve11(root),
         entries
       },
       null,
@@ -11704,34 +12454,34 @@ function mcpOutputs(spec) {
 
 // src/project/hooks.ts
 import { createHash as createHash12 } from "crypto";
-import { existsSync as existsSync15, readFileSync as readFileSync22 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync23 } from "fs";
+import { join as join22 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/project/hook-adapter.ts
 import { spawnSync as spawnSync2 } from "child_process";
 import { createHash as createHash11 } from "crypto";
-import { existsSync as existsSync14, readFileSync as readFileSync21, realpathSync as realpathSync3, statSync as statSync10 } from "fs";
-import { dirname as dirname15, isAbsolute as isAbsolute6, relative as relative10, resolve as resolve13 } from "path";
+import { existsSync as existsSync17, readFileSync as readFileSync22, realpathSync as realpathSync5, statSync as statSync10 } from "fs";
+import { dirname as dirname16, isAbsolute as isAbsolute6, relative as relative10, resolve as resolve12 } from "path";
 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/");
   }
-  const absolute2 = resolve13(root, script);
-  const base = resolve13(root, ".agents/guards");
+  const absolute2 = resolve12(root, script);
+  const base = resolve12(root, ".agents/guards");
   const inside = relative10(base, absolute2);
   if (isAbsolute6(inside) || inside === ".." || inside.startsWith("../") || inside.startsWith("..\\")) {
     throw new Error("Hook guard must stay under .agents/guards/");
   }
-  if (!existsSync14(absolute2) || !statSync10(absolute2).isFile()) {
+  if (!existsSync17(absolute2) || !statSync10(absolute2).isFile()) {
     throw new Error("Hook guard script must exist");
   }
-  const actual = relative10(base, realpathSync3(absolute2));
+  const actual = relative10(base, realpathSync5(absolute2));
   if (isAbsolute6(actual) || actual === ".." || actual.startsWith("../") || actual.startsWith("..\\")) {
     throw new Error("Hook guard cannot resolve outside .agents/guards/");
   }
@@ -11776,10 +12526,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;
@@ -11800,7 +12550,7 @@ function evaluateShellHook(root, policy, tool, payload) {
       input: JSON.stringify({
         runtime: tool,
         event: "before_shell",
-        command: command2,
+        command: command3,
         cwd
       }),
       encoding: "utf8",
@@ -11849,8 +12599,8 @@ async function main() {
     if (!file2) {
       throw new Error("Missing hook policy");
     }
-    const bytes = readFileSync21(file2);
-    const adapter = readFileSync21(process.argv[1]);
+    const bytes = readFileSync22(file2);
+    const adapter = readFileSync22(process.argv[1]);
     const actual = createHash11("sha256").update(adapter).update(bytes).digest("hex");
     if (actual !== integrity2) {
       throw new Error("Hook integrity mismatch");
@@ -11869,8 +12619,8 @@ async function main() {
       }
       chunks.push(bytes2);
     }
-    const root = resolve13(dirname15(file2), "../..");
-    const guardSha256 = createHash11("sha256").update(readFileSync21(guardPath(root, policy.command))).digest("hex");
+    const root = resolve12(dirname16(file2), "../..");
+    const guardSha256 = createHash11("sha256").update(readFileSync22(guardPath(root, policy.command))).digest("hex");
     if (policy.contractVersion !== 1 || guardSha256 !== policy.guardSha256) {
       throw new Error(
         "Hook guard source changed; reproject and review native trust"
@@ -11923,13 +12673,13 @@ function object4(value) {
   return value;
 }
 function groups(root, file2, key) {
-  const absolute2 = join20(root, file2);
-  if (!existsSync15(absolute2)) {
+  const absolute2 = join22(root, file2);
+  if (!existsSync18(absolute2)) {
     return [];
   }
   let value;
   try {
-    value = JSON.parse(readFileSync22(absolute2, "utf8"));
+    value = JSON.parse(readFileSync23(absolute2, "utf8"));
   } catch {
     throw new ProjectError(
       "Cannot parse native hook configuration; contents are redacted"
@@ -11953,15 +12703,15 @@ function adapterSource() {
   const sourceBuild = fileURLToPath2(
     new URL("../../dist/project/hook-adapter.js", import.meta.url)
   );
-  const file2 = existsSync15(published) ? published : sourceBuild;
-  if (!existsSync15(file2)) {
+  const file2 = existsSync18(published) ? published : sourceBuild;
+  if (!existsSync18(file2)) {
     throw new ProjectError("Build pmcp before projecting shell hook adapters");
   }
-  return readFileSync22(file2, "utf8");
+  return readFileSync23(file2, "utf8");
 }
 function hookOutputs(spec) {
-  const lockFile = join20(spec.root, "pmcp.lock");
-  const lock = existsSync15(lockFile) ? JSON.parse(readFileSync22(lockFile, "utf8")) : {};
+  const lockFile = join22(spec.root, "pmcp.lock");
+  const lock = existsSync18(lockFile) ? JSON.parse(readFileSync23(lockFile, "utf8")) : {};
   const previous = new Map(
     (lock.outputs ?? []).filter((entry2) => entry2.managed !== void 0).map((entry2) => [entry2.path, entry2.managed])
   );
@@ -11978,7 +12728,7 @@ function hookOutputs(spec) {
     outputs.push({ kind: "file", path: ADAPTER, content: adapter });
     for (const hook of selected) {
       const policyFile = `${HOOK_DIRECTORY}/${hook.name}.json`;
-      const guardSha256 = createHash12("sha256").update(readFileSync22(guardPath(spec.root, hook.command))).digest("hex");
+      const guardSha256 = createHash12("sha256").update(readFileSync23(guardPath(spec.root, hook.command))).digest("hex");
       const policy = `${JSON.stringify({ ...hook, contractVersion: 1, guardSha256 }, null, 2)}
 `;
       outputs.push({ kind: "file", path: policyFile, content: policy });
@@ -11988,11 +12738,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) ?? {
@@ -12042,11 +12792,11 @@ function hookOutputs(spec) {
 }
 
 // src/project/frontmatter.ts
-import { parse as parse3 } from "yaml";
+import { parse as parse4 } from "yaml";
 function splitFrontmatter(source2) {
   const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/u.exec(source2);
   if (!match) return { meta: {}, body: source2 };
-  const meta = parse3(match[1] ?? "");
+  const meta = parse4(match[1] ?? "");
   const object9 = meta !== null && typeof meta === "object" && !Array.isArray(meta) ? meta : {};
   return { meta: object9, body: match[2] ?? "" };
 }
@@ -12076,28 +12826,28 @@ ${lines2.join("\n")}
 }
 
 // src/project/plan.ts
-import { existsSync as existsSync16, readFileSync as readFileSync23, readdirSync as readdirSync8 } from "fs";
-import { join as join21 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync24, readdirSync as readdirSync8 } from "fs";
+import { join as join23 } from "path";
 var AGENT_FIELDS = {
   claude: ["name", "description", "tools", "model", "effort"],
   gemini: ["name", "description"]
 };
 var SETTINGS = ".claude/settings.json";
 function listDirs(dir) {
-  if (!existsSync16(dir)) return [];
+  if (!existsSync19(dir)) return [];
   return readdirSync8(dir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
 }
 var tomlString = (value) => JSON.stringify(typeof value === "string" ? value : String(value ?? ""));
 function skillNames(root) {
-  const dir = join21(root, ".agents/skills");
+  const dir = join23(root, ".agents/skills");
   return listDirs(dir).filter(
-    (name) => existsSync16(join21(dir, name, "SKILL.md"))
+    (name) => existsSync19(join23(dir, name, "SKILL.md"))
   );
 }
 function agentNames(root) {
-  const dir = join21(root, ".agents/agents");
+  const dir = join23(root, ".agents/agents");
   return listDirs(dir).filter(
-    (name) => existsSync16(join21(dir, name, "agent.md"))
+    (name) => existsSync19(join23(dir, name, "agent.md"))
   );
 }
 function skillOutputs(spec) {
@@ -12131,13 +12881,13 @@ policy:
 }
 function ruleOutputs(spec) {
   if (!spec.tools.has("claude")) return [];
-  const dir = join21(spec.root, ".agents/rules");
-  if (!existsSync16(dir)) return [];
+  const dir = join23(spec.root, ".agents/rules");
+  if (!existsSync19(dir)) return [];
   const outputs = [];
   for (const file2 of readdirSync8(dir).filter((f) => f.endsWith(".md")).sort()) {
     const rel = `.agents/rules/${file2}`;
     const { meta, body } = splitFrontmatter(
-      readFileSync23(join21(spec.root, rel), "utf8")
+      readFileSync24(join23(spec.root, rel), "utf8")
     );
     const globs = [meta["globs"] ?? []].flat().filter((g) => typeof g === "string" && g !== "");
     const head = globs.length > 0 ? renderFrontmatter({ paths: globs }) : "";
@@ -12156,7 +12906,7 @@ function agentOutputs(spec) {
   for (const name of agentNames(spec.root)) {
     const rel = `.agents/agents/${name}/agent.md`;
     const { meta, body } = splitFrontmatter(
-      readFileSync23(join21(spec.root, rel), "utf8")
+      readFileSync24(join23(spec.root, rel), "utf8")
     );
     const overrides = spec.agents[name] ?? {};
     const note = `<!-- ${MARK} from ${rel} -->
@@ -12225,6 +12975,67 @@ function censusDirs(spec) {
   return dirs;
 }
 
+// src/project/write.ts
+import { randomUUID as randomUUID4 } from "crypto";
+import {
+  closeSync as closeSync3,
+  fchmodSync as fchmodSync2,
+  fsyncSync,
+  lstatSync as lstatSync4,
+  openSync as openSync3,
+  renameSync as renameSync3,
+  rmSync as rmSync4,
+  symlinkSync,
+  writeFileSync as writeFileSync5
+} from "fs";
+import { dirname as dirname17 } from "path";
+function fileMode(path) {
+  try {
+    const stat = lstatSync4(path);
+    if (stat.isFile()) return stat.mode & 511;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  return 438 & ~process.umask();
+}
+function syncDirectory(path) {
+  if (process.platform === "win32") return;
+  const descriptor = openSync3(dirname17(path), "r");
+  try {
+    fsyncSync(descriptor);
+  } finally {
+    closeSync3(descriptor);
+  }
+}
+function replaceFile(path, content) {
+  const mode = fileMode(path);
+  const temporary = `${path}.${randomUUID4()}.new`;
+  const descriptor = openSync3(temporary, "wx", 384);
+  try {
+    try {
+      writeFileSync5(descriptor, content);
+      fchmodSync2(descriptor, mode);
+      fsyncSync(descriptor);
+    } finally {
+      closeSync3(descriptor);
+    }
+    renameSync3(temporary, path);
+    syncDirectory(path);
+  } finally {
+    rmSync4(temporary, { force: true });
+  }
+}
+function replaceLink(path, target2) {
+  const temporary = `${path}.${randomUUID4()}.new`;
+  try {
+    symlinkSync(target2, temporary);
+    renameSync3(temporary, path);
+    syncDirectory(path);
+  } finally {
+    rmSync4(temporary, { force: true });
+  }
+}
+
 // src/project/apply.ts
 var LOCK_FILE = "pmcp.lock";
 var BEGIN = "# >>> pmcp project (edit pmcp.toml, not this block) >>>";
@@ -12235,24 +13046,24 @@ var PREDECESSORS = [
 ];
 var sha = (text3) => createHash13("sha256").update(text3).digest("hex");
 function readLock(root) {
-  const path = join22(root, LOCK_FILE);
-  if (!existsSync17(path)) return [];
-  const lock = JSON.parse(readFileSync24(path, "utf8"));
+  const path = join24(root, LOCK_FILE);
+  if (!existsSync20(path)) return [];
+  const lock = JSON.parse(readFileSync25(path, "utf8"));
   return lock.outputs ?? [];
 }
 function linkOf(abs) {
   try {
-    return lstatSync4(abs).isSymbolicLink() ? readlinkSync2(abs) : null;
+    return lstatSync5(abs).isSymbolicLink() ? readlinkSync2(abs) : null;
   } catch {
     return null;
   }
 }
-var exists = (abs) => existsSync17(abs) || linkOf(abs) !== null;
+var exists = (abs) => existsSync20(abs) || linkOf(abs) !== null;
 function readJson2(abs) {
-  if (!existsSync17(abs)) return {};
+  if (!existsSync20(abs)) return {};
   let value;
   try {
-    value = JSON.parse(readFileSync24(abs, "utf8"));
+    value = JSON.parse(readFileSync25(abs, "utf8"));
   } catch {
     throw new ProjectError(
       "Cannot parse native JSON configuration; contents are redacted"
@@ -12304,19 +13115,19 @@ function withoutBlock(text3) {
   return `${text3.slice(0, start2).replace(/\n+$/u, "\n")}${after}`;
 }
 function present(root, output) {
-  const abs = join22(root, "file" in output ? output.file : output.path);
+  const abs = join24(root, "file" in output ? output.file : output.path);
   switch (output.kind) {
     case "link":
       return linkOf(abs) === output.target;
     case "file":
-      return existsSync17(abs) && linkOf(abs) === null && readFileSync24(abs, "utf8") === output.content;
+      return existsSync20(abs) && linkOf(abs) === null && readFileSync25(abs, "utf8") === output.content;
     case "json":
       if (output.managed && Array.isArray(output.value) && output.value.length === 0) {
         return getKey(readJson2(abs), output.key) === void 0;
       }
       return same(getKey(readJson2(abs), output.key), output.value);
     case "block":
-      return existsSync17(abs) && readFileSync24(abs, "utf8").includes(block(output.content));
+      return existsSync20(abs) && readFileSync25(abs, "utf8").includes(block(output.content));
   }
 }
 function replaceable(root, output, owned) {
@@ -12324,28 +13135,28 @@ function replaceable(root, output, owned) {
     if (output.key[0] !== "mcpServers" || owned.has(output.path)) {
       return true;
     }
-    const existing = getKey(readJson2(join22(root, output.file)), output.key);
+    const existing = getKey(readJson2(join24(root, output.file)), output.key);
     return existing === void 0 || same(existing, output.value);
   }
   if (output.kind === "block") {
-    const absolute2 = join22(root, output.file);
-    const text4 = existsSync17(absolute2) ? readFileSync24(absolute2, "utf8") : "";
-    const outside = parse4(withoutBlock(text4));
-    const proposed = parse4(output.content);
+    const absolute2 = join24(root, output.file);
+    const text4 = existsSync20(absolute2) ? readFileSync25(absolute2, "utf8") : "";
+    const outside = parse5(withoutBlock(text4));
+    const proposed = parse5(output.content);
     const existing = objectKeys(outside["mcp_servers"]);
     return !objectKeys(proposed["mcp_servers"]).some(
       (name) => existing.includes(name)
     );
   }
   if (owned.has(output.path)) return true;
-  const abs = join22(root, output.path);
+  const abs = join24(root, output.path);
   if (!exists(abs)) return true;
   const target2 = linkOf(abs);
   if (target2 !== null) {
     return output.kind === "link" && target2 === output.target;
   }
-  if (lstatSync4(abs).isDirectory()) return false;
-  const text3 = readFileSync24(abs, "utf8");
+  if (lstatSync5(abs).isDirectory()) return false;
+  const text3 = readFileSync25(abs, "utf8");
   if (output.kind === "file" && text3 === output.content) return true;
   return PREDECESSORS.some((mark) => text3.includes(mark));
 }
@@ -12359,15 +13170,15 @@ function undeclared(spec, outputs) {
   const declared = new Set(outputs.map((o) => o.path));
   const found = [];
   for (const dir of censusDirs(spec)) {
-    const abs = join22(spec.root, dir);
-    if (!existsSync17(abs)) continue;
+    const abs = join24(spec.root, dir);
+    if (!existsSync20(abs)) continue;
     for (const entry2 of readdirSync9(abs)) {
       const path = `${dir}/${entry2}`;
       if (!declared.has(path)) found.push(path);
     }
   }
-  const rules = join22(spec.root, RULES_DIR);
-  if (spec.tools.has("grok") && existsSync17(rules)) {
+  const rules = join24(spec.root, RULES_DIR);
+  if (spec.tools.has("grok") && existsSync20(rules)) {
     for (const entry2 of readdirSync9(rules, { withFileTypes: true })) {
       if (entry2.isDirectory()) continue;
       found.push(`${RULES_DIR}/${entry2.name}`);
@@ -12394,9 +13205,9 @@ function deadGlobs(root, outputs) {
     if (rule.kind === "file") {
       text3 = rule.content;
     } else if (rule.kind === "link") {
-      const abs = join22(root, posix2.join(posix2.dirname(rule.path), rule.target));
-      if (!existsSync17(abs)) continue;
-      text3 = readFileSync24(abs, "utf8");
+      const abs = join24(root, posix2.join(posix2.dirname(rule.path), rule.target));
+      if (!existsSync20(abs)) continue;
+      text3 = readFileSync25(abs, "utf8");
     } else {
       continue;
     }
@@ -12446,7 +13257,7 @@ function project(spec, options2) {
     }
   }
   for (const path of jsonPaths) {
-    readJson2(join22(spec.root, path));
+    readJson2(join24(spec.root, path));
   }
   if (options2.check) {
     const problems = [
@@ -12508,11 +13319,13 @@ function project(spec, options2) {
   for (const output of outputs) {
     if (output.kind !== "link" && output.kind !== "file") continue;
     if (present(spec.root, output)) continue;
-    const abs = join22(spec.root, output.path);
-    mkdirSync7(dirname16(abs), { recursive: true });
-    rmSync4(abs, { force: true, recursive: true });
-    if (output.kind === "link") symlinkSync(output.target, abs);
-    else writeFileSync5(abs, output.content);
+    const abs = join24(spec.root, output.path);
+    mkdirSync7(dirname18(abs), { recursive: true });
+    if (output.kind === "link") {
+      replaceLink(abs, output.target);
+      continue;
+    }
+    replaceFile(abs, output.content);
   }
   let pruned = 0;
   const jsonFiles = /* @__PURE__ */ new Map();
@@ -12534,12 +13347,12 @@ function project(spec, options2) {
       group.drops.push(keyed.key);
       jsonFiles.set(keyed.file, group);
     } else {
-      rmSync4(join22(spec.root, entry2.path), { force: true, recursive: true });
+      rmSync5(join24(spec.root, entry2.path), { force: true, recursive: true });
     }
     pruned += 1;
   }
   for (const [file2, { sets, drops }] of jsonFiles) {
-    const abs = join22(spec.root, file2);
+    const abs = join24(spec.root, file2);
     const before = readJson2(abs);
     const after = structuredClone(before);
     for (const key of drops) deleteKey(after, key);
@@ -12554,22 +13367,22 @@ function project(spec, options2) {
       }
     }
     if (same(before, after)) continue;
-    if (!existsSync17(abs) && Object.keys(after).length === 0) continue;
-    mkdirSync7(dirname16(abs), { recursive: true });
-    writeFileSync5(abs, `${JSON.stringify(after, null, 2)}
+    if (!existsSync20(abs) && Object.keys(after).length === 0) continue;
+    mkdirSync7(dirname18(abs), { recursive: true });
+    replaceFile(abs, `${JSON.stringify(after, null, 2)}
 `);
   }
   for (const [file2, content] of blockFiles) {
-    const abs = join22(spec.root, file2);
-    const before = existsSync17(abs) ? readFileSync24(abs, "utf8") : "";
+    const abs = join24(spec.root, file2);
+    const before = existsSync20(abs) ? readFileSync25(abs, "utf8") : "";
     let after = withoutBlock(before);
     if (content !== null) {
       const sep7 = after === "" || after.endsWith("\n\n") ? "" : after.endsWith("\n") ? "\n" : "\n\n";
       after = `${after}${sep7}${block(content)}`;
     }
     if (after === before) continue;
-    mkdirSync7(dirname16(abs), { recursive: true });
-    writeFileSync5(abs, after);
+    mkdirSync7(dirname18(abs), { recursive: true });
+    replaceFile(abs, after);
   }
   if (spec.packageRules) {
     const linkedDirs = new Set(
@@ -12580,15 +13393,15 @@ function project(spec, options2) {
       )
     );
     for (const [name, target2] of legacyLinks(spec.root)) {
-      const abs = join22(spec.root, RULES_DIR, `${name}.md`);
-      const broken = !existsSync17(abs);
+      const abs = join24(spec.root, RULES_DIR, `${name}.md`);
+      const broken = !existsSync20(abs);
       if (!broken && !linkedDirs.has(posix2.dirname(target2))) continue;
-      rmSync4(abs, { force: true });
+      rmSync5(abs, { force: true });
       pruned += 1;
     }
   }
-  writeFileSync5(
-    join22(spec.root, LOCK_FILE),
+  replaceFile(
+    join24(spec.root, LOCK_FILE),
     `${JSON.stringify({ version: 1, outputs: outputs.filter((output) => output.kind !== "json" || output.managed === void 0 || output.managed.length > 0).map(lockEntry) }, null, 2)}
 `
   );
@@ -12602,11 +13415,11 @@ function project(spec, options2) {
 }
 
 // src/project/mcp-import.ts
-import { readFileSync as readFileSync25, statSync as statSync11, writeFileSync as writeFileSync6 } from "fs";
+import { readFileSync as readFileSync26, statSync as statSync11, writeFileSync as writeFileSync6 } from "fs";
 import { createHash as createHash14 } from "crypto";
-import { basename as basename6, dirname as dirname17, resolve as resolve14 } from "path";
+import { basename as basename6, dirname as dirname19, resolve as resolve13 } from "path";
 import { homedir as homedir4 } from "os";
-import { parse as parse5, stringify } from "smol-toml";
+import { parse as parse6, stringify } from "smol-toml";
 
 // src/project/mcp-spec.ts
 init_config();
@@ -12643,13 +13456,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");
@@ -12663,7 +13476,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"
@@ -12672,7 +13485,7 @@ function readHooks(path, root, raw) {
     names.add(name);
     return {
       name,
-      command: command2,
+      command: command3,
       targets,
       timeoutMs
     };
@@ -12895,13 +13708,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"]]
     ]) {
@@ -12999,7 +13812,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 } : {},
@@ -13034,11 +13847,11 @@ function sourceServers(source2, root) {
       "Use --source <claude|codex|gemini|grok|antigravity>:<file>"
     );
   }
-  const path = resolve14(root, source2.slice(split + 1));
+  const path = resolve13(root, source2.slice(split + 1));
   if (statSync11(path).size > 2 * 1024 * 1024) {
     throw new ProjectError("MCP source exceeds the 2 MiB limit");
   }
-  const bytes = readFileSync25(path);
+  const bytes = readFileSync26(path);
   const sha2562 = createHash14("sha256").update(bytes).digest("hex");
   const text3 = bytes.toString("utf8").replace(/^\uFEFF/u, "");
   let parsed;
@@ -13046,7 +13859,7 @@ function sourceServers(source2, root) {
     if (text3.trim() === "") {
       parsed = {};
     } else if (path.endsWith(".toml")) {
-      parsed = parse5(text3);
+      parsed = parse6(text3);
     } else {
       parsed = object6(JSON.parse(text3));
     }
@@ -13229,9 +14042,9 @@ function equivalent(alias, left, right) {
   return JSON.stringify(readMcp("import", { [alias]: left })[alias]) === JSON.stringify(readMcp("import", { [alias]: right })[alias]);
 }
 function planMcpImport(config, sources2, names = []) {
-  const original = readFileSync25(config, "utf8");
-  const root = dirname17(resolve14(config));
-  const existing = object6(parse5(original)["mcp"] ?? {});
+  const original = readFileSync26(config, "utf8");
+  const root = dirname19(resolve13(config));
+  const existing = object6(parse6(original)["mcp"] ?? {});
   const additions = {};
   const entries = [];
   const fingerprints = [];
@@ -13280,11 +14093,11 @@ function writeMcpImport(plan2) {
       "Resolve blocked or conflicting MCP entries before importing"
     );
   }
-  if (readFileSync25(plan2.config, "utf8") !== plan2.original) {
+  if (readFileSync26(plan2.config, "utf8") !== plan2.original) {
     throw new ProjectError("pmcp.toml changed after planning; plan again");
   }
   for (const source2 of plan2.sources) {
-    const current = createHash14("sha256").update(readFileSync25(source2.path)).digest("hex");
+    const current = createHash14("sha256").update(readFileSync26(source2.path)).digest("hex");
     if (current !== source2.sha256) {
       throw new ProjectError("MCP source changed after planning; plan again");
     }
@@ -13293,8 +14106,8 @@ function writeMcpImport(plan2) {
   const after = `${plan2.original.trimEnd()}
 
 ${additions}`;
-  parse5(after);
-  const backup = backupFiles(dirname17(resolve14(plan2.config)), [
+  parse6(after);
+  const backup = backupFiles(dirname19(resolve13(plan2.config)), [
     basename6(plan2.config)
   ]);
   writeFileSync6(plan2.config, after);
@@ -13303,25 +14116,25 @@ ${additions}`;
 
 // src/project/mcp-env.ts
 import { spawn } from "child_process";
-import { readFileSync as readFileSync26, statSync as statSync12 } from "fs";
+import { readFileSync as readFileSync27, statSync as statSync12 } from "fs";
 import { homedir as homedir5 } from "os";
-import { resolve as resolve15 } from "path";
-import { parse as parse6 } from "smol-toml";
+import { resolve as resolve14 } from "path";
+import { parse as parse7 } from "smol-toml";
 function sourcePath(file2, root) {
   if (file2.startsWith("~/")) {
-    return resolve15(homedir5(), file2.slice(2));
+    return resolve14(homedir5(), file2.slice(2));
   }
-  return resolve15(root, file2.replaceAll("${PROJECT_ROOT}", root));
+  return resolve14(root, file2.replaceAll("${PROJECT_ROOT}", root));
 }
 function sourceValue(file2, pointer) {
   try {
     if (statSync12(file2).size > 2 * 1024 * 1024) {
       throw new Error("size");
     }
-    const text3 = readFileSync26(file2, "utf8").replace(/^\uFEFF/u, "");
+    const text3 = readFileSync27(file2, "utf8").replace(/^\uFEFF/u, "");
     let value;
     if (file2.endsWith(".toml")) {
-      value = parse6(text3);
+      value = parse7(text3);
     } else {
       value = JSON.parse(text3);
     }
@@ -13399,11 +14212,11 @@ async function execMcp(spec, alias, env) {
 
 // src/project/doctor.ts
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync18, readFileSync as readFileSync27 } from "fs";
-import { join as join23 } from "path";
-import { parse as parse7 } from "smol-toml";
-var spawnRunner = (command2, args, cwd, env) => {
-  const result = spawnSync3(command2, [...args], {
+import { existsSync as existsSync21, readFileSync as readFileSync28 } from "fs";
+import { join as join25 } from "path";
+import { parse as parse8 } from "smol-toml";
+var spawnRunner = (command3, args, cwd, env) => {
+  const result = spawnSync3(command3, [...args], {
     cwd,
     ...env ? { env: { ...process.env, ...env } } : {},
     encoding: "utf8",
@@ -13477,10 +14290,10 @@ function claude(spec, o) {
 }
 function codex(spec, o) {
   const findings = [];
-  const config = join23(o.home, ".codex/config.toml");
+  const config = join25(o.home, ".codex/config.toml");
   let trusted = false;
-  if (existsSync18(config)) {
-    const projects = parse7(readFileSync27(config, "utf8")).projects ?? {};
+  if (existsSync21(config)) {
+    const projects = parse8(readFileSync28(config, "utf8")).projects ?? {};
     const root = spec.root.replace(/\/$/u, "");
     trusted = projects[root]?.trust_level === "trusted" || projects[`${root}/`]?.trust_level === "trusted";
   }
@@ -13606,8 +14419,8 @@ function grok(spec, o) {
 }
 function antigravity(spec, options2) {
   const foreign = agentNames(spec.root).filter((name) => {
-    const text3 = readFileSync27(
-      join23(spec.root, ".agents/agents", name, "agent.md"),
+    const text3 = readFileSync28(
+      join25(spec.root, ".agents/agents", name, "agent.md"),
       "utf8"
     );
     return splitFrontmatter(text3).meta["tools"] !== void 0;
@@ -13627,7 +14440,7 @@ function antigravity(spec, options2) {
   if (serversForTool(spec, "antigravity").length > 0) {
     const result = options2.run(
       "agy",
-      ["plugin", "validate", join23(spec.root, ANTIGRAVITY_MCP_PLUGIN)],
+      ["plugin", "validate", join25(spec.root, ANTIGRAVITY_MCP_PLUGIN)],
       spec.root
     );
     findings.push(
@@ -13658,9 +14471,9 @@ function doctor(spec, options2) {
 }
 
 // src/project/memory.ts
-import { existsSync as existsSync19, readFileSync as readFileSync28 } from "fs";
-import { isAbsolute as isAbsolute7, join as join24, resolve as resolve16 } from "path";
-import { parse as parse8 } from "smol-toml";
+import { existsSync as existsSync22, readFileSync as readFileSync29 } from "fs";
+import { isAbsolute as isAbsolute7, join as join26, resolve as resolve15 } from "path";
+import { parse as parse9 } from "smol-toml";
 function object7(value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw new Error("Configuration is not an object");
@@ -13668,11 +14481,11 @@ function object7(value) {
   return value;
 }
 function settings(file2, toml = false) {
-  if (!existsSync19(file2)) {
+  if (!existsSync22(file2)) {
     return {};
   }
-  const text3 = readFileSync28(file2, "utf8");
-  return object7(toml ? parse8(text3) : JSON.parse(text3));
+  const text3 = readFileSync29(file2, "utf8");
+  return object7(toml ? parse9(text3) : JSON.parse(text3));
 }
 function configuredState(value) {
   if (value === true) {
@@ -13684,11 +14497,11 @@ function configuredState(value) {
   return "unknown";
 }
 function located(metadata2, path, pathScope) {
-  return { ...metadata2, path, pathScope, exists: existsSync19(path) };
+  return { ...metadata2, path, pathScope, exists: existsSync22(path) };
 }
 function metadata(tool, spec, options2) {
   const env = options2.env ?? {};
-  const directory = (name, fallback) => resolve16(spec.root, env[name] ?? join24(options2.home, fallback));
+  const directory = (name, fallback) => resolve15(spec.root, env[name] ?? join26(options2.home, fallback));
   if (tool === "antigravity") {
     return {
       state: "unsupported",
@@ -13712,7 +14525,7 @@ function metadata(tool, spec, options2) {
         state,
         source: result.missing ? "Native CLI not installed" : "codex features list; active session overrides are not inspected"
       },
-      join24(home2, "memories"),
+      join26(home2, "memories"),
       "store"
     );
   }
@@ -13725,12 +14538,12 @@ function metadata(tool, spec, options2) {
   }
   if (tool === "claude") {
     const home2 = directory("CLAUDE_CONFIG_DIR", ".claude");
-    const user2 = settings(join24(home2, "settings.json"));
+    const user2 = settings(join26(home2, "settings.json"));
     const state = env["CLAUDE_CODE_DISABLE_AUTO_MEMORY"] === "1" ? "disabled" : configuredState(user2["autoMemoryEnabled"]);
     const source2 = "User configuration and disable environment flag; project trust and active session overrides are not inspected";
     const override = user2["autoMemoryDirectory"];
     if (typeof override === "string") {
-      const path = override.startsWith("~/") ? join24(options2.home, override.slice(2)) : override;
+      const path = override.startsWith("~/") ? join26(options2.home, override.slice(2)) : override;
       if (!isAbsolute7(path)) {
         return {
           state: "unknown",
@@ -13743,7 +14556,7 @@ function metadata(tool, spec, options2) {
     if (env["CLAUDE_CONFIG_DIR"] && projectName && !projectName.includes("/") && !projectName.includes("\\") && projectName !== "." && projectName !== "..") {
       return located(
         { state, source: source2 },
-        join24(home2, "projects", projectName, "memory"),
+        join26(home2, "projects", projectName, "memory"),
         "store"
       );
     }
@@ -13752,14 +14565,14 @@ function metadata(tool, spec, options2) {
         state,
         source: `${source2}; native project directory encoding is not guessed`
       },
-      join24(home2, "projects"),
+      join26(home2, "projects"),
       "base"
     );
   }
   if (tool === "grok") {
-    const home2 = join24(options2.home, ".grok");
-    const user2 = settings(join24(home2, "config.toml"), true);
-    const project2 = settings(join24(spec.root, ".grok/config.toml"), true);
+    const home2 = join26(options2.home, ".grok");
+    const user2 = settings(join26(home2, "config.toml"), true);
+    const project2 = settings(join26(spec.root, ".grok/config.toml"), true);
     const userMemory = user2["memory"] === void 0 ? {} : object7(user2["memory"]);
     const projectMemory = project2["memory"] === void 0 ? {} : object7(project2["memory"]);
     const overridden = projectMemory["enabled"] !== void 0;
@@ -13769,12 +14582,12 @@ function metadata(tool, spec, options2) {
         state,
         source: "User memory configuration; project trust and workspace encoding are not exposed by a read-only native memory command"
       },
-      join24(home2, "memory-v2/workspaces"),
+      join26(home2, "memory-v2/workspaces"),
       "base"
     );
   }
   const home = directory("GEMINI_CLI_HOME", ".gemini");
-  const user = settings(join24(home, "settings.json"));
+  const user = settings(join26(home, "settings.json"));
   const context = user["context"] === void 0 ? {} : object7(user["context"]);
   const names = context["fileName"] ?? "GEMINI.md";
   const contextFileNames = typeof names === "string" ? [names] : names;
@@ -13790,7 +14603,7 @@ function metadata(tool, spec, options2) {
       source: "Global memory file existence and user context filenames; active memory tool enablement is not exposed",
       contextFileNames
     },
-    join24(home, "GEMINI.md"),
+    join26(home, "GEMINI.md"),
     "store"
   );
 }
@@ -13823,14 +14636,14 @@ function memoryFindings(spec, options2) {
 // src/project/edit.ts
 import {
   cpSync,
-  existsSync as existsSync20,
+  existsSync as existsSync23,
   mkdirSync as mkdirSync8,
-  readFileSync as readFileSync29,
-  rmSync as rmSync5,
+  readFileSync as readFileSync30,
+  rmSync as rmSync6,
   statSync as statSync13,
   writeFileSync as writeFileSync7
 } from "fs";
-import { basename as basename7, dirname as dirname18, join as join25 } from "path";
+import { basename as basename7, dirname as dirname20, join as join27 } from "path";
 var CROSS_TOOL = ["name", "description"];
 var tomlValue2 = (value) => JSON.stringify(value);
 function findEntry(entries, wanted) {
@@ -13854,7 +14667,7 @@ function addEntry(root, entry2) {
       `${entry2.name} is a ${kind2}; only skills and agents are added to .agents/`
     );
   }
-  const { meta, body } = splitFrontmatter(readFileSync29(entry2.path, "utf8"));
+  const { meta, body } = splitFrontmatter(readFileSync30(entry2.path, "utf8"));
   const name = basename7(entry2.slug);
   if (!/^[a-z0-9][a-z0-9-]*$/u.test(name)) {
     throw new ProjectError(
@@ -13862,11 +14675,11 @@ function addEntry(root, entry2) {
     );
   }
   if (kind2 === "skill") {
-    const dest2 = join25(root, ".agents/skills", name);
-    if (existsSync20(dest2))
+    const dest2 = join27(root, ".agents/skills", name);
+    if (existsSync23(dest2))
       throw new ProjectError(`.agents/skills/${name} already exists`);
-    const source2 = entry2.root ?? dirname18(entry2.path);
-    mkdirSync8(dirname18(dest2), { recursive: true });
+    const source2 = entry2.root ?? dirname20(entry2.path);
+    mkdirSync8(dirname20(dest2), { recursive: true });
     if (statSync13(source2).isDirectory()) {
       cpSync(source2, dest2, { recursive: true });
     } else {
@@ -13878,14 +14691,14 @@ function addEntry(root, entry2) {
       description: meta["description"] ?? entry2.description
     });
     writeFileSync7(
-      join25(dest2, "SKILL.md"),
+      join27(dest2, "SKILL.md"),
       `${head}
 ${body.replace(/^\n/u, "")}`
     );
     return { kind: kind2, name, path: `.agents/skills/${name}` };
   }
-  const dest = join25(root, ".agents/agents", name);
-  if (existsSync20(dest))
+  const dest = join27(root, ".agents/agents", name);
+  if (existsSync23(dest))
     throw new ProjectError(`.agents/agents/${name} already exists`);
   const kept = {};
   const moved = {};
@@ -13895,17 +14708,17 @@ ${body.replace(/^\n/u, "")}`
   }
   mkdirSync8(dest, { recursive: true });
   writeFileSync7(
-    join25(dest, "agent.md"),
+    join27(dest, "agent.md"),
     `${renderFrontmatter(kept)}
 ${body.replace(/^\n/u, "")}`
   );
   if (Object.keys(moved).length > 0) {
-    const config = join25(root, "pmcp.toml");
+    const config = join27(root, "pmcp.toml");
     const lines2 = [
       `[agents.${name}.claude]`,
       ...Object.entries(moved).map(([k, v]) => `${k} = ${tomlValue2(v)}`)
     ];
-    const before = existsSync20(config) ? readFileSync29(config, "utf8") : "";
+    const before = existsSync23(config) ? readFileSync30(config, "utf8") : "";
     const sep7 = before === "" || before.endsWith("\n\n") ? "" : "\n";
     writeFileSync7(config, `${before}${sep7}${lines2.join("\n")}
 `);
@@ -13928,15 +14741,15 @@ function withoutTables(toml, name) {
 function removeAsset(root, name) {
   const removed = [];
   for (const rel of [`.agents/skills/${name}`, `.agents/agents/${name}`]) {
-    if (!existsSync20(join25(root, rel))) continue;
-    rmSync5(join25(root, rel), { recursive: true, force: true });
+    if (!existsSync23(join27(root, rel))) continue;
+    rmSync6(join27(root, rel), { recursive: true, force: true });
     removed.push(rel);
   }
   if (removed.length === 0)
     throw new ProjectError(`no skill or agent named ${name} in .agents/`);
-  const config = join25(root, "pmcp.toml");
-  if (existsSync20(config)) {
-    const before = readFileSync29(config, "utf8");
+  const config = join27(root, "pmcp.toml");
+  if (existsSync23(config)) {
+    const before = readFileSync30(config, "utf8");
     const after = withoutTables(before, name);
     if (after !== before) writeFileSync7(config, after);
   }
@@ -14175,16 +14988,16 @@ var doctorCommand = {
 };
 
 // src/validate.ts
-import { existsSync as existsSync21, readFileSync as readFileSync30, statSync as statSync14 } from "fs";
-import { basename as basename8, join as join26, resolve as resolve17 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync31, statSync as statSync14 } from "fs";
+import { basename as basename8, join as join28, resolve as resolve16 } from "path";
 function validateSkillDir(dir) {
-  const root = resolve17(dir);
-  const skillMd = basename8(root) === "SKILL.md" ? root : join26(root, "SKILL.md");
-  if (!existsSync21(skillMd) || !statSync14(skillMd).isFile()) {
+  const root = resolve16(dir);
+  const skillMd = basename8(root) === "SKILL.md" ? root : join28(root, "SKILL.md");
+  if (!existsSync24(skillMd) || !statSync14(skillMd).isFile()) {
     return [{ path: root, reason: "no SKILL.md", level: "error" }];
   }
-  const front = frontmatterObject(readFileSync30(skillMd, "utf8"));
-  const directory = basename8(skillMd === root ? join26(root, "..") : root);
+  const front = frontmatterObject(readFileSync31(skillMd, "utf8"));
+  const directory = basename8(skillMd === root ? join28(root, "..") : root);
   return specProblems(front, directory).map((reason) => ({
     path: skillMd,
     reason,
@@ -14229,8 +15042,8 @@ var validateCommand = {
 };
 
 // src/commands/mailbox.ts
-import { readFileSync as readFileSync31, writeFileSync as writeFileSync8 } from "fs";
-import { resolve as resolve18 } from "path";
+import { readFileSync as readFileSync32, writeFileSync as writeFileSync8 } from "fs";
+import { resolve as resolve17 } from "path";
 init_config2();
 init_service();
 init_schemas();
@@ -14313,7 +15126,7 @@ var mailboxCommand = {
     }
     if (verb === "init") {
       const config2 = initializeMailboxConfig(
-        resolve18(context.cwd, one(context.args, "config") ?? "pmcp.toml"),
+        resolve17(context.cwd, one(context.args, "config") ?? "pmcp.toml"),
         one(context.args, "state-dir")
       );
       const store2 = await MailboxStore.open(config2);
@@ -14338,7 +15151,7 @@ var mailboxCommand = {
     if (verb === "restore") {
       await restoreBackup(required(context, "input"), {
         ...config,
-        databasePath: resolve18(context.cwd, required(context, "output"))
+        databasePath: resolve17(context.cwd, required(context, "output"))
       });
       context.ui.data(
         `${JSON.stringify({ ok: true, data: { restored: true } })}
@@ -14412,7 +15225,7 @@ var mailboxCommand = {
         ownsBinding = true;
       }
       const inputFile = one(context.args, "input");
-      const input = inputFile ? JSON.parse(readFileSync31(inputFile, "utf8")) : {};
+      const input = inputFile ? JSON.parse(readFileSync32(inputFile, "utf8")) : {};
       const result = await new MailboxService(store, binding).call(
         operation,
         input
@@ -14496,7 +15309,7 @@ var harnessOptions = [
 ];
 
 // src/commands/harness/invocation.ts
-import { readFileSync as readFileSync32, statSync as statSync15 } from "fs";
+import { readFileSync as readFileSync33, statSync as statSync15 } from "fs";
 init_validation();
 var common = ["group-file", "generation"];
 var options = {
@@ -14536,7 +15349,7 @@ function file(path) {
   const stat = statSync15(path);
   if (!stat.isFile() || stat.size > 65536)
     throw new ArgumentError("Input file exceeds 65536 bytes");
-  return readFileSync32(path, "utf8");
+  return readFileSync33(path, "utf8");
 }
 function parseInvocation(context) {
   const [family, action, ...extra] = context.args.positional;
@@ -14642,6 +15455,9 @@ var harnessCommand = {
   }
 };
 
+// src/commands/tui.ts
+init_config();
+
 // src/commands/tui/invocation.ts
 var tuiOptions = [
   {
@@ -14657,6 +15473,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",
@@ -14664,9 +15485,24 @@ var tuiOptions = [
   },
   {
     name: "config",
-    describe: "Optional mailbox pmcp.toml",
+    describe: "Project pmcp.toml (or mailbox config for create)",
     placeholder: "<file>"
   },
+  {
+    name: "runtime",
+    describe: "Native runtime ID for main launch or worker start",
+    placeholder: "<runtime>"
+  },
+  {
+    name: "yes",
+    describe: "Confirm the first native runtime start",
+    boolean: true
+  },
+  {
+    name: "new",
+    describe: "Create a workspace after the previous group is stopped",
+    boolean: true
+  },
   {
     name: "actor-file",
     describe: "Optional private mailbox observer credential",
@@ -14674,6 +15510,10 @@ 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"],
@@ -14691,10 +15531,12 @@ var allowed2 = {
   close: ["view"],
   dismiss: ["view"],
   management: ["view"],
+  "worker-menu": ["view"],
   check: ["view"]
 };
 function parseTui(args) {
-  const [action, ...extra] = args.positional;
+  let [action, ...extra] = args.positional;
+  if (action === void 0) action = one(args, "view") ? "open" : "launch";
   const options2 = action ? allowed2[action] : void 0;
   if (!action || !options2 || extra.length)
     throw new ArgumentError("Provide one supported TUI operation");
@@ -14714,6 +15556,33 @@ function parseTui(args) {
     return Number(value);
   };
   if (action === "doctor") return { action, input: {} };
+  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: {},
+      startup: {
+        config: one(args, "config"),
+        runtime: one(args, "runtime"),
+        fresh: args.flags.has("new"),
+        confirmed: args.flags.has("yes")
+      }
+    };
   if (action === "create") {
     const config = one(args, "config");
     const actorFile = one(args, "actor-file");
@@ -14753,19 +15622,52 @@ function parseTui(args) {
 // src/commands/tui.ts
 var tuiCommand = {
   name: "tui",
-  describe: "View an owned native harness group with explicit input control",
-  usage: "pmcp tui doctor | create --group-file <file> | operation --view <file>",
+  describe: "Open a native terminal workspace with optional configuration",
+  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 {
-      const receipt = await invokeTui2(invocation2);
-      if (invocation2.action !== "open" || receipt.ok !== true)
+      let receipt;
+      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(
+          request3,
+          invocation2.startup?.confirmed === true
+        );
+      } else {
+        receipt = await invokeTui2(invocation2);
+      }
+      if (!["open", "launch"].includes(invocation2.action) || receipt.ok !== true)
         context.ui.data(`${JSON.stringify(receipt)}
 `);
       return receipt.ok === true ? 0 : 1;
     } catch (error) {
+      if (error instanceof ConfigError) throw new ArgumentError(error.message);
       context.ui.data(
         `${JSON.stringify(failedInvocation2(invocation2.action, error))}
 `
@@ -14780,14 +15682,14 @@ import { resolve as resolve21 } from "path";
 
 // src/marketplace/export.ts
 import {
-  existsSync as existsSync33,
-  lstatSync as lstatSync12,
-  mkdirSync as mkdirSync12,
-  readFileSync as readFileSync37,
+  existsSync as existsSync37,
+  lstatSync as lstatSync14,
+  mkdirSync as mkdirSync13,
+  readFileSync as readFileSync38,
   readdirSync as readdirSync13,
   writeFileSync as writeFileSync14
 } from "fs";
-import { dirname as dirname24, join as join52, resolve as resolve20 } from "path";
+import { dirname as dirname27, join as join55, resolve as resolve20 } from "path";
 var NATIVE_PLUGIN_RUNTIMES = [
   "claude",
   "codex",
@@ -14812,7 +15714,7 @@ function readResources(directory, prefix, files) {
   for (const entry2 of readdirSync13(directory, { withFileTypes: true })) {
     if (entry2.isSymbolicLink())
       throw new Error("Plugin exports cannot contain symlinks");
-    const path = join52(directory, entry2.name);
+    const path = join55(directory, entry2.name);
     const relativePath = `${prefix}/${entry2.name}`;
     if (entry2.isDirectory()) {
       if (relativePath.split("/").length > 6)
@@ -14822,10 +15724,10 @@ function readResources(directory, prefix, files) {
     }
     if (!entry2.isFile())
       throw new Error("Plugin resources must be regular files");
-    const stats = lstatSync12(path);
+    const stats = lstatSync14(path);
     if (stats.size > 1024 * 1024 || files.size >= 256)
       throw new Error("Plugin resources exceed the export budget");
-    files.set(relativePath, readFileSync37(path));
+    files.set(relativePath, readFileSync38(path));
   }
 }
 function pluginExportFiles(root, name, runtime2) {
@@ -14834,7 +15736,7 @@ function pluginExportFiles(root, name, runtime2) {
   const files = /* @__PURE__ */ new Map();
   readResources(containedPath(plugin.directory, "skills"), "skills", files);
   for (const name2 of ["LICENSE", "NOTICE"])
-    files.set(name2, readFileSync37(containedPath(root, name2)));
+    files.set(name2, readFileSync38(containedPath(root, name2)));
   const manifests = {
     claude: [".claude-plugin/plugin.json", ".mcp.json"],
     codex: ["plugin.json", "mcp.json"],
@@ -14843,10 +15745,10 @@ function pluginExportFiles(root, name, runtime2) {
     agy: []
   };
   for (const filename of manifests[runtime2]) {
-    if (existsSync33(join52(plugin.directory, filename)))
+    if (existsSync37(join55(plugin.directory, filename)))
       files.set(
         filename,
-        readFileSync37(containedPath(plugin.directory, filename))
+        readFileSync38(containedPath(plugin.directory, filename))
       );
   }
   if (runtime2 === "agy") {
@@ -14857,11 +15759,11 @@ function pluginExportFiles(root, name, runtime2) {
 `
       )
     );
-    const mcp = join52(plugin.directory, ".mcp.json");
-    if (existsSync33(mcp))
+    const mcp = join55(plugin.directory, ".mcp.json");
+    if (existsSync37(mcp))
       files.set(
         "mcp_config.json",
-        readFileSync37(containedPath(plugin.directory, mcp))
+        readFileSync38(containedPath(plugin.directory, mcp))
       );
   }
   return files;
@@ -14869,9 +15771,9 @@ function pluginExportFiles(root, name, runtime2) {
 function exportPublicPlugin(root, name, runtime2, output) {
   const destination = resolve20(output);
   const files = pluginExportFiles(root, name, runtime2);
-  mkdirSync12(dirname24(destination), { recursive: true });
+  mkdirSync13(dirname27(destination), { recursive: true });
   try {
-    mkdirSync12(destination);
+    mkdirSync13(destination);
   } catch (error) {
     if (error.code === "EEXIST")
       throw new Error(
@@ -14880,8 +15782,8 @@ function exportPublicPlugin(root, name, runtime2, output) {
     throw error;
   }
   for (const [path, bytes] of files) {
-    const target2 = join52(destination, path);
-    mkdirSync12(dirname24(target2), { recursive: true });
+    const target2 = join55(destination, path);
+    mkdirSync13(dirname27(target2), { recursive: true });
     writeFileSync14(target2, bytes, { flag: "wx" });
   }
   return { plugin: name, runtime: runtime2, output: destination, files: files.size };
@@ -15002,10 +15904,10 @@ function dispatch(argv, options2 = {}) {
   });
   const [verb, ...rest] = rest0;
   if (verb === void 0) {
-    return run(serveCommand, [], { ui, env, cwd });
+    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;
@@ -15018,8 +15920,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}"`);
@@ -15027,22 +15929,45 @@ 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.16.0";
+async function defaultEntry(options2, context) {
+  const terminal = options2.terminal ?? {
+    stdin: process.stdin.isTTY === true,
+    stdout: process.stdout.isTTY === true
+  };
+  const mode = entryMode({
+    ...terminal,
+    term: context.env.TERM,
+    ci: context.env.CI
+  });
+  if (mode === "server") return run(serveCommand, [], context);
+  if (mode === "terminal") {
+    const { terminalSupport: terminalSupport2 } = await Promise.resolve().then(() => (init_host(), host_exports));
+    const support = terminalSupport2();
+    if (support.supported) return run(tuiCommand, [], context);
+    context.ui.info(`Terminal workspace unavailable: ${support.reason}`);
+    context.ui.line(
+      "Run pmcp tui doctor for prerequisites, or pmcp serve for MCP."
+    );
+  }
+  printHelp(context.ui, COMMANDS, PLANNED);
+  return 0;
 }
-var VERSION = "0.14.1";
-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");