mtech-ai-local-runner 0.1.112 → 0.1.114

package/README.md

@@ -1,3 +1,26 @@
+## 0.1.114: ask your AI from the menu bar window
+
+Select a request, decision, review or outcome record in the menu bar window, or a thread in its Rooms tab, and press
+**Ask Claude** or **Ask Codex** (only the apps on this Mac show). A new session opens in that app with a short prompt
+that names the item; nothing runs until you press Enter. Your AI then reads the item with your own sign-in and
+discusses it with you. It answers, decides or records an outcome only after you confirm, the same as a session opened
+from the Slack card. The button itself sends nothing and marks nothing read: **Mark read** stays the only way to mark
+Room messages read from the window. The menu bar app is now version 1.3.0; `setup` installs it.
+
+0.1.114 also carries the Codex app setup execution entry merged after 0.1.113 (PR #975). It is not wired in, so nothing
+runs it.
+
+## 0.1.113: the Work Room pane mod is removed
+
+The Claude Code Work Room pane (`ai-gateway-work-room`) is no longer shipped (Gateway Work Item 2ae9d471). The menu bar
+app answers requests and shows Rooms instead. Run `setup` once after updating: it uninstalls the pane and its
+`mtec-ai-gateway` marketplace from Claude Code and deletes the runner's old copy. If setup reports `workRoomPane` as
+`skipped` or `failed`, the pane keeps working until a later setup can remove it; `skipped` means no Claude CLI 2.1.299 or
+newer was found. Ask Claude, Share answer to Room and Hide went with the pane.
+
+0.1.113 also carries the runner work merged after 0.1.112 (PRs #964, #966, #968, #971). Reviewed-host registration stays
+empty, so D4 execution stays closed, and the Codex app setup code is not wired in.
+
 ## 0.1.112: a failed Claude job says why it stopped
 
 When a Claude job fails, the runner now tells the Gateway why, as one code: `auth` (the Claude account's sign-in was
@@ -486,7 +509,7 @@ covers it. A stored delivery is forgotten an hour after it arrived, by which tim
 long run.
 
 Integrations are installed only on request, with `setup --integrations` or `integrations install`; setup never asks
-about them. The Work Room pane, below, is the one exception: every setup installs it. An app already installed in the directory the environment names is skipped and reported installed, without
+about them. An app already installed in the directory the environment names is skipped and reported installed, without
 rewriting its files:
 
 ```bash
@@ -506,54 +529,14 @@ then the Slack message covers each ask. A
 reports `CODEX_HOOKS_JSON_INVALID`. `uninstall` removes both integrations, the shim, `asks.json` and any temporary
 `asks.json.*.tmp` file a crash left behind, and it also works on a setup that never finished.
 
-The Claude integration also installs the Work Room pane, the mod `ai-gateway-work-room@mtec-ai-gateway` (Work Item
-98da2635). A band above the prompt says how many Room shares and requests are waiting. Its button, or `/work-room`,
-opens a pane beside the conversation with two tabs, each with its count. "Requests" shows each request, decision and
-review as a small card, newest first: a ► or ▼ title, and under it who asked and how long ago (with "Decision" or
-"Review request" in front when it is not a plain request). A reminder joins the request it repeats (same asker and
-title once a "Reminder:" or "Nhắc lại:" prefix is dropped, with ":" and "–" counted alike) as "+1 reminder". The
-newest card opens by itself; pressing a title opens or closes it, and only the open card shows its answer box, Ask
-Claude and Hide. "Rooms" shows each Room in its own box; pressing its ► or ▼ title opens it (with its newest
-messages) or closes it, and its threads and messages are indented under it, each message under its author's name. From the pane you can answer a request,
-reply in a thread, share an answer to a Room or mark messages read. Each of these starts with Send (or the button that
-names it), then a confirm row under that field or button that names who will see it, then Claude's permission dialog.
-Opening a Room shows its threads with unread messages first and every unread message in them. The Room's Mark read
-marks up to 100 of them at once; a Room with more than one thread also has a Mark read on each thread.
-
-Ask Claude puts only ids and tool names in the conversation and asks Claude to read the full request and sum it up
-in one line; nothing is sent, and it is the only button that starts a model turn. Hide hides a request, decision or
-review, with every reminder joined to it, on this Mac only, with no Gateway call: it stays open for the person who asked and on your other devices.
-"Hidden (N)" with Show lists them again, each with Unhide. The pane calls the AI Gateway only through your own AI
-Gateway connector in Claude; without the connector the pane says so. The Claude mobile app draws no input field, so
-there the pane reads, shares, marks read and offers Ask Claude.
-
-After a Gateway change to a tool's arguments, refresh the AI Gateway tools list in Claude (Settings, Connectors, AI
-Gateway) and start a new session: a session drops arguments its tools list does not declare. The pane says so when
-its Room reads lose their arguments.
-
-The pane calls the connector with no model turn, so a Claude session in auto mode would refuse every one of those
-calls. The mod therefore ships PreToolUse hooks that match any AI Gateway connector and apply to every caller in the
-session, the model included:
-
-- They allow the two reads, `work_room_read` and `work_inbox`.
-- They allow `work_room_receipt_report` only when its `state` is `presented`, the record that the pane showed you a
-  message.
-- They ask you in Claude's own permission dialog before every write: `work_room_write`, `work_request_answer`, and
-  `work_room_receipt_report` for marking messages read. A write from the pane therefore needs its confirm press and
-  then your answer in that dialog.
-
-The runner copies the mod to `claude-mod/<version>/` in the state root, without its tests, and installs it with the
-Claude CLI as a local marketplace (`plugin marketplace add` and `plugin install --scope user`). This needs a Claude CLI
-2.1.299 or newer: the first `claude` on `PATH` when it is new enough, else the newest one the Claude desktop app
-bundles. Without one, the hooks are installed as before and the result reports the mod as `skipped`. Setup reinstalls
-only a missing or older copy, and it never turns on a mod you turned off. `integrations status` and `doctor` report the
-mod's state under `mod`; `integrations remove claude` and `uninstall` remove it. The daemon never runs the Claude CLI.
-
-Every `setup` installs or updates the mod, with or without `--integrations`, and reports it as `workRoomPane`. So
-rerunning `npx mtech-ai-local-runner@<version> setup` is enough to get the newest pane. With `--integrations claude`
-the Claude integration installs it and reports it under its own `mod` instead. After `integrations remove claude`,
-setup leaves the mod out, and its result says so. `integrations install claude` adds the mod again, and from then
-setup keeps it up to date once more. `uninstall` forgets the removal, so a later setup starts fresh.
+Runners from 0.1.79 also installed the Work Room pane, the Claude Code mod `ai-gateway-work-room@mtec-ai-gateway`
+(Work Item 98da2635). It is retired: the menu bar app answers requests and shows Rooms instead, and the package no
+longer carries the mod. Every `setup`, `integrations remove claude` and `uninstall` removes the copy an older runner
+installed: it uninstalls the mod and its local marketplace with the Claude CLI, then deletes `claude-mod/` in the state
+root, and reports what it did as `workRoomPane` (setup) or under the Claude integration's `mod`. With no such copy
+nothing runs and nothing is reported. The copy is deleted only once the Claude CLI no longer lists the mod, so a Mac
+without a Claude CLI of 2.1.299 or newer, or a failed uninstall, keeps a working pane and says why; a later setup tries
+again. The daemon never runs the Claude CLI.
 
 `CLAUDE_CONFIG_DIR` and `CODEX_HOME` are honoured. The LaunchAgent that runs the daemon gets only `PATH`, so every
 install adds the directory it used to a list per app in `integrations.json` in the state root, and the daemon,

package/dist/src/asks/claude-mod.js

@@ -1,30 +1,28 @@
 import { execFile } from "node:child_process";
 import { constants } from "node:fs";
-import { access, cp, mkdir, readdir, rm, stat, writeFile } from "node:fs/promises";
-import { basename, delimiter, isAbsolute, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { packageVersion } from "../package-version.js";
+import { access, readdir, rm, stat } from "node:fs/promises";
+import { delimiter, isAbsolute, join } from "node:path";
 /*
- * The Work Room pane mod (Work Item 98da2635), shipped in this package under claude-mod/ and installed through the
- * Claude CLI as a local marketplace, the way Plan A proved on 2026-10-30: `plugin marketplace add <folder>` and
- * `plugin install <mod>@<marketplace> --scope user`, both without a prompt. Claude reads the mod from that folder, so
- * it lives under <stateRoot>/claude-mod/<runner version>/ and an older folder is removed only after a newer install.
+ * The retired Work Room pane mod. Runners from 0.1.79 until this change shipped the Claude Code mod
+ * `ai-gateway-work-room` (Work Item 98da2635) under claude-mod/ and installed it through the Claude CLI as a local
+ * marketplace: a copy under
+ * <stateRoot>/claude-mod/<runner version>/, `plugin marketplace add <copy>` and `plugin install <mod>@<marketplace>
+ * --scope user`. The menu bar app (Work Items b9218937, d2b6d0da and b35d65cb) now answers requests and shows Rooms,
+ * so the package no longer carries the mod (owner decision 2026-11-12, agreed with Henry).
  *
- * Only a CLI that loads `modules` hooks can install it. On 2026-10-30 the terminal `claude` 2.1.212 could not, and the
- * desktop-bundled 2.1.299 and 2.1.308 could; the desktop app bundles one even when the terminal `claude` is older.
- * A mod the person disabled stays disabled: setup reinstalls only a missing or older one.
- *
- * Every setup installs the mod, with or without --integrations (owner decision 2026-10-31), unless the person removed
- * it with `integrations remove claude`. That removal leaves <stateRoot>/claude-mod-removed, which
- * `integrations install claude` and uninstall delete again.
+ * What is left removes a copy an older runner installed: setup, `integrations remove claude` and uninstall uninstall
+ * the mod and its marketplace and then delete <stateRoot>/claude-mod. Only that folder says an older runner installed
+ * it, so without it nothing runs, and the Claude CLI is never started.
  */
 export const CLAUDE_MOD_NAME = "ai-gateway-work-room";
-/** <stateRoot>/claude-mod-removed: the person removed the mod, so setup leaves it out until they install it again. */
-export const CLAUDE_MOD_REMOVED_FILE = "claude-mod-removed";
 export const CLAUDE_MOD_MARKETPLACE = "mtec-ai-gateway";
+/** The folder in the state root that holds the copies an older runner installed. */
+export const CLAUDE_MOD_DIR = "claude-mod";
+/** Left by `integrations remove claude` on older runners; it means nothing any more and is deleted. */
+export const CLAUDE_MOD_REMOVED_FILE = "claude-mod-removed";
 const ID = `${CLAUDE_MOD_NAME}@${CLAUDE_MOD_MARKETPLACE}`;
 const MIN_VERSION = [2, 1, 299];
-const NO_CLI = "no Claude CLI 2.1.299 or newer (run claude update or install the Claude desktop app)";
+const NO_CLI = "no Claude CLI 2.1.299 or newer to uninstall the Work Room pane with; the copy stays until a later setup can";
 const BUNDLED = ["Library", "Application Support", "Claude", "claude-code"];
 const RUN_TIMEOUT_MS = 60_000;
 function parseVersion(text) {
@@ -41,7 +39,10 @@ async function isExecutable(file) {
         return false;
     }
 }
-/** `claude` on PATH when it is new enough, else the newest desktop-bundled CLI that is; null when none is. */
+/**
+ * `claude` on PATH when it is new enough, else the newest desktop-bundled CLI that is; null when none is. Only a CLI of
+ * 2.1.299 or newer could install the mod, so only such a CLI is asked to remove it.
+ */
 export async function findClaudeCli(deps) {
     const versionOf = async (file) => {
         const out = await deps.run(file, ["--version"]);
@@ -71,92 +72,52 @@ export async function findClaudeCli(deps) {
     }
     return best?.file ?? null;
 }
-/** This runner's mod as `plugin list --json` reports it, or null when it is not listed. */
+/** Whether `plugin list --json` lists the mod, enabled or not; null when the list cannot be read. */
 async function listed(deps, cli) {
     const out = await deps.run(cli, ["plugin", "list", "--json"]);
     if (out.code !== 0)
         return null;
     try {
         const rows = JSON.parse(out.stdout);
-        const row = Array.isArray(rows) ? rows.find(entry => entry.id === ID) : undefined;
-        if (!row)
-            return null;
-        return { enabled: row.enabled === true, ...(typeof row.readFromFolder === "string" ? { folder: row.readFromFolder } : {}) };
+        return Array.isArray(rows) ? rows.some(entry => entry.id === ID) : null;
     }
     catch {
         return null;
     }
 }
-// The mod's own tests and the types the engine lays while developing are not part of what Claude loads.
-const shipped = (source) => !/\.test\.tsx?$/.test(source) && !(basename(source) === "types" && source.includes(".claude-plugin"));
-/** Installs the mod for the person, or leaves it as it is when this release's copy is installed or the person disabled it. Never throws. */
-export async function installClaudeMod(deps) {
+/** Whether an older runner left a copy of the mod in the state root. */
+export async function claudeModCopyExists(stateRoot) {
+    return stat(join(stateRoot, CLAUDE_MOD_DIR)).then(entry => entry.isDirectory(), () => false);
+}
+/**
+ * Removes the mod an older runner installed: uninstalls it and its marketplace, then deletes the runner's copies.
+ * Returns null when no older runner installed it. A copy Claude may still load is deleted only once the CLI no longer
+ * lists the mod, so a CLI that is missing or fails leaves a working pane for a later setup to remove. Never throws.
+ */
+export async function retireClaudeMod(deps) {
+    await rm(join(deps.stateRoot, CLAUDE_MOD_REMOVED_FILE), { force: true }).catch(() => undefined);
+    if (!await claudeModCopyExists(deps.stateRoot))
+        return null;
     const cli = await findClaudeCli(deps);
     if (cli === null)
         return { state: "skipped", reason: NO_CLI };
-    const base = join(deps.stateRoot, "claude-mod");
-    const dir = join(base, deps.version);
     try {
-        const current = await listed(deps, cli);
-        if (current && !current.enabled)
-            return { state: "disabled", cli };
-        const copied = await stat(join(dir, "hooks", "hooks.json")).then(entry => entry.isFile(), () => false);
-        if (current?.folder === dir && copied)
-            return { state: "installed", cli };
-        await rm(dir, { recursive: true, force: true });
-        await mkdir(base, { recursive: true });
-        await cp(deps.sourceDir, dir, { recursive: true, filter: shipped });
-        // Both fail harmlessly when nothing is installed yet.
-        await deps.run(cli, ["plugin", "uninstall", ID, "--scope", "user"]);
+        const before = await listed(deps, cli);
+        if (before === null)
+            return { state: "failed", cli, reason: "plugin list failed" };
+        if (before) {
+            await deps.run(cli, ["plugin", "uninstall", ID, "--scope", "user"]);
+            if (await listed(deps, cli) !== false)
+                return { state: "failed", cli, reason: "plugin uninstall failed" };
+        }
+        // It fails harmlessly when the marketplace is already gone.
         await deps.run(cli, ["plugin", "marketplace", "remove", CLAUDE_MOD_MARKETPLACE]);
-        if ((await deps.run(cli, ["plugin", "marketplace", "add", dir])).code !== 0)
-            return { state: "failed", cli, reason: "plugin marketplace add failed" };
-        if ((await deps.run(cli, ["plugin", "install", ID, "--scope", "user", "--json"])).code !== 0)
-            return { state: "failed", cli, reason: "plugin install failed" };
-        for (const old of await readdir(base))
-            if (old !== deps.version)
-                await rm(join(base, old), { recursive: true, force: true });
-        return { state: "installed", cli };
+        await rm(join(deps.stateRoot, CLAUDE_MOD_DIR), { recursive: true, force: true });
+        return { state: "removed", cli };
     }
     catch (error) {
-        return { state: "failed", cli, reason: error.code ?? "install failed" };
-    }
-}
-/** Uninstalls the mod and its marketplace, then deletes the runner's copies. Never throws. */
-export async function removeClaudeMod(deps) {
-    const cli = await findClaudeCli(deps);
-    if (cli !== null) {
-        await deps.run(cli, ["plugin", "uninstall", ID, "--scope", "user"]);
-        await deps.run(cli, ["plugin", "marketplace", "remove", CLAUDE_MOD_MARKETPLACE]);
-    }
-    await rm(join(deps.stateRoot, "claude-mod"), { recursive: true, force: true }).catch(() => undefined);
-    return { state: "removed", ...(cli ? { cli } : {}) };
-}
-/** Whether the person removed the mod with `integrations remove claude` since it was last installed on request. */
-export async function claudeModRemovedByPerson(stateRoot) {
-    return stat(join(stateRoot, CLAUDE_MOD_REMOVED_FILE)).then(entry => entry.isFile(), () => false);
-}
-/** Records or clears the person's removal. */
-export async function setClaudeModRemovedByPerson(stateRoot, removed) {
-    const file = join(stateRoot, CLAUDE_MOD_REMOVED_FILE);
-    if (!removed) {
-        await rm(file, { force: true });
-        return;
+        return { state: "failed", cli, reason: error.code ?? "removal failed" };
     }
-    await mkdir(stateRoot, { recursive: true });
-    await writeFile(file, "Removed with integrations remove claude. Run integrations install claude to add the Work Room pane again.\n", { mode: 0o600 });
-}
-/** What `plugin list` says of the mod. Never throws. */
-export async function claudeModStatus(deps) {
-    const cli = await findClaudeCli(deps);
-    if (cli === null)
-        return { state: "skipped", reason: NO_CLI };
-    const current = await listed(deps, cli).catch(() => null);
-    return { state: current === null ? "not_installed" : current.enabled ? "installed" : "disabled", cli };
-}
-/** The package's claude-mod/: two folders up from src/asks/, three from dist/src/asks/. */
-function packagedModDir(moduleUrl = import.meta.url) {
-    return fileURLToPath(new URL(moduleUrl.toString().includes("/dist/src/") ? "../../../claude-mod/" : "../../claude-mod/", moduleUrl));
 }
 /**
  * The deps setup, integrations and uninstall use. Each CLI call gets a fixed environment, as the Claude login probe
@@ -172,7 +133,7 @@ export function claudeModDeps(env, stateRoot, home) {
             childEnv[key] = value;
     }
     return {
-        home, path: env.PATH, stateRoot, version: packageVersion(), sourceDir: packagedModDir(),
+        home, path: env.PATH, stateRoot,
         run: (file, args) => new Promise(resolve => {
             execFile(file, args, { encoding: "utf8", timeout: RUN_TIMEOUT_MS, maxBuffer: 1_048_576, env: childEnv }, (error, stdout) => {
                 const code = error ? (typeof error.code === "number" ? error.code : 1) : 0;

package/dist/src/asks/commands.js

@@ -1,13 +1,13 @@
 import { readdir, rm } from "node:fs/promises";
 import { join } from "node:path";
 import { ASKS_FILE } from "./store.js";
-import { claudeModDeps, claudeModRemovedByPerson, claudeModStatus, installClaudeMod, removeClaudeMod, setClaudeModRemovedByPerson } from "./claude-mod.js";
+import { claudeModCopyExists, claudeModDeps, retireClaudeMod } from "./claude-mod.js";
 import { homeDirectory, installIntegration, integrationStatus, removeIntegration, removeShimIfUnused } from "./integrations.js";
 import { APPS, isApp } from "./types.js";
 import { deleteGuideState } from "../guide/files.js";
 import { guideStatus, installGuide, removeGuide, removeGuideShimIfUnused } from "../guide/integrations.js";
 const NEXT_STEP = {
-    claude: "Start a new Claude Code session, or run /reload-plugins in an open one, to load mtec-ai-gateway-asks@skills-dir and the Work Room pane (/work-room).",
+    claude: "Start a new Claude Code session, or run /reload-plugins in an open one, to load mtec-ai-gateway-asks@skills-dir.",
     // /hooks is a command of the Codex CLI in a terminal only: the Codex app sends it to the model as text.
     codex: "Codex runs the four AI Gateway hooks only after you trust them once. In the Codex app, trust them under Settings → Hooks "
         + "or with the Review hooks button. In the Codex CLI in a terminal, trust them with /hooks. Until then the Slack message covers each ask.",
@@ -80,27 +80,19 @@ export async function statusOf(app, env, stateRoot, error) {
         return { app, state: "unreadable", path: "", error: error ?? errorCode(failure) };
     }
 }
-/** One act on the Work Room mod. It never fails the hooks: a mod that cannot be handled is reported on its own. */
-async function claudeMod(env, stateRoot, act) {
+/**
+ * Removes the retired Work Room pane mod when an older runner installed it, and reports what happened; null when there
+ * was none. It never fails the hooks: a mod that cannot be removed is reported on its own. Never throws.
+ */
+export async function retireWorkRoomPane(env, stateRoot) {
     try {
-        return await act(claudeModDeps(env, stateRoot, homeDirectory(env)));
+        return await retireClaudeMod(claudeModDeps(env, stateRoot, homeDirectory(env)));
     }
     catch (error) {
-        return { state: "failed", reason: errorCode(error) };
-    }
-}
-/**
- * setup's Work Room mod: installed on every setup, with or without --integrations (owner decision 2026-10-31), unless
- * the person removed it with `integrations remove claude`. Never throws.
- */
-export async function setupClaudeMod(env, stateRoot) {
-    if (await claudeModRemovedByPerson(stateRoot)) {
-        return { state: "skipped", reason: "removed with integrations remove claude; run integrations install claude to add it again" };
+        // A home that cannot be found matters only when there is a copy to remove.
+        return await claudeModCopyExists(stateRoot) ? { state: "failed", reason: errorCode(error) } : null;
     }
-    return claudeMod(env, stateRoot, installClaudeMod);
 }
-/** The Work Room mod's state, for integrations status and doctor. It runs the Claude CLI, so the daemon never calls it. */
-export const claudeModStatusOf = (env, stateRoot) => claudeMod(env, stateRoot, claudeModStatus);
 async function attempt(app, env, stateRoot, change) {
     try {
         return await change();
@@ -113,19 +105,17 @@ export async function installIntegrations(apps, env, stateRoot) {
     const results = [];
     for (const app of apps) {
         const result = await attempt(app, env, stateRoot, () => installIntegration(app, env, stateRoot));
-        const done = result.error === undefined ? { ...result, action: NEXT_STEP[app] } : result;
-        // The hooks first: they work without the mod, and a Claude CLI too old for the mod leaves them in place. Installing
-        // on request undoes an earlier removal, so setup keeps the mod again.
-        if (app === "claude")
-            await setClaudeModRemovedByPerson(stateRoot, false).catch(() => undefined);
-        results.push(app === "claude" ? { ...done, mod: await claudeMod(env, stateRoot, installClaudeMod) } : done);
+        results.push(result.error === undefined ? { ...result, action: NEXT_STEP[app] } : result);
     }
     return results;
 }
-/** Removes one app's asks hooks and, for Claude, the Work Room mod. */
+/** Removes one app's asks hooks and, for Claude, the retired Work Room pane mod an older runner installed. */
 async function removeAsks(app, env, stateRoot) {
     const result = await attempt(app, env, stateRoot, () => removeIntegration(app, env, stateRoot));
-    return app === "claude" ? { ...result, mod: await claudeMod(env, stateRoot, removeClaudeMod) } : result;
+    if (app !== "claude")
+        return result;
+    const mod = await retireWorkRoomPane(env, stateRoot);
+    return mod === null ? result : { ...result, mod };
 }
 /** The guide state of one app; a status that cannot be read is reported with its error, never thrown. */
 export async function guideStatusOf(app, env, stateRoot, error) {
@@ -176,8 +166,6 @@ export async function removeAsksInstall(env, stateRoot) {
     const results = [];
     for (const app of APPS)
         results.push(await removeAsks(app, env, stateRoot));
-    // Uninstall removes everything, so a later setup starts fresh and installs the Work Room mod again.
-    await setClaudeModRemovedByPerson(stateRoot, false).catch(() => undefined);
     // A hook left behind (an unreadable Codex hooks file) keeps its shim, which then prints nothing and exits 0.
     await removeShimIfUnused(env, stateRoot).catch(() => false);
     await rm(join(stateRoot, ASKS_FILE), { force: true });
@@ -202,14 +190,10 @@ export async function runIntegrationsCommand(argv, io) {
         else if (parsed.action === "remove") {
             for (const app of parsed.apps)
                 results.push(await removeAsks(app, io.env, io.stateRoot));
-            // The person removed the Work Room mod: setup leaves it out until integrations install claude.
-            if (parsed.apps.includes("claude"))
-                await setClaudeModRemovedByPerson(io.stateRoot, true).catch(() => undefined);
             await removeShimIfUnused(io.env, io.stateRoot).catch(() => false);
         }
         else {
-            results = await Promise.all(parsed.apps.map(async (app) => app === "claude"
-                ? { ...await statusOf(app, io.env, io.stateRoot), mod: await claudeModStatusOf(io.env, io.stateRoot) } : statusOf(app, io.env, io.stateRoot)));
+            results = await Promise.all(parsed.apps.map(app => statusOf(app, io.env, io.stateRoot)));
         }
     }
     if (!features.includes("guide")) {

package/dist/src/asks/doctor.js

@@ -1,6 +1,6 @@
 import { execFile } from "node:child_process";
 import { connect } from "node:net";
-import { claudeModStatusOf, statusOf } from "./commands.js";
+import { statusOf } from "./commands.js";
 import { hubSocketPath } from "./hub.js";
 import { MAX_LINE_BYTES, encodeLine } from "./hub-protocol.js";
 import { CLAUDE_PLUGIN_NAME } from "./integrations.js";
@@ -93,9 +93,8 @@ export async function asksDoctorReport(input) {
     const [status, statuses] = await Promise.all([hubStatus(input.stateRoot), Promise.all(APPS.map(app => statusOf(app, input.env, input.stateRoot)))]);
     const integrations = [];
     for (const report of statuses) {
-        const mod = report.app === "claude" ? { mod: await claudeModStatusOf(input.env, input.stateRoot) } : {};
         if (report.state !== "installed") {
-            integrations.push({ ...report, ...mod });
+            integrations.push(report);
             continue;
         }
         if (report.app === "codex") {
@@ -103,7 +102,7 @@ export async function asksDoctorReport(input) {
             continue;
         }
         const loaded = await claudePluginLoaded(input.env, input.run);
-        integrations.push({ ...report, ...mod, ...(loaded === null ? {} : { loaded }), ...(loaded === false ? { action: CLAUDE_NOT_LOADED } : {}) });
+        integrations.push({ ...report, ...(loaded === null ? {} : { loaded }), ...(loaded === false ? { action: CLAUDE_NOT_LOADED } : {}) });
     }
     return { mode: input.mode, hub: status === null ? { status: "not_running" } : { status: "running", ...status }, integrations };
 }

package/dist/src/cli.js

@@ -36,7 +36,7 @@ import { access, mkdir, rm } from "node:fs/promises";
 import { buildMessengerDaemon } from "./asks/messenger.js";
 import { removeMenubarInstall, runMenubarCommand, setupMenubarApp } from "./menubar/commands.js";
 import { runHookClient } from "./asks/hook-client.js";
-import { installGuideIntegrations, installIntegrations, parseFeatures, parseSetupIntegrations, removeAsksInstall, removeGuideInstall, runIntegrationsCommand, setupClaudeMod } from "./asks/commands.js";
+import { installGuideIntegrations, installIntegrations, parseFeatures, parseSetupIntegrations, removeAsksInstall, removeGuideInstall, retireWorkRoomPane, runIntegrationsCommand } from "./asks/commands.js";
 import { asksDoctorReport } from "./asks/doctor.js";
 import { guideDoctorReport, guideReportShown } from "./guide/doctor.js";
 import { runClaudeReleaseCommand } from "./commands/claude-release.js";
@@ -316,8 +316,8 @@ export async function main(argv, env, io = {}) {
                 const features = requestedFeatures ?? ["asks"];
                 const integrations = features.includes("asks") ? await installIntegrations(requestedIntegrations ?? [], env, config.stateRoot) : [];
                 const guide = features.includes("guide") ? await installGuideIntegrations(requestedIntegrations ?? [], env, config.stateRoot) : undefined;
-                // The Work Room pane goes with every setup (owner decision 2026-10-31); --integrations claude has just installed it.
-                const workRoomPane = integrations.some(report => report.app === "claude" && report.mod !== undefined) ? undefined : await setupClaudeMod(env, config.stateRoot);
+                // The Work Room pane mod is retired (owner decision 2026-11-12): every setup removes the copy an older runner installed.
+                const workRoomPane = await retireWorkRoomPane(env, config.stateRoot) ?? undefined;
                 // The menu bar app (Work Item b9218937) goes with every setup unless the person removed it.
                 const menubar = await setupMenubarApp(env, config.stateRoot);
                 // The LaunchAgent runs a copy under releases/<version>, never the npx cache that may have run setup.

package/dist/src/daemon/codex-app-host-entry.js

@@ -0,0 +1,94 @@
+import { randomUUID } from "node:crypto";
+import { connectCodexAppSetup } from "./codex-app-tools-host.js";
+const object = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+const blocked = () => ({ status: "blocked", creationBlocked: true, gatewayWritesBlocked: true });
+/**
+ * One ephemeral, read-only callback invocation across the supported Node REPL/app tools.
+ * No network listener, durable inbox, execution aggregate, credentials or live-mode option.
+ * The authenticated supervisor dispatches only the returned exact official read call, then
+ * supplies its raw MCP response. Correlation IDs identify RPCs, never app/Work Sessions.
+ */
+export class CodexAppHostReadOnlyEntry {
+    connection;
+    scope;
+    started = false;
+    closed = false;
+    result;
+    waiting;
+    constructor(scope) {
+        this.scope = { ...scope };
+        const deny = async () => { throw new Error("Creation and Gateway writes are blocked in read-only host entry"); };
+        this.connection = connectCodexAppSetup({ approvedHostId: scope.hostId, approvedProjectId: scope.projectId,
+            tools: {
+                listProjects: args => this.request({ id: randomUUID(), tool: "list_projects", arguments: args }),
+                readThread: args => this.request({ id: randomUUID(), tool: "read_thread", arguments: args }),
+                createThread: deny,
+            }, claimDispatch: deny, report: deny });
+    }
+    start(input) {
+        if (this.started || this.closed)
+            throw new Error("Probe is single-use");
+        if (!object(input) || Object.keys(input).some(k => k !== "threadId") || (input.threadId !== undefined
+            && (typeof input.threadId !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(input.threadId))))
+            throw new Error("Exact existing thread ID or empty discovery input required");
+        const threadId = input.threadId;
+        this.started = true;
+        void this.probe(threadId).then(result => { if (!this.closed)
+            this.result = result; }, () => { if (!this.closed)
+            this.result = blocked(); });
+    }
+    async next() {
+        // Flush the local promise chain only; never waits for an external tool or polls a server.
+        await new Promise(resolve => setImmediate(resolve));
+        if (this.result)
+            return { kind: "done", result: { ...this.result } };
+        if (!this.waiting)
+            return { kind: this.started ? "awaiting_reply" : "idle" };
+        if (this.waiting.delivered)
+            return { kind: "awaiting_reply" };
+        this.waiting.delivered = true;
+        return { kind: "tool_call", call: structuredClone(this.waiting.call) };
+    }
+    reply(id, response) {
+        const pending = this.waiting;
+        if (this.closed || !pending?.delivered || pending.call.id !== id)
+            throw new Error("No matching outstanding official call");
+        this.waiting = undefined;
+        pending.resolve(response);
+    }
+    close() {
+        this.closed = true;
+        this.result = blocked();
+        const pending = this.waiting;
+        this.waiting = undefined;
+        pending?.reject(new Error("Host probe closed"));
+    }
+    /** No caller-controlled flag, receipt or copied approval can enable side effects here. */
+    execute(_input) { return { status: "creation_blocked" }; }
+    /** Local fixtures only: exercise the original adapter up to its denied write boundary. */
+    startAdapterCheck(input) {
+        if (this.started || this.closed)
+            throw new Error("Probe is single-use");
+        this.started = true;
+        void this.connection.adapter.execute(input).then(result => {
+            if (!this.closed)
+                this.result = { ...blocked(), adapterStatus: result.status };
+        }, () => { if (!this.closed)
+            this.result = blocked(); });
+    }
+    request(call) {
+        if (this.closed || this.waiting)
+            return Promise.reject(new Error("Probe cannot issue another call"));
+        return new Promise((resolve, reject) => { this.waiting = { call, delivered: false, resolve, reject }; });
+    }
+    async probe(threadId) {
+        const projects = await this.connection.host.listProjects();
+        if (!projects.some(p => p.hostId === this.scope.hostId && p.projectId === this.scope.projectId))
+            return blocked();
+        if (!threadId)
+            return { status: "connected_read_only", creationBlocked: true, gatewayWritesBlocked: true };
+        const observation = await this.connection.host.track({ threadId });
+        const verified = observation.status === "identity_observed";
+        return { ...blocked(), status: verified ? "connected_read_only" : "blocked", identity: verified ? "identity_observed" : "unverified" };
+    }
+}