@armstrongnate/april 0.1.4 → 0.2.0

package/dist/commands/investigate.js

@@ -0,0 +1,93 @@
+import { loadConfig } from "../config.js";
+import { getAgent } from "../agents.js";
+import { getSessionBackend } from "../session/index.js";
+import { slugify } from "../slug.js";
+import { resolveRepo, INVESTIGATE_PREFIX } from "../work.js";
+import { INVESTIGATE_SKILL } from "../skill.js";
+const USAGE = `april investigate "<problem>" [--repo OWNER/NAME] [--auto]
+
+  Dispatch a research agent in the CURRENT directory to investigate a problem
+  and file a GitHub issue. The session may span repos; it is not tied to a
+  worktree.
+
+  "<problem>"  free-text description of what to investigate
+  --repo       suggest the owning repo (the agent still decides where it belongs)
+  --auto       create the issue already labeled so april picks it up immediately
+  --review     explicit deferred mode (the default): file for human review, no label
+  --dry-run    print the session name and the prompt that would be dispatched, then exit`;
+export async function run(args) {
+    let repoFlag;
+    let auto = false;
+    let dryRun = false;
+    const words = [];
+    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 === "--auto") {
+            auto = true;
+        }
+        else if (a === "--review") {
+            auto = false;
+        }
+        else if (a === "--dry-run") {
+            dryRun = true;
+        }
+        else if (a.startsWith("--")) {
+            console.error(`Unknown option: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+        else {
+            words.push(a);
+        }
+    }
+    const problem = words.join(" ").trim();
+    if (!problem) {
+        console.error(`Missing problem description.\n\n${USAGE}`);
+        return 2;
+    }
+    const config = loadConfig();
+    // Validate the hint early so a typo'd --repo fails before spawning a session.
+    const suggested = repoFlag ? resolveRepo(config, repoFlag) : undefined;
+    const mode = auto ? "auto" : "deferred";
+    const cwd = process.cwd();
+    const shortId = Date.now().toString(36).slice(-4);
+    const slug = `${INVESTIGATE_PREFIX}${shortId}-${slugify(problem, 30, "investigation")}`;
+    const repoList = config.repos
+        .map((r) => `  - ${r.owner}/${r.name} — ${r.path}`)
+        .join("\n");
+    const modeLine = mode === "auto"
+        ? `create the issue assigned to ${config.assignee} AND apply the "${config.label}" label so april picks it up immediately.`
+        : `create the issue assigned to ${config.assignee} WITHOUT the "${config.label}" label, then print the URL for review.`;
+    const body = [
+        problem,
+        "",
+        "Context for filing the issue:",
+        `- Assignee: ${config.assignee}`,
+        `- Trigger label: ${config.label}`,
+        `- Mode: ${mode}`,
+        ...(suggested ? [`- Suggested owning repo: ${suggested.owner}/${suggested.name}`] : []),
+        "- Candidate repos:",
+        repoList,
+        "",
+        `Investigate the problem above, then ${modeLine}`,
+    ].join("\n");
+    const agent = getAgent(config.llm);
+    const prompt = agent.buildPrompt(INVESTIGATE_SKILL, body);
+    const command = agent.buildCommand(config);
+    if (dryRun) {
+        console.log(`session: ${slug}`);
+        console.log(`cwd:     ${cwd}`);
+        console.log(`mode:    ${mode}`);
+        console.log(`command: ${command}`);
+        console.log(`\nprompt:\n${prompt}`);
+        return 0;
+    }
+    console.log(`Starting investigation "${slug}" in ${cwd} (${mode} mode)…`);
+    await getSessionBackend(config).spawn({ name: slug, cwd, command, prompt });
+    console.log(`Done. Track it with \`april ps\`; attach to the session "${slug}".`);
+    return 0;
+}

package/dist/commands/kill.js

@@ -0,0 +1,91 @@
+import { execFileSync } from "node:child_process";
+import { findConfigPath, parseConfigFile } from "../config.js";
+import { getSessionBackend } from "../session/index.js";
+import { listActiveWork } from "../work.js";
+const USAGE = `april kill <slug|issue> [--repo OWNER/NAME] [--worktree]
+
+  Kill a single session by slug or issue number. Works for investigations
+  (inv-…) too. With --worktree, also remove the backing worktree.
+
+  <slug|issue>  a session slug (gh-123-…, inv-…) or an issue number (123)
+  --repo        disambiguate when an issue number matches more than one repo
+  --worktree    also remove the worktree (only applies to issue work)`;
+export async function run(args) {
+    let target;
+    let repoFlag;
+    let withWorktree = 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 === "--worktree") {
+            withWorktree = true;
+        }
+        else if (a.startsWith("--")) {
+            console.error(`Unknown option: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+        else if (!target) {
+            target = a;
+        }
+        else {
+            console.error(`Unexpected argument: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+    }
+    if (!target) {
+        console.error(`Missing slug or issue number.\n\n${USAGE}`);
+        return 2;
+    }
+    const config = parseConfigFile(findConfigPath());
+    const items = await listActiveWork(config);
+    let slug;
+    let item;
+    if (/^#?\d+$/.test(target)) {
+        const n = parseInt(target.replace(/^#/, ""), 10);
+        let matches = items.filter((it) => it.issueNumber === n);
+        if (repoFlag)
+            matches = matches.filter((it) => it.repo === repoFlag || it.repo?.endsWith(`/${repoFlag}`));
+        if (matches.length === 0) {
+            console.log(`No active session or worktree for issue #${n}.`);
+            return 0;
+        }
+        if (matches.length > 1) {
+            console.error(`#${n} matches multiple repos — pass --repo OWNER/NAME:`);
+            for (const m of matches)
+                console.error(`  ${m.repo} (${m.slug})`);
+            return 2;
+        }
+        item = matches[0];
+        slug = item.slug;
+    }
+    else {
+        slug = target;
+        item = items.find((it) => it.slug === target);
+    }
+    console.log(`Killing session "${slug}"…`);
+    await getSessionBackend(config).kill(slug);
+    if (withWorktree) {
+        if (item?.repoPath && item.worktreePath) {
+            try {
+                execFileSync("wt", ["remove", slug, "-f", "-D"], {
+                    cwd: item.repoPath,
+                    timeout: 60_000,
+                    stdio: "pipe",
+                });
+                console.log(`Removed worktree ${item.worktreePath}`);
+            }
+            catch (err) {
+                console.warn(`wt remove ${slug} failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        else {
+            console.log("No worktree associated with this session — nothing to remove.");
+        }
+    }
+    console.log("Done.");
+    return 0;
+}

package/dist/commands/ps.js

@@ -0,0 +1,70 @@
+import { findConfigPath, parseConfigFile } from "../config.js";
+import { listActiveWork } from "../work.js";
+import { daemonStatus } from "../daemon.js";
+const USAGE = `april ps [--json]
+
+  List active work — issues in flight and investigations — derived from
+  worktrees and live sessions. Works whether or not the daemon is running.`;
+function fmtUptime(seconds) {
+    const s = Math.floor(seconds);
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    if (h > 0)
+        return `${h}h${m}m`;
+    if (m > 0)
+        return `${m}m${s % 60}s`;
+    return `${s}s`;
+}
+function renderTable(items) {
+    const header = ["KIND", "ISSUE", "SESSION", "REPO", "SLUG"];
+    const rows = items.map((it) => [
+        it.kind === "investigation" ? "investigate" : "issue",
+        it.issueNumber ? `#${it.issueNumber}` : "-",
+        it.sessionAlive ? "live" : "stale",
+        it.repo ?? "-",
+        it.slug,
+    ]);
+    const widths = header.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+    const fmt = (cols) => cols.map((c, i) => c.padEnd(widths[i])).join("  ").trimEnd();
+    console.log(fmt(header));
+    for (const r of rows)
+        console.log(fmt(r));
+}
+export async function run(args) {
+    const wantJson = args.includes("--json");
+    for (const a of args) {
+        if (a !== "--json") {
+            console.error(`Unknown option: ${a}\n\n${USAGE}`);
+            return 2;
+        }
+    }
+    let config;
+    try {
+        config = parseConfigFile(findConfigPath());
+    }
+    catch (err) {
+        console.error(err instanceof Error ? err.message : String(err));
+        return 1;
+    }
+    const items = await listActiveWork(config);
+    const status = await daemonStatus(config.port);
+    if (wantJson) {
+        console.log(JSON.stringify({ daemon: status, work: items }, null, 2));
+        return 0;
+    }
+    if (status) {
+        const fw = status.forwarders;
+        const liveFw = fw.filter((f) => f.alive).length;
+        console.log(`daemon: up (${fmtUptime(status.uptime)}), ${liveFw}/${fw.length} forwarder${fw.length === 1 ? "" : "s"} live`);
+    }
+    else {
+        console.log(`daemon: not reachable on :${config.port}`);
+    }
+    console.log("");
+    if (items.length === 0) {
+        console.log("No active work.");
+        return 0;
+    }
+    renderTable(items);
+    return 0;
+}

package/dist/commands/run-issue.js

@@ -0,0 +1,46 @@
+import { loadConfig } from "../config.js";
+import { handleNewIssue } from "../spawner.js";
+import { parseIssueRef, resolveRepo, fetchIssue } from "../work.js";
+const USAGE = `april run <issue> [--repo OWNER/NAME]
+
+  Manually start work on an issue — the same path the daemon takes on a
+  labeled+assigned webhook, minus the label requirement. Creates the worktree,
+  spawns the agent session, and flips labels to agent:wip.
+
+  <issue>   123, #123, or owner/name#123
+  --repo    Repo to act on when <issue> is a bare number and multiple are configured.`;
+export async function run(args) {
+    let ref;
+    let repoFlag;
+    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.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 = loadConfig();
+    const { repoRef, number } = parseIssueRef(ref);
+    const repo = resolveRepo(config, repoFlag ?? repoRef);
+    const issue = fetchIssue(repo, number);
+    console.log(`Starting work on ${repo.owner}/${repo.name}#${issue.number} — "${issue.title}"`);
+    await handleNewIssue(repo, issue, config);
+    console.log(`Done. Track it with \`april ps\`.`);
+    return 0;
+}

package/dist/config.js

@@ -7,7 +7,7 @@ import { createLogger } from "./logger.js";
 import { isGhWebhookExtensionInstalled, GH_EXTENSION_INSTALL_CMD } from "./precheck.js";
 import { AGENT_KINDS, getAgent } from "./agents.js";
 const log = createLogger("config");
-function findConfigPath() {
+export function findConfigPath() {
     const envPath = process.env.APRIL_CONFIG;
     if (envPath) {
         if (!existsSync(envPath)) {
@@ -29,13 +29,23 @@ function findConfigPath() {
         `  - ${localPath}\n` +
         "Create a config.yaml (see config.example.yaml).");
 }
+/** Whether a binary is resolvable on PATH. Non-throwing; used by `doctor`. */
+export function checkTool(tool) {
+    try {
+        execSync(`which ${tool}`, { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** The external binaries april needs for this agent + session backend. */
+export function requiredTools(agentCli, sessionManager) {
+    return ["gh", "git", agentCli, sessionManager === "herdr" ? "herdr" : "tmux"];
+}
 function validateTools(agentCli, sessionManager) {
-    const tools = ["gh", "git", agentCli, sessionManager === "herdr" ? "herdr" : "tmux"];
-    for (const tool of tools) {
-        try {
-            execSync(`which ${tool}`, { stdio: "pipe" });
-        }
-        catch {
+    for (const tool of requiredTools(agentCli, sessionManager)) {
+        if (!checkTool(tool)) {
             throw new Error(`Required tool "${tool}" not found on PATH. Install it before running april.`);
         }
     }

package/dist/daemon.js

@@ -0,0 +1,27 @@
+/**
+ * Tiny client for the running daemon's HTTP endpoints. Used by `ps`/`doctor`
+ * to enrich their output when the daemon is up; every caller treats `null`
+ * (daemon down/unreachable) as a normal, non-error condition.
+ */
+async function getJson(url, timeoutMs = 1500) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, { signal: controller.signal });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function daemonStatus(port) {
+    return getJson(`http://127.0.0.1:${port}/status`);
+}
+export async function daemonReachable(port) {
+    return (await getJson(`http://127.0.0.1:${port}/health`)) !== null;
+}

package/dist/index.js

@@ -1,5 +1,6 @@
 import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join, dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
 import { createLogger } from "./logger.js";
 import { loadConfig } from "./config.js";
@@ -8,6 +9,16 @@ import { startServer } from "./server.js";
 import { startWebhookForwarders, shutdownForwarders } from "./processes.js";
 const log = createLogger("main");
 const PID_PATH = join(homedir(), ".config", "april", "april.pid");
+function readVersion() {
+    try {
+        // dist/index.js -> package root
+        const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+        return JSON.parse(readFileSync(join(root, "package.json"), "utf-8")).version ?? "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
 function checkPidFile() {
     if (!existsSync(PID_PATH))
         return;
@@ -42,7 +53,7 @@ function removePidFile() {
 }
 async function main() {
     console.log("");
-    console.log("  april v0.0.1");
+    console.log(`  april v${readVersion()}`);
     console.log("");
     // 1. Load config
     const config = loadConfig();

package/dist/processes.js

@@ -95,6 +95,14 @@ function spawnForwarder(config, repoKey, url) {
     start();
     return state;
 }
+/** Snapshot of the webhook forwarders, for the daemon's /status endpoint. */
+export function getForwarderStatus() {
+    return forwarders.map((f) => ({
+        repoKey: f.repoKey,
+        alive: !!f.child && !f.child.killed && f.child.exitCode === null && !f.stopped,
+        consecutiveFailures: f.consecutiveFailures,
+    }));
+}
 export function startWebhookForwarders(config) {
     const url = `http://localhost:${config.port}/webhook/github`;
     for (const repo of config.repos) {

package/dist/server.js

@@ -1,7 +1,8 @@
 import Fastify from "fastify";
 import { createLogger } from "./logger.js";
 import { parseWebhookEvent } from "./webhook.js";
-import { isIssueActive, handlePrClosed } from "./spawner.js";
+import { isIssueActive, handlePrClosed, getActiveCounts } from "./spawner.js";
+import { getForwarderStatus } from "./processes.js";
 const log = createLogger("server");
 export async function startServer(config, onNewIssue) {
     const app = Fastify({ logger: false });
@@ -68,6 +69,17 @@ export async function startServer(config, onNewIssue) {
         return reply.code(200).send({ ok: true });
     });
     app.get("/health", async () => ({ status: "ok" }));
+    // Live daemon state for `april ps` / `april doctor`. Everything here is also
+    // derivable from disk, so the CLI degrades gracefully when the daemon is down.
+    app.get("/status", async () => ({
+        uptime: process.uptime(),
+        assignee: config.assignee,
+        label: config.label,
+        sessionManager: config.sessionManager ?? "tmux",
+        repos: config.repos.map((r) => `${r.owner}/${r.name}`),
+        active: await getActiveCounts(config),
+        forwarders: getForwarderStatus(),
+    }));
     await app.listen({ port: config.port, host: "127.0.0.1" });
     log.info(`Server listening on http://127.0.0.1:${config.port}`);
     return app;

package/dist/service/systemd.js

@@ -50,7 +50,7 @@ function ensureSystemctlPresent() {
         throw new Error("systemctl not found on PATH. april service install requires systemd.");
     }
 }
-function lingerEnabled() {
+export function lingerEnabled() {
     try {
         const out = execFileSync("loginctl", ["show-user", process.env.USER ?? ""], {
             encoding: "utf-8",

package/dist/skill.js

@@ -3,20 +3,25 @@ import { dirname, resolve } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { configuredLlmKind } from "./config.js";
 import { getAgent } from "./agents.js";
-const SKILL_NAME = "issue-worker";
-export function bundledSkillPath() {
-    // dist/skill.js -> dist/.. -> package root, then skills/issue-worker/SKILL.md
+/** Skill that works a labeled issue end-to-end (the daemon's worker). */
+export const ISSUE_WORKER_SKILL = "issue-worker";
+/** Skill that researches a free-text problem and files a GitHub issue. */
+export const INVESTIGATE_SKILL = "issue-investigator";
+/** Every skill april bundles and keeps installed for the configured agent. */
+export const ALL_BUNDLED_SKILLS = [ISSUE_WORKER_SKILL, INVESTIGATE_SKILL];
+export function bundledSkillPath(skill) {
+    // dist/skill.js -> dist/.. -> package root, then skills/<skill>/SKILL.md
     const here = fileURLToPath(import.meta.url);
-    return resolve(dirname(here), "..", "skills", SKILL_NAME, "SKILL.md");
+    return resolve(dirname(here), "..", "skills", skill, "SKILL.md");
 }
-export function skillDestPath(kind = configuredLlmKind()) {
-    return getAgent(kind).skillFile(SKILL_NAME);
+export function skillDestPath(skill, kind = configuredLlmKind()) {
+    return getAgent(kind).skillFile(skill);
 }
-export function compareSkill(kind = configuredLlmKind()) {
-    const dst = skillDestPath(kind);
+export function compareSkill(skill, kind = configuredLlmKind()) {
+    const dst = skillDestPath(skill, kind);
     if (!existsSync(dst))
         return "missing";
-    const src = bundledSkillPath();
+    const src = bundledSkillPath(skill);
     if (!existsSync(src))
         return "matches-bundled"; // can't compare; don't alarm
     return readFileSync(dst).equals(readFileSync(src))

package/dist/slug.js

@@ -1,21 +1,21 @@
-export function makeSlug(issueNumber, title) {
-    let slug = title
+/** Lowercase, hyphenate, and truncate text at a word boundary for use in names. */
+export function slugify(text, maxLen = 40, fallback = "issue") {
+    let slug = text
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/-{2,}/g, "-")
         .replace(/^-+|-+$/g, "");
-    // Truncate to 40 chars at word boundary
-    if (slug.length > 40) {
-        slug = slug.substring(0, 40);
+    // Truncate at a word boundary
+    if (slug.length > maxLen) {
+        slug = slug.substring(0, maxLen);
         const lastHyphen = slug.lastIndexOf("-");
         if (lastHyphen > 0) {
             slug = slug.substring(0, lastHyphen);
         }
         slug = slug.replace(/-+$/, "");
     }
-    // Fallback if empty
-    if (slug.length === 0) {
-        slug = "issue";
-    }
-    return `gh-${issueNumber}-${slug}`;
+    return slug.length === 0 ? fallback : slug;
+}
+export function makeSlug(issueNumber, title) {
+    return `gh-${issueNumber}-${slugify(title)}`;
 }

package/dist/work.js

@@ -0,0 +1,144 @@
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { createLogger } from "./logger.js";
+import { getSessionBackend } from "./session/index.js";
+const log = createLogger("work");
+/** Session/worktree name prefix for daemon-driven issue work. */
+export const ISSUE_PREFIX = "gh-";
+/** Session name prefix for `april investigate` research sessions. */
+export const INVESTIGATE_PREFIX = "inv-";
+/**
+ * Parse an issue reference accepted by `run` / `cancel` / `kill`.
+ * Forms: `123`, `#123`, `owner/name#123`.
+ */
+export function parseIssueRef(ref) {
+    const hash = ref.indexOf("#");
+    if (hash !== -1) {
+        const repoRef = ref.slice(0, hash).trim() || undefined;
+        const number = parseInt(ref.slice(hash + 1).trim(), 10);
+        if (Number.isNaN(number))
+            throw new Error(`Invalid issue reference: ${ref}`);
+        return { repoRef, number };
+    }
+    const number = parseInt(ref.replace(/^#/, "").trim(), 10);
+    if (Number.isNaN(number))
+        throw new Error(`Invalid issue reference: ${ref}`);
+    return { number };
+}
+/**
+ * Pick the RepoConfig a command should act on. `ref` is an explicit
+ * "owner/name" (from `--repo` or an `owner/name#n` issue ref). When absent,
+ * defaults to the sole configured repo, else errors with the candidate list.
+ */
+export function resolveRepo(config, ref) {
+    if (ref) {
+        const norm = ref.trim();
+        const match = config.repos.find((r) => `${r.owner}/${r.name}` === norm || r.name === norm);
+        if (!match) {
+            const list = config.repos.map((r) => `${r.owner}/${r.name}`).join(", ");
+            throw new Error(`Repo "${ref}" is not configured. Known repos: ${list}`);
+        }
+        return match;
+    }
+    if (config.repos.length === 1)
+        return config.repos[0];
+    const list = config.repos.map((r) => `${r.owner}/${r.name}`).join(", ");
+    throw new Error(`Multiple repos configured — specify which with --repo or owner/name#issue. Known repos: ${list}`);
+}
+/** Fetch a single issue's number+title via gh. Throws if it can't be read. */
+export function fetchIssue(repo, number) {
+    let output;
+    try {
+        output = execFileSync("gh", [
+            "issue", "view", String(number),
+            "--repo", `${repo.owner}/${repo.name}`,
+            "--json", "number,title",
+        ], { encoding: "utf-8", timeout: 30_000, stdio: ["pipe", "pipe", "pipe"] });
+    }
+    catch (err) {
+        throw new Error(`Could not fetch issue #${number} from ${repo.owner}/${repo.name}: ` +
+            `${err instanceof Error ? err.message : String(err)}`);
+    }
+    const parsed = JSON.parse(output);
+    return { number: parsed.number, title: parsed.title };
+}
+/** Parse the issue number out of a `gh-<n>-...` slug, if present. */
+export function issueNumberFromSlug(slug) {
+    const m = /^gh-(\d+)-/.exec(slug);
+    return m ? parseInt(m[1], 10) : undefined;
+}
+/** Worktree directory names under a repo's `.worktrees` that look like april work. */
+function listWorktreeSlugs(repo) {
+    const dir = join(repo.path, ".worktrees");
+    if (!existsSync(dir))
+        return [];
+    try {
+        return readdirSync(dir, { withFileTypes: true })
+            .filter((d) => d.isDirectory() && d.name.startsWith(ISSUE_PREFIX))
+            .map((d) => d.name);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Find the active slug for an issue by scanning this repo's worktrees and the
+ * session backend for a `gh-<n>-` match. Returns undefined if nothing is active.
+ */
+export async function resolveActiveSlug(repo, issueNumber, config) {
+    const prefix = `${ISSUE_PREFIX}${issueNumber}-`;
+    const wt = listWorktreeSlugs(repo).find((s) => s.startsWith(prefix));
+    if (wt)
+        return wt;
+    const sessions = await getSessionBackend(config).listSessions();
+    return sessions.find((s) => s.startsWith(prefix));
+}
+/**
+ * Enumerate everything april is working on, derived purely from disk
+ * (`.worktrees/gh-*`) and the session backend — so it works whether or not the
+ * daemon is running. Correlates worktrees and sessions by slug.
+ */
+export async function listActiveWork(config) {
+    const bySlug = new Map();
+    // Worktrees pin a slug to a specific repo + path.
+    for (const repo of config.repos) {
+        for (const slug of listWorktreeSlugs(repo)) {
+            bySlug.set(slug, {
+                kind: "issue",
+                slug,
+                issueNumber: issueNumberFromSlug(slug),
+                repo: `${repo.owner}/${repo.name}`,
+                repoPath: repo.path,
+                worktreePath: join(repo.path, ".worktrees", slug),
+                sessionAlive: false,
+            });
+        }
+    }
+    // Sessions mark slugs alive, and surface session-only work (notably `inv-`).
+    let sessions = [];
+    try {
+        sessions = await getSessionBackend(config).listSessions();
+    }
+    catch (err) {
+        log.warn(`Could not list sessions: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    for (const name of sessions) {
+        const existing = bySlug.get(name);
+        if (existing) {
+            existing.sessionAlive = true;
+        }
+        else if (name.startsWith(INVESTIGATE_PREFIX)) {
+            bySlug.set(name, { kind: "investigation", slug: name, sessionAlive: true });
+        }
+        else if (name.startsWith(ISSUE_PREFIX)) {
+            bySlug.set(name, {
+                kind: "issue",
+                slug: name,
+                issueNumber: issueNumberFromSlug(name),
+                sessionAlive: true,
+            });
+        }
+    }
+    return [...bySlug.values()].sort((a, b) => a.slug.localeCompare(b.slug));
+}