@bli-cockpit/cli 0.1.17 → 0.1.18

package/README.md

@@ -40,17 +40,20 @@ staging, a custom dashboard, or deliberately forcing a different dashboard
 pairing. Already-onboarded users update with
 `npm install -g @bli-cockpit/cli@latest`, then run
 `cockpit sync --workspace "$PWD" --json`. `--repo <path>` remains supported
-for older prompts and the Codex ticket-binding guardrail.
+for older prompts and the agent ticket-binding guardrail.
 
-On machines where Codex agents will do ticketed work, install the user-scope
-agent rule once:
+On machines where Codex or Claude agents will do ticketed work, install the
+user-scope agent rule once:
 
 ```bash
 cockpit agent-rules install
 ```
 
-That updates `~/.codex/AGENTS.md` with the Cockpit rule to bind known Linear
-tickets before edits, or ask once when the ticket ID is missing.
+That updates `~/.codex/AGENTS.md` and `~/.claude/CLAUDE.md` with the Cockpit
+rule to bind known Linear tickets before edits, or ask once when the ticket ID
+is missing. That binding starts attributing the session's work to the specific
+ticket in Cockpit. It checks for the managed block first, so current files are
+left unchanged and stale managed blocks are replaced.
 
 Parent mode scans child git repos/worktrees (3 folder levels deep, up to 50
 repos by default — tune with `--max-depth` / `--max-repos`; a warning prints

package/dist/agent-rules.js

@@ -4,56 +4,88 @@ import path from "node:path";
 const MANAGED_BLOCK_START = "<!-- BLI_COCKPIT_AGENT_RULES:START -->";
 const MANAGED_BLOCK_END = "<!-- BLI_COCKPIT_AGENT_RULES:END -->";
 export async function installCodexAgentRules(options = {}) {
-    const agentsFile = codexAgentsFile(options.homeDir);
+    return installAgentRulesForHost("codex", options);
+}
+export async function installClaudeAgentRules(options = {}) {
+    return installAgentRulesForHost("claude", options);
+}
+export async function installAgentRules(options = {}) {
+    const targets = await Promise.all(targetHosts(options.hosts).map((host) => installAgentRulesForHost(host, options)));
+    return aggregateAgentRulesResult(targets);
+}
+async function installAgentRulesForHost(host, options = {}) {
+    const rulesFile = agentRulesFile(host, options.homeDir);
     const block = cockpitAgentRulesBlock();
     let existing = "";
     let existed = true;
     try {
-        existing = await readFile(agentsFile, "utf8");
+        existing = await readFile(rulesFile, "utf8");
     }
     catch {
         existed = false;
     }
     const next = upsertManagedBlock(existing, block);
     if (next === existing) {
-        return { status: "unchanged", agents_file: agentsFile, block };
+        return agentRulesResult(host, rulesFile, "unchanged", block);
     }
-    await mkdir(path.dirname(agentsFile), { recursive: true });
-    await writeFile(agentsFile, next, "utf8");
-    return { status: existed ? "updated" : "created", agents_file: agentsFile, block };
+    await mkdir(path.dirname(rulesFile), { recursive: true });
+    await writeFile(rulesFile, next, "utf8");
+    return agentRulesResult(host, rulesFile, existed ? "updated" : "created", block);
 }
 export async function uninstallCodexAgentRules(options = {}) {
-    const agentsFile = codexAgentsFile(options.homeDir);
+    return uninstallAgentRulesForHost("codex", options);
+}
+export async function uninstallClaudeAgentRules(options = {}) {
+    return uninstallAgentRulesForHost("claude", options);
+}
+export async function uninstallAgentRules(options = {}) {
+    const targets = await Promise.all(targetHosts(options.hosts).map((host) => uninstallAgentRulesForHost(host, options)));
+    return aggregateAgentRulesResult(targets);
+}
+async function uninstallAgentRulesForHost(host, options = {}) {
+    const rulesFile = agentRulesFile(host, options.homeDir);
     const block = cockpitAgentRulesBlock();
     let existing = "";
     try {
-        existing = await readFile(agentsFile, "utf8");
+        existing = await readFile(rulesFile, "utf8");
     }
     catch {
-        return { status: "missing", agents_file: agentsFile, block };
+        return agentRulesResult(host, rulesFile, "missing", block);
     }
     const next = removeManagedBlock(existing);
     if (next === existing) {
-        return { status: "missing", agents_file: agentsFile, block };
+        return agentRulesResult(host, rulesFile, "missing", block);
     }
-    await writeFile(agentsFile, next, "utf8");
-    return { status: "updated", agents_file: agentsFile, block };
+    await writeFile(rulesFile, next, "utf8");
+    return agentRulesResult(host, rulesFile, "updated", block);
 }
 export async function inspectCodexAgentRules(options = {}) {
-    const agentsFile = codexAgentsFile(options.homeDir);
+    return inspectAgentRulesForHost("codex", options);
+}
+export async function inspectClaudeAgentRules(options = {}) {
+    return inspectAgentRulesForHost("claude", options);
+}
+export async function inspectAgentRules(options = {}) {
+    const targets = await Promise.all(targetHosts(options.hosts).map((host) => inspectAgentRulesForHost(host, options)));
+    return {
+        ...aggregateAgentRulesResult(targets),
+        installed: targets.every((target) => target.installed),
+    };
+}
+async function inspectAgentRulesForHost(host, options = {}) {
+    const rulesFile = agentRulesFile(host, options.homeDir);
     const block = cockpitAgentRulesBlock();
     let existing = "";
     try {
-        existing = await readFile(agentsFile, "utf8");
+        existing = await readFile(rulesFile, "utf8");
     }
     catch {
-        return { status: "missing", agents_file: agentsFile, block, installed: false };
+        return { ...agentRulesResult(host, rulesFile, "missing", block), installed: false };
     }
+    const installed = hasManagedBlock(existing);
     return {
-        status: hasManagedBlock(existing) ? "unchanged" : "missing",
-        agents_file: agentsFile,
-        block,
-        installed: hasManagedBlock(existing),
+        ...agentRulesResult(host, rulesFile, installed ? "unchanged" : "missing", block),
+        installed,
     };
 }
 export function cockpitAgentRulesBlock() {
@@ -61,7 +93,7 @@ export function cockpitAgentRulesBlock() {
         MANAGED_BLOCK_START,
         "## Cockpit Ticket Binding",
         "",
-        "- For implementation, debugging, review, PR, or ship work tied to a clear Linear ticket, run `cockpit start --ticket <ticket-id> --repo \"$PWD\"` before the first code edit or mutating tool call.",
+        "- For implementation, debugging, review, PR, or ship work tied to a clear Linear ticket, run `cockpit start --ticket <ticket-id> --repo \"$PWD\"` before the first code edit or mutating tool call. This starts attributing the session's work to that specific ticket in Cockpit.",
         "- Use `--ticket`; do not invent `--ticketId` or other flag shapes.",
         "- If the user mentions ticketed work but no ticket ID is visible, ask once for the Linear ticket ID before editing. Agents cannot reliably infer it from context.",
         "- If there is truly no ticket, state that the work remains in general ambient capture and do not invent a ticket.",
@@ -86,9 +118,36 @@ export function removeManagedBlock(contents) {
         return contents;
     return contents.replace(managedBlockPattern(), "").replace(/\n{3,}/gu, "\n\n").trimEnd() + "\n";
 }
-function codexAgentsFile(homeDir = os.homedir()) {
+function agentRulesFile(host, homeDir = os.homedir()) {
+    if (host === "claude") {
+        return path.join(homeDir, ".claude", "CLAUDE.md");
+    }
     return path.join(homeDir, ".codex", "AGENTS.md");
 }
+function agentRulesResult(host, rulesFile, status, block) {
+    return {
+        host,
+        status,
+        rules_file: rulesFile,
+        agents_file: rulesFile,
+        block,
+    };
+}
+function targetHosts(hosts) {
+    return hosts && hosts.length > 0 ? hosts : ["codex", "claude"];
+}
+function aggregateAgentRulesResult(targets) {
+    if (targets.every((target) => target.status === "unchanged")) {
+        return { status: "unchanged", targets };
+    }
+    if (targets.every((target) => target.status === "missing")) {
+        return { status: "missing", targets };
+    }
+    if (targets.every((target) => target.status === "created")) {
+        return { status: "created", targets };
+    }
+    return { status: "updated", targets };
+}
 function managedBlockPattern() {
     return new RegExp(`${escapeRegExp(MANAGED_BLOCK_START)}[\\s\\S]*?${escapeRegExp(MANAGED_BLOCK_END)}`, "u");
 }

package/dist/commands/local-args.js

@@ -345,8 +345,8 @@ function parseAutostartArgs(args) {
 }
 function parseAgentRulesArgs(args) {
     const values = parseNamedArgs(args, {
-        allowedFlags: ["--home", "--json"],
-        valueFlags: ["--home"],
+        allowedFlags: ["--home", "--host", "--json"],
+        valueFlags: ["--home", "--host"],
     });
     if (values.positionals.length > 1) {
         throw new Error("agent-rules accepts at most one action (install|uninstall|status).");
@@ -358,10 +358,17 @@ function parseAgentRulesArgs(args) {
     return {
         kind: "agent-rules",
         action,
+        host: parseAgentRulesHost(values.flags.get("--host")),
         homeDir: optionalNonEmpty(values.flags.get("--home")),
         json: values.booleans.has("--json"),
     };
 }
+function parseAgentRulesHost(value) {
+    const host = value?.trim().toLowerCase() || "all";
+    if (host === "codex" || host === "claude" || host === "all")
+        return host;
+    throw new Error("agent-rules --host must be codex, claude, or all.");
+}
 function parseNamedArgs(args, options) {
     const allowed = new Set(options.allowedFlags);
     const valueFlags = new Set(options.valueFlags);

package/dist/commands/local.js

@@ -2,7 +2,7 @@ import { execFile } from "node:child_process";
 import os from "node:os";
 import path from "node:path";
 import { createCollectorServer } from "../server.js";
-import { inspectCodexAgentRules, installCodexAgentRules, uninstallCodexAgentRules, } from "../agent-rules.js";
+import { inspectAgentRules, installAgentRules, uninstallAgentRules, } from "../agent-rules.js";
 import { parseLocalArgs, normalizeUrl } from "./local-args.js";
 import { autostartStatus, installAutostartAgent, uninstallAutostartAgent } from "../autostart.js";
 import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, inspectLocalCollectorStatus, installLocalCollector, logoutLocalCollector, pairLocalCollector, readLocalCollectorSessionFile, readLocalSessionReference, startLocalWorkContext } from "../local-state.js";
@@ -86,7 +86,7 @@ export function localCommandHelp(command) {
         "  cockpit sessions [--source codex|claude] [--workspace <path>] [--max-depth <n>] [--max-repos <n>] [--json]",
         "  cockpit serve [--port <port>] [--workspace <path>]",
         "  cockpit autostart [install|uninstall|status] [--workspace <path>] [--dashboard-url <url>] [--interval-seconds <n>] [--json]",
-        "  cockpit agent-rules [install|uninstall|status] [--json]",
+        "  cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--json]",
         "",
         `Default dashboard: ${DEFAULT_DASHBOARD_URL}. Omit --dashboard-url for normal production use; pass it only for staging/custom dashboards or to force a different pairing.`,
     ].join("\n");
@@ -208,11 +208,13 @@ function localSubcommandHelp(command) {
         [
             "agent-rules",
             [
-                "Usage: cockpit agent-rules [install|uninstall|status] [--json]",
+                "Usage: cockpit agent-rules [install|uninstall|status] [--host codex|claude|all] [--json]",
                 "",
-                "Installs a managed Cockpit Ticket Binding block into ~/.codex/AGENTS.md.",
-                "This gives Codex agents a user-scope rule to run `cockpit start --ticket <id>`",
-                "before ticketed implementation work, or ask once when the ticket ID is missing.",
+                "Installs a managed Cockpit Ticket Binding block into ~/.codex/AGENTS.md",
+                "and ~/.claude/CLAUDE.md by default. Pass --host to manage only one.",
+                "This gives Codex and Claude agents a user-scope rule to run",
+                "`cockpit start --ticket <id>` before ticketed implementation work, or ask",
+                "once when the ticket ID is missing.",
                 "Action defaults to `install`.",
             ],
         ],
@@ -1032,39 +1034,47 @@ async function runAutostart(command, io) {
     return result.status === "unsupported" ? 1 : 0;
 }
 async function runAgentRules(command, io) {
+    const hosts = agentRuleHosts(command.host);
     const result = command.action === "install"
-        ? await installCodexAgentRules({ homeDir: command.homeDir })
+        ? await installAgentRules({ homeDir: command.homeDir, hosts })
         : command.action === "uninstall"
-            ? await uninstallCodexAgentRules({ homeDir: command.homeDir })
-            : await inspectCodexAgentRules({ homeDir: command.homeDir });
+            ? await uninstallAgentRules({ homeDir: command.homeDir, hosts })
+            : await inspectAgentRules({ homeDir: command.homeDir, hosts });
     if (command.json) {
         writeLine(io.stdout, JSON.stringify(result, null, 2));
         return 0;
     }
     if ("installed" in result) {
         writeLine(io.stdout, result.installed
-            ? "Cockpit Codex agent rules are installed."
-            : "Cockpit Codex agent rules are not installed.");
+            ? "Cockpit agent rules are installed."
+            : "Cockpit agent rules are not installed.");
     }
     else {
-        switch (result.status) {
-            case "created":
-                writeLine(io.stdout, "Cockpit Codex agent rules installed.");
-                break;
-            case "updated":
-                writeLine(io.stdout, "Cockpit Codex agent rules updated.");
-                break;
-            case "unchanged":
-                writeLine(io.stdout, "Cockpit Codex agent rules already current.");
-                break;
-            case "missing":
-                writeLine(io.stdout, "Cockpit Codex agent rules were not installed.");
-                break;
-        }
+        writeLine(io.stdout, agentRulesStatusLine(result));
+    }
+    for (const target of result.targets) {
+        writeLine(io.stdout, `${agentRuleHostLabel(target.host)}: ${target.rules_file}`);
     }
-    writeLine(io.stdout, `AGENTS.md: ${result.agents_file}`);
     return 0;
 }
+function agentRuleHosts(host) {
+    return host === "all" ? ["codex", "claude"] : [host];
+}
+function agentRulesStatusLine(result) {
+    switch (result.status) {
+        case "created":
+            return "Cockpit agent rules installed.";
+        case "updated":
+            return "Cockpit agent rules updated.";
+        case "unchanged":
+            return "Cockpit agent rules already current.";
+        case "missing":
+            return "Cockpit agent rules were not installed.";
+    }
+}
+function agentRuleHostLabel(host) {
+    return host === "claude" ? "CLAUDE.md" : "AGENTS.md";
+}
 function writeAutostartResult(io, result) {
     switch (result.status) {
         case "installed":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.1.17",
+  "version": "0.1.18",
   "private": false,
   "type": "module",
   "bin": {