@catalyst-cloud/cli 0.16.34 → 0.16.35

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.16.35
+
+On a self-hosted machine set up before 0.16.33, the runner update agent kept running the CLI it was installed with, and that CLI could not update itself. The daily job installed newer versions into its own folder, but the agent never ran them. Installing this release globally (`npm install -g @catalyst-cloud/cli`) now points that agent at the newly installed copy. It only ever moves the agent to a newer catalyst, and keeps the agent's runner folder and PATH. It saves the previous agent file beside it, as `<file>.before-0.16.35`, so you can roll back. On a Mac it waits for an update already in progress to finish. An agent file you cannot change is left alone. Each outcome is written to the runner's `update.log`, and a failed attempt puts the agent back exactly as it was. The install itself never fails because of this. To turn it off, set `CATALYST_NO_AGENT_REPOINT=1`.
+
+`catalyst runner update --check` now says when the last update failed or was rolled back, with its time, its reason and the release it was offered, between the image result and the component report. The JSON output carries the same as `lastProblem`.
+
 ## 0.16.34
 
 `catalyst runner update` now tells Catalyst how its previous run went when it reads the approved release. A self-hosted machine that keeps waiting, refusing or rolling back an update shows up without anyone reading its local log. It sends a short report: the outcome, its reason code, the release it runs, the release that run was offered, when it ran and the CLI version. `--check` sends nothing, and nothing beyond that fixed set of words leaves the machine. When a self-hosted Mac cannot re-check its private storage during an update, the update log now names the reason instead of a generic failure.

package/bin/postinstall.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+// npm's postinstall for @catalyst-cloud/cli (CTC-6975): on a global install, point an older runner
+// update agent at this copy (src/agent-repoint.ts). A local or workspace install does nothing, and
+// nothing here ever fails the install. CATALYST_NO_AGENT_REPOINT=1 turns it off.
+if (process.env.npm_config_global === "true" && process.env.CATALYST_NO_AGENT_REPOINT !== "1") {
+  try {
+    const { postinstallRepoint } = await import("../dist/agent-repoint.js");
+    const line = postinstallRepoint();
+    if (line) console.error(line);
+  } catch (err) {
+    console.error(`catalyst: could not check the runner update agent (${err instanceof Error ? err.message : String(err)}). Run: catalyst runner auto-update on`);
+  }
+}

package/dist/agent-repoint.js

@@ -0,0 +1,241 @@
+// agent-repoint.ts — CTC-6975. A machine set up before 0.16.33 runs its runner update agent from a CLI
+// that can never move itself: those CLIs read no approved component release on a self-hosted machine,
+// so the agent's own copy stays where it was installed, while the daily job installs the newest CLI
+// into its own global prefix. npm runs this from that install (bin/postinstall.js) and points an older
+// agent at the copy updates do move.
+//
+// It only ever moves the agent forward, touches only this CLI's own agent, keeps the agent's runner
+// directory and PATH, and never fails the install. The agent file it replaces is kept beside it, named
+// `<file>.before-<version>`, which neither launchd nor systemd loads: that copy is the rollback.
+// Removing the stale CLI copy is the installer's job.
+import { accessSync, appendFileSync, constants, copyFileSync, existsSync, readFileSync, realpathSync, unlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { compareVersions, exactVersion } from "./approved-release.js";
+import { LEGACY_PACKAGE_NAME, readManifest } from "./config.js";
+import { AUTO_UPDATE_LABEL, defaultRun, enableAutoUpdate, launchAgentPath, scheduledPath, systemdUnitPaths, writeFileAtomic, } from "./runner-auto-update.js";
+import { CLAUDE_PATH_ENV, resolveClaude } from "./update-plugin.js";
+/** Long enough for an in-place update (under a minute on a Mac measured 2026-10-24), well inside the
+ *  installer's 600-second budget for the whole npm install. */
+export const BUSY_WAIT_MS = 240_000;
+const BUSY_POLL_MS = 5_000;
+const blockingSleep = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+const unxml = (value) => value.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&amp;/g, "&");
+/** The agent's command, from a plist this CLI wrote (launchAgentPlist). Anything else is unrecognized. */
+function plistProgram(text) {
+    const array = /<key>ProgramArguments<\/key>\s*<array>([\s\S]*?)<\/array>/.exec(text)?.[1];
+    if (array === undefined)
+        return null;
+    const args = [...array.matchAll(/<string>([\s\S]*?)<\/string>/g)].map((m) => unxml(m[1] ?? ""));
+    const env = (key) => {
+        const m = new RegExp(`<key>${key}</key>\\s*<string>([\\s\\S]*?)</string>`).exec(text);
+        return m ? unxml(m[1] ?? "") : null;
+    };
+    return programOf(args, env("PATH"), env(CLAUDE_PATH_ENV));
+}
+/** systemd's quoted words, as systemdUnits writes them. */
+function unitWords(line) {
+    return [...line.matchAll(/"((?:[^"\\]|\\.)*)"/g)].map((m) => (m[1] ?? "").replace(/\\(.)/g, "$1").replace(/%%/g, "%"));
+}
+function unitProgram(text) {
+    const lines = text.split("\n");
+    const exec = lines.find((l) => l.startsWith("ExecStart="));
+    if (exec === undefined)
+        return null;
+    const envs = lines.filter((l) => l.startsWith("Environment=")).flatMap((l) => unitWords(l));
+    const env = (key) => envs.find((e) => e.startsWith(`${key}=`))?.slice(key.length + 1) ?? null;
+    return programOf(unitWords(exec), env("PATH"), env(CLAUDE_PATH_ENV));
+}
+function programOf(args, path, claude) {
+    const [cli, ...rest] = args;
+    if (cli === undefined || !cli.startsWith("/") || rest.length !== 5)
+        return null;
+    const [a, b, c, d, dir] = rest;
+    if (a !== "runner" || b !== "update" || c !== "--auto" || d !== "--dir" || dir === undefined || !dir.startsWith("/"))
+        return null;
+    return { cli, dir, path, claude };
+}
+const real = (path) => {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return null;
+    }
+};
+const writable = (path) => {
+    try {
+        accessSync(path, constants.W_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/** The version of the catalyst package a command belongs to, or null when it is not one. */
+export function cliVersionAt(command) {
+    const resolved = real(command);
+    if (resolved === null)
+        return null;
+    let dir = dirname(resolved);
+    for (let i = 0; i < 4; i++) {
+        const manifest = join(dir, "package.json");
+        if (existsSync(manifest)) {
+            try {
+                const pkg = JSON.parse(readFileSync(manifest, "utf8"));
+                if (pkg.name === "@catalyst-cloud/cli" || pkg.name === LEGACY_PACKAGE_NAME)
+                    return exactVersion(pkg.version);
+            }
+            catch {
+                return null;
+            }
+            return null;
+        }
+        dir = dirname(dir);
+    }
+    return null;
+}
+/** Whether the macOS agent is idle, waiting up to the budget for a running update to finish. */
+function waitIdle(deps) {
+    const run = deps.run ?? defaultRun;
+    const sleep = deps.sleep ?? blockingSleep;
+    const target = `gui/${deps.uid ?? process.getuid?.() ?? 0}/${AUTO_UPDATE_LABEL}`;
+    for (let waited = 0;; waited += BUSY_POLL_MS) {
+        if (!/^\s*state = running\s*$/m.test(run("launchctl", ["print", target]).stdout))
+            return true;
+        if (waited >= (deps.busyWaitMs ?? BUSY_WAIT_MS))
+            return false;
+        sleep(BUSY_POLL_MS);
+    }
+}
+/** Put the agent file back and load it again, best effort, then drop the backup. */
+function restore(deps, platform, agent, original, backup) {
+    if (!existsSync(agent) || !readFileSync(agent).equals(original)) {
+        writeFileAtomic(agent, original.toString("utf8"));
+        const run = deps.run ?? defaultRun;
+        try {
+            if (platform === "darwin")
+                run("launchctl", ["bootstrap", `gui/${deps.uid ?? process.getuid?.() ?? 0}`, agent]);
+            else
+                run("systemctl", ["--user", "daemon-reload"]);
+        }
+        catch {
+            // the file is back; the scheduler picks it up at the next login or reload
+        }
+    }
+    unlinkSync(backup);
+}
+/** Point an older runner update agent at this install. Never throws. Every outcome for an agent this
+ *  CLI recognizes is also appended to the agent's own update.log: npm hides a postinstall's output on
+ *  a global install, so that log is where a person, or a later run, reads what happened. */
+export function repointAgent(deps) {
+    const seen = {};
+    const result = decide(deps, seen);
+    if (seen.dir !== undefined) {
+        try {
+            appendFileSync(join(seen.dir, "update.log"), `${new Date().toISOString()} ${logLine(result, deps.version)}\n`);
+        }
+        catch {
+            // the agent's log is a courtesy; the outcome is already decided
+        }
+    }
+    return result;
+}
+function decide(deps, seen) {
+    try {
+        const platform = deps.platform ?? process.platform;
+        let program;
+        let agent;
+        if (platform === "darwin") {
+            agent = launchAgentPath(deps.home);
+            if (!existsSync(agent))
+                return { action: "skipped", reason: "no_agent" };
+            program = plistProgram(readFileSync(agent, "utf8"));
+        }
+        else if (platform === "linux") {
+            agent = systemdUnitPaths(deps.home).service;
+            if (!existsSync(agent))
+                return { action: "skipped", reason: "no_agent" };
+            program = unitProgram(readFileSync(agent, "utf8"));
+        }
+        else {
+            return { action: "skipped", reason: "unsupported_platform" };
+        }
+        if (program === null)
+            return { action: "skipped", reason: "agent_unrecognized" };
+        seen.dir = program.dir;
+        const from = real(program.cli);
+        if (from !== null && from === real(deps.self))
+            return { action: "skipped", reason: "already_current" };
+        // A program that no longer exists runs nothing, so any working copy is better. One that exists
+        // moves only when it is a catalyst CLI older than this one.
+        let fromVersion = null;
+        if (from !== null) {
+            fromVersion = cliVersionAt(program.cli);
+            if (fromVersion === null)
+                return { action: "skipped", reason: "agent_cli_unrecognized" };
+            if (compareVersions(fromVersion, deps.version) >= 0)
+                return { action: "skipped", reason: "agent_cli_not_older" };
+        }
+        const canWrite = deps.canWrite ?? writable;
+        const files = platform === "linux" ? [agent, systemdUnitPaths(deps.home).timer].filter((f) => existsSync(f)) : [agent];
+        if (![...files, dirname(agent)].every(canWrite))
+            return { action: "skipped", reason: "agent_not_writable", agent };
+        // launchctl bootout stops a running job, and the daily job starts on the same quarter hour as the
+        // agent does: wait for an update in progress to finish rather than cut it off.
+        if (platform === "darwin" && !waitIdle(deps))
+            return { action: "skipped", reason: "agent_busy" };
+        const original = readFileSync(agent);
+        const backup = `${agent}.before-${deps.version}`;
+        copyFileSync(agent, backup);
+        let status;
+        try {
+            status = enableAutoUpdate({
+                platform,
+                home: deps.home,
+                uid: deps.uid,
+                cli: deps.self,
+                path: scheduledPath(deps.self, deps.nodeExecutable, program.path ?? deps.env.PATH),
+                claude: program.claude ?? resolveClaude(deps.home, deps.env),
+                run: deps.run,
+            }, program.dir);
+        }
+        finally {
+            // A repoint that did not take puts the agent back exactly as it was, and leaves no backup.
+            if (status?.state !== "on")
+                restore(deps, platform, agent, original, backup);
+        }
+        if (status.state !== "on")
+            return { action: "failed", detail: status.detail };
+        return { action: "repointed", from: program.cli, fromVersion, to: deps.self, backup };
+    }
+    catch (err) {
+        return { action: "failed", detail: (err instanceof Error ? err.message : String(err)).slice(0, 160) };
+    }
+}
+/** One line for the person, or null when there is nothing to say. */
+export function repointLine(result, version) {
+    if (result.action === "repointed")
+        return `catalyst: the runner update agent now runs ${result.to} (${version}) instead of ${result.from} (${result.fromVersion ?? "missing"}). The previous agent file is kept at ${result.backup}.`;
+    if (result.action === "skipped" && result.reason === "agent_not_writable")
+        return `catalyst: the runner update agent at ${result.agent} runs an older catalyst, and this install cannot change it. Ask whoever installed it to run: catalyst runner auto-update on`;
+    if (result.action === "skipped" && result.reason === "agent_busy")
+        return "catalyst: the runner update agent was busy updating, so it keeps its current catalyst until the next install. Or run: catalyst runner auto-update on";
+    if (result.action === "failed")
+        return `catalyst: could not point the runner update agent at this install (${result.detail}). Run: catalyst runner auto-update on`;
+    return null;
+}
+/** The update.log line for any outcome: the person's line, or for a quiet skip, its reason. */
+export function logLine(result, version) {
+    return repointLine(result, version) ?? `catalyst ${version}: the runner update agent was left as it is (${result.action === "skipped" ? result.reason : result.action}).`;
+}
+/** npm's postinstall, for a global install: this install's own command, version and node. */
+export function postinstallRepoint(env = process.env) {
+    const version = readManifest().version;
+    const linked = env.npm_config_prefix ? join(env.npm_config_prefix, "bin", "catalyst") : null;
+    const self = linked !== null && existsSync(linked) ? linked : fileURLToPath(new URL("../bin/catalyst.js", import.meta.url));
+    const home = env.HOME;
+    if (!home)
+        return null;
+    return repointLine(repointAgent({ home, self, version, nodeExecutable: process.execPath, env }), version);
+}

package/dist/runner-command.js

@@ -2,7 +2,7 @@ import { isAbsolute, resolve } from "node:path";
 import { flagBool, flagString, positionals } from "./args.js";
 import { CliError, UsageError } from "./errors.js";
 import { autoUpdateStatus, disableAutoUpdate, enableAutoUpdate, scheduledPath, } from "./runner-auto-update.js";
-import { dockerRunnerUpdateEngine, readReleaseState, RELEASE_COMPONENTS, runnerDir, runRunnerUpdate, updateResultLines, } from "./runner-update.js";
+import { dockerRunnerUpdateEngine, readReleaseState, RELEASE_COMPONENTS, runnerDir, runRunnerUpdate, updateResultLines, lastProblem, lastProblemLines, } from "./runner-update.js";
 import { dockerFleetUpdateEngine, runFleetUpdate } from "./runner-update-fleet.js";
 import { runUpdate, sharedReleaseRead, updateReportJson, updateReportLines } from "./update.js";
 import { effectivePolicy, readUpdatePolicy, setComponentPolicy } from "./update-policy.js";
@@ -140,12 +140,14 @@ export async function cmdRunner(args, ctx, deps = {}) {
                         ctx.stdout(line);
                 return result.exitCode;
             }
+            // A check also names the last failed or rolled-back update, which a clean read would hide (CTC-6709).
+            const state = readReleaseState(dir());
             if (args.json) {
                 const { schemaVersion, release, components, projects } = updateReportJson(report);
-                ctx.stdout(JSON.stringify({ ...result, schemaVersion, release, components, projects }));
+                ctx.stdout(JSON.stringify({ ...result, schemaVersion, release, components, projects, lastProblem: lastProblem(state) }));
             }
             else
-                for (const line of [...updateResultLines(result), ...updateReportLines(report)])
+                for (const line of [...updateResultLines(result), ...lastProblemLines(state), ...updateReportLines(report)])
                     ctx.stdout(line);
             return result.exitCode;
         }

package/dist/runner-update.js

@@ -604,6 +604,20 @@ const OUTCOME_TEXT = {
     rolled_back: "The new supervisor did not become ready, so the previous images were restored.",
     failed: "The update could not finish. Look at the runner with docker compose ps.",
 };
+/** The last run's record when it ended badly: a failed or rolled-back update a person should know
+ *  about even after a later check reads clean (CTC-6709). Null otherwise. */
+export function lastProblem(state) {
+    const last = state.last;
+    return last !== null && (last.outcome === "failed" || last.outcome === "rolled_back") ? last : null;
+}
+/** One line naming the last failed or rolled-back update, for `runner update --check`. */
+export function lastProblemLines(state) {
+    const last = lastProblem(state);
+    if (last === null)
+        return [];
+    const what = last.outcome === "rolled_back" ? "was rolled back" : "failed";
+    return [`The last update, at ${new Date(last.atMs).toISOString()}, ${what} (${last.detail}; offered generation ${last.generation ?? "none"}).`];
+}
 export function updateResultLines(result) {
     return [
         OUTCOME_TEXT[result.outcome],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@catalyst-cloud/cli",
-  "version": "0.16.34",
+  "version": "0.16.35",
   "description": "Set up Catalyst Cloud, check your tickets and manage your account from the command line.",
   "license": "MIT",
   "type": "module",
@@ -39,6 +39,7 @@
     "typecheck": "tsc --noEmit",
     "build": "tsc -p tsconfig.build.json",
     "prepare": "tsc -p tsconfig.build.json",
+    "postinstall": "node bin/postinstall.js",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "version:sync": "node scripts/sync-plugin-version.mjs",

package/skills/catalyst-github/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Catalyst's GitHub: show a ticket's pull request with its checks, reviews and review threads, say whether it is mergeable under this repository's policy, and explain what a PR accumulates as the ticket moves (the branch, the draft, the rewrite, the force-pushes, the labels, the queue). Use when someone asks "show me the PR", "what are the checks saying", "why hasn't it merged", "what does the queue need", "what does that label mean", or wants the branch and merge conventions Catalyst follows.
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.34 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.35 — written in this repository for customer accounts -->
 
 # Catalyst's GitHub
 

package/skills/catalyst-linear/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Catalyst's view of Linear on the customer's own cloud account. Reads a ticket with its comments, relations, labels, linked pull requests and agent sessions inline, from the cloud API by default, with local replica reads available as an explicit opt-in, always naming the source; searches tickets, PRs, projects and initiatives; writes comments, card moves, labels and new tickets through the account's agent proxy as the app actor, with every route, stage id, label id and marker read from the account's contract. Knows what a ticket accumulates as Catalyst works it (phase-outcome comments, the document per phase, the agent session, the labels, the single blocks relation, the bookkeeping marker, the eyes acknowledgement). Use when a person says "show me the ticket", "what did Catalyst write on it", "comment on it", "move it", "label it" or "file a ticket". Not for raising a decision for a human (what-needs-me) and not for pull requests (catalyst-github).
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.34 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.35 — written in this repository for customer accounts -->
 
 # Catalyst Linear
 

package/skills/catalyst-onboard/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Set up Catalyst Cloud and say whether setup is working. Walks a person from nothing to their first ticket running, one step at a time: the coding account, the project, the integrations and connected accounts, each repository's settings file, then one real ticket moving. Also logs this machine in, reads the readiness verdict with who can fix each failure, and checks the optional local replica. Use when someone says "set me up", "onboard me", "I just signed up", "get me started", "what do I do first", "log me in", "which account is this machine on", "am I set up", "what is missing", "why does nothing happen" or "is the replica running", when a login expired, or when a skill script exits 2 saying this machine is not connected. Does every step a key can do through the catalyst CLI, hands over the exact page for the steps only a browser can do, and never claims a step it did not watch succeed.
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.34 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.35 — written in this repository for customer accounts -->
 
 # Onboard me
 

package/skills/run-this-project/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Own one Catalyst Cloud project end to end until it closes. Use when the person says "run this project for me", "own this until it ships", "keep this moving", or hands you a project id or a set of tickets to drive. Subscribes to the account's event stream for the scope through the catalyst CLI, reacts to each change in the same turn, makes tickets ready and moves them to dispatch, parks what should stop, chases stalls, escalates inward, and keeps one status summary current. Writes to Linear as the app actor; never polls.
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.34 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.35 — written in this repository for customer accounts -->
 
 # Run this project
 

package/skills/unstick/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Get a stuck Catalyst Cloud ticket moving again. Use when the person asks "why is this parked and can you release it?", "unpark this", "get things flowing again", "the outage is over, retry what failed", or hands you a ticket that is not moving. Reads why nothing runs and what holds the ticket through the catalyst CLI, decides whether the recorded cause is fixed, previews the release, releases every governor holding the ticket the right way (or one failure class across a team), and raises an ask only for what a person has to do. Never releases a cause it cannot show changed without saying so.
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.34 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.35 — written in this repository for customer accounts -->
 
 # Unstick
 

package/skills/what-needs-me/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   The human's decision inbox on Catalyst Cloud, and the one way an agent raises a decision on their behalf. Use when the person asks "what needs me?", "what am I blocking?", or when active work is gated on a choice only they can make. Lists open asks ranked by how much open work each one holds, files an ask through the cloud's ask route with the account's own template, and records the answer so the held work releases. Never answers as the human, never duplicates an open ask.
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.34 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.35 — written in this repository for customer accounts -->
 
 # What needs me
 

package/skills/what-this-repo-needs/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   What environment variable names does this repository need, and where does each one come from? Scans the repository offline (no login, no network) and lists the names in three groups (build/test, deploy-only, bindings), each with where it was found, what uses it, and where a local value would come from. Never reads a value or prints one. Also checks the environment variable table in `.catalyst/catalyst.toml` offline. Use when someone asks "what does catalyst.env.json mean", "what env vars does this repo need", "why does the container need this", or before reviewing or writing the declaration.
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.34 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.35 — written in this repository for customer accounts -->
 
 # What this repository needs
 

package/skills/whats-happening/SKILL.md

@@ -4,7 +4,7 @@ description: >-
   Use for "what's happening?", "what machines do we have?", "how much capacity do we have?", "where are we?", "why is that stuck?", "what closed?", "what's next?", "how does this work?", "why did it do that?", "how does it prioritise?" and "what does this setting do, where is it set?" in Catalyst Cloud, or asks for something to be done rather than known. Reads the contract via catalyst CLI. Read-only: route work/decisions, never answer as the human.
 allowed-tools: Bash(catalyst:*) Bash(npx -p @catalyst-cloud/cli catalyst:*)
 ---
-<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.34 — written in this repository for customer accounts -->
+<!-- vendored-from: @catalyst-cloud/catalyst-skills@0.16.35 — written in this repository for customer accounts -->
 
 # What's happening