mason-context 0.16.0 → 0.16.2

package/dist/mason.js

@@ -2521,7 +2521,7 @@ var init_evidence = __esm({
     init_dead_command();
     init_storage();
     exec7 = promisify8(execFile8);
-    engineVersion = true ? "0.16.0" : "development";
+    engineVersion = true ? "0.16.2" : "development";
     hash = (value) => createHash3("sha256").update(JSON.stringify(value)).digest("hex");
     content = readAuditInput;
     internal = (file) => file === ".mason" || file === ".mason/reports" || file.startsWith(".mason/reports/");
@@ -2628,6 +2628,25 @@ var init_store = __esm({
 
 // src/automation/runtime.ts
 import { randomUUID as randomUUID4 } from "crypto";
+async function observeReadOnlyTool(dir, event) {
+  const ws = await workspace(dir);
+  await withLock(ws.root, ws.directory, async () => {
+    const statePath = ws.directory + "/state.json";
+    const raw = await readStoreJson(ws.root, statePath);
+    if (raw === null) return;
+    const state = parseState(raw);
+    if (state.root !== ws.root || state.gitDir !== ws.gitDir || state.branch !== ws.branch) {
+      throw new Error("Automation state belongs to another branch or worktree; original evidence was retained.");
+    }
+    const session = event.host && event.sessionId ? state.sessions[hash([event.host, event.sessionId])] : null;
+    if (!session) return;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    session.lastUsed = now;
+    session.events[event.event] = { at: now, count: (session.events[event.event]?.count ?? 0) + 1 };
+    await writeStoreJson(ws.root, statePath, state);
+  });
+  return { root: ws.root, directory: ws.directory };
+}
 function summarize(report) {
   const open = report.findings.filter((f) => f.status !== "resolved");
   return [
@@ -2905,6 +2924,7 @@ __export(launcher_exports, {
 });
 import { execFile as execFile9 } from "child_process";
 import { promisify as promisify9 } from "util";
+import fs13 from "fs/promises";
 function globalCommand(args2, platform = process.platform) {
   return platform === "win32" ? { command: "cmd.exe", args: ["/d", "/s", "/c", "mason", ...args2] } : { command: "mason", args: args2 };
 }
@@ -2923,13 +2943,17 @@ async function installedCommand() {
     return { available: false, version: null, message: "An up-to-date mason command is not available on this process's PATH. Install or upgrade Mason, then reopen your terminal or desktop assistant and rerun mason setup." };
   }
 }
-async function prepareLaunch(host) {
-  const ws = await workspace(process.cwd());
-  const entry = (await loadSetup(ws.root))?.hosts[host];
-  if (!entry) throw new Error(`Mason is not configured locally for ${host}. Run mason setup --host ${host} in this checkout.`);
-  process.env.MASON_SETUP_ROOT = ws.root;
+async function prepareLaunch(host, options = {}) {
+  const root = await fs13.realpath((await git2(process.cwd(), "rev-parse", "--show-toplevel")).trim());
+  const entry = (await loadSetup(root))?.hosts[host];
+  if (!entry) {
+    if (options.allowInactive) return false;
+    throw new Error(`Mason is not configured locally for ${host}. Run mason setup --host ${host} in this checkout.`);
+  }
+  process.env.MASON_SETUP_ROOT = root;
   process.env.MASON_SETUP_HOST = host;
   process.env.MASON_SETUP_REVISION = entry.revision;
+  return true;
 }
 var executingVersion, mcpCommand, hookCommand;
 var init_launcher = __esm({
@@ -2937,7 +2961,7 @@ var init_launcher = __esm({
     "use strict";
     init_evidence();
     init_model();
-    executingVersion = () => true ? "0.16.0" : "development";
+    executingVersion = () => true ? "0.16.2" : "development";
     mcpCommand = (host) => globalCommand(["--setup-host", host, "mcp"]);
     hookCommand = (host) => `mason --setup-host ${host} auto`;
   }
@@ -2950,7 +2974,7 @@ __export(observations_exports, {
   observeActivation: () => observeActivation,
   readObservation: () => readObservation
 });
-import fs13 from "fs/promises";
+import fs14 from "fs/promises";
 import { z as z8 } from "zod";
 function observationPath(directory, host, revision, version = executingVersion()) {
   return `${directory}/activation/${host}-${revision}-${hash(version).slice(0, 12)}.json`;
@@ -2966,9 +2990,9 @@ async function observeActivation(dir, event, options = {}) {
   const host = process.env.MASON_SETUP_HOST, revision = process.env.MASON_SETUP_REVISION;
   if (host !== "codex" && host !== "claude" || !revision || !process.env.MASON_SETUP_ROOT) return null;
   try {
-    const capturedDirectory = options.reportPath?.match(/^(\.mason\/reports\/automation\/[a-f0-9]{24})\/checks\//)?.[1];
-    const ws = capturedDirectory ? { root: await fs13.realpath(dir), directory: capturedDirectory } : await workspace(dir);
-    if (ws.root !== await fs13.realpath(process.env.MASON_SETUP_ROOT)) return null;
+    const capturedDirectory = options.directory?.match(/^\.mason\/reports\/automation\/[a-f0-9]{24}$/)?.[0] ?? options.reportPath?.match(/^(\.mason\/reports\/automation\/[a-f0-9]{24})\/checks\//)?.[1];
+    const ws = capturedDirectory ? { root: await fs14.realpath(dir), directory: capturedDirectory } : await workspace(dir);
+    if (ws.root !== await fs14.realpath(process.env.MASON_SETUP_ROOT)) return null;
     const setup = await loadSetup(ws.root);
     if (setup?.hosts[host]?.revision !== revision) return "Mason setup changed; restart the assistant to observe the current integration.";
     const directory = ws.directory + "/activation";
@@ -3039,13 +3063,13 @@ import { z as z9 } from "zod";
 function normalizeHook(host, raw) {
   hostSchema.parse(host);
   const input = inputSchema.parse(raw);
-  const readOnly = host === "claude" ? /^(Read|Glob|Grep|WebSearch|WebFetch)$/ : /^(read_file|list_dir|grep_files)$/;
-  return { cwd: input.cwd, name: input.hook_event_name, event: {
+  const readOnly = (host === "claude" ? /^(Read|Glob|Grep|WebSearch|WebFetch)$/ : /^(read_file|list_dir|grep_files|Read|Glob|Grep)$/).test(input.tool_name ?? "");
+  return { cwd: input.cwd, name: input.hook_event_name, readOnly, event: {
     event: lifecycle[input.hook_event_name],
     host,
     sessionId: input.session_id,
     toolId: input.tool_use_id,
-    mutating: !!input.tool_name && !readOnly.test(input.tool_name),
+    mutating: !!input.tool_name && !readOnly,
     stopHookActive: input.stop_hook_active || input.permission_mode === "plan"
   } };
 }
@@ -3053,8 +3077,20 @@ async function runAutomationHook(host, stdin) {
   let name = "";
   try {
     if (Buffer.byteLength(stdin) > 1024 * 1024) throw new Error("Hook input exceeds 1 MiB.");
-    const input = normalizeHook(host, JSON.parse(stdin));
+    let raw;
+    try {
+      raw = JSON.parse(stdin);
+    } catch {
+      throw new Error("Hook input is not valid JSON.");
+    }
+    const input = normalizeHook(host, raw);
     name = input.name;
+    if (["before_tool", "after_tool"].includes(input.event.event) && input.readOnly) {
+      const observed = await observeReadOnlyTool(input.cwd, input.event);
+      const { observeActivation: observeActivation3 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
+      const warning2 = await observeActivation3(observed.root, input.event.event, { sessionId: input.event.sessionId, directory: observed.directory });
+      return warning2 ? { systemMessage: warning2 } : null;
+    }
     const result = await automate(input.cwd, input.event);
     const { observeActivation: observeActivation2 } = await Promise.resolve().then(() => (init_observations(), observations_exports));
     const warning = await observeActivation2(result.report.root, input.event.event, {
@@ -3073,8 +3109,15 @@ async function runAutomationHook(host, stdin) {
     return { systemMessage: message2, ...["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse"].includes(name) ? { hookSpecificOutput: { hookEventName: name, additionalContext: message2 } } : {} };
   }
 }
+function managedHookCommand(host, platform = process.platform) {
+  const command2 = `mason --setup-host ${host} auto hook --host ${host}`;
+  return platform === "win32" ? `cmd.exe /d /s /c "where mason >nul 2>nul & if errorlevel 1 (exit /b 0) else (${command2})"` : `if command -v mason >/dev/null 2>&1; then ${command2}; fi`;
+}
+function knownManagedHookCommands(host) {
+  return [managedHookCommand(host, "linux"), managedHookCommand(host, "win32"), `mason --setup-host ${host} auto hook --host ${host}`];
+}
 function hookConfig(host, command2 = "npx --no-install --package mason-context mason-auto") {
-  const handler = { type: "command", command: command2 + " hook --host " + host, timeout: 30 };
+  const handler = { type: "command", command: command2 === `mason --setup-host ${host} auto` ? managedHookCommand(host) : command2 + " hook --host " + host, timeout: 30 };
   return { hooks: Object.fromEntries(HOOK_EVENTS.map((name) => [
     name,
     [{ ...["PreToolUse", "PostToolUse"].includes(name) ? { matcher: ".*" } : {}, hooks: [{ ...handler }] }]
@@ -3115,7 +3158,7 @@ __export(files_exports, {
   managedBlock: () => managedBlock,
   readText: () => readText
 });
-import fs14 from "fs/promises";
+import fs15 from "fs/promises";
 import path18 from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 async function readText(root, file) {
@@ -3145,14 +3188,14 @@ async function applyEdit(root, edit) {
   if (edit.after === null) {
     const file2 = await storePath(root, edit.path);
     if (await readText(root, edit.path) !== edit.before) throw new Error("Input changed during removal: " + edit.path);
-    await fs14.unlink(file2);
+    await fs15.unlink(file2);
     return true;
   }
   const file = await storePath(root, edit.path, true);
   const temporary = path18.join(path18.dirname(file), ".mason-setup-" + randomUUID5() + ".tmp");
   try {
-    const mode = await fs14.stat(file).then((s) => s.mode & 511, () => 384);
-    const handle = await fs14.open(temporary, "wx", mode);
+    const mode = await fs15.stat(file).then((s) => s.mode & 511, () => 384);
+    const handle = await fs15.open(temporary, "wx", mode);
     try {
       await handle.writeFile(edit.after, "utf8");
       await handle.sync();
@@ -3160,10 +3203,10 @@ async function applyEdit(root, edit) {
       await handle.close();
     }
     if (await readText(root, edit.path) !== edit.before) throw new Error("Integration input changed during update: " + edit.path);
-    await fs14.rename(temporary, file);
+    await fs15.rename(temporary, file);
     return true;
   } finally {
-    await fs14.rm(temporary, { force: true });
+    await fs15.rm(temporary, { force: true });
   }
 }
 var init_files2 = __esm({
@@ -3265,9 +3308,9 @@ var init_init = __esm({
 
 Mason provides recorded decisions and file impact over MCP. A concept map is optional.
 
-- Task, bug, or change request \u2192 \`get_context\` with the task text and known files: matching decisions, related tests, impact, and any available map entries.
+- Task, bug, change request, or investigation of why the project works this way \u2192 \`get_context\` with the task text and known files: matching decisions, related tests, impact, and any available map entries.
 - Before editing a file \u2192 \`get_impact\` to check references, tests, and historical change partners.
-- Learned something the code cannot explain (a failed approach, an incident's cause, a workaround's reason, a review-settled convention) \u2192 \`save_decision\` with rationale, anchors, and any known owner, sources, and recorder. It creates a proposal immediately without setup or a map. Never invent attribution or record code-derivable facts, session trivia, or secrets.
+- Investigation or correction reveals a reusable project lesson \u2192 \`save_decision\` before finishing. Capture only the lasting constraint and reason, with anchors and known sources, owner, and recorder. This creates a proposal; never infer approval. Preserve uncertain causes and unknown attribution. Route project lessons here; keep personal preferences in agent memory. Skip code summaries, current checkout status, temporary task permissions, session trivia, and secrets. No qualifying lesson means no record.
 - Consult trust metadata before relying on entries: unknown or changed freshness requires inspection, and failed verification means the description must be corrected. Check approval too: proposals are suggestions, legacy records are unreviewed, and accepted decisions are recorded constraints subject to freshness checks. An accepted revision remains operative while a pending proposal is reviewed; keep both versions and their freshness distinct.
 - Asked to review or re-verify a decision \u2192 \`review_decision\` first to inspect content, sources, history, and code changes. Record acceptance, reaffirmation, or retirement only when authorized by the user or a cited team review, with the actual reviewer and reason. Never infer approval from unchanged code. Review and commit the local record through the normal project workflow.
 - For an architectural overview, use \`get_snapshot\` if a map is available. If \`map.status\` is missing or invalid, use available decisions and source evidence; do not start building a map unless requested.
@@ -3519,7 +3562,7 @@ async function planAutomationInstall(root, host, command2) {
   const previous = record.hosts[host]?.command;
   const ownershipText = await readText(root, OWNERSHIP_PATH);
   const pending = ownershipText === null ? [] : ownershipSchema.parse(JSON.parse(ownershipText)).files[file]?.hookCommands ?? [];
-  const owned = /* @__PURE__ */ new Set([previous, ...pending, newCommand]);
+  const owned = /* @__PURE__ */ new Set([previous, ...pending, newCommand, ...knownManagedHookCommands(host)]);
   const hooks = existing.hooks ?? {};
   for (const event of HOOK_EVENTS) {
     hooks[event] = (hooks[event] ?? []).map((group) => ({
@@ -3623,6 +3666,7 @@ async function planTeardown(root, selected) {
   const commands = (host) => new Set([
     automation?.hosts[host]?.command,
     ...ownership.files[configPath(host)]?.hookCommands ?? [],
+    ...knownManagedHookCommands(host),
     hookConfig(host, hookCommand(host)).hooks.SessionStart[0].hooks[0].command,
     hookConfig(host).hooks.SessionStart[0].hooks[0].command
   ].filter((command2) => !!command2));
@@ -4352,7 +4396,7 @@ var init_evidence2 = __esm({
 });
 
 // src/review/review.ts
-import fs15 from "fs/promises";
+import fs16 from "fs/promises";
 import path20 from "path";
 import { execFile as execFile12 } from "child_process";
 import { promisify as promisify12 } from "util";
@@ -4432,7 +4476,7 @@ async function computeReview(rootDir, base, options = {}) {
     analyzed,
     async (relPath) => {
       try {
-        await fs15.access(path20.join(resolvedRoot, relPath));
+        await fs16.access(path20.join(resolvedRoot, relPath));
         return true;
       } catch {
         return false;
@@ -4586,7 +4630,7 @@ async function setupStatus(dir) {
       version: 1,
       status: pending.length ? "incomplete" : "not-configured",
       hosts: {},
-      next: pending.length ? "Setup did not finish. Rerun mason-auto setup --host " + pending[0] + " to resume using the retained original evidence." : "Run mason-auto setup --host codex or --host claude."
+      next: pending.length ? "Setup did not finish. Rerun mason-auto setup --host " + pending[0] + " to resume using the retained original evidence." : "Project hooks are inactive until local setup. Run mason setup --host codex or --host claude."
     };
   }
   const hosts2 = {};
@@ -4795,12 +4839,12 @@ var init_setup = __esm({
 });
 
 // src/distribution/bundle.ts
-import fs16 from "fs/promises";
+import fs17 from "fs/promises";
 import path21 from "path";
 import { createHash as createHash4 } from "crypto";
 import { z as z18 } from "zod";
 async function readBundle(root) {
-  const bytes = await fs16.readFile(await storePath(root, "bundle.json"));
+  const bytes = await fs17.readFile(await storePath(root, "bundle.json"));
   const manifest = bundleSchema.parse(JSON.parse(bytes.toString("utf8")));
   const windows = manifest.target.startsWith("win32-");
   for (const file of Object.keys(manifest.files)) {
@@ -4819,7 +4863,7 @@ async function verifyBundle(root, expectedHash) {
   if (bundle.manifest.target !== `${process.platform}-${process.arch}`) throw new Error("Mason bundle is for another platform. Install this platform's bundle and rerun setup.");
   const files = Object.keys(bundle.manifest.files);
   for (let i = 0; i < files.length; i += 8) await Promise.all(files.slice(i, i + 8).map(async (file) => {
-    if (sha256(await fs16.readFile(await storePath(root, file))) !== bundle.manifest.files[file]) throw new Error("Mason bundle checksum mismatch: " + file);
+    if (sha256(await fs17.readFile(await storePath(root, file))) !== bundle.manifest.files[file]) throw new Error("Mason bundle checksum mismatch: " + file);
   }));
   return bundle;
 }
@@ -4842,7 +4886,7 @@ var init_bundle = __esm({
 });
 
 // src/distribution/path.ts
-import fs17 from "fs/promises";
+import fs18 from "fs/promises";
 import os3 from "os";
 import path22 from "path";
 import { execFile as execFile13 } from "child_process";
@@ -4881,7 +4925,7 @@ ${alreadyOnPath ? message2 : `Add ${bin} to your PATH, then run: mason setup --h
     else {
       const candidates = [".bash_profile", ".bash_login", ".profile"].map((name) => path22.join(userHome, name));
       let login = candidates[2];
-      for (const file of candidates) if (await fs17.lstat(file).then(() => true, (error) => {
+      for (const file of candidates) if (await fs18.lstat(file).then(() => true, (error) => {
         if (error.code === "ENOENT") return false;
         throw error;
       })) {
@@ -4892,12 +4936,12 @@ ${alreadyOnPath ? message2 : `Add ${bin} to your PATH, then run: mason setup --h
     }
     const marker = `# >>> mason PATH ${createHash5("sha256").update(bin).digest("hex").slice(0, 12)} >>>`;
     for (const profile of profiles) {
-      const stat = await fs17.lstat(profile).catch((error) => {
+      const stat = await fs18.lstat(profile).catch((error) => {
         if (error.code === "ENOENT") return null;
         throw error;
       });
-      const file = stat?.isSymbolicLink() ? await fs17.realpath(profile) : path22.resolve(profile);
-      const original = await fs17.readFile(file).catch((error) => {
+      const file = stat?.isSymbolicLink() ? await fs18.realpath(profile) : path22.resolve(profile);
+      const original = await fs18.readFile(file).catch((error) => {
         if (error.code === "ENOENT" && !stat) return null;
         throw error;
       });
@@ -4912,8 +4956,8 @@ ${alreadyOnPath ? message2 : `Add ${bin} to your PATH, then run: mason setup --h
         changes.push({ kind: "profile", file, block, created: original === null });
         await save(changes);
       }
-      await fs17.mkdir(path22.dirname(file), { recursive: true });
-      const handle = await fs17.open(file, original === null ? "ax+" : "a+", 384);
+      await fs18.mkdir(path22.dirname(file), { recursive: true });
+      const handle = await fs18.open(file, original === null ? "ax+" : "a+", 384);
       try {
         if (!(await handle.readFile()).equals(original ?? Buffer.alloc(0))) throw new Error(`Shell profile changed during installation: ${profile}`);
         await handle.writeFile(block);
@@ -4937,13 +4981,13 @@ async function removePath(changes) {
         await windowsPath("remove", change.entry, current, change.created);
         continue;
       }
-      const stat = await fs17.lstat(change.file).catch((error) => {
+      const stat = await fs18.lstat(change.file).catch((error) => {
         if (error.code === "ENOENT") return null;
         throw error;
       });
       if (!stat) continue;
       if (!stat.isFile()) throw new Error("profile type changed");
-      const bytes = await fs17.readFile(change.file), text2 = bytes.toString("utf8");
+      const bytes = await fs18.readFile(change.file), text2 = bytes.toString("utf8");
       if (!Buffer.from(text2).equals(bytes)) throw new Error("profile encoding changed");
       const index2 = text2.indexOf(change.block);
       if (index2 < 0 || text2.indexOf(change.block, index2 + change.block.length) >= 0) throw new Error("PATH block was edited or removed");
@@ -4953,7 +4997,7 @@ async function removePath(changes) {
       const temporary = change.file + ".mason-" + randomUUID7();
       try {
         if (stat.nlink > 1) throw new Error("profile has multiple hard links");
-        const handle = await fs17.open(temporary, "wx", stat.mode & 511);
+        const handle = await fs18.open(temporary, "wx", stat.mode & 511);
         try {
           await handle.writeFile(next);
           await handle.chmod(stat.mode & 511);
@@ -4962,11 +5006,11 @@ async function removePath(changes) {
         } finally {
           await handle.close();
         }
-        const current = await fs17.lstat(change.file);
-        if (!current.isFile() || current.ino !== stat.ino || !(await fs17.readFile(change.file)).equals(bytes)) throw new Error("profile changed during uninstall");
-        await fs17.rename(temporary, change.file);
+        const current = await fs18.lstat(change.file);
+        if (!current.isFile() || current.ino !== stat.ino || !(await fs18.readFile(change.file)).equals(bytes)) throw new Error("profile changed during uninstall");
+        await fs18.rename(temporary, change.file);
       } finally {
-        await fs17.rm(temporary, { force: true });
+        await fs18.rm(temporary, { force: true });
       }
     } catch (error) {
       warnings.push(`Retained PATH setting ${change.kind === "profile" ? change.file : change.entry}: ${error instanceof Error ? error.message : String(error)}`);
@@ -5031,7 +5075,7 @@ __export(install_exports2, {
   uninstallStandalone: () => uninstallStandalone,
   upgradeStandalone: () => upgradeStandalone
 });
-import fs18 from "fs/promises";
+import fs19 from "fs/promises";
 import os4 from "os";
 import path23 from "path";
 import { fileURLToPath } from "url";
@@ -5041,31 +5085,31 @@ import { z as z20 } from "zod";
 async function replace(file, content2, mode = 384) {
   const temp = file + ".tmp-" + randomUUID8();
   try {
-    await fs18.writeFile(temp, content2, { mode, flag: "wx" });
-    await fs18.rename(temp, file);
+    await fs19.writeFile(temp, content2, { mode, flag: "wx" });
+    await fs19.rename(temp, file);
   } finally {
-    await fs18.rm(temp, { force: true });
+    await fs19.rm(temp, { force: true });
   }
 }
 async function installStandalone(source) {
   const bundle = await verifyBundle(source);
   const selectedHome = path23.resolve(defaultHome());
-  await fs18.mkdir(selectedHome, { recursive: true });
-  const home = await fs18.realpath(selectedHome);
+  await fs19.mkdir(selectedHome, { recursive: true });
+  const home = await fs19.realpath(selectedHome);
   const selectedBin = path23.resolve(process.env.MASON_BIN_DIR ?? (process.platform === "win32" ? path23.join(home, "bin") : path23.join(os4.homedir(), ".local/bin")));
   return withLock(home, ".install-lock", async () => {
     const raw = await readStoreJson(home, "install.json");
     const previous = raw === null ? null : recordSchema2.parse(raw);
-    if (!previous) for (const file of await fs18.readdir(home)) {
+    if (!previous) for (const file of await fs19.readdir(home)) {
       if (file === ".install-lock") continue;
       const directory = path23.join(home, file);
-      const stat = await fs18.lstat(directory);
-      if (!["versions", "bin"].includes(file) || !stat.isDirectory() || (await fs18.readdir(directory)).length) {
+      const stat = await fs19.lstat(directory);
+      if (!["versions", "bin"].includes(file) || !stat.isDirectory() || (await fs19.readdir(directory)).length) {
         throw new Error("Mason installation directory is not empty and has no ownership receipt.");
       }
     }
-    await fs18.mkdir(selectedBin, { recursive: true });
-    const bin = await fs18.realpath(selectedBin);
+    await fs19.mkdir(selectedBin, { recursive: true });
+    const bin = await fs19.realpath(selectedBin);
     if (previous && (previous.home !== home || previous.bin !== bin)) throw new Error("Installation paths differ from the existing Mason receipt.");
     const id = bundle.manifestHash.slice(0, 24);
     const destination = await storePath(home, "versions/" + id);
@@ -5092,7 +5136,7 @@ exec ${shQuote(path23.join(destination, "node"))} ${shQuote(path23.join(destinat
 ` };
     for (const [name, content2] of Object.entries(launchers)) {
       const file = await storePath(bin, name);
-      const old = await fs18.readFile(file, "utf8").catch((error) => {
+      const old = await fs19.readFile(file, "utf8").catch((error) => {
         if (error.code === "ENOENT") return null;
         throw error;
       });
@@ -5101,7 +5145,7 @@ exec ${shQuote(path23.join(destination, "node"))} ${shQuote(path23.join(destinat
     const retired = Object.entries({ ...previous?.previousLaunchers, ...previous?.launchers }).filter(([name]) => !(name in launchers));
     const checkRetired = async (name, expected) => {
       if (!launcherNames.includes(name)) throw new Error("Invalid owned launcher name.");
-      const actual = await fs18.readFile(await storePath(bin, name), "utf8").catch((error) => {
+      const actual = await fs19.readFile(await storePath(bin, name), "utf8").catch((error) => {
         if (error.code === "ENOENT") return null;
         throw error;
       });
@@ -5111,28 +5155,28 @@ exec ${shQuote(path23.join(destination, "node"))} ${shQuote(path23.join(destinat
     const receipt = { format: 1, home, bin, current: id, version: bundle.manifest.version, launchers, pathChanges: previous?.pathChanges ?? [] };
     await writeStoreJson(home, "install.json", { ...receipt, previousLaunchers: previous?.previousLaunchers ?? previous?.launchers });
     const stage = await storePath(home, "versions/.install-" + randomUUID8(), true);
-    await fs18.mkdir(stage);
+    await fs19.mkdir(stage);
     try {
       for (const file of ["bundle.json", ...Object.keys(bundle.manifest.files)]) {
         const from = await storePath(source, file), to = await storePath(stage, file, true);
-        await fs18.copyFile(from, to);
-        await fs18.chmod(to, (await fs18.stat(from)).mode & 511);
+        await fs19.copyFile(from, to);
+        await fs19.chmod(to, (await fs19.stat(from)).mode & 511);
       }
       await verifyBundle(stage, bundle.manifestHash);
-      const exists2 = await fs18.lstat(destination).then(() => true, (error) => {
+      const exists2 = await fs19.lstat(destination).then(() => true, (error) => {
         if (error.code === "ENOENT") return false;
         throw error;
       });
       if (exists2) await verifyBundle(destination, bundle.manifestHash);
-      else await fs18.rename(stage, destination);
+      else await fs19.rename(stage, destination);
       for (const [name, content2] of Object.entries(launchers)) await replace(await storePath(bin, name, true), content2, 493);
       for (const [name, expected] of retired) {
         await checkRetired(name, expected);
-        await fs18.rm(await storePath(bin, name), { force: true });
+        await fs19.rm(await storePath(bin, name), { force: true });
       }
       await writeStoreJson(home, "install.json", receipt);
     } finally {
-      await fs18.rm(stage, { recursive: true, force: true });
+      await fs19.rm(stage, { recursive: true, force: true });
     }
     const pathResult = await configurePath(bin, receipt.pathChanges, async (changes) => {
       receipt.pathChanges = changes;
@@ -5147,7 +5191,7 @@ async function currentInstallation() {
   const raw = await readStoreJson(home, "install.json");
   if (!raw) throw new Error("Run this command from a standalone installation. npm users can upgrade with npm.");
   const record = recordSchema2.parse(raw);
-  if (record.home !== await fs18.realpath(home) || path23.dirname(bundle) !== path23.join(home, "versions")) throw new Error("Invalid standalone installation receipt.");
+  if (record.home !== await fs19.realpath(home) || path23.dirname(bundle) !== path23.join(home, "versions")) throw new Error("Invalid standalone installation receipt.");
   return { home, bundle, record };
 }
 async function upgradeStandalone(version) {
@@ -5176,7 +5220,7 @@ async function uninstallStandalone() {
     for (const [name, expected] of Object.entries(record.launchers)) {
       if (!launcherNames.includes(name)) throw new Error("Invalid owned launcher name.");
       const file = await storePath(record.bin, name);
-      const actual = await fs18.readFile(file, "utf8").catch((error) => {
+      const actual = await fs19.readFile(file, "utf8").catch((error) => {
         if (error.code === "ENOENT") return null;
         throw error;
       });
@@ -5184,9 +5228,9 @@ async function uninstallStandalone() {
     }
     for (const warning of await removePath(record.pathChanges ?? [])) console.error(warning);
     if (process.platform === "win32") await replace(await storePath(home, ".uninstall-request.txt", true), token);
-    for (const name of Object.keys(record.launchers)) await fs18.rm(await storePath(record.bin, name), { force: true });
+    for (const name of Object.keys(record.launchers)) await fs19.rm(await storePath(record.bin, name), { force: true });
   });
-  if (process.platform !== "win32") await fs18.rm(home, { recursive: true, force: true });
+  if (process.platform !== "win32") await fs19.rm(home, { recursive: true, force: true });
   return home;
 }
 var recordSchema2, shQuote, psQuote, WINDOWS_BATCH_LAUNCHER, launcherNames, defaultHome;
@@ -5341,7 +5385,7 @@ var inputArgs = process.argv.slice(2);
 var managedLaunch = inputArgs[0] === "--setup-host";
 var setupHost = managedLaunch ? inputArgs.splice(0, 2)[1] : void 0;
 var [command, ...args] = inputArgs;
-var usage = `Mason ${"0.16.0"}
+var usage = `Mason ${"0.16.2"}
 
 Usage: mason <command> [options]
 
@@ -5362,11 +5406,12 @@ try {
   if (managedLaunch) {
     if (!setupHost || !["codex", "claude"].includes(setupHost) || !["mcp", "auto"].includes(command)) throw new Error("Invalid setup invocation.");
     const { prepareLaunch: prepareLaunch2 } = await Promise.resolve().then(() => (init_launcher(), launcher_exports));
-    await prepareLaunch2(setupHost);
+    const active = await prepareLaunch2(setupHost, { allowInactive: command === "auto" && isHookCommand(args) });
+    if (!active) process.exit(0);
   }
-  if (command === "internal-integration-version") console.log(JSON.stringify({ protocol: 1, version: "0.16.0" }));
+  if (command === "internal-integration-version") console.log(JSON.stringify({ protocol: 1, version: "0.16.2" }));
   else if (!command || ["--help", "-h", "help"].includes(command)) console.log(usage);
-  else if (["--version", "-v"].includes(command)) console.log("0.16.0");
+  else if (["--version", "-v"].includes(command)) console.log("0.16.2");
   else if (command === "internal-install") {
     if (args.length) throw new Error("internal-install takes no arguments.");
     const { installStandalone: installStandalone2 } = await Promise.resolve().then(() => (init_install2(), install_exports2));