@catalyst-cloud/cli 0.16.22 → 0.16.24

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.16.24
+
+One self-hosted machine can now work for several Linear teams. On a machine already set up for one team, run `catalyst setup --runner` with another team selected, and setup adds that team instead of stopping. Each team's own setting still decides whether its work may run there, and the machine asks each of its teams for work in turn. A new machine starts on Catalyst's current approved release, which can serve several teams from its first setup; a machine you already set up gets that release on its next 15-minute update check.
+
+New: `catalyst mcp status <server>` shows one MCP server's state, how it authenticates, how many of its tools are granted to this machine's login, and how many tools it offers. It then lists the server's last 50 tool calls: when each ran, the ticket and phase it ran for, the tool, how long it took and the outcome. A call that failed names its reason in plain words. The command exits 0 whenever it could read the server, even when some of the calls failed. `--json` prints the server's status and calls exactly as Catalyst Cloud returns them.
+
+## 0.16.23
+
+You can now answer an ask by telling your agent in chat, and have the agent record it for you. `catalyst ask answer <ask> --proxy --quote "<your exact words>" --said-in <session>` records your words on the ask as an answer by proxy, with `--option <letter>` when you picked one. It is kept apart from answers you give on the ask yourself, and the work the ask held moves on. It works only on your own asks, and only after you turn it on with `catalyst ask proxy on` (`catalyst ask proxy` shows whether it is on; `off` turns it off). If an agent recorded something you did not mean, `catalyst ask disown <ask>` takes it back and reopens the ask. Update the Catalyst plugin's skills with the CLI so your agent knows when it may do this.
+
 ## 0.16.22
 
 A self-hosted Linux machine set up over SSH now keeps updating after you log out, with no `sudo` step. Setup turns on lingering for your user by itself, and says so along with how to undo it (`loginctl disable-linger $USER`). Only when the machine does not allow that does setup name the one `sudo loginctl enable-linger $USER` command, and it says updates stop at logout until you run it. `catalyst runner auto-update status` now says whether updates keep running after you log out. For a machine you already set up, install this version and run `catalyst runner auto-update on`.

package/README.md

@@ -236,7 +236,7 @@ Some of these only read, and some write: a comment, a card move, an ask, a relea
 
 ## What a key cannot see yet
 
-Your personal key reads everything the skills need — tickets, pull requests, the eligibility explainer, the dispatch queue, fleet activity, per-ticket execution history (`catalyst explain --history <ticket>`: phase attempts, remediation rounds, park state) and coding-account status (`catalyst accounts`: provider, declared and observed state, usage limits, walls, quarantine — never a credential; enrolling or pausing one is `<your cloud>/settings/coding-accounts`, with no command yet). It also releases a parked or held ticket once its cause is fixed: `catalyst release <ticket> --because <what changed>` (the `unstick` skill runs it), recorded against your name and shown in the ticket's history. And it declares what your containers need: `catalyst environment` reads the account-wide declaration, `environment propose --file <path> --approve` proposes and approves it in one compare-and-set, and the values behind the names stay in the cloud — reading needs any active seat, proposing and approving need an admin or owner one. An admin or owner can put a repository's values in from the terminal. `catalyst secret import .env --repo owner/name` stores every name in the file and lists the declared names that still have no value. `catalyst secret set NAME --repo owner/name --command 'op read op://Vault/item/field'` runs the command on your machine and stores its output; with no `--command` it reads the value from stdin, or asks for it without echoing. No value is ever printed, and the cloud's audit records the command, not its output. That is the account's own declaration — a repository's own `.catalyst/catalyst.toml`, which `catalyst-onboard` already reports on, is a separate thing. `catalyst env inventory` lists the environment variable names a repository needs — never a value; `env check` checks the TOML syntax and environment variable table in `.catalyst/catalyst.toml` offline; `env migrate [catalyst.env.json]` prints a TOML environment table from a legacy declaration, with all names optional and values omitted. These commands need no login (the `what-this-repo-needs` skill walks through them). Two things it cannot do, and the skills say so by name rather than guess:
+Your personal key reads everything the skills need — tickets, pull requests, the eligibility explainer, the dispatch queue, fleet activity, per-ticket execution history (`catalyst explain --history <ticket>`: phase attempts, remediation rounds, park state) and coding-account status (`catalyst accounts`: provider, declared and observed state, usage limits, walls, quarantine — never a credential; enrolling or pausing one is `<your cloud>/settings/coding-accounts`, with no command yet). It also releases a parked or held ticket once its cause is fixed: `catalyst release <ticket> --because <what changed>` (the `unstick` skill runs it), recorded against your name and shown in the ticket's history. And it declares what your containers need: `catalyst environment` reads the account-wide declaration, `environment propose --file <path> --approve` proposes and approves it in one compare-and-set, and the values behind the names stay in the cloud — reading needs any active seat, proposing and approving need an admin or owner one. An admin or owner can put a repository's values in from the terminal. `catalyst secret import .env --repo owner/name` stores every name in the file and lists the declared names that still have no value. `catalyst secret set NAME --repo owner/name --command 'op read op://Vault/item/field'` runs the command on your machine and stores its output; with no `--command` it reads the value from stdin, or asks for it without echoing. No value is ever printed, and the cloud's audit records the command, not its output. That is the account's own declaration — a repository's own `.catalyst/catalyst.toml`, which `catalyst-onboard` already reports on, is a separate thing. `catalyst env inventory` lists the environment variable names a repository needs — never a value; `env check` checks the TOML syntax and environment variable table in `.catalyst/catalyst.toml` offline; `env migrate [catalyst.env.json]` prints a TOML environment table from a legacy declaration, with all names optional and values omitted. `env draft --write` writes a new `.catalyst/catalyst.toml` from the repository's files and from this computer — the names the repository's `.envrc` exports, and Claude Code's HTTP MCP servers with each header as a variable reference — then offers to store this computer's values; `catalyst env import` stores them later. A value is never written to the file or printed. These commands need no login, except `env import` (the `what-this-repo-needs` skill walks through them). Two things it cannot do, and the skills say so by name rather than guess:
 
 - Read pull-request labels or the reviewer's reaction. The mirror does not carry them; GitHub's own page does.
 - Compute a flow number — cycle time, throughput, or how long pull requests have been open. Nothing serves those yet, so say they are not computed rather than counting something else and calling it that.

package/dist/args.js

@@ -278,7 +278,7 @@ export const FLAG_TABLES = {
         option: {
             value: true,
             repeat: true,
-            help: "raise: an option (repeatable)",
+            help: "raise: an option (repeatable); answer: the letter of the option the owner chose (leave out for free text)",
         },
         default: { value: true, help: "raise: the default if silent" },
         blocks: {
@@ -315,7 +315,20 @@ export const FLAG_TABLES = {
         },
         "ask-key": { value: true, help: "raise: idempotency key" },
         answer: { value: true, help: "accept: the answering comment id" },
-        role: { value: true, help: "accept: the role recording the answer" },
+        role: { value: true, help: "accept/answer: the role recording the answer" },
+        proxy: {
+            value: false,
+            help: "answer: record an answer the ask's owner gave you in chat (required)",
+        },
+        quote: { value: true, help: "answer: the owner's exact words" },
+        "said-in": {
+            value: true,
+            help: "answer: the chat session or channel id where the owner said it",
+        },
+        "said-at": {
+            value: true,
+            help: "answer: when the owner said it, as an ISO-8601 time (default now)",
+        },
     },
     ready: {
         onboarding: {
@@ -344,7 +357,7 @@ export const FLAG_TABLES = {
     env: {
         root: {
             value: true,
-            help: "draft, shell: repository directory (default: the current repository's top level)",
+            help: "draft, import, shell: repository directory (default: current directory; shell: the current repository's top level)",
         },
         write: {
             value: false,
@@ -354,6 +367,18 @@ export const FLAG_TABLES = {
             value: false,
             help: "draft: show the generated TOML as an additions-only diff",
         },
+        "import-values": {
+            value: false,
+            help: "draft: after --write, store this computer's values for the declared names without asking",
+        },
+        repo: {
+            value: true,
+            help: "draft --import-values, import: the repository (owner/name); default: this checkout's GitHub origin",
+        },
+        yes: {
+            value: false,
+            help: "import: store without asking (needed without a terminal)",
+        },
         "env-file": {
             value: true,
             repeat: true,
@@ -538,13 +563,13 @@ export const VERB_USAGE = {
     queue: "queue [--team K] [--json]",
     watch: "watch [--team K] [--ticket T]... [--project P] [--exec CMD] [--cursor-file <path>] [--from cursor|head]",
     write: "write <comment <ticket> --body|--stdin [--parent] [--bookkeeping] [--as-user] | state <ticket> --slot|--state-id|--state-type | label <ticket> --add... --remove... | create --team --title [--description|--stdin] [--label] [--priority] | reaction <ticket>|--comment <id> --emoji <e> | attachment <ticket> --title --url | session <ticket> [--title] [--plan-file] [--activity]>",
-    ask: "ask <raise --team --title [--context] [--option]... [--default] --blocks <ticket>...|--nothing-to-block [--ask-key] [--gates-pr <n>... --released-by <letter>... [--gates-label hold|hold:preview]... [--gates-repo <owner/name>]] | accept <askTicket> --answer <commentId> --role <role> | list [--anyone] [--json]>",
+    ask: "ask <raise --team --title [--context] [--option]... [--default] --blocks <ticket>...|--nothing-to-block [--ask-key] [--gates-pr <n>... --released-by <letter>... [--gates-label hold|hold:preview]... [--gates-repo <owner/name>]] | accept <askTicket> --answer <commentId> --role <role> | answer <askTicket> --proxy --quote <owner's exact words> [--option <letter>] --said-in <session or channel id> [--said-at <ISO-8601 time>] [--role <role>] | proxy [status|on|off] | disown <askTicket> | list [--anyone]> [--json]",
     ready: "ready [--onboarding] [--local-sync] [--json] [--offline]",
     accounts: "accounts [--all] [--json]",
     seat: "seat checkout --size big|med --harness claude,codex,opencode [--session-id ID] [--stage STAGE] [--key-env NAME]",
-    mcp: "mcp <add <name> --url URL <--auth none|--bearer SECRET_NAME|--header NAME=SECRET_NAME...>|list|remove <name>> [--json]",
+    mcp: "mcp <add <name> --url URL <--auth none|--bearer SECRET_NAME|--header NAME=SECRET_NAME...>|list|remove <name>|status <name>> [--json]",
     team: "team <list|check <KEY>|check --all|map <KEY> [--stage role=StateName]... [--yes --plan-hash H]|adopt <KEY> [--undo] [--yes --plan-hash H]|migrate <KEY> [--choice sourceId=destinationId]... [--retire] [--yes --plan-hash H]|checklist <KEY>> [--json]",
-    env: "env <inventory [path] | check <file> | migrate [catalyst.env.json] | draft [--root DIR] [--diff] [--write] | shell [--root DIR] [--env-file FILE]... [--image REF] [--check]> [--json]   (THIS repository; no login — shell needs Docker and downloads Catalyst's image once)",
+    env: "env <inventory [path] | check <file> | migrate [catalyst.env.json] | draft [--root DIR] [--diff] [--write [--import-values]] | import [--root DIR] [--repo owner/name] [--yes] | shell [--root DIR] [--env-file FILE]... [--image REF] [--check]> [--json]   (THIS repository; no login, except import and --import-values, which sign in and store values — shell needs Docker and downloads Catalyst's image once)",
     environment: "environment [read] [--json] | environment propose --file <path>|--stdin [--expect-revision N] [--approve] [--json] | environment approve [--revision N --hash H] [--json]   (your ACCOUNT's declaration; needs login)",
     secret: "secret set <NAME> --repo <owner/name> [--command '<cmd>'] [--json]   (value from --command, stdin, or a hidden prompt) | secret import <file> --repo <owner/name> [--names NAME[,NAME...]] [--rotate NAME]... [--json]",
     var: "var <set NAME|import <file>> [--repo <owner/name>] [--names NAME[,NAME...]] [--json]   (plain environment variables; set reads stdin or a hidden prompt)",

package/dist/ask.js

@@ -1,28 +1,41 @@
-// ask.ts — `ask raise|accept|list`: raise a decision through the contract's ask route (the cloud
-// renders the body from its own template, so this passes fields, never headings), record an answer
-// through ask-accept, and list open asks ranked by the work each one holds.
+// ask.ts — `ask raise|accept|answer|proxy|disown|list`: raise a decision through the contract's ask
+// route (the cloud renders the body from its own template, so this passes fields, never headings),
+// record an answer through ask-accept, record an owner's chat answer by proxy (CTC-6279) and let the
+// owner switch that on, off or take one back, and list open asks ranked by the work each one holds.
 import { flagBool, flagList, flagString, positionals } from "./args.js";
 import { requireConfig } from "./config.js";
 import { loadContract, teamByKey } from "./contract.js";
-import { UsageError } from "./errors.js";
+import { CliError, UsageError } from "./errors.js";
 import { apiClient } from "./transport.js";
 import { fetchAllPages } from "./pagination.js";
 import { fetchWorkflowStates, postAgent, resolveIssue } from "./write.js";
 export async function cmdAsk(args, ctx) {
     const [sub, ...rest] = positionals(args);
     if (!sub)
-        throw new UsageError("ask needs a subcommand: raise | accept | list");
+        throw new UsageError("ask needs a subcommand: raise | accept | answer | proxy | disown | list");
     if (sub === "raise" && !flagBool(args, "nothing-to-block") && flagList(args, "blocks").length === 0) {
         throw new UsageError("ask raise needs --blocks <ticket>... (what this decision holds) or --nothing-to-block");
     }
+    // Everything these three would refuse is refused before the config is read or anything is sent.
+    const proxyBody = sub === "answer" ? proxyAnswerBody(args, rest, ctx.now().getTime()) : undefined;
+    const proxyAction = sub === "proxy" ? proxySettingAction(rest) : undefined;
+    if (sub === "disown" && (!rest[0] || rest.length > 1))
+        throw new UsageError("ask disown needs exactly one <ask>");
     const cfg = requireConfig(ctx);
-    const { doc } = await loadContract(ctx, cfg);
     const api = apiClient(cfg, ctx);
+    // The two personal settings routes are not contract routes: they act as the logged-in person.
+    if (proxyAction)
+        return proxySetting(args, ctx, api, proxyAction);
+    if (sub === "disown")
+        return disown(args, ctx, api, rest[0]);
+    const { doc } = await loadContract(ctx, cfg);
     switch (sub) {
         case "raise":
             return raise(args, ctx, doc, api);
         case "accept":
             return accept(args, ctx, doc, api, rest);
+        case "answer":
+            return answerByProxy(args, ctx, doc, api, proxyBody);
         case "list":
             return list(args, ctx, doc, api, cfg);
         default:
@@ -130,6 +143,227 @@ async function accept(args, ctx, doc, api, rest) {
     ctx.stdout(args.json ? JSON.stringify(result) : `ask ${ask.identifier}: answer ${answer} recorded by ${role}`);
     return 0;
 }
+/** The cloud's bounds on an answer by proxy, checked here first so a refusal never costs a write. */
+const QUOTE_MAX = 4000;
+const SAID_IN_MAX = 200;
+const ROLE_MAX = 64;
+const FUTURE_SKEW_MS = 5 * 60_000;
+const SINGLE_LINE = /^[^\r\n]+$/;
+/** CTC-6279 — `ask answer <ask> --proxy ...` → the ask-answer-proxy body. `--proxy` is required so the
+ *  command can never be mistaken for the owner answering: an answer the owner posted on the ask is
+ *  recorded with `ask accept`. The option letter maps A=0; no `--option` is a free-text answer, recorded
+ *  as written. The quote is sent exactly as given, never trimmed. */
+export function proxyAnswerBody(args, rest, nowMs) {
+    const usage = 'ask answer <ask> --proxy --quote "<owner\'s exact words>" [--option <letter>] --said-in <session or channel id> [--said-at <ISO-8601 time>] [--role <role>]';
+    if (!flagBool(args, "proxy")) {
+        throw new UsageError(`ask answer records only an answer the ask's owner gave you in chat, and needs --proxy: ${usage}. For an answer the owner posted on the ask themselves, use: catalyst ask accept <ask> --answer <commentId> --role <role>`);
+    }
+    const ask = rest[0];
+    if (!ask || rest.length > 1)
+        throw new UsageError(`ask answer needs exactly one <ask>: ${usage}`);
+    const quote = flagString(args, "quote");
+    if (quote === undefined || quote.trim() === "")
+        throw new UsageError("ask answer --proxy needs --quote with the owner's exact words");
+    if (quote.length > QUOTE_MAX)
+        throw new UsageError(`--quote is ${quote.length} characters; the most an answer can carry is ${QUOTE_MAX}`);
+    const saidIn = flagString(args, "said-in");
+    if (saidIn === undefined || saidIn.trim() === "")
+        throw new UsageError("ask answer --proxy needs --said-in <session or channel id>: where the owner said it");
+    if (!SINGLE_LINE.test(saidIn) || saidIn.length > SAID_IN_MAX)
+        throw new UsageError(`--said-in must be one line of at most ${SAID_IN_MAX} characters`);
+    const role = flagString(args, "role");
+    if (role !== undefined && (!SINGLE_LINE.test(role) || role.length > ROLE_MAX))
+        throw new UsageError(`--role must be one line of at most ${ROLE_MAX} characters`);
+    const saidAtRaw = flagString(args, "said-at");
+    let saidAtMs = nowMs;
+    if (saidAtRaw !== undefined) {
+        saidAtMs = Date.parse(saidAtRaw);
+        if (!Number.isFinite(saidAtMs))
+            throw new UsageError(`--said-at must be an ISO-8601 time, such as 2026-10-20T14:05:00Z (got "${saidAtRaw}")`);
+        if (saidAtMs > nowMs + FUTURE_SKEW_MS)
+            throw new UsageError(`--said-at ${saidAtRaw} is in the future; give the time the owner said it`);
+    }
+    const options = flagList(args, "option");
+    if (options.length > 1)
+        throw new UsageError("ask answer takes one --option: the letter the owner chose");
+    let optionIndex;
+    if (options.length === 1) {
+        const letter = options[0].trim().toUpperCase();
+        if (!/^[A-Z]$/.test(letter))
+            throw new UsageError(`--option must be one letter from A to Z (got "${options[0]}"); leave it out for a free-text answer`);
+        optionIndex = letter.charCodeAt(0) - 65;
+    }
+    return {
+        // The cloud matches an identifier exactly, so `ctc-12` is sent as `CTC-12`.
+        askIssueId: /^[A-Za-z][A-Za-z0-9]*-\d+$/.test(ask) ? ask.toUpperCase() : ask,
+        ownerQuote: quote,
+        ...(optionIndex !== undefined ? { optionIndex } : {}),
+        saidIn,
+        saidAtMs,
+        ...(role !== undefined ? { acceptedByRole: role } : {}),
+    };
+}
+const letterOf = (index) => String.fromCharCode(65 + index);
+/** One plain sentence per refusal reason the ask-answer-proxy route answers. */
+function proxyRefusal(ask, reason, body, optionCount) {
+    switch (reason) {
+        case "not-an-ask":
+            return `${ask} is not an ask, so there is no answer to record.`;
+        case "issue-not-mirrored":
+            return `Catalyst cannot see ${ask} yet. Check the identifier, or try again in a minute.`;
+        case "already-resolved":
+            return `${ask} already has an answer. Nothing was recorded.`;
+        case "proxy-answer-already-recorded":
+            return `An answer by proxy is already recorded on ${ask}, so nothing new was recorded. If an earlier run of this command failed partway, run it again from the same login with the same --quote, --option, --said-in, --said-at and --role to finish recording that answer.`;
+        case "readiness-needs-tap":
+            return `${ask} must be answered by its owner in the app. An answer by proxy cannot settle it.`;
+        case "ask-has-no-team":
+            return `${ask} is not in a project Catalyst works, so it cannot be answered by proxy.`;
+        case "ask-has-no-owner":
+            return `${ask} has no owner, so nobody's chat answer can be recorded on it.`;
+        case "proxy-caller-not-owner":
+            return `${ask} belongs to someone else. Only an agent logged in as the ask's owner can record their answer. If it is your ask, check that your Linear identity is matched: catalyst identity linear status`;
+        case "proxy-answering-off":
+            return `${ask}'s owner has not turned on answers by proxy, so nothing was recorded. Only the owner can turn it on, by running: catalyst ask proxy on`;
+        case "option-out-of-range": {
+            const chosen = body.optionIndex !== undefined ? letterOf(body.optionIndex) : "that option";
+            if (optionCount === 0)
+                return `${ask} has no lettered options. Leave out --option to record the answer as written.`;
+            if (typeof optionCount === "number" && optionCount > 0)
+                return `${ask} has options A to ${letterOf(optionCount - 1)}; ${chosen} is not one of them.`;
+            return `${ask} has no option ${chosen}.`;
+        }
+        case "already-in-flight":
+            return `Another answer to ${ask} is being recorded right now. Check it again in a moment.`;
+        default:
+            return `${ask}: the answer was refused (${reason || "no reason given"}).`;
+    }
+}
+async function answerByProxy(args, ctx, doc, api, body) {
+    const result = await postAgent(api, doc, "ask-answer-proxy", body, { accept: [409, 502] });
+    const outcome = result.outcome;
+    // A record-failed answer may be partly written, and the cloud finishes it only for the same said-at,
+    // so the retry names the time this run sent rather than letting --said-at default to a new now.
+    const saidAt = new Date(body.saidAtMs).toISOString();
+    if (args.json)
+        ctx.stdout(JSON.stringify(outcome === "record-failed" ? { ...result, retrySaidAt: saidAt } : result));
+    const ask = typeof result.askIdentifier === "string" ? result.askIdentifier : body.askIssueId;
+    if (outcome === "recorded") {
+        if (!args.json) {
+            const how = body.optionIndex !== undefined ? `${letterOf(body.optionIndex)} by proxy` : "by proxy, in the owner's words";
+            ctx.stdout(`${ask} answered ${how}: "${body.ownerQuote}"`);
+            const failed = Array.isArray(result.failedBlockedComments) ? result.failedBlockedComments.length : typeof result.failedBlockedComments === "number" ? result.failedBlockedComments : 0;
+            if (failed > 0)
+                ctx.stdout(`${failed} held ticket${failed === 1 ? "" : "s"} did not get the note naming this answer; the answer itself is recorded.`);
+            ctx.stdout(`The owner can take it back with: catalyst ask disown ${ask}`);
+        }
+        return 0;
+    }
+    if (outcome === "refused") {
+        if (!args.json)
+            ctx.stdout(proxyRefusal(ask, typeof result.reason === "string" ? result.reason : "", body, result.optionCount));
+        return 1;
+    }
+    if (outcome === "record-failed") {
+        if (!args.json)
+            ctx.stdout(`The answer to ${ask} did not finish recording${typeof result.reason === "string" && result.reason ? ` (${result.reason})` : ""}; part of it may already be on the ask. Run the same command again with --said-at ${saidAt} to finish it.`);
+        return 2;
+    }
+    throw new CliError(`ask-answer-proxy answered an outcome this CLI does not know: ${JSON.stringify(outcome)}`, "shape");
+}
+const PROXY_SETTING_PATH = "/api/v1/me/ask-proxy-answering";
+const ASK_DISOWN_PATH = "/api/v1/me/ask-disown";
+function proxySettingAction(rest) {
+    const action = rest[0] ?? "status";
+    if (rest.length > 1 || !["status", "on", "off"].includes(action))
+        throw new UsageError("ask proxy takes: status | on | off");
+    return action;
+}
+/** The two refusals both personal routes share, in plain words: an account key (403) throws, an
+ *  unmatched Linear identity (409) prints and exits 1. Returns undefined when the status was neither;
+ *  --json has already printed the body, so it prints nothing more. */
+function personalRefusal(args, ctx, status, body, what) {
+    const error = body && typeof body === "object" ? body.error : undefined;
+    if (status === 403 && error === "personal_credential_required") {
+        throw new CliError(`${what} needs your own login, not the workspace's shared key. Run catalyst login as yourself, then try again.`, "member-required", 2, 403);
+    }
+    if (status === 409 && error === "no_linear_identity") {
+        if (!args.json)
+            ctx.stdout("Your Linear identity is not matched yet, so Catalyst cannot tell which asks are yours. Match it with: catalyst identity linear options, then catalyst identity linear set <linearUserId>");
+        return 1;
+    }
+    if (status === 403 || (status === 409 && error !== undefined)) {
+        throw new CliError(`${what} was refused (${status}${typeof error === "string" ? `: ${error}` : ""})`, status === 403 ? "forbidden" : "http", 2, status);
+    }
+    return undefined;
+}
+function proxySettingLine(enabled, changed) {
+    return enabled
+        ? `${changed ? "Turned on: " : "On: "}agents may record an answer you give them in chat on your asks. Turn it off with: catalyst ask proxy off`
+        : `${changed ? "Turned off: " : "Off: "}agents may not record an answer you give them in chat; answer on the ask itself. Turn it on with: catalyst ask proxy on`;
+}
+async function proxySetting(args, ctx, api, action) {
+    const res = action === "status"
+        ? await api.getJson(PROXY_SETTING_PATH, { accept: [403, 409], parseAccepted: true })
+        : await api.putJson(PROXY_SETTING_PATH, { enabled: action === "on" }, { accept: [403, 409] });
+    if (args.json && res.status !== 403)
+        ctx.stdout(JSON.stringify(res.body ?? {}));
+    const refused = personalRefusal(args, ctx, res.status, res.body, "ask proxy");
+    if (refused !== undefined)
+        return refused;
+    if (typeof res.body?.enabled !== "boolean")
+        throw new CliError(`${PROXY_SETTING_PATH} answered without an enabled flag`, "shape");
+    if (!args.json)
+        ctx.stdout(proxySettingLine(res.body.enabled, action !== "status"));
+    return 0;
+}
+/** One plain sentence per refusal reason the ask-disown route answers. */
+function disownRefusal(ask, reason) {
+    switch (reason) {
+        case "not-owner":
+            return `${ask} is not your ask, so you cannot take back its answer.`;
+        case "not-proxy-answered":
+            return `${ask} was not answered by proxy, so there is nothing to take back.`;
+        case "already-disowned":
+            return `You already took back the answer on ${ask}.`;
+        case "already-in-flight":
+            return `A change to ${ask} is being recorded right now. Check it again in a moment.`;
+        default:
+            return `${ask}: taking back the answer was refused (${reason || "no reason given"}).`;
+    }
+}
+async function disown(args, ctx, api, askTicket) {
+    const ask = await resolveIssue(api, askTicket);
+    const res = await api.postJson(ASK_DISOWN_PATH, { issueId: ask.id }, { accept: [403, 409, 502] });
+    const body = res.body ?? {};
+    if (args.json && res.status !== 403)
+        ctx.stdout(JSON.stringify(body));
+    const refused = personalRefusal(args, ctx, res.status, body, "ask disown");
+    if (refused !== undefined)
+        return refused;
+    const name = typeof body.askIdentifier === "string" ? body.askIdentifier : ask.identifier;
+    switch (body.outcome) {
+        case "disowned": {
+            if (args.json)
+                return 0;
+            ctx.stdout(`${name} is open again: the answer recorded by proxy is taken back.`);
+            const tickets = Array.isArray(body.tickets) ? body.tickets : [];
+            for (const t of tickets)
+                ctx.stdout(`  ${String(t.ticket ?? "?")}: ${String(t.phase ?? "?")} ${String(t.status ?? "")}`.trimEnd());
+            return 0;
+        }
+        case "refused":
+            if (!args.json)
+                ctx.stdout(disownRefusal(name, typeof body.reason === "string" ? body.reason : ""));
+            return 1;
+        case "disown-failed":
+            if (!args.json)
+                ctx.stdout(`The answer on ${name} was not taken back${typeof body.reason === "string" && body.reason ? ` (${body.reason})` : ""}. Nothing changed; run the same command again.`);
+            return 2;
+        default:
+            throw new CliError(`${ASK_DISOWN_PATH} answered an outcome this CLI does not know: ${JSON.stringify(body.outcome)}`, "shape");
+    }
+}
 /** Decide the inbox scope from the connected identity and the `--anyone` flag. A personal key with a
  *  matched Linear identity reads "mine" by default; `--anyone` widens; an unmatched identity or a
  *  host key cannot mean "me" and says so rather than filtering to nothing. */

package/dist/capabilities.js

@@ -37,12 +37,17 @@ export const CAPABILITIES = [
     { verb: "environment approve", does: "approve the workspace-wide environment declaration", needs: "admin", routes: [agent("POST", "account-environment/approve")], since: "0.8.0" },
     { verb: "secret set|import", does: "enter a repository secret's value from this terminal, never echoed", needs: "admin", routes: [], since: "0.8.0" },
     { verb: "var set|import", does: "enter plain environment variable values from this terminal, never echoed", needs: "admin", routes: [], since: "0.13.2" },
+    { verb: "env import", does: "store this computer's values for the names .catalyst/catalyst.toml declares, never printed", needs: "admin", routes: [], since: "0.16.20" },
     { verb: "accounts", does: "read the workspace's coding accounts and which can take work", needs: "member", routes: [], since: "0.5.0" },
     { verb: "explain|running|queue|history", does: "read why a ticket runs or waits, what runs now, and what is queued", needs: "member", routes: [], since: "0.1.0" },
     { verb: "write comment|state|label|create|reaction|attachment|session", does: "act on a ticket as the person, through the agent proxy", needs: "member", routes: [agent("POST", "issue-comment"), agent("POST", "issue-state"), agent("POST", "issue-label"), agent("POST", "issue-create")], since: "0.1.0" },
     { verb: "ask raise|accept|list", does: "raise a decision to a human, or answer one", needs: "member", routes: [agent("POST", "ask"), agent("POST", "ask-accept")], since: "0.1.0" },
+    { verb: "ask answer --proxy", does: "record an answer the ask's owner gave in chat, quoted exactly, when the owner has turned answers by proxy on", needs: "member", routes: [agent("POST", "ask-answer-proxy")], since: "0.16.23" },
+    { verb: "ask proxy status|on|off", does: "read or set whether agents may record an answer you give them in chat (your own login only)", needs: "member", routes: [], since: "0.16.23" },
+    { verb: "ask disown", does: "take back an answer recorded by proxy on your ask, reopening it (your own login only)", needs: "member", routes: [], since: "0.16.23" },
     { verb: "release", does: "release a parked ticket or a whole failure class back to work", needs: "admin", routes: [agent("POST", "ticket-release"), agent("POST", "ticket-release-class")], since: "0.6.0" },
     { verb: "mcp add|list|remove", does: "register an MCP server for the workspace by vault-secret name", needs: "admin", routes: [agent("POST", "mcp")], since: "0.9.0" },
+    { verb: "mcp status", does: "read an MCP server's state, auth kind, grants for this key, tool count and its last 50 tool calls with each failure's reason", needs: "member", routes: [], since: "0.16.24" },
 ];
 /** Judge each capability against the routes a contract serves. `null` means no contract is cached,
  *  so nothing that rides a route can be called available; local and read-plane verbs still are. */

package/dist/cli.js

@@ -86,7 +86,7 @@ export function usageText() {
         "  catalyst seat checkout --size big|med --harness claude,codex,opencode [--session-id ID] [--stage STAGE]",
         "  catalyst hosts [list] | hosts remove <name-or-id> [--yes] | hosts rename <name-or-id> <new-name>",
         "  catalyst runner update [--check] | runner auto-update [status|on|off]   (move this machine's runner to the approved release)",
-        "  catalyst mcp add|list|remove (vault references only)",
+        "  catalyst mcp add|list|remove (vault references only) | mcp status <name>   (a server's state, grants and last 50 tool calls)",
         "  catalyst contract [--refresh] [--path <a.b.c>]",
         "  catalyst query <issues|issue <id>|pulls|pull <id>|projects|cycles|search <terms>|changes --since <cursor|head>>",
         '  catalyst replica <start [--detach]|stop|status [--probe]|sql "<select>"|schema [table]>',
@@ -95,7 +95,7 @@ export function usageText() {
         "  catalyst explain <ticket> | history <ticket> | running [--ticket T --phase P] | queue [--team K]",
         "  catalyst watch [--team K] [--ticket T]... [--project P] [--exec CMD]",
         "  catalyst write <comment|state|label|create|reaction|attachment|session> ...",
-        "  catalyst ask <raise|accept|list> ...",
+        "  catalyst ask <raise|accept|answer --proxy|proxy [status|on|off]|disown|list> ...",
         "  catalyst release <ticket> --because <what changed> [--retry-unchanged] [--dry-run] | release --class <c> --team <K> ...",
         "  catalyst environment [read] | environment propose --file <path>|--stdin [--approve] | environment approve   (your account; needs login)",
         "  catalyst env <inventory [path] | check <file> | migrate [catalyst.env.json] | draft [--root DIR] [--diff] [--write] | shell [--root DIR] [--env-file FILE]... [--image REF] [--check]> [--json]   (this repository; no login — shell needs Docker and downloads Catalyst's image once)",

package/dist/env/draft.js

@@ -2,41 +2,35 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { convertLegacyEnvironmentJson } from "./legacy.js";
 import { inventoryRepo } from "./inventory.js";
+import { scanMachine } from "./machine.js";
+import { mcpServerToml } from "./scan-claude-mcp.js";
 import { walkRepo } from "./walk.js";
 const SECRET_NAME_RE = /(?:^|_)(?:API_?KEY|AUTH|CREDENTIALS?|PASSWORD|PRIVATE_?KEY|SECRET|TOKEN)(?:_|$)/i;
 const ENV_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const MAX_VARIABLES = 128;
+/** The draft's secret rule: a name that says it holds a key, a token, a password or a secret. */
+export function isSecretName(name) {
+    return SECRET_NAME_RE.test(name);
+}
 /** Build a stable, value-free environment table from repository evidence. `.env` is never read:
  *  inventoryRepo's walker only opens supported examples and source/config files. The legacy
- *  declaration is parsed for names and explicit secret flags, and no legacy value escapes. */
-export function draftEnvironment(root, deps = {}) {
-    const inventory = inventoryRepo(root, deps);
+ *  declaration is parsed for names and explicit secret flags, and no legacy value escapes.
+ *  With `options.machine`, the names this computer's `.envrc` exports and Claude Code's HTTP MCP
+ *  servers join the draft (`catalyst env draft`); without it (`catalyst onboard`) nothing changes. */
+export function draftEnvironment(root, deps = {}, options = {}) {
+    const repository = repositoryNames(root, deps);
+    if (repository.state === "invalid")
+        return repository;
+    const { names, secrets, sources } = repository;
     const files = (deps.listFiles ?? walkRepo)(root);
-    const names = new Set();
-    const secrets = new Set();
-    const sources = new Set();
-    for (const entry of inventory.entries) {
-        if (entry.group === "bindings" || !entry.needsDeclaration || !ENV_NAME_RE.test(entry.name))
-            continue;
-        names.add(entry.name);
-        if (SECRET_NAME_RE.test(entry.name))
-            secrets.add(entry.name);
-        for (const finding of entry.found)
-            sources.add(finding.file);
-    }
-    const legacyPath = join(root, "catalyst.env.json");
-    const legacy = deps.readFile !== undefined ? deps.readFile(legacyPath) : readOptional(legacyPath);
-    if (legacy !== undefined) {
-        const converted = convertLegacyEnvironmentJson(legacy);
-        if (converted.state === "invalid")
-            return converted;
-        for (const name of converted.variableNames)
-            names.add(name);
-        for (const name of converted.secretNames)
-            secrets.add(name);
-        if (converted.variableNames.length > 0)
-            sources.add("catalyst.env.json");
-    }
+    const machine = options.machine === undefined ? null : scanMachine(root, options.machine, new Set(names));
+    for (const name of machine?.names ?? [])
+        names.add(name);
+    for (const name of machine?.secretNames ?? [])
+        secrets.add(name);
+    for (const source of machine?.sources ?? [])
+        sources.add(source);
+    const mcpServers = machine?.claude?.servers ?? [];
     const sortedNames = [...names].sort((a, b) => a.localeCompare(b, "en"));
     if (sortedNames.length > MAX_VARIABLES) {
         return { state: "invalid", errors: [`environment has more than ${MAX_VARIABLES} names`] };
@@ -59,7 +53,7 @@ export function draftEnvironment(root, deps = {}) {
             "required = false",
             "",
         ].join("\n"));
-    chunks.push(...standard.setup, ...standard.verify);
+    chunks.push(...mcpServers.map(mcpServerToml), ...standard.setup, ...standard.verify);
     const toml = `${chunks.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd()}\n`;
     return {
         state: "valid",
@@ -69,8 +63,41 @@ export function draftEnvironment(root, deps = {}) {
         verify: standard.verify,
         toml,
         sources: [...sources].sort((a, b) => a.localeCompare(b, "en")),
+        mcpServers,
+        machine,
     };
 }
+/** The names the repository itself declares: its examples, source and config files, and the legacy
+ *  `catalyst.env.json`. A derived MCP header variable must not take one of these (`scanMachine`). */
+export function repositoryNames(root, deps = {}) {
+    const inventory = inventoryRepo(root, deps);
+    const names = new Set();
+    const secrets = new Set();
+    const sources = new Set();
+    for (const entry of inventory.entries) {
+        if (entry.group === "bindings" || !entry.needsDeclaration || !ENV_NAME_RE.test(entry.name))
+            continue;
+        names.add(entry.name);
+        if (isSecretName(entry.name))
+            secrets.add(entry.name);
+        for (const finding of entry.found)
+            sources.add(finding.file);
+    }
+    const legacyPath = join(root, "catalyst.env.json");
+    const legacy = deps.readFile !== undefined ? deps.readFile(legacyPath) : readOptional(legacyPath);
+    if (legacy !== undefined) {
+        const converted = convertLegacyEnvironmentJson(legacy);
+        if (converted.state === "invalid")
+            return converted;
+        for (const name of converted.variableNames)
+            names.add(name);
+        for (const name of converted.secretNames)
+            secrets.add(name);
+        if (converted.variableNames.length > 0)
+            sources.add("catalyst.env.json");
+    }
+    return { state: "valid", names, secrets, sources };
+}
 /** Conservative package.json/lockfile inference. No repository script is executed. */
 function standardSteps(root, files, deps) {
     if (!files.includes("package.json"))

package/dist/env/machine-values.js

@@ -0,0 +1,63 @@
+// machine-values.ts — this computer's values for the names a reviewed `.catalyst/catalyst.toml`
+// declares, for `catalyst env import` and `catalyst env draft --import-values`.
+//
+// ⛔ VALUES ARE HELD IN MEMORY AND RETURNED ONLY TO `src/env-import.ts`, which sends them in request
+// bodies and prints names. Nothing here logs, prints or writes a value.
+//
+// A value can come from four places, in this order, and nowhere else:
+//   1. the direnv environment: this process's environment, only when DIRENV_DIR names this
+//      repository and only for names `.envrc` exports and assigns (direnv has already run the file;
+//      a bare `export NAME` with no assignment would pass on whatever the shell held);
+//   2. a static literal in `.envrc`;
+//   3. a literal header in `~/.claude.json`, only for a variable the draft derived from that header;
+//   4. this process's environment, for a name a `~/.claude.json` header references, since that is
+//      where Claude Code itself reads it.
+// `.envrc` is never run, `direnv` is never called, and `.env` is never opened. The file's declared
+// names are the allowlist: a name this computer has but the file does not declare is never resolved.
+import { claudeHeaderLiterals, scanClaudeMcp } from "./scan-claude-mcp.js";
+import { envrcLiteralValues, scanEnvrc } from "./scan-envrc.js";
+import { readMachineFiles } from "./machine.js";
+export function resolveMachineValues(root, options, declared, repositoryNames = new Set()) {
+    const files = readMachineFiles(root, options);
+    const wanted = new Set(declared.map(({ name }) => name));
+    const envrc = files.envrcText === undefined ? null : scanEnvrc(files.envrcText);
+    const exported = new Map((envrc?.exported ?? []).map((entry) => [entry.name, entry]));
+    const literals = files.envrcText === undefined ? new Map() : envrcLiteralValues(files.envrcText, wanted);
+    const direnvDir = options.env.DIRENV_DIR;
+    const direnvLoaded = typeof direnvDir === "string" && files.repoRoots.some((path) => direnvDir === `-${path}`);
+    // The draft saw the repository's names and the `.envrc` names when it derived header variables;
+    // the same set keeps lookups aligned.
+    const envrcNames = new Set([...repositoryNames, ...exported.keys()]);
+    const headerLiterals = files.claudeText === undefined ? new Map() : claudeHeaderLiterals(files.claudeText, files.repoRoots, wanted, envrcNames);
+    const referenced = new Set();
+    if (files.claudeText !== undefined) {
+        for (const server of scanClaudeMcp(files.claudeText, files.repoRoots, envrcNames).servers) {
+            const derived = new Set(server.derived.map(({ variable }) => variable));
+            for (const name of server.references)
+                if (!derived.has(name))
+                    referenced.add(name);
+        }
+    }
+    const values = new Map();
+    const noValue = [];
+    for (const { name } of declared) {
+        const found = pick(
+        // A bare `export NAME` the file never assigns hands direnv the shell's own value: not the file's.
+        direnvLoaded && exported.has(name) && exported.get(name)?.inherited !== true ? [options.env[name], "direnv environment"] : undefined, [literals.get(name), ".envrc"], [headerLiterals.get(name), "~/.claude.json"], referenced.has(name) ? [options.env[name], "shell environment"] : undefined);
+        if (found !== null)
+            values.set(name, found);
+        else
+            noValue.push({ name, computed: exported.get(name)?.computed === true });
+    }
+    return { values, noValue };
+}
+function pick(...candidates) {
+    for (const candidate of candidates) {
+        if (candidate === undefined)
+            continue;
+        const [value, from] = candidate;
+        if (value !== undefined && value !== "")
+            return { value, from };
+    }
+    return null;
+}