mtech-ai-local-runner 0.1.111 → 0.1.113

package/README.md

@@ -1,3 +1,26 @@
+## 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
+refused or expired), `usage_limit`, `model_unavailable`, `rate_limited`, `provider_error`, `budget_exceeded`,
+`cli_error` or `unknown` (Gateway Work Item 2ee28765). The Sentry "AI fix failed" card then says, for example, "Claude
+stopped before the first answer: usage limit reached on the runner's Claude account." The runner reads only the Claude
+CLI's error kind and HTTP status; it never sends the CLI's own text. If the card says `auth`, sign Claude in again on
+this Mac (or renew the runner's token with `setup --claude-token`) and retry.
+
+0.1.112 also carries the D4 work merged after 0.1.111 (PRs #943, #949, #957). Reviewed-host registration stays empty,
+so D4 execution stays closed.
+
 ## 0.1.111: Work Rooms in the menu bar app
 
 The menu bar window now has a **Rooms** tab (Gateway Work Item b35d65cb); the menu's **Show Rooms (n unread)…** opens
@@ -474,7 +497,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
@@ -494,54 +517,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/adapters/claude-code/adapter.js

@@ -7,6 +7,7 @@ import { CLAUDE_LAUNCH_OPT_OUTS, CLAUDE_RELEASE_MODE, CLAUDE_TRANSPORT, claudeCa
 import { createJobSecurityReceipt } from '../../safety/job-security-receipt.js';
 import { isTerminalEventType } from "../../protocol.js";
 import { parseClaudeLine } from "./stream-parser.js";
+import { runtimeFailure } from "../runtime-failure.js";
 import { p1ModelEvent } from '../../verification/p1-execution-host.js';
 import { compilePrompt } from "./prompt-compiler.js";
 import { CLAUDE_COMPLETION_SCHEMA } from "../completion-report.js";
@@ -180,7 +181,8 @@ export class ClaudeCodeAdapter {
                     || this.options.securityPolicy?.pin.toolsSha256 !== profile.tools_sha256 || this.options.securityPolicy?.pin.requirementsSha256 !== profile.cli_security_fingerprint
                     || this.options.securityPolicy?.pin.securityMode !== CLAUDE_RELEASE_MODE)
                     throw Error('D4_REVIEW_HOST_REQUIRED');
-                await host.assertCurrent(structuredClone(descriptor));
+                await host.assertCurrent(structuredClone(descriptor), { jobId: this.options.jobId ?? ctx.bindingId, bindingId: ctx.bindingId, generation: ctx.generation,
+                    launchFingerprint: ctx.securityBinding?.launchFingerprint ?? '', contractFingerprint: ctx.securityBinding?.contractFingerprint ?? '', taskPackageFingerprint: ctx.securityBinding?.taskPackageFingerprint ?? '' });
             };
             if (this.d4Limits)
                 await assertD4Host();
@@ -193,7 +195,8 @@ export class ClaudeCodeAdapter {
             if (!cwd || !path.isAbsolute(cwd) || rel === "" || (!rel.startsWith(".." + path.sep) && rel !== ".." && !path.isAbsolute(rel)))
                 throw new Error("trusted cwd must live outside the assigned worktree");
             const unbounded = isUnboundedLocalExecution(ctx.taskPackage);
-            if (!unbounded && (!Number.isFinite(this.options.maxBudgetUsd) || this.options.maxBudgetUsd <= 0)) {
+            const recordOnly = !!this.d4Limits && !('max_total_tokens' in this.d4Limits);
+            if (!unbounded && !recordOnly && (!Number.isFinite(this.options.maxBudgetUsd) || this.options.maxBudgetUsd <= 0)) {
                 throw new Error("refusing to start: no positive remaining contract budget was supplied");
             }
             if (!this.options.worktreeRoot) {
@@ -216,9 +219,9 @@ export class ClaudeCodeAdapter {
             if (this.cancelled)
                 throw new Error("adapter startup cancelled");
             const mcpConfigPath = this.options.writeLocalMcpConfig(endpoint);
-            const maxBudgetUsd = unbounded
+            const maxBudgetUsd = unbounded || recordOnly
                 ? null
-                : Math.min(this.options.maxBudgetUsd, this.d4Limits ? this.d4Limits.max_estimated_cost_microusd / 1_000_000 : contractBudget(ctx.taskPackage));
+                : Math.min(this.options.maxBudgetUsd, this.d4Limits && 'max_estimated_cost_microusd' in this.d4Limits ? this.d4Limits.max_estimated_cost_microusd / 1_000_000 : contractBudget(ctx.taskPackage));
             const hookPolicy = buildHookPolicy({
                 taskPackage: ctx.taskPackage,
                 worktreeRoot: this.options.worktreeRoot,
@@ -309,6 +312,9 @@ export class ClaudeCodeAdapter {
             exitInfo.signal = signal;
         });
         let sawTerminal = false;
+        // The CLI names an API error's kind on the assistant message before the result (stream-parser.ts); a later
+        // assistant message without one replaces it.
+        let assistantError;
         try {
             const lines = this.d4Guard ? this.d4Lines(handle, this.d4Guard) : handle.stdout;
             for await (const line of lines) {
@@ -348,7 +354,9 @@ export class ClaudeCodeAdapter {
                         return;
                     }
                 }
-                let parsed = parseClaudeLine(line, this.options.worktreeRoot, { p1: this.p1 });
+                if (message.type === "assistant")
+                    assistantError = typeof message.error === "string" ? message.error : undefined;
+                let parsed = parseClaudeLine(line, this.options.worktreeRoot, { p1: this.p1, assistantError });
                 if (!parsed)
                     continue;
                 if (parsed.eventType === "completed") {
@@ -357,7 +365,7 @@ export class ClaudeCodeAdapter {
                     if (this.candidateReview)
                         parsed = candidateReviewCompletion(parsed);
                     if (d4Usage)
-                        parsed = { ...parsed, payload: { ...parsed.payload, d4_usage: { ...d4Usage, policy: 'observed_stop_possible_overshoot' } } };
+                        parsed = { ...parsed, payload: { ...parsed.payload, d4_usage: { ...d4Usage, policy: this.d4Limits && 'max_total_tokens' in this.d4Limits ? 'observed_stop_possible_overshoot' : 'record_only' } } };
                     if (this.p1)
                         parsed = p1ModelEvent({ ...parsed, payload: { ...parsed.payload, usage: observedUsage } });
                 }
@@ -370,7 +378,8 @@ export class ClaudeCodeAdapter {
                 }
             }
             if (!sawTerminal) {
-                yield { eventType: "failed", summary: `claude process exited unexpectedly (code ${exitInfo.code ?? "unknown"})` };
+                yield { eventType: "failed", summary: `claude process exited unexpectedly (code ${exitInfo.code ?? "unknown"})`,
+                    payload: { runtime_failure: runtimeFailure("cli_error") } };
             }
         }
         catch (error) {

package/dist/src/adapters/claude-code/stream-parser.js

@@ -1,6 +1,7 @@
 import { isAbsolute, relative, resolve } from "node:path";
 import { MAX_EVENT_SUMMARY_CHARS } from "../../protocol.js";
 import { p1ModelEvent } from '../../verification/p1-execution-host.js';
+import { runtimeFailure } from "../runtime-failure.js";
 const EDIT_TOOL_NAMES = new Set(["Edit", "Write", "MultiEdit"]);
 function bounded(summary) {
     return summary.length > MAX_EVENT_SUMMARY_CHARS ? summary.slice(0, MAX_EVENT_SUMMARY_CHARS) : summary;
@@ -69,7 +70,66 @@ function parseSystemMessage(message) {
     }
     return null;
 }
-function parseResultMessage(message) {
+/*
+ * How Claude Code 2.1.308 (the listed release) says why a turn failed. An API error comes as a top-level assistant
+ * message with `error`, a coarse kind such as "authentication_failed", then a result with subtype "success",
+ * is_error true, `api_error_status` and, for some causes, `api_error`, a finer kind such as "usage_limit_reached".
+ * The CLI's own stops end with an error_* subtype. Only these identifiers and the status are read; the result text and
+ * `errors` hold provider wording and are never copied. Kinds this table does not name fall through to the status.
+ */
+const AUTH_KINDS = new Set(["authentication_failed", "oauth_org_not_allowed", "account_on_hold", "verification_required",
+    "cloud_credential_error"]);
+const AUTH_API_ERRORS = new Set(["invalid_credential_header", "org_disabled_credential", "api_key_auth_disabled",
+    "provider_credentials", "gateway_signin_required", "gateway_session_expired"]);
+const USAGE_API_ERRORS = new Set(["usage_limit_reached", "model_requires_usage_credits", "long_context_credits_required"]);
+const KIND_CODES = new Map([["billing_error", "usage_limit"], ["rate_limit", "rate_limited"],
+    ["model_not_found", "model_unavailable"], ["overloaded", "provider_error"], ["server_error", "provider_error"],
+    ["max_output_tokens", "cli_error"]]);
+const FAILURE_SUMMARIES = {
+    auth: "execution failed: Claude account sign-in refused",
+    usage_limit: "execution failed: Claude usage limit reached",
+    model_unavailable: "execution failed: model unavailable to the Claude account",
+    rate_limited: "execution failed: rate limited",
+    provider_error: "execution failed: provider API error",
+    budget_exceeded: "execution failed: budget exceeded",
+    cli_error: "execution failed: Claude CLI error",
+    unknown: "execution failed",
+};
+/** `assistantError` is the `error` of the last top-level assistant message before this result, if it had one. */
+export function classifyClaudeFailure(message, assistantError) {
+    const subtype = String(message.subtype ?? "");
+    // The CLI ended the turn itself; no API error can be the cause.
+    if (subtype === "error_max_budget_usd" || subtype === "error_max_budget_exceeded")
+        return "budget_exceeded";
+    if (subtype === "error_max_turns")
+        return "cli_error";
+    const apiError = typeof message.api_error === "string" ? message.api_error : "";
+    if (AUTH_API_ERRORS.has(apiError))
+        return "auth";
+    if (USAGE_API_ERRORS.has(apiError))
+        return "usage_limit";
+    const kind = assistantError ?? "";
+    if (AUTH_KINDS.has(kind))
+        return "auth";
+    const mapped = KIND_CODES.get(kind);
+    if (mapped)
+        return mapped;
+    const status = message.api_error_status;
+    if (status === 401 || status === 403)
+        return "auth";
+    if (status === 402)
+        return "usage_limit";
+    if (status === 404)
+        return "model_unavailable";
+    if (status === 429)
+        return "rate_limited";
+    if (typeof status === "number" && Number.isInteger(status) && status >= 500 && status <= 599)
+        return "provider_error";
+    if (kind === "invalid_request" || subtype === "error_during_execution" || message.terminal_reason === "turn_setup_failed")
+        return "cli_error";
+    return "unknown";
+}
+function parseResultMessage(message, assistantError) {
     const isError = message.is_error === true;
     const costUsd = typeof message.total_cost_usd === "number" ? message.total_cost_usd : undefined;
     if (!isError) {
@@ -90,8 +150,9 @@ function parseResultMessage(message) {
         return { eventType: "failed", summary: "execution failed: structured output missing",
             payload: { ...(costUsd !== undefined ? { cost_usd: costUsd } : {}), completion_rejection: { version: "completion-rejection-v1", code } } };
     }
-    const summary = subtype === "error_max_budget_exceeded" ? "execution failed: budget exceeded" : "execution failed";
-    return { eventType: "failed", summary, payload: costUsd !== undefined ? { cost_usd: costUsd } : undefined };
+    const code = classifyClaudeFailure(message, assistantError);
+    return { eventType: "failed", summary: FAILURE_SUMMARIES[code],
+        payload: { ...(costUsd !== undefined ? { cost_usd: costUsd } : {}), runtime_failure: runtimeFailure(code, message.api_error_status) } };
 }
 export function parseClaudeLine(line, worktreeRoot, options = {}) {
     let message;
@@ -110,7 +171,7 @@ export function parseClaudeLine(line, worktreeRoot, options = {}) {
             case "user":
                 return parseUserMessage(message.message ?? {});
             case "result":
-                return parseResultMessage(message);
+                return parseResultMessage(message, options.assistantError);
             default:
                 return null;
         }

package/dist/src/adapters/runtime-failure.js

@@ -0,0 +1,34 @@
+/**
+ * Why a provider CLI stopped, as one bounded code (no provider text). The Claude parser sets it on a failed terminal
+ * event; the daemon copies it into the job completion so the Gateway can tell an account problem from a code problem.
+ *
+ * - auth: the CLI's account was signed out, expired or refused.
+ * - usage_limit: the account's usage limit or credit ran out.
+ * - model_unavailable: the account cannot use the requested model.
+ * - rate_limited: the provider throttled the account for a short time.
+ * - provider_error: the provider's API failed or was overloaded.
+ * - budget_exceeded: the job's own cost budget ran out.
+ * - cli_error: the CLI stopped on its own error, not the account's or the provider's.
+ * - unknown: an error the CLI reported without a recognisable kind.
+ */
+export const RUNTIME_FAILURE_CODES = ["auth", "usage_limit", "model_unavailable", "rate_limited", "provider_error",
+    "budget_exceeded", "cli_error", "unknown"];
+export function runtimeFailure(code, httpStatus) {
+    return { version: "runtime-failure-v1", code, ...(isHttpErrorStatus(httpStatus) ? { http_status: httpStatus } : {}) };
+}
+/** The exact v1 shape or undefined; copies nothing else. */
+export function runtimeFailureDiagnostic(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const d = value;
+    if (d.version !== "runtime-failure-v1" || !RUNTIME_FAILURE_CODES.includes(d.code))
+        return undefined;
+    if (Object.keys(d).some(key => !["version", "code", "http_status"].includes(key)))
+        return undefined;
+    if (d.http_status !== undefined && !isHttpErrorStatus(d.http_status))
+        return undefined;
+    return runtimeFailure(d.code, d.http_status);
+}
+function isHttpErrorStatus(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 400 && value <= 599;
+}

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")) {