@dyzsasd/dev-loop 0.22.0 → 0.23.0

package/dist/run-agents.js

@@ -0,0 +1,373 @@
+#!/usr/bin/env node
+// `dev-loop run` — a small scheduler that fires agent SKILLs through a headless CLI.
+// It deliberately does NOT depend on Claude/Codex `/loop`; it owns cadence here and
+// shells out to `claude -p` or `codex exec` once per agent fire.
+import { spawn } from "node:child_process";
+import { createWriteStream, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveProjectFromCwd } from "./resolve-project.js";
+const VALID_AGENTS = [
+    "pm", "qa", "dev", "senior-dev", "junior-dev", "sweep", "reflect",
+    "ops", "architect", "communication",
+];
+const AGENT_SET = new Set(VALID_AGENTS);
+const GROUPS = {
+    core: ["pm", "qa", "dev", "sweep"],
+    split: ["pm", "qa", "senior-dev", "junior-dev", "sweep"],
+    outward: ["ops", "architect", "communication"],
+    all: [...VALID_AGENTS],
+};
+const DEFAULT_AGENTS = GROUPS.core;
+const DEFAULT_INTERVALS = {
+    pm: 5 * 60_000,
+    qa: 5 * 60_000,
+    dev: 5 * 60_000,
+    "senior-dev": 5 * 60_000,
+    "junior-dev": 5 * 60_000,
+    sweep: 30 * 60_000,
+    reflect: 24 * 60 * 60_000,
+    ops: 10 * 60_000,
+    architect: 24 * 60 * 60_000,
+    communication: 24 * 60 * 60_000,
+};
+const here = dirname(fileURLToPath(import.meta.url)); // hub/src (dev) | dist (build)
+const EXT = fileURLToPath(import.meta.url).endsWith(".js") ? ".js" : ".ts"; // server sibling: .ts source / .js published
+const isPluginRoot = (p) => existsSync(join(p, "skills")) && existsSync(join(p, "references"));
+const defaultRoot = () => {
+    // Source checkout: hub/src -> repo root. Published package: dist/plugin -> bundled skills/references.
+    const candidates = [join(here, "plugin"), resolve(here, "..", "..")];
+    return candidates.find(isPluginRoot) ?? resolve(here, "..", "..");
+};
+const defaultDataDir = () => process.env.CLAUDE_PLUGIN_DATA || join(homedir(), ".claude", "plugins", "data", "dev-loop");
+const defaultHubDb = () => process.env.DEVLOOP_HUB_DB || join(homedir(), ".dev-loop", "hub.db");
+function usage() {
+    console.log(`dev-loop run — schedule dev-loop agents with a headless CLI
+
+Usage:
+  dev-loop run --cli claude [--project <key>] [--agents core,communication]
+  dev-loop run --cli codex  [--project <key>] [--agents core,outward]
+
+Cadence is owned by this process, not by Claude/Codex /loop. Each fire shells out once:
+  claude -p <agent skill prompt>
+  codex exec ... <agent skill prompt>
+
+Options:
+  --cli claude|codex          CLI to invoke (default: claude)
+  --project <key>             project key; optional. Defaults to DEVLOOP_PROJECT, then cwd→repo match, then defaultProject
+  --agents <list>             comma list of agents or groups: core, split, outward, all
+  --agent <name>              add one agent; may repeat
+  --dev-split                 replace dev with senior-dev + junior-dev in the selected set
+  --interval <agent=dur>      override cadence, e.g. pm=2m, communication=24h; may repeat
+  --once                      run each selected agent once, then exit
+  --dry-run                   print resolved commands; do not launch Claude/Codex
+  --root <path>               dev-loop checkout root (default: inferred, or CLAUDE_PLUGIN_ROOT)
+  --data <path>               plugin data dir (default: CLAUDE_PLUGIN_DATA or ~/.claude/plugins/data/dev-loop)
+  --hub-db <path>             hub db path (default: DEVLOOP_HUB_DB or ~/.dev-loop/hub.db)
+  --cwd <path>                working directory for CLI subprocesses (default: project repoPath)
+  --mcp-config <path>         claude: MCP config to load + --strict-mcp-config (default: <cwd>/.mcp.json if present)
+  --max-fires <n>             stop after N total agent fires, then drain + exit (cost guard; default 0 = unlimited)
+  --codex-safe                omit Codex's unsafe bypass flags; useful for read-only/dry runs
+  --cli-arg <arg>             pass an extra arg to the selected CLI before the prompt; may repeat
+                              (CLI binaries: set DEVLOOP_CLAUDE_BIN / DEVLOOP_CODEX_BIN to override)
+
+Durations accept ms/s/m/h/d. Default agents: core = pm,qa,dev,sweep.`);
+}
+function die(msg, code = 2) {
+    console.error(`dev-loop run: ${msg}`);
+    process.exit(code);
+}
+function parseDuration(input) {
+    const m = input.trim().match(/^(\d+(?:\.\d+)?)(ms|s|m|h|d)?$/);
+    if (!m)
+        die(`invalid duration '${input}'`);
+    const n = Number(m[1]);
+    const unit = m[2] ?? "m";
+    const mult = unit === "ms" ? 1 : unit === "s" ? 1_000 : unit === "m" ? 60_000 : unit === "h" ? 60 * 60_000 : 24 * 60 * 60_000;
+    const ms = Math.round(n * mult);
+    if (!Number.isFinite(ms) || ms <= 0)
+        die(`invalid duration '${input}'`);
+    return ms;
+}
+function formatDuration(ms) {
+    if (ms % (24 * 60 * 60_000) === 0)
+        return `${ms / (24 * 60 * 60_000)}d`;
+    if (ms % (60 * 60_000) === 0)
+        return `${ms / (60 * 60_000)}h`;
+    if (ms % 60_000 === 0)
+        return `${ms / 60_000}m`;
+    if (ms % 1_000 === 0)
+        return `${ms / 1_000}s`;
+    return `${ms}ms`;
+}
+function expandAgentSpec(parts) {
+    const out = [];
+    for (const raw of parts.flatMap((p) => p.split(","))) {
+        const name = raw.trim();
+        if (!name)
+            continue;
+        if (GROUPS[name])
+            out.push(...GROUPS[name]);
+        else if (AGENT_SET.has(name))
+            out.push(name);
+        else
+            die(`unknown agent/group '${name}'`);
+    }
+    return [...new Set(out)];
+}
+function parseArgs(argv) {
+    const agentSpecs = [];
+    const intervals = { ...DEFAULT_INTERVALS };
+    const extraArgs = [];
+    const opts = {
+        cli: process.env.DEVLOOP_RUNNER_CLI || "claude",
+        agents: [],
+        intervals,
+        once: false,
+        dryRun: false,
+        devSplit: false,
+        root: process.env.CLAUDE_PLUGIN_ROOT || process.env.DEVLOOP_PLUGIN_ROOT || defaultRoot(),
+        dataDir: defaultDataDir(),
+        hubDb: defaultHubDb(),
+        claudeBin: process.env.DEVLOOP_CLAUDE_BIN || "claude",
+        codexBin: process.env.DEVLOOP_CODEX_BIN || "codex",
+        codexSafe: false,
+        maxFires: 0,
+        extraArgs,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const next = () => argv[++i] ?? die(`${a} requires a value`);
+        if (a === "--help" || a === "-h") {
+            usage();
+            process.exit(0);
+        }
+        else if (a === "--cli") {
+            const v = next();
+            if (v !== "claude" && v !== "codex")
+                die("--cli must be claude or codex");
+            opts.cli = v;
+        }
+        else if (a === "--project")
+            opts.project = next();
+        else if (a === "--agents")
+            agentSpecs.push(next());
+        else if (a === "--agent")
+            agentSpecs.push(next());
+        else if (a === "--dev-split")
+            opts.devSplit = true;
+        else if (a === "--interval") {
+            const raw = next();
+            const eq = raw.indexOf("=");
+            if (eq <= 0)
+                die("--interval must look like agent=duration");
+            const agent = raw.slice(0, eq);
+            if (!AGENT_SET.has(agent))
+                die(`unknown agent in --interval '${agent}'`);
+            intervals[agent] = parseDuration(raw.slice(eq + 1));
+        }
+        else if (a === "--once")
+            opts.once = true;
+        else if (a === "--dry-run")
+            opts.dryRun = true;
+        else if (a === "--root")
+            opts.root = resolve(next());
+        else if (a === "--data")
+            opts.dataDir = resolve(next());
+        else if (a === "--hub-db")
+            opts.hubDb = resolve(next());
+        else if (a === "--cwd")
+            opts.cwd = resolve(next());
+        else if (a === "--mcp-config")
+            opts.mcpConfig = resolve(next());
+        else if (a === "--max-fires") {
+            opts.maxFires = Number(next());
+            if (!Number.isInteger(opts.maxFires) || opts.maxFires < 0)
+                die("--max-fires must be a non-negative integer (0 = unlimited)");
+        }
+        else if (a === "--codex-safe")
+            opts.codexSafe = true;
+        else if (a === "--cli-arg")
+            extraArgs.push(next());
+        else
+            die(`unknown option '${a}'`);
+    }
+    let agents = expandAgentSpec(agentSpecs.length ? agentSpecs : DEFAULT_AGENTS);
+    if (opts.devSplit) {
+        agents = agents.flatMap((a) => a === "dev" ? ["senior-dev", "junior-dev"] : [a]);
+        agents = [...new Set(agents)];
+    }
+    opts.agents = agents;
+    return opts;
+}
+function readProjects(dataDir) {
+    const p = process.env.DEVLOOP_PROJECTS_JSON || join(dataDir, "projects.json");
+    if (!existsSync(p))
+        return null;
+    try {
+        return JSON.parse(readFileSync(p, "utf8"));
+    }
+    catch (e) {
+        die(`could not parse ${p}: ${e.message}`, 1);
+    }
+}
+function resolveProject(opts, cfg) {
+    const explicit = opts.project || process.env.DEVLOOP_PROJECT?.trim();
+    if (explicit)
+        return explicit;
+    const fromCwd = cfg ? resolveProjectFromCwd(opts.cwd || process.cwd(), cfg) : null;
+    return fromCwd || cfg?.defaultProject || Object.keys(cfg?.projects ?? {})[0] || "demo";
+}
+function resolveCwd(opts, cfg, project) {
+    if (opts.cwd)
+        return opts.cwd;
+    const p = cfg?.projects?.[project];
+    const primaryRepo = p?.repos?.find((r) => r.role === "primary" && r.path)?.path;
+    const docRepo = p?.repos?.find((r) => r.role === "docs" && r.path)?.path;
+    return p?.repoPath || primaryRepo || docRepo || p?.repos?.find((r) => r.path)?.path || process.cwd();
+}
+function stripFrontmatter(raw) {
+    const lines = raw.split(/\r?\n/);
+    if (lines[0]?.trim() !== "---")
+        return raw;
+    const end = lines.findIndex((line, i) => i > 0 && line.trim() === "---");
+    return end > 0 ? lines.slice(end + 1).join("\n").trimStart() : raw;
+}
+function readPrompt(opts, agent) {
+    const skill = join(opts.root, "skills", `${agent}-agent`, "SKILL.md");
+    if (!existsSync(skill))
+        die(`skill file not found for '${agent}': ${skill}. Pass --root <dev-loop checkout>.`, 1);
+    const body = stripFrontmatter(readFileSync(skill, "utf8"))
+        .replaceAll("${CLAUDE_PLUGIN_ROOT}", opts.root)
+        .replaceAll("${CLAUDE_PLUGIN_DATA}", opts.dataDir);
+    return `You are launched by dev-loop's own scheduler. Run exactly one fresh fire for this agent, then stop.\n\n${body}`;
+}
+function shellQuote(s) {
+    return /^[A-Za-z0-9_/:=.,@%+-]+$/.test(s) ? s : `'${s.replaceAll("'", "'\\''")}'`;
+}
+// The dev-loop-hub MCP server the scheduler injects itself, so NEITHER CLI needs the plugin or a
+// pre-existing config. Points at this package's own server entry (.ts source / .js published) + the
+// resolved hub db, with the per-fire actor/project. claude takes it as inline --mcp-config JSON;
+// codex takes the same shape as `-c` overrides (which define the server, not just patch env).
+const serverEntry = join(here, `server${EXT}`);
+function commandFor(opts, agent, project, prompt) {
+    if (opts.cli === "claude") {
+        // explicit --mcp-config file wins; otherwise inject the hub inline so a fresh project needs no .mcp.json.
+        const mcpArg = opts.mcpConfig ?? JSON.stringify({
+            mcpServers: { "dev-loop-hub": { command: "node", args: [serverEntry], env: { DEVLOOP_ACTOR: agent, DEVLOOP_PROJECT: project, DEVLOOP_HUB_DB: opts.hubDb } } },
+        });
+        return { command: opts.claudeBin, args: ["--mcp-config", mcpArg, "--strict-mcp-config", ...opts.extraArgs, "-p", prompt] };
+    }
+    const args = [
+        "exec",
+        ...opts.extraArgs,
+        "-c", `mcp_servers.dev-loop-hub.command="node"`,
+        "-c", `mcp_servers.dev-loop-hub.args=["${serverEntry}"]`,
+        "-c", `mcp_servers.dev-loop-hub.env.DEVLOOP_ACTOR="${agent}"`,
+        "-c", `mcp_servers.dev-loop-hub.env.DEVLOOP_PROJECT="${project}"`,
+        "-c", `mcp_servers.dev-loop-hub.env.DEVLOOP_HUB_DB="${opts.hubDb}"`,
+    ];
+    if (!opts.codexSafe)
+        args.push("--dangerously-bypass-approvals-and-sandbox", "--skip-git-repo-check");
+    args.push(prompt);
+    return { command: opts.codexBin, args };
+}
+function displayCommand(command, args, prompt) {
+    return [command, ...args.map((a) => a === prompt ? `<prompt:${prompt.length} chars>` : a).map(shellQuote)].join(" ");
+}
+async function runAgent(opts, agent, project, cwd) {
+    const prompt = readPrompt(opts, agent);
+    const { command, args } = commandFor(opts, agent, project, prompt);
+    const env = {
+        ...process.env,
+        DEVLOOP_ACTOR: agent,
+        DEVLOOP_PROJECT: project,
+        DEVLOOP_HUB_DB: opts.hubDb,
+        CLAUDE_PLUGIN_ROOT: opts.root,
+        CLAUDE_PLUGIN_DATA: opts.dataDir,
+    };
+    const rendered = displayCommand(command, args, prompt);
+    if (opts.dryRun) {
+        console.log(`[dry-run] ${agent}: cwd=${cwd}`);
+        console.log(`[dry-run] ${agent}: ${rendered}`);
+        return 0;
+    }
+    const logDir = opts.logDir || join(opts.dataDir, project, "runner-logs");
+    mkdirSync(logDir, { recursive: true });
+    const logPath = join(logDir, `${agent}.log`);
+    const log = createWriteStream(logPath, { flags: "a" });
+    log.write(`\n\n===== ${new Date().toISOString()} ${rendered} cwd=${cwd} =====\n`);
+    console.log(`[${new Date().toISOString()}] ${agent}: start (${opts.cli}); log ${logPath}`);
+    const child = spawn(command, args, { cwd, env, stdio: ["ignore", "pipe", "pipe"] });
+    activeChildren.add(child);
+    child.stdout.on("data", (d) => { process.stdout.write(`[${agent}] ${d}`); log.write(d); });
+    child.stderr.on("data", (d) => { process.stderr.write(`[${agent}] ${d}`); log.write(d); });
+    return await new Promise((resolveExit) => {
+        child.on("error", (e) => { log.write(`\nERROR: ${e.message}\n`); console.error(`[${agent}] failed to start: ${e.message}`); resolveExit(1); });
+        child.on("close", (code, signal) => {
+            activeChildren.delete(child);
+            log.write(`\n===== exit code=${code ?? "null"} signal=${signal ?? "null"} =====\n`);
+            log.end();
+            console.log(`[${new Date().toISOString()}] ${agent}: exit ${code ?? `signal ${signal}`}`);
+            resolveExit(code ?? 1);
+        });
+    });
+}
+const activeChildren = new Set();
+async function main() {
+    const opts = parseArgs(process.argv.slice(2));
+    const cfg = readProjects(opts.dataDir);
+    const project = resolveProject(opts, cfg);
+    const cwd = resolveCwd(opts, cfg, project);
+    if (!existsSync(cwd))
+        die(`cwd does not exist: ${cwd}`, 1);
+    console.log(`dev-loop run: cli=${opts.cli} project=${project} cwd=${cwd}`);
+    console.log(`dev-loop run: root=${opts.root} data=${opts.dataDir} hubDb=${opts.hubDb}`);
+    console.log(`dev-loop run: agents=${opts.agents.map((a) => `${a}@${formatDuration(opts.intervals[a])}`).join(", ")}`);
+    if (opts.once) {
+        const results = await Promise.all(opts.agents.map((a) => runAgent(opts, a, project, cwd)));
+        process.exit(results.every((c) => c === 0) ? 0 : 1);
+    }
+    const slots = opts.agents.map((agent) => ({ agent, nextAt: Date.now(), running: false }));
+    let stopping = false;
+    let fired = 0; // total fires started; --max-fires caps it (0 = unlimited)
+    const stop = () => {
+        if (stopping)
+            return;
+        stopping = true;
+        clearInterval(timer);
+        console.log("dev-loop run: stopping; forwarding SIGINT to active agent processes");
+        for (const child of activeChildren)
+            child.kill("SIGINT");
+        if (activeChildren.size === 0)
+            process.exit(0);
+    };
+    process.on("SIGINT", stop);
+    process.on("SIGTERM", stop);
+    const tick = () => {
+        const now = Date.now();
+        for (const slot of slots) {
+            if (stopping || slot.running || slot.nextAt > now)
+                continue;
+            slot.running = true;
+            fired++;
+            runAgent(opts, slot.agent, project, cwd)
+                .catch((e) => { console.error(`[${slot.agent}] ${e instanceof Error ? e.message : String(e)}`); return 1; })
+                .finally(() => {
+                slot.running = false;
+                slot.nextAt = Date.now() + opts.intervals[slot.agent];
+                if (stopping && activeChildren.size === 0)
+                    process.exit(0);
+            });
+            if (opts.maxFires && fired >= opts.maxFires) {
+                console.log(`dev-loop run: reached --max-fires ${opts.maxFires}; draining active fires then exiting`);
+                stop();
+                break;
+            }
+        }
+    };
+    const timer = setInterval(tick, 1_000);
+    tick();
+}
+main().catch((e) => die(e instanceof Error ? e.message : String(e), 1));

package/dist/seed.js

@@ -2,12 +2,13 @@
 // Run directly (`node src/seed.ts <key> <name>`) or called by the server on first run.
 import { randomUUID } from "node:crypto";
 import { openDb, nowIso } from "./db.js";
-// The live dev-loop agents + the human operator. P5 repurposed `signal` → `director`.
+// The live dev-loop agents + the human operator.
 // DL split (senior/junior dev): `senior-dev` + `junior-dev` join as ACTIVE actors; the legacy single
 // `dev` STAYS ACTIVE (NOT retired) — it remains the canonical single-pane fallback for non-split
 // projects (e.g. monpick on Linear), so adding the two-tier model breaks no existing project.
-const AGENT_HANDLES = ["pm", "qa", "dev", "senior-dev", "junior-dev", "sweep", "reflect", "ops", "architect", "director"];
-// `signal` retired into `director` (P5): kept as an INACTIVE actor so its historical comment/event
+// Communication is an active outward actor for public article drafts; it writes drafts, not tickets.
+const AGENT_HANDLES = ["pm", "qa", "dev", "senior-dev", "junior-dev", "sweep", "reflect", "ops", "architect", "communication"];
+// `signal` is a RETIRED actor: kept as an INACTIVE actor so its historical comment/event
 // attribution stays readable, but refused for NEW writes (actorExists/G1 filter active=1).
 const RETIRED_HANDLES = ["signal"];
 // §4 label taxonomy (+ the `notified` workflow label from §9 notify).

package/dist/server.js

@@ -79,7 +79,7 @@ if (process.argv[2] === "daemon") {
     await daemonLifecycle(sub); // resolves project from env/cwd; calls process.exit
 }
 const db = openDb(DB_PATH);
-ensureActors(db); // the 8 agents + operator are always present (needed for attribution + the guard below)
+ensureActors(db); // the configured agents + operator are always present (needed for attribution + the guard below)
 // P3/G1 — phantom-actor guard: a typo'd DEVLOOP_ACTOR would silently write an unattributable
 // author into created_by / events.actor / comments.author. Refuse to start instead (exit non-zero
 // ⇒ the MCP client can't connect ⇒ the failure is visible to the launching pane).

package/dist/shim.js

@@ -11,12 +11,11 @@
 //
 // SCOPE: the 5 core ticket tools (list_issues/get_issue/save_issue/save_comment/list_comments) + a LOCAL
 // whoami (DL-55), PLUS (DL-62) the doc/event family — list_events + doc.list/get/history/diff/save/publish,
-// PLUS (DL-64) the discussion-board family — topic.list/get/open + post.add + topic.synthesize/close,
 // PLUS (DL-67) the IM channel family — channel.register/send/poll/ack/status, PLUS (DL-68) P7 mirror +
 // label/project — mirror.push/mirror.status + list_issue_labels/create_issue_label/get_project. That is the
-// FINAL slice: the shim now proxies ALL 29 server.ts tools — a 100% server.ts drop-in.
-// The shim holds NO SoR / NO ticket/doc/topic/channel/mirror logic (Decision #3): a pure thin client over the
-// op-API (which mirrors server.ts 1:1 via agentops.ts + the shared docstore/topicstore/channelstore/mirrorstore/labelstore).
+// FINAL slice: the shim now proxies ALL 23 server.ts tools — a 100% server.ts drop-in.
+// The shim holds NO SoR / NO ticket/doc/channel/mirror logic (Decision #3): a pure thin client over the
+// op-API (which mirrors server.ts 1:1 via agentops.ts + the shared docstore/channelstore/mirrorstore/labelstore).
 //
 // DL-85: the tool { name, description, inputSchema } registry is now SHARED from tooldefs.ts (registerTools),
 // so the names/schemas can no longer drift between this shim and server.ts by hand — the old "PARITY TRIPWIRE:

package/dist/tooldefs.js

@@ -1,6 +1,6 @@
 // dev-loop hub — the SINGLE source of the MCP tool surface (DL-85). Before this, server.ts (direct-db) and
-// shim.ts (daemon-transport) each copy-pasted all 29 `registerTool(name, {description, inputSchema}, handler)`
-// triples byte-identically; the only per-file difference is the handler (dispatch vs proxy). Here the 29
+// shim.ts (daemon-transport) each copy-pasted all 23 `registerTool(name, {description, inputSchema}, handler)`
+// triples byte-identically; the only per-file difference is the handler (dispatch vs proxy). Here the 23
 // {name, description, inputSchema} triples live ONCE; each entrypoint calls registerTools() and supplies only
 // its per-name handler factory. The ok()/err() MCP-result helpers are shared from here too.
 //
@@ -12,7 +12,7 @@ import { z } from "zod";
 import { DOC_KINDS } from "./docstore.js"; // the doc-kind enum for doc.save's zod schema (a shared schema constant, not SoR/doc logic)
 export const ok = (data) => ({ content: [{ type: "text", text: JSON.stringify(data) }] });
 export const err = (message) => ({ isError: true, content: [{ type: "text", text: JSON.stringify({ error: message }) }] });
-// ─── the canonical tool-name list — whoami (answered locally per transport) + the 28 op-backed tools ────────
+// ─── the canonical tool-name list — whoami (answered locally per transport) + the 22 op-backed tools ────────
 // agentops.ts derives AGENT_OPS = TOOL_NAMES minus "whoami" (the only tool that is NOT an op-API op), so this
 // is the ONE source of the tool/op names. Order matches the historical AGENT_OPS order (registration order is
 // irrelevant to MCP — tools resolve by name — but keeping it stable keeps diffs/feeds readable).
@@ -20,7 +20,6 @@ export const TOOL_NAMES = [
     "whoami",
     "list_issues", "get_issue", "save_issue", "save_comment", "list_comments",
     "list_events", "doc.list", "doc.get", "doc.history", "doc.diff", "doc.save", "doc.publish",
-    "topic.list", "topic.get", "topic.open", "post.add", "topic.synthesize", "topic.close",
     "channel.register", "channel.send", "channel.poll", "channel.ack", "channel.status",
     "mirror.push", "mirror.status", "list_issue_labels", "create_issue_label", "get_project",
 ];
@@ -68,27 +67,6 @@ const DEFS = {
         description: "OPERATOR-ONLY: publish a draft version → current (the live doc). Cooperative role-gate (DEVLOOP_ACTOR=operator), not anti-spoof — see §18/HUB-ARCHITECTURE §16.",
         inputSchema: { slug: z.string().optional(), kind: z.string().optional(), version: z.number().int().positive() },
     },
-    "topic.open": {
-        description: "Open a discussion topic (the caller becomes the chair = opened_by). invited = actor handles asked to post a perspective. Director-style use; any actor may chair its own topics.",
-        inputSchema: { question: z.string().min(1), invited: z.array(z.string()).min(1) },
-    },
-    "topic.list": {
-        description: "List discussion topics (no post bodies). Each row carries the current round, round_opened_at, and YOUR/the invited set's `pending` for this round (who still owes a perspective).",
-        inputSchema: { status: z.enum(["open", "closed"]).optional() },
-    },
-    "topic.get": { description: "A topic + all its posts (perspectives + the chair's synthesis), oldest first.", inputSchema: { id: z.string() } },
-    "post.add": {
-        description: "Post YOUR perspective to an OPEN topic you're invited to — once per round, your lane only (attributed to DEVLOOP_ACTOR). Append-only; you never edit/synthesize/close.",
-        inputSchema: { topicId: z.string(), body: z.string().min(1) },
-    },
-    "topic.synthesize": {
-        description: "CHAIR-ONLY (ACTOR === opened_by): write a synthesis post at the current round, optionally bumping to the next round (resets the round clock). Does NOT close — use topic.close to record the decision.",
-        inputSchema: { topicId: z.string(), body: z.string().min(1), nextRound: z.boolean().optional() },
-    },
-    "topic.close": {
-        description: "CHAIR-ONLY (ACTOR === opened_by): close the topic with a terminal decision. The decision is DATA (a recorded conclusion) — it NEVER auto-applies a code/SKILL/conventions change (§17).",
-        inputSchema: { topicId: z.string(), decision: z.string().min(1) },
-    },
     "channel.register": {
         description: "Idempotently register/update this project's IM channel from config. Stores ONLY the ENV-VAR NAMES (configRef = bot token / lark app_id; secretRef = lark app_secret) + the room id — NEVER a token/secret.",
         inputSchema: { provider: z.enum(["slack", "lark"]), configRef: z.string().min(1), secretRef: z.string().optional(), channelRef: z.string().min(1) },

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@dyzsasd/dev-loop",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "type": "module",
-  "description": "Standalone local coordination hub for the dev-loop agents — a zero-build, zero-native-dep MCP system-of-record over node:sqlite with per-agent identity, a localhost web-UI daemon, an opt-in agent op-API + thin stdio shim, and a CLI-portable transport (Claude Code / Codex / opencode). See https://github.com/dyzsasd/dev-loop (docs/HUB-ARCHITECTURE.md, docs/PORTABILITY.md).",
+  "description": "Standalone local coordination hub for the dev-loop agents — a zero-build, zero-native-dep MCP system-of-record over node:sqlite with per-agent identity, a localhost web-UI daemon, an opt-in agent op-API + thin stdio shim, a CLI-portable transport (Claude Code / Codex / opencode), and a scheduler that shells out to Claude/Codex without relying on /loop. See https://github.com/dyzsasd/dev-loop (docs/HUB-ARCHITECTURE.md, docs/PORTABILITY.md).",
   "keywords": [
     "dev-loop",
     "agents",
@@ -38,7 +38,7 @@
     "README.md"
   ],
   "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && mkdir -p dist/plugin && cp -R ../.claude-plugin ../skills ../references ../hooks ../config dist/plugin/",
     "prepack": "npm run build",
     "start": "DEVLOOP_CREATE_PROJECT=1 node src/server.ts",
     "daemon": "node src/daemon.ts",
@@ -51,11 +51,11 @@
     "release-version": "node src/release-version.ts",
     "doctor": "node src/server.ts doctor",
     "identity-check": "node src/server.ts identity-check",
+    "run-agents-test": "node test/run-agents.ts",
     "smoke": "node test/smoke.ts",
     "loop": "node test/loop.ts",
     "isolation": "node test/isolation.ts",
     "docs": "node test/docs.ts",
-    "board": "node test/board.ts",
     "channel": "node test/channel.ts",
     "mirror": "node test/mirror.ts",
     "identity": "node test/identity.ts",
@@ -64,7 +64,7 @@
     "shim": "DEVLOOP_CHANNEL_DRYRUN=1 DEVLOOP_CHANNEL_TOKEN=xoxb-DRYRUNSECRET DEVLOOP_MIRROR_DRYRUN=1 node test/shim.ts",
     "lifecycle": "node test/lifecycle.ts",
     "lifecycle-race": "node test/lifecycle-race.ts",
-    "test": "node test/smoke.ts && node test/loop.ts && node test/isolation.ts && node test/docs.ts && node test/board.ts && node test/channel.ts && node test/mirror.ts && node test/identity.ts && node test/resolve-project.ts && node test/daemon.ts && DEVLOOP_CHANNEL_DRYRUN=1 DEVLOOP_CHANNEL_TOKEN=xoxb-DRYRUNSECRET DEVLOOP_MIRROR_DRYRUN=1 node test/agent-api.ts && DEVLOOP_CHANNEL_DRYRUN=1 DEVLOOP_CHANNEL_TOKEN=xoxb-DRYRUNSECRET DEVLOOP_MIRROR_DRYRUN=1 node test/shim.ts && node test/lifecycle.ts && node test/lifecycle-race.ts && node test/blocked.ts && node test/no-progress.ts && node test/migrate.ts && node test/release.ts && node test/mcp-config.ts && node test/init-service.ts && node test/mcp-merge.ts && node test/wal-checkpoint.ts && node test/version-sync.ts && node test/build-artifact.ts && node test/accept-rate.ts && node test/cycle-stage.ts && node test/seed.ts && node test/cli-tickets.ts && node test/open-wip.ts",
+    "test": "node test/smoke.ts && node test/loop.ts && node test/isolation.ts && node test/docs.ts && node test/channel.ts && node test/mirror.ts && node test/identity.ts && node test/run-agents.ts && node test/resolve-project.ts && node test/daemon.ts && DEVLOOP_CHANNEL_DRYRUN=1 DEVLOOP_CHANNEL_TOKEN=xoxb-DRYRUNSECRET DEVLOOP_MIRROR_DRYRUN=1 node test/agent-api.ts && DEVLOOP_CHANNEL_DRYRUN=1 DEVLOOP_CHANNEL_TOKEN=xoxb-DRYRUNSECRET DEVLOOP_MIRROR_DRYRUN=1 node test/shim.ts && node test/lifecycle.ts && node test/lifecycle-race.ts && node test/blocked.ts && node test/no-progress.ts && node test/migrate.ts && node test/release.ts && node test/mcp-config.ts && node test/init-service.ts && node test/mcp-merge.ts && node test/wal-checkpoint.ts && node test/version-sync.ts && node test/build-artifact.ts && node test/accept-rate.ts && node test/cycle-stage.ts && node test/seed.ts && node test/cli-tickets.ts && node test/open-wip.ts",
     "cli-tickets": "node test/cli-tickets.ts",
     "open-wip": "node test/open-wip.ts",
     "wal-checkpoint": "node test/wal-checkpoint.ts",