@armstrongnate/april 0.1.4 → 0.2.0

package/README.md

@@ -110,18 +110,54 @@ Healthy logs include `Starting webhook forwarder for <repo>` and no immediate er
 
 ## Commands
 
+### Setup & service
+
 | Command | What it does |
 | --- | --- |
-| `april init` | Copies the bundled `config.example.yaml` to `~/.config/april/config.yaml` and the `issue-worker` skill to the configured agent's skill dir (`~/.claude/skills/` for claude, `~/.agents/skills/` for codex). **Only writes files that don't already exist** — never overwrites. |
+| `april init` | Copies the bundled `config.example.yaml` to `~/.config/april/config.yaml` and the bundled skills (`issue-worker`, `issue-investigator`) to the configured agent's skill dir (`~/.claude/skills/` for claude, `~/.agents/skills/` for codex). **Only writes files that don't already exist** — never overwrites. |
 | `april install` | Installs and starts the user service. Pass `--print` to see the unit/plist without writing it. |
-| `april install-skill [-y]` | Install or refresh the issue-worker skill. Prompts before overwriting an existing copy; `--yes` skips the prompt (use in non-interactive scripts). |
-| `april upgrade [VER]` | Upgrade the npm package, regenerate the unit, restart the service, and reconcile the skill. |
+| `april install-skill [-y]` | Install or refresh the bundled skills. Prompts before overwriting a changed copy; `--yes` skips the prompt (use in non-interactive scripts). |
+| `april upgrade [VER]` | Upgrade the npm package, regenerate the unit, restart the service, and reconcile the skills. |
 | `april uninstall` | Stops and removes the service. |
 | `april start` / `stop` / `restart` | Lifecycle. |
 | `april status` | Shows service status. |
 | `april logs -f [-n N]` | Streams logs. `-n` sets line count (default 100). |
 | `april daemon` | Runs the worker in the foreground (for debugging; the service uses `dist/index.js` directly). |
 
+### Runtime & work
+
+These run **in-process** against the filesystem, the session backend, and `gh` — so they work whether or not the daemon is running. State is derived from `.worktrees/gh-*` dirs and live sessions, not from daemon memory.
+
+| Command | What it does |
+| --- | --- |
+| `april ps [--json]` | Lists active work — issues in flight and `inv-` investigations — with session liveness and the owning repo. Shows a daemon-liveness line (uptime, forwarders) when the daemon's `/status` endpoint is reachable. |
+| `april config [--path\|--validate\|--json]` | Prints the resolved config and its path. `--validate` exits non-zero if invalid; `--path` prints just the path; `--json` emits JSON. |
+| `april doctor` | Health checklist without starting the daemon: config validity, required tools on PATH, `gh-webhook` extension, `gh` auth, repo paths, service unit, daemon reachability, and (Linux) linger. Exits non-zero on hard failures. |
+| `april run <issue> [--repo O/N]` | Manually start work on an issue (`123` or `owner/name#123`) — the same path the daemon takes on a labeled webhook, minus the label requirement. `--repo` disambiguates a bare number across repos. |
+| `april cancel <issue> [--requeue]` | Stop an issue's work: kill the session and remove the worktree, and remove the `agent:wip` label. `--requeue` re-adds `agent:todo` so the daemon picks it up again. |
+| `april kill <slug\|issue> [--worktree]` | Kill a single session by slug or issue number (handles `inv-` investigations too). `--worktree` also removes the backing worktree. |
+| `april clean [--force] [--repo O/N]` | Prune orphaned worktrees — stale (no live session) work whose issue is **closed** and has **no open PR**. Dry run unless `--force`; anything in progress or in review is kept. |
+| `april investigate "<problem>" [--repo O/N] [--auto]` | Dispatch a research agent in the current directory to investigate a problem and file a GitHub issue. See [Investigate](#investigate) below. |
+
+## Investigate
+
+`april investigate` is the front half of the loop: it turns a vague problem into a well-scoped GitHub issue, which the daemon can then pick up and implement.
+
+```bash
+april investigate "study space pull-to-refresh shows a duplicate spinner on ios"
+```
+
+It spawns a research agent (using the configured `llm` and the bundled `issue-investigator` skill) **in the current working directory** — which need not be a repo, and may be your home directory. This is deliberate: an investigation can span repos, and the owning repo isn't always known up front. The agent reads the configured repos' local checkouts and uses `gh` to research, decides where the work belongs, and files the issue there.
+
+Each investigation runs as its own session (named `inv-…`), so it shows up in `april ps` and can be torn down with `april kill <slug>`.
+
+**Modes:**
+
+- **Deferred (default).** The agent creates the issue assigned to you, *without* the trigger label, and prints the URL. You review it and label it `agent:todo` when you're ready to hand it to the daemon. This matches the usual discovery → review → handoff flow.
+- **`--auto`.** The agent also applies the trigger label, so the daemon picks the issue up and starts implementation immediately — one command goes from prompt → research → issue → PR.
+
+Use `--repo OWNER/NAME` to suggest the owning repo (the agent still decides), and `--dry-run` to print the session name and the exact prompt that would be dispatched without spawning anything.
+
 ## Environment variables
 
 The daemon reads extra env vars from `~/.config/april/env`. One `KEY=VALUE` per line, `#` for comments, optional double-quotes around values:
@@ -168,7 +204,7 @@ codex:
 | Skill install dir | `~/.claude/skills/` | `~/.agents/skills/` |
 | Default approval behavior | `permissionMode: "auto"` | `askForApproval: "never"` |
 
-The bundled `issue-worker` skill is the same SKILL.md for both; april just installs it under the right tree based on `llm`. Switching agents later: edit `config.yaml`, then run `april install-skill && april restart`.
+The bundled skills (`issue-worker`, used by the daemon; `issue-investigator`, used by `april investigate`) are the same SKILL.md for both agents; april just installs them under the right tree based on `llm`. Switching agents later: edit `config.yaml`, then run `april install-skill && april restart`.
 
 ## Service backend
 

package/dist/cli.js

@@ -3,31 +3,58 @@ import { backend } from "./service/index.js";
 import { run as runInit } from "./commands/init.js";
 import { run as runUpgrade } from "./commands/upgrade.js";
 import { run as runInstallSkill } from "./commands/install-skill.js";
+import { run as runConfig } from "./commands/config.js";
+import { run as runDoctor } from "./commands/doctor.js";
+import { run as runPs } from "./commands/ps.js";
+import { run as runRunIssue } from "./commands/run-issue.js";
+import { run as runCancel } from "./commands/cancel.js";
+import { run as runKill } from "./commands/kill.js";
+import { run as runClean } from "./commands/clean.js";
+import { run as runInvestigate } from "./commands/investigate.js";
 const HELP = `april — issue worker
 
 Usage:
   april <command> [options]
 
-Commands:
-  init              Copy bundled config, skill, and env file if missing.
+Setup:
+  init              Copy bundled config, skills, and env file if missing.
   install [--print] Install and start the user service. --print emits the unit/plist to stdout instead.
-  install-skill [-y] Install or refresh the issue-worker skill. Prompts before overwriting an existing
+  install-skill [-y] Install or refresh the bundled skills. Prompts before overwriting a changed
                     one; --yes (-y) skips the prompt.
-  upgrade [VER]     Upgrade the npm package, regenerate the unit, restart, and reconcile the skill.
+  upgrade [VER]     Upgrade the npm package, regenerate the unit, restart, and reconcile the skills.
                     VER defaults to "latest". --with npm|pnpm|yarn overrides the package manager.
   uninstall         Stop and remove the user service
+
+Service lifecycle:
   start             Start the service
   stop              Stop the service
   restart           Restart the service
   status            Show service status
   logs [-f] [-n N]  Show service logs (-f to follow, -n lines, default 100)
   daemon            Run april in the foreground (used by the service; rarely invoked directly)
+
+Runtime:
+  ps [--json]       List active work (issues in flight + investigations).
+  config [--path|--validate|--json]
+                    Print/validate the resolved config.
+  doctor            Check prereqs and health (config, tools, gh auth, repos, service, daemon).
+
+Work:
+  run <issue>       Manually start work on an issue (123 or owner/name#123). --repo to disambiguate.
+  cancel <issue>    Stop an issue's work (kill session + remove worktree). --requeue re-adds agent:todo.
+  kill <slug|issue> Kill one session (incl. investigations). --worktree also removes the worktree.
+  clean [--force]   Prune orphaned worktrees (closed issue, no open PR). Dry run unless --force.
+  investigate, inv "<problem>" [--repo O/N] [--auto]
+                    Dispatch a research agent in the current dir to investigate a problem and file
+                    a GitHub issue. Deferred (review) by default; --auto labels it for pickup.
+
+Meta:
   help              Show this help
   version           Show version
 
 Notes:
   Nothing is ever overwritten silently. To reset config, delete ~/.config/april/config.yaml
-  and re-run init. To refresh the skill, use install-skill (it prompts before overwriting).
+  and re-run init. To refresh skills, use install-skill (it prompts before overwriting).
 `;
 function parseLogsArgs(args) {
     let follow = false;
@@ -83,6 +110,30 @@ async function main() {
     if (cmd === "install-skill") {
         return await runInstallSkill(rest);
     }
+    if (cmd === "config") {
+        return runConfig(rest);
+    }
+    if (cmd === "doctor") {
+        return await runDoctor(rest);
+    }
+    if (cmd === "ps") {
+        return await runPs(rest);
+    }
+    if (cmd === "run") {
+        return await runRunIssue(rest);
+    }
+    if (cmd === "cancel") {
+        return await runCancel(rest);
+    }
+    if (cmd === "kill") {
+        return await runKill(rest);
+    }
+    if (cmd === "clean") {
+        return await runClean(rest);
+    }
+    if (cmd === "investigate" || cmd === "inv") {
+        return await runInvestigate(rest);
+    }
     if (cmd === "daemon") {
         // Run the long-running process inline. Importing index.js triggers main();
         // we then hang forever and let its SIGINT/SIGTERM handlers terminate the process.

package/dist/commands/cancel.js

@@ -0,0 +1,72 @@
+import { execFileSync } from "node:child_process";
+import { findConfigPath, parseConfigFile } from "../config.js";
+import { handlePrClosed } from "../spawner.js";
+import { parseIssueRef, resolveRepo, resolveActiveSlug } from "../work.js";
+const USAGE = `april cancel <issue> [--repo OWNER/NAME] [--requeue]
+
+  Stop work on an issue: kill its session and remove its worktree.
+  Removes the agent:wip label so it won't look in-flight.
+
+  <issue>      123, #123, or owner/name#123
+  --repo       Repo to act on when <issue> is a bare number and multiple are configured.
+  --requeue    Re-add agent:todo so the daemon picks it up again.`;
+function editLabels(repo, issueNumber, requeue) {
+    const args = [
+        "issue", "edit", String(issueNumber),
+        "--repo", `${repo.owner}/${repo.name}`,
+        "--remove-label", "agent:wip",
+    ];
+    if (requeue)
+        args.push("--add-label", "agent:todo");
+    try {
+        execFileSync("gh", args, { timeout: 15_000, stdio: "pipe" });
+        console.log(`Labels updated: removed agent:wip${requeue ? ", added agent:todo" : ""}`);
+    }
+    catch (err) {
+        console.warn(`Could not update labels: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+export async function run(args) {
+    let ref;
+    let repoFlag;
+    let requeue = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--repo") {
+            repoFlag = args[++i];
+            if (!repoFlag)
+                throw new Error("--repo requires a value");
+        }
+        else if (a === "--requeue") {
+            requeue = true;
+        }
+        else if (a.startsWith("--")) {
+            console.error(`Unknown option: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+        else if (!ref) {
+            ref = a;
+        }
+        else {
+            console.error(`Unexpected argument: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+    }
+    if (!ref) {
+        console.error(`Missing issue reference.\n\n${USAGE}`);
+        return 2;
+    }
+    const config = parseConfigFile(findConfigPath());
+    const { repoRef, number } = parseIssueRef(ref);
+    const repo = resolveRepo(config, repoFlag ?? repoRef);
+    const slug = await resolveActiveSlug(repo, number, config);
+    if (!slug) {
+        console.log(`Nothing active for ${repo.owner}/${repo.name}#${number}.`);
+        return 0;
+    }
+    console.log(`Cancelling ${repo.owner}/${repo.name}#${number} (${slug})…`);
+    await handlePrClosed(repo, slug, config);
+    editLabels(repo, number, requeue);
+    console.log("Done.");
+    return 0;
+}

package/dist/commands/clean.js

@@ -0,0 +1,118 @@
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+import { findConfigPath, parseConfigFile } from "../config.js";
+import { getSessionBackend } from "../session/index.js";
+import { listActiveWork } from "../work.js";
+const execFileP = promisify(execFile);
+const USAGE = `april clean [--repo OWNER/NAME] [--force]
+
+  Prune orphaned worktrees — stale (no live session) work whose issue is closed
+  on GitHub and has no open PR. Conservative by design: anything in progress,
+  still open, or in review (open PR) is kept.
+
+  --repo     Limit to one repo.
+  --force    Actually remove. Without it, clean only reports (dry run).`;
+async function gh(repoKey, args) {
+    const { stdout } = await execFileP("gh", ["--repo", repoKey, ...args], { timeout: 30_000 });
+    return stdout;
+}
+async function classify(item) {
+    if (item.kind === "investigation")
+        return { action: "keep", reason: "investigation (running)" };
+    if (item.sessionAlive)
+        return { action: "keep", reason: "session live" };
+    if (!item.worktreePath || !item.repo)
+        return { action: "keep", reason: "no worktree" };
+    if (!item.issueNumber)
+        return { action: "keep", reason: "no issue number" };
+    // Stale worktree — cross-reference GitHub before declaring it an orphan.
+    const [stateOut, prOut] = await Promise.allSettled([
+        gh(item.repo, ["issue", "view", String(item.issueNumber), "--json", "state"]),
+        gh(item.repo, ["pr", "list", "--head", item.slug, "--state", "open", "--json", "number"]),
+    ]);
+    if (stateOut.status !== "fulfilled")
+        return { action: "keep", reason: "issue state unknown" };
+    const state = JSON.parse(stateOut.value).state?.toLowerCase();
+    if (state !== "closed")
+        return { action: "keep", reason: `issue ${state ?? "?"}` };
+    if (prOut.status !== "fulfilled")
+        return { action: "keep", reason: "PR state unknown" };
+    if (JSON.parse(prOut.value).length > 0)
+        return { action: "keep", reason: "open PR" };
+    return { action: "remove", reason: "issue closed, no open PR" };
+}
+function removeWorktree(config, item) {
+    try {
+        execFileSync("wt", ["remove", item.slug, "-f", "-D"], {
+            cwd: item.repoPath,
+            timeout: 60_000,
+            stdio: "pipe",
+        });
+        return true;
+    }
+    catch (err) {
+        console.warn(`  wt remove ${item.slug} failed: ${err instanceof Error ? err.message : String(err)}`);
+        return false;
+    }
+}
+export async function run(args) {
+    let repoFlag;
+    let force = false;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--repo") {
+            repoFlag = args[++i];
+            if (!repoFlag)
+                throw new Error("--repo requires a value");
+        }
+        else if (a === "--force") {
+            force = true;
+        }
+        else {
+            console.error(`Unknown option: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+    }
+    const config = parseConfigFile(findConfigPath());
+    let items = await listActiveWork(config);
+    if (repoFlag)
+        items = items.filter((it) => it.repo === repoFlag || it.repo?.endsWith(`/${repoFlag}`));
+    if (items.length === 0) {
+        console.log("Nothing to clean.");
+        return 0;
+    }
+    console.log(`april clean ${force ? "(--force)" : "(dry run)"} — checking ${items.length} item(s) against GitHub…\n`);
+    const dispositions = await Promise.all(items.map(classify));
+    const removable = [];
+    for (let i = 0; i < items.length; i++) {
+        const it = items[i];
+        const d = dispositions[i];
+        if (d.action === "remove") {
+            removable.push(it);
+            console.log(`  REMOVE  ${it.slug}  (${d.reason})`);
+        }
+        else {
+            console.log(`  keep    ${it.slug}  (${d.reason})`);
+        }
+    }
+    console.log("");
+    if (removable.length === 0) {
+        console.log("No orphans to remove.");
+        return 0;
+    }
+    if (!force) {
+        console.log(`${removable.length} orphaned worktree(s) eligible for removal. Re-run with --force to remove them.`);
+        return 0;
+    }
+    const backend = getSessionBackend(config);
+    let removed = 0;
+    for (const it of removable) {
+        await backend.kill(it.slug); // no-op if no session
+        if (removeWorktree(config, it)) {
+            removed++;
+            console.log(`  removed ${it.slug}`);
+        }
+    }
+    console.log(`\nRemoved ${removed}/${removable.length} orphan(s).`);
+    return 0;
+}

package/dist/commands/config.js

@@ -0,0 +1,47 @@
+import { stringify as stringifyYaml } from "yaml";
+import { findConfigPath, parseConfigFile } from "../config.js";
+const USAGE = `april config [--path] [--validate] [--json]
+
+  (no flags)   Print the resolved config file path and its parsed contents.
+  --path       Print only the resolved config file path.
+  --validate   Parse and validate the config; exit non-zero if invalid.
+  --json       Emit the parsed config as JSON instead of YAML.`;
+export function run(args) {
+    for (const a of args) {
+        if (!["--path", "--validate", "--json"].includes(a)) {
+            console.error(`Unknown option: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+    }
+    const wantPath = args.includes("--path");
+    const wantValidate = args.includes("--validate");
+    const wantJson = args.includes("--json");
+    let path;
+    try {
+        path = findConfigPath();
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+    if (wantPath) {
+        console.log(path);
+        return 0;
+    }
+    let config;
+    try {
+        config = parseConfigFile(path);
+    }
+    catch (err) {
+        console.error(`✗ Invalid config (${path}):`);
+        console.error(`  ${err instanceof Error ? err.message : String(err)}`);
+        return 1;
+    }
+    if (wantValidate) {
+        console.log(`✓ Config is valid (${path})`);
+        return 0;
+    }
+    console.log(`# ${path}`);
+    console.log(wantJson ? JSON.stringify(config, null, 2) : stringifyYaml(config).trimEnd());
+    return 0;
+}

package/dist/commands/doctor.js

@@ -0,0 +1,119 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { findConfigPath, parseConfigFile, checkTool, requiredTools } from "../config.js";
+import { getAgent } from "../agents.js";
+import { isGhWebhookExtensionInstalled, GH_EXTENSION_INSTALL_CMD } from "../precheck.js";
+import { systemdUnitPath, launchdPlistPath } from "../service/paths.js";
+import { lingerEnabled } from "../service/systemd.js";
+import { daemonReachable } from "../daemon.js";
+const GLYPH = { ok: "✓", warn: "⚠", fail: "✗" };
+class Report {
+    rows = [];
+    add(level, label, detail) {
+        this.rows.push({ level, label, detail });
+    }
+    print() {
+        for (const r of this.rows) {
+            console.log(`  ${GLYPH[r.level]} ${r.label}${r.detail ? ` — ${r.detail}` : ""}`);
+        }
+    }
+    get failed() {
+        return this.rows.some((r) => r.level === "fail");
+    }
+}
+function isGitRepo(path) {
+    try {
+        execFileSync("git", ["-C", path, "rev-parse", "--git-dir"], { stdio: "pipe", timeout: 10_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function ghAuthOk() {
+    try {
+        const out = execFileSync("gh", ["auth", "token"], {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 10_000,
+        });
+        return out.trim().length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+export async function run(_args) {
+    const report = new Report();
+    // 1. Config
+    let config;
+    try {
+        const path = findConfigPath();
+        config = parseConfigFile(path);
+        report.add("ok", "config", `valid (${path})`);
+    }
+    catch (err) {
+        report.add("fail", "config", err instanceof Error ? err.message : String(err));
+    }
+    // 2. Required tools
+    const tools = config
+        ? requiredTools(getAgent(config.llm).cli, config.sessionManager ?? "tmux")
+        : ["gh", "git"];
+    for (const tool of tools) {
+        if (checkTool(tool))
+            report.add("ok", `tool: ${tool}`, "on PATH");
+        else
+            report.add("fail", `tool: ${tool}`, "not found on PATH");
+    }
+    // 3. gh-webhook extension
+    if (isGhWebhookExtensionInstalled())
+        report.add("ok", "gh extension cli/gh-webhook", "installed");
+    else
+        report.add("fail", "gh extension cli/gh-webhook", `missing — ${GH_EXTENSION_INSTALL_CMD}`);
+    // 4. gh auth
+    if (ghAuthOk())
+        report.add("ok", "gh auth", "token available");
+    else
+        report.add("warn", "gh auth", "no extractable token — set GH_TOKEN/GH_ENTERPRISE_TOKEN in ~/.config/april/env");
+    // 5. Repo paths
+    if (config) {
+        for (const repo of config.repos) {
+            const key = `${repo.owner}/${repo.name}`;
+            if (!existsSync(repo.path))
+                report.add("fail", `repo: ${key}`, `path missing: ${repo.path}`);
+            else if (!isGitRepo(repo.path))
+                report.add("fail", `repo: ${key}`, `not a git repo: ${repo.path}`);
+            else
+                report.add("ok", `repo: ${key}`, repo.path);
+        }
+    }
+    // 6. Service installed
+    const unitPath = process.platform === "darwin" ? launchdPlistPath() : systemdUnitPath();
+    if (existsSync(unitPath))
+        report.add("ok", "service unit", unitPath);
+    else
+        report.add("warn", "service unit", `not installed — run \`april install\``);
+    // 7. Daemon reachable
+    if (config) {
+        if (await daemonReachable(config.port))
+            report.add("ok", "daemon", `responding on :${config.port}`);
+        else
+            report.add("warn", "daemon", `not reachable on :${config.port} (not running?)`);
+    }
+    // 8. Linger (Linux only)
+    if (process.platform === "linux") {
+        if (lingerEnabled())
+            report.add("ok", "linger", "enabled");
+        else
+            report.add("warn", "linger", `disabled — april stops at logout. sudo loginctl enable-linger ${process.env.USER ?? "$USER"}`);
+    }
+    console.log("april doctor\n");
+    report.print();
+    console.log("");
+    if (report.failed) {
+        console.log("✗ One or more required checks failed.");
+        return 1;
+    }
+    console.log("✓ All required checks passed.");
+    return 0;
+}

package/dist/commands/init.js

@@ -4,7 +4,7 @@ import { copyFileSync, existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { ensureEnvFile, envFilePath } from "../service/envfile.js";
 import { isGhWebhookExtensionInstalled, GH_EXTENSION_INSTALL_CMD } from "../precheck.js";
-import { skillDestPath, bundledSkillPath, compareSkill } from "../skill.js";
+import { skillDestPath, bundledSkillPath, compareSkill, ALL_BUNDLED_SKILLS } from "../skill.js";
 // Resolve the bundled package root from this file's installed location.
 // dist/commands/init.js -> dist/.. (the package root, where config.example.yaml lives)
 function packageRoot() {
@@ -32,16 +32,18 @@ export function run(_args) {
         return 1;
     }
     const configResult = copyIfMissing(configSrc, configDst, "config");
-    const skillSrc = bundledSkillPath();
-    if (!existsSync(skillSrc)) {
-        console.error(`  Cannot find bundled skill at ${skillSrc}`);
-        return 1;
-    }
-    // Skill install path depends on the configured LLM. Before init writes
+    // Skill install paths depend on the configured LLM. Before init writes
     // a config, configuredLlmKind() falls back to claude, which matches the
     // bundled example. If the user switches the agent later, they re-run
     // `april install-skill`.
-    copyIfMissing(skillSrc, skillDestPath(), "skill");
+    for (const skill of ALL_BUNDLED_SKILLS) {
+        const skillSrc = bundledSkillPath(skill);
+        if (!existsSync(skillSrc)) {
+            console.error(`  Cannot find bundled skill at ${skillSrc}`);
+            return 1;
+        }
+        copyIfMissing(skillSrc, skillDestPath(skill), `skill ${skill}`);
+    }
     const envState = ensureEnvFile();
     console.log(`  env:    ${envState === "created" ? "wrote" : "already exists"} ${envFilePath()}`);
     console.log("");
@@ -54,10 +56,10 @@ export function run(_args) {
         console.log(`    Install with:  ${GH_EXTENSION_INSTALL_CMD}`);
         console.log("    (april will refuse to start without it.)");
     }
-    // If the installed skill differs from what we shipped, surface it without prompting.
-    if (compareSkill() === "differs-from-bundled") {
+    // If any installed skill differs from what we shipped, surface it without prompting.
+    if (ALL_BUNDLED_SKILLS.some((s) => compareSkill(s) === "differs-from-bundled")) {
         console.log("");
-        console.log(`  i  installed skill differs from bundled. Refresh with: april install-skill`);
+        console.log(`  i  an installed skill differs from bundled. Refresh with: april install-skill`);
     }
     console.log("");
     if (configResult === "wrote") {

package/dist/commands/install-skill.js

@@ -2,50 +2,59 @@ import { copyFileSync, existsSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { stdin, stdout } from "node:process";
-import { skillDestPath, bundledSkillPath, compareSkill } from "../skill.js";
-export async function run(args) {
-    const yes = args.includes("--yes") || args.includes("-y");
-    const src = bundledSkillPath();
+import { skillDestPath, bundledSkillPath, compareSkill, ALL_BUNDLED_SKILLS } from "../skill.js";
+async function confirm(question) {
+    const rl = createInterface({ input: stdin, output: stdout });
+    const answer = (await rl.question(question)).trim().toLowerCase();
+    rl.close();
+    return answer === "y" || answer === "yes";
+}
+/** Install or refresh one bundled skill. Returns 0 on success, non-zero on hard error. */
+async function installSkill(skill, yes) {
+    const src = bundledSkillPath(skill);
     if (!existsSync(src)) {
         console.error(`Cannot find bundled skill at ${src}`);
         return 1;
     }
-    const dst = skillDestPath();
-    const state = compareSkill();
+    const dst = skillDestPath(skill);
+    const state = compareSkill(skill);
     if (state === "matches-bundled") {
-        console.log(`✓ Skill at ${dst} is already up to date`);
+        console.log(`✓ ${skill}: already up to date (${dst})`);
         return 0;
     }
     if (state === "missing") {
         mkdirSync(dirname(dst), { recursive: true });
         copyFileSync(src, dst);
-        console.log(`✓ Installed skill at ${dst}`);
+        console.log(`✓ ${skill}: installed at ${dst}`);
         return 0;
     }
     // differs-from-bundled
-    console.log("Bundled issue-worker skill differs from the installed copy.");
+    console.log(`${skill}: bundled copy differs from the installed one.`);
     console.log(`  installed: ${dst}`);
     console.log(`  bundled:   ${src}`);
-    console.log("");
-    console.log(`Diff with: diff ${dst} ${src}`);
-    console.log("");
+    console.log(`  Diff with: diff ${dst} ${src}`);
     if (!yes) {
         if (!stdin.isTTY) {
-            console.error("Refusing to overwrite without confirmation in a non-interactive session.\n" +
+            console.error(`Refusing to overwrite ${skill} without confirmation in a non-interactive session.\n` +
                 "Re-run with --yes to confirm, or run interactively to be prompted.");
             return 1;
         }
-        const rl = createInterface({ input: stdin, output: stdout });
-        const answer = (await rl.question("Overwrite installed skill with bundled version? [y/N] "))
-            .trim()
-            .toLowerCase();
-        rl.close();
-        if (answer !== "y" && answer !== "yes") {
-            console.log("Skipped — installed skill is unchanged.");
+        if (!(await confirm(`Overwrite installed ${skill} with bundled version? [y/N] `))) {
+            console.log(`Skipped — ${skill} is unchanged.`);
             return 0;
         }
     }
     copyFileSync(src, dst);
-    console.log(`✓ Overwrote skill at ${dst}`);
+    console.log(`✓ ${skill}: overwrote ${dst}`);
     return 0;
 }
+export async function run(args) {
+    const yes = args.includes("--yes") || args.includes("-y");
+    let exit = 0;
+    for (const skill of ALL_BUNDLED_SKILLS) {
+        const code = await installSkill(skill, yes);
+        if (code !== 0)
+            exit = code;
+    }
+    return exit;
+}