@dyzsasd/dev-loop 0.22.0 → 0.23.0

package/README.md

@@ -1,12 +1,12 @@
 # dev-loop
 
 The standalone local **coordination hub** for the [dev-loop](https://github.com/dyzsasd/dev-loop)
-agents — a **zero-build, zero-native-dependency** 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).
+agents. It is a **zero-build, zero-native-dependency** 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 transport that works across CLIs (Claude Code · Codex · opencode).
 
-> One trusted host, localhost-only. Identity is **cooperative attribution** (not anti-spoof). Secrets
-> live in env by **name** only. See the security envelope in
+> One trusted host, localhost-only. Identity is **cooperative attribution**, not anti-spoofing.
+> Secrets live in env by **name** only. See the security envelope in
 > [`docs/HUB-ARCHITECTURE.md`](https://github.com/dyzsasd/dev-loop/blob/main/docs/HUB-ARCHITECTURE.md).
 
 ## Install
@@ -15,7 +15,14 @@ and a **CLI-portable** transport (Claude Code · Codex · opencode).
 npm install -g @dyzsasd/dev-loop   # requires Node >= 23.6 (built-in node:sqlite + .ts type-stripping; zero build); installs the `dev-loop` + `dev-loop-hub` bins
 ```
 
-This puts two bins on `PATH`: **`dev-loop`** (the CLI) and **`dev-loop-hub`** (the MCP server entry).
+This installs two binaries on `PATH`: **`dev-loop`** for the CLI and **`dev-loop-hub`** for the
+MCP server entrypoint. The package also ships the agent skills + shared references used by
+`dev-loop run`, so the **scheduler mode needs no plugin** (it injects the skills + the hub MCP
+itself). For Claude Code **interactive** slash commands, register the plugin from npm (no GitHub):
+
+```bash
+dev-loop install-claude-plugin   # writes a local npm-source marketplace, then prints the /plugin commands to run
+```
 
 ## CLI
 
@@ -24,6 +31,8 @@ dev-loop serve                       run the stdio MCP server (the agent transpo
 dev-loop shim                        the thin stdio MCP shim → the loopback daemon op-API
 dev-loop daemon up|down|status       per-project daemon lifecycle — idempotent, auto web UI
 dev-loop init-service <key> <name> <PREFIX>   turnkey-bootstrap a service-backend project
+dev-loop run --cli claude|codex [--project <key>] [--agents core,outward] [--max-fires N]   schedule agents (self-injects the hub MCP; no plugin)
+dev-loop install-claude-plugin     register a local npm-source marketplace so /plugin install loads it
 dev-loop mcp-merge <args>            merge dev-loop-hub into a product .mcp.json (never clobbers)
 dev-loop seed <key> <name> [PREFIX]  seed a project + actors + labels
 dev-loop doctor                      health-check the system-of-record (DOCTOR_OK)
@@ -33,18 +42,29 @@ dev-loop version | help
 
 ## Identity & project (the env contract)
 
-Every launcher sets, **per pane**, the identity the write is attributed to:
+Every launcher sets the write identity **per pane**:
 
 | Env var | Meaning |
 |---|---|
-| `DEVLOOP_ACTOR` | the per-agent identity (`pm`/`qa`/`dev`/…) — the attribution |
+| `DEVLOOP_ACTOR` | the per-agent identity (`pm`/`qa`/`dev`/...) — the attribution |
 | `DEVLOOP_PROJECT` | the pinned project key (or resolved from the cwd) |
 | `DEVLOOP_HUB_DB` | the SQLite system-of-record (default `~/.dev-loop/hub.db`) |
 
-Register it as an MCP server for your CLI — `{ "command": "dev-loop", "args": ["serve"] }` (or
-`["shim"]` for the daemon transport). Per-CLI recipes + the identity gate:
+Register it as an MCP server for your CLI with `{ "command": "dev-loop", "args": ["serve"] }`,
+or use `["shim"]` for the daemon transport. Per-CLI recipes and the identity gate live in:
 [`docs/PORTABILITY.md`](https://github.com/dyzsasd/dev-loop/blob/main/docs/PORTABILITY.md).
 
+For an unattended loop without Claude/Codex `/loop`, run the built-in scheduler:
+
+```bash
+cd /path/to/product-repo   # project is inferred from repoPath / repos[].path
+dev-loop run --cli claude --agents core,communication
+dev-loop run --cli codex  --agents core,outward
+```
+
+It owns cadence itself and shells out to the selected CLI once per agent fire. Use
+`--project <key>` only when launching from outside the repo or overriding cwd detection.
+
 ## Docs
 
 - [Architecture + safety envelope](https://github.com/dyzsasd/dev-loop/blob/main/docs/HUB-ARCHITECTURE.md)

package/dist/agentops.js

@@ -3,11 +3,11 @@
 // since DL-69 (the dispatch-sharing refactor) — the stdio MCP server (server.ts), whose 27 op-backed tool
 // handlers are now thin call-throughs to agentOp() (server.ts's toMcp() maps {status,body}→MCP ok()/err()).
 // So each policy — the read SELECTs, the save_issue/save_comment orchestration (the DL-24 per-transition
-// assignTo + the DL-32 prod-promotion gate + the REPLACE-labels/APPEND-relatedTo merge), and the doc/topic/
-// channel/mirror/label families (which also reuse the shared ticketwrite/docstore/topicstore/channelstore/
+// assignTo + the DL-32 prod-promotion gate + the REPLACE-labels/APPEND-relatedTo merge), and the doc/
+// channel/mirror/label families (which also reuse the shared ticketwrite/docstore/channelstore/
 // mirrorstore/labelstore) — has EXACTLY ONE definition. The old "edit both files" drift tripwire is RETIRED:
 // a change to any policy now lands in ONE place, and the differential-parity suite (test/shim.ts +
-// test/agent-api.ts, shim ≡ stdio for all 29 tools) is the structural guard against a future re-divergence.
+// test/agent-api.ts, shim ≡ stdio for all 23 tools) is the structural guard against a future re-divergence.
 //
 // Each function takes a hub connection + the caller's already-resolved+validated actor (server.ts resolves it
 // from DEVLOOP_ACTOR + the G1 phantom-actor guard; the daemon from the X-Devloop-Actor header) and returns an
@@ -28,15 +28,9 @@ import { insertTicket, updateTicketRow, insertComment, loadRelease } from "./tic
 // The doc READS (doc.list/get/history/diff) + list_events are the SINGLE definition of those SELECTs — since
 // DL-69 server.ts's handlers dispatch through them (no longer a 1:1 duplicate of a server.ts copy).
 import { resolveDoc, latestVersion, docSave, docPublish, statusForDocErr, DOC_KINDS } from "./docstore.js";
-// DL-64 discussion-board family — the topic/post reads + writes (incl. the §25 chair/invited role gates +
-// the round/append rules) + the error→HTTP-status map are reused VERBATIM from the shared, side-effect-free
-// topicstore (exactly as the doc family reuses docstore.ts), so the op-API and the stdio server.ts can never
-// drift on a gate or a response shape. The op-API parses raw JSON, so each handler hand-validates the input
-// shapes server.ts gets from zod (the DL-63 read-handler lesson — a non-string id/body must 400, never a 500).
-import { topicList, topicGet, topicOpen, postAdd, topicSynthesize, topicClose, statusForTopicErr } from "./topicstore.js";
 // DL-67 channel family — the channel register/send/poll/ack/status HANDLER logic + the DL-4 roadmap bridge are
-// reused VERBATIM from the shared, side-effect-free channelstore (exactly as the doc/topic families reuse
-// docstore/topicstore), so the op-API and the stdio server.ts can never drift. channel.send/poll are ASYNC
+// reused VERBATIM from the shared, side-effect-free channelstore (exactly as the doc family reuses
+// docstore), so the op-API and the stdio server.ts can never drift. channel.send/poll are ASYNC
 // (network/dryrun), so agentOp returns OpResult|Promise<OpResult> and the daemon awaits it. The op-API parses
 // raw JSON → each handler hand-validates the shapes server.ts gets from zod (DL-63: a non-string arg → 400, never a 500).
 import { channelRegister, channelSend, channelPoll, channelAck, channelStatus, statusForChannelErr } from "./channelstore.js";
@@ -53,7 +47,6 @@ export const AGENT_OPS = TOOL_NAMES.filter((n) => n !== "whoami");
 // never mutate, so they bypass both). Kept here next to AGENT_OPS so the two lists can't drift. doc.save /
 // doc.publish join the ticket writes; the doc/event reads stay read-only (parity with the read ticket ops).
 export const AGENT_WRITE_OPS = new Set(["save_issue", "save_comment", "doc.save", "doc.publish",
-    "topic.open", "post.add", "topic.synthesize", "topic.close", // DL-64: the 4 board writes
     "channel.register", "channel.send", "channel.poll", "channel.ack", // DL-67: the 4 channel writes (register/send/poll/ack mutate the channels/channel_messages tables); channel.status stays a read (query_only)
     "mirror.push", "create_issue_label"]); // DL-68: the 2 writes (mirror.push → mirror_map + the one-way Linear network write; create_issue_label → labels). mirror.status/list_issue_labels/get_project stay reads (query_only)
 export const isAgentOp = (s) => AGENT_OPS.includes(s);
@@ -354,56 +347,6 @@ function opDocPublish(db, projectId, actor, a) {
     const r = docPublish(db, projectId, actor, a);
     return r.ok ? okR(r.data) : errR(statusForDocErr(r.error), r.error);
 }
-// ─── DL-64: the discussion-board family (topic.*/post.add) — thin op-API wrappers over the shared topicstore ──
-// Mirror the doc-family pattern: hand-validate the raw-JSON inputs to a clean 400 (server.ts gets these from
-// zod), then delegate to topicstore (which owns the §25 role gates + round/append rules); a TopicResult error
-// maps to its HTTP status via statusForTopicErr. The reads (topic.list/topic.get) take the query_only db; the
-// writes (topic.open/post.add/topic.synthesize/topic.close ∈ AGENT_WRITE_OPS) take writeDb — the daemon routes.
-function opTopicList(db, projectId, actor, a) {
-    if (a.status !== undefined && a.status !== "open" && a.status !== "closed")
-        return errR(400, `status must be "open" or "closed"`);
-    return okR(topicList(db, projectId, actor, a.status));
-}
-function opTopicGet(db, projectId, projectKey, a) {
-    if (typeof a.id !== "string")
-        return errR(400, "id must be a string");
-    const r = topicGet(db, projectId, projectKey, a.id);
-    return r.ok ? okR(r.data) : errR(statusForTopicErr(r.error), r.error);
-}
-function opTopicOpen(db, projectId, actor, a) {
-    if (typeof a.question !== "string" || !a.question)
-        return errR(400, "question required (a non-empty string)");
-    if (!isStrArr(a.invited) || a.invited.length === 0)
-        return errR(400, "invited required (a non-empty array of strings)");
-    const r = topicOpen(db, projectId, actor, a);
-    return r.ok ? okR(r.data) : errR(statusForTopicErr(r.error), r.error);
-}
-function opPostAdd(db, projectId, projectKey, actor, a) {
-    if (typeof a.topicId !== "string")
-        return errR(400, "topicId must be a string");
-    if (typeof a.body !== "string" || !a.body)
-        return errR(400, "body required (a non-empty string)");
-    const r = postAdd(db, projectId, projectKey, actor, a);
-    return r.ok ? okR(r.data) : errR(statusForTopicErr(r.error), r.error);
-}
-function opTopicSynthesize(db, projectId, projectKey, actor, a) {
-    if (typeof a.topicId !== "string")
-        return errR(400, "topicId must be a string");
-    if (typeof a.body !== "string" || !a.body)
-        return errR(400, "body required (a non-empty string)");
-    if (a.nextRound !== undefined && typeof a.nextRound !== "boolean")
-        return errR(400, "nextRound must be a boolean");
-    const r = topicSynthesize(db, projectId, projectKey, actor, a);
-    return r.ok ? okR(r.data) : errR(statusForTopicErr(r.error), r.error);
-}
-function opTopicClose(db, projectId, projectKey, actor, a) {
-    if (typeof a.topicId !== "string")
-        return errR(400, "topicId must be a string");
-    if (typeof a.decision !== "string" || !a.decision)
-        return errR(400, "decision required (a non-empty string)");
-    const r = topicClose(db, projectId, projectKey, actor, a);
-    return r.ok ? okR(r.data) : errR(statusForTopicErr(r.error), r.error);
-}
 // ─── DL-67: the IM channel family (channel.*) — thin op-API wrappers over the shared channelstore ──
 // Mirror the doc/topic pattern: hand-validate the raw-JSON inputs to a clean 400 (server.ts gets these from
 // zod — the DL-63 lesson), then delegate to channelstore (which owns the §16 line-build, the DL-4 roadmap
@@ -531,12 +474,6 @@ export function agentOp(op, db, projectId, projectKey, actor, args) {
         case "doc.diff": return opDocDiff(db, projectId, args);
         case "doc.save": return opDocSave(db, projectId, actor, args);
         case "doc.publish": return opDocPublish(db, projectId, actor, args);
-        case "topic.list": return opTopicList(db, projectId, actor, args);
-        case "topic.get": return opTopicGet(db, projectId, projectKey, args);
-        case "topic.open": return opTopicOpen(db, projectId, actor, args);
-        case "post.add": return opPostAdd(db, projectId, projectKey, actor, args);
-        case "topic.synthesize": return opTopicSynthesize(db, projectId, projectKey, actor, args);
-        case "topic.close": return opTopicClose(db, projectId, projectKey, actor, args);
         case "channel.register": return opChannelRegister(db, projectId, actor, args);
         case "channel.send": return opChannelSend(db, projectId, projectKey, actor, args);
         case "channel.poll": return opChannelPoll(db, projectId, projectKey, actor);

package/dist/cli.js

@@ -20,6 +20,8 @@ const ROUTES = {
     daemon: ["server", "daemon"], // up | down | status | ensure (DL-41)
     doctor: ["server", "doctor"],
     seed: ["seed"],
+    run: ["run-agents"], // scheduler: own cadence + shells out to claude/codex once per fire
+    "install-claude-plugin": ["install-claude-plugin"], // register a local npm-source marketplace so Claude Code loads the published plugin
     "init-service": ["init-service"], // turnkey bootstrap (DL-60)
     "mcp-merge": ["mcp-merge"], // merge into a product .mcp.json, never clobbers (DL-61)
     "identity-check": ["server", "identity-check"], // the portability gate (PORTABILITY.md §4)
@@ -47,6 +49,8 @@ Usage: dev-loop <command> [args]
   shim                        run the thin stdio MCP shim → the loopback daemon op-API (hub.transport:"daemon")
   daemon up|down|status       per-project daemon lifecycle — idempotent, auto-starts the localhost web UI
   init-service <key> <name> <PREFIX>   turnkey-bootstrap a service-backend project (seed → doctor → daemon up)
+  run --cli claude|codex [--project <key>] [--agents core,outward]   schedule agents by calling the selected CLI
+  install-claude-plugin      register a local npm-source marketplace so /plugin install can load it
   mcp-merge <args>            merge dev-loop-hub into a product .mcp.json (never clobbers other servers)
   seed <key> <name> [PREFIX]  seed a project + actors + labels into the hub db
   doctor                      health-check the hub system-of-record (DOCTOR_OK)

package/dist/db.js

@@ -116,32 +116,6 @@ CREATE TABLE IF NOT EXISTS document_versions (
   UNIQUE(doc_id, version)
 );
 CREATE INDEX IF NOT EXISTS idx_docversions_doc ON document_versions(doc_id, version);
--- ── P5 discussion board: the Director chairs; invited agents post per round ────
-CREATE TABLE IF NOT EXISTS topics (
-  id TEXT PRIMARY KEY,
-  project_id TEXT NOT NULL REFERENCES projects(id),
-  question TEXT NOT NULL,
-  invited TEXT NOT NULL DEFAULT '[]',          -- JSON array of actor handles
-  status TEXT NOT NULL DEFAULT 'open' CHECK(status IN ('open','closed')),
-  round INTEGER NOT NULL DEFAULT 1,
-  round_opened_at TEXT NOT NULL,               -- wall-clock for the state-free termination budget
-  opened_by TEXT NOT NULL,                     -- the chair (authority = opened_by)
-  opened_at TEXT NOT NULL,
-  closed_at TEXT,
-  decision TEXT                                -- inline terminal decision (set on close); DATA, never auto-applied (§17)
-);
-CREATE INDEX IF NOT EXISTS idx_topics_project_status ON topics(project_id, status);
-CREATE TABLE IF NOT EXISTS posts (
-  id TEXT PRIMARY KEY,
-  topic_id TEXT NOT NULL REFERENCES topics(id),
-  round INTEGER NOT NULL,
-  author TEXT NOT NULL,                         -- actor HANDLE (attribution)
-  kind TEXT NOT NULL DEFAULT 'perspective' CHECK(kind IN ('perspective','synthesis')),
-  body TEXT NOT NULL,
-  created_at TEXT NOT NULL,
-  UNIQUE(topic_id, round, author, kind)         -- one perspective per (round, author); chair's synthesis coexists
-);
-CREATE INDEX IF NOT EXISTS idx_posts_topic ON posts(topic_id, round, created_at);
 -- ── P6 IM channel: per-project provider-agnostic two-way plane (§9/§16/§25) ───
 -- §16 STRUCTURAL: this table holds the ENV-VAR NAME (config_ref/secret_ref) + the room id
 -- (channel_ref), NEVER a token/secret/URL. The secret is read from process.env[config_ref]

package/dist/doctor.js

@@ -41,7 +41,7 @@ export async function runDoctor(dbPath, opts = {}) {
     // 2b. A 0-byte file IS a valid (empty) SQLite db, so the read-only open above SUCCEEDS on a
     //     truncated / zeroed / placeholder file — it just carries no schema; a non-SQLite file throws
     //     on the first read. Either way it is not a system-of-record: report INVALID and write nothing.
-    const HUB_TABLES = ["projects", "tickets", "documents", "topics", "actors", "events"]; // every table step 4 below counts — so a partial/foreign db fails HERE, cleanly, not mid-check
+    const HUB_TABLES = ["projects", "tickets", "documents", "actors", "events"]; // every table step 4 below counts — so a partial/foreign db fails HERE, cleanly, not mid-check
     let missing;
     try {
         const present = new Set(db.prepare("SELECT name FROM sqlite_master WHERE type='table'").all().map((r) => r.name));
@@ -67,7 +67,7 @@ export async function runDoctor(dbPath, opts = {}) {
     Object.values(qc)[0] === "ok" ? pass("quick_check ok (no corruption)") : fail(`quick_check: ${JSON.stringify(qc)}`);
     // 4. Counts + per-project, and the unique-prefix integrity check (the real multi-project guard)
     const c = (sql) => db.prepare(sql).get().c;
-    info(`projects=${c("SELECT count(*) c FROM projects")} tickets=${c("SELECT count(*) c FROM tickets")} docs=${c("SELECT count(*) c FROM documents")} topics=${c("SELECT count(*) c FROM topics")} actors=${c("SELECT count(*) c FROM actors")} events=${c("SELECT count(*) c FROM events")}`);
+    info(`projects=${c("SELECT count(*) c FROM projects")} tickets=${c("SELECT count(*) c FROM tickets")} docs=${c("SELECT count(*) c FROM documents")} actors=${c("SELECT count(*) c FROM actors")} events=${c("SELECT count(*) c FROM events")}`);
     const projects = db.prepare("SELECT id, key, ticket_prefix FROM projects ORDER BY key").all();
     const countByProject = db.prepare("SELECT count(*) c FROM tickets WHERE project_id = ?");
     for (const p of projects) {

package/dist/install-claude-plugin.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+// `dev-loop install-claude-plugin` — register a LOCAL marketplace whose single plugin has an `npm`
+// source, so Claude Code installs the published @dyzsasd/dev-loop plugin from npm (no GitHub, no
+// file-copy that drifts from the npm version). Claude Code marketplaces support an npm plugin source
+// (docs: plugin-marketplaces). We write the tiny marketplace.json + print the two `/plugin` commands
+// (those are interactive — this CLI can't run them).
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+const MARKETPLACE = "dev-loop-npm";
+const PLUGIN = "dev-loop";
+const defaultDest = () => join(homedir(), ".claude", "plugins", "marketplaces", MARKETPLACE);
+function usage() {
+    console.log(`dev-loop install-claude-plugin — register a local npm-source marketplace for the Claude plugin
+
+Usage:
+  dev-loop install-claude-plugin [--dest <dir>] [--package <name>] [--version <semver>] [--dry-run]
+
+Writes a marketplace.json whose plugin pulls from npm (default @dyzsasd/dev-loop), then prints the
+two interactive /plugin commands to run. No GitHub, no file copy — the npm package is the single
+source of truth for the plugin version.
+
+Options:
+  --dest <dir>      marketplace dir (default: ~/.claude/plugins/marketplaces/${MARKETPLACE})
+  --package <name>  npm package (default: @dyzsasd/dev-loop)
+  --version <semver> pin a version (default: latest)
+  --dry-run         print the marketplace.json + commands without writing`);
+}
+function die(msg, code = 2) {
+    console.error(`dev-loop install-claude-plugin: ${msg}`);
+    process.exit(code);
+}
+export function installClaudePlugin(argv = process.argv.slice(2)) {
+    const opts = { dest: defaultDest(), pkg: "@dyzsasd/dev-loop", version: "", dryRun: false };
+    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();
+            return 0;
+        }
+        else if (a === "--dest")
+            opts.dest = resolve(next());
+        else if (a === "--package")
+            opts.pkg = next();
+        else if (a === "--version")
+            opts.version = next();
+        else if (a === "--dry-run")
+            opts.dryRun = true;
+        else
+            die(`unknown option '${a}'`);
+    }
+    const source = { source: "npm", package: opts.pkg };
+    if (opts.version)
+        source.version = opts.version;
+    const marketplace = { name: MARKETPLACE, owner: { name: "Shuai" }, plugins: [{ name: PLUGIN, source }] };
+    const file = join(opts.dest, ".claude-plugin", "marketplace.json");
+    const json = JSON.stringify(marketplace, null, 2) + "\n";
+    if (opts.dryRun) {
+        console.log(`would write ${file}:\n${json}`);
+    }
+    else {
+        mkdirSync(join(opts.dest, ".claude-plugin"), { recursive: true });
+        writeFileSync(file, json);
+        console.log(`wrote ${file}`);
+    }
+    console.log(`\nNow run these two interactive Claude Code commands:`);
+    console.log(`  /plugin marketplace add ${opts.dest}`);
+    console.log(`  /plugin install ${PLUGIN}@${MARKETPLACE}`);
+    console.log(`\nThen /reload-plugins (or restart). Skills appear as /dev-loop:pm-agent … /dev-loop:init.`);
+    if (!opts.dryRun && !existsSync(file))
+        die(`failed to write ${file}`, 1);
+    return 0;
+}
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+    process.exit(installClaudePlugin());
+}

package/dist/mcp-merge.js

@@ -2,21 +2,22 @@
 // so init's `service` auto-wiring registers the hub server WITHOUT destroying any other MCP servers the
 // product already declares. Composes onto DL-60's init-service seam (c). §16: env-NAME-only — the entry
 // carries only `${VAR:-default}` env references (copied from the committed template), never a literal secret;
-// the hub DB path is intentionally omitted (the server defaults to ~/.dev-loop/hub.db). §17: this is a
+// the hub DB path is intentionally omitted (the server defaults to ~/.dev-loop/hub.db). The normal installed
+// shape is `command:"dev-loop", args:["serve"]`; old source templates with a `server.ts` arg are still patched
+// in place. §17: this is a
 // data-file utility — it can only ever write the product `.mcp.json`, never a SKILL/conventions/code file.
 import { existsSync, readFileSync, writeFileSync, renameSync, unlinkSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 const SERVER_NAME = "dev-loop-hub";
-// The published npm package packs only hub/dist + README — config/ lives OUTSIDE the packed dir, so the repo
-// template is absent when installed (Codex review 2026-06-27). This embedded default is the fallback: the
-// canonical dev-loop-hub entry shape (env NAME-only; an args slot ending in server.ts that buildEntry rewrites
-// to the real absolute path). Keep it in sync with config/mcp.example.json's dev-loop-hub entry.
+// The published npm package may not have the repo's config/ beside dist, so this embedded default is the
+// fallback. Keep it in sync with config/mcp.example.json's dev-loop-hub entry.
 const DEFAULT_TEMPLATE = {
     mcpServers: {
         [SERVER_NAME]: {
-            command: "node",
-            args: ["server.ts"],
+            type: "stdio",
+            command: "dev-loop",
+            args: ["serve"],
             env: { DEVLOOP_ACTOR: "${DEVLOOP_ACTOR:-operator}" },
         },
     },
@@ -36,8 +37,9 @@ function resolveTemplate(explicitPath, repoPath) {
     return DEFAULT_TEMPLATE;
 }
 // Build the dev-loop-hub entry FROM the resolved template (the single source of truth for its shape — so a
-// future template change propagates), filling the absolute hub server path into `args` and pinning the
-// DEVLOOP_PROJECT default to the project key (matches the dogfood `.mcp.json` `${DEVLOOP_PROJECT:-<key>}`).
+// future template change propagates), pinning the DEVLOOP_PROJECT default to the project key (matches the
+// dogfood `.mcp.json` `${DEVLOOP_PROJECT:-<key>}`). Old templates with a `server.ts` arg are rewritten to the
+// supplied source path for back-compat; current templates already use the PATH bin (`dev-loop serve`).
 function buildEntry(tmpl, hubServerPath, projectKey) {
     const src = tmpl.mcpServers?.[SERVER_NAME];
     if (!src || typeof src !== "object")
@@ -47,19 +49,16 @@ function buildEntry(tmpl, hubServerPath, projectKey) {
     // than write a malformed config. Real project keys are plain identifiers, so this never bites in practice.
     if (/[${}]/.test(projectKey))
         throw new Error(`project key ${JSON.stringify(projectKey)} contains '$', '{', or '}', which would break the .mcp.json \${VAR:-default} interpolation (DL-44) — use a plain identifier key`);
-    // DL-66: the hub server path lands verbatim in the entry's `args` (line below) — another interpolated
-    // .mcp.json string position — so a path carrying `$`/`{`/`}` would nest a `${...}` that Claude Code
-    // mis-expands at parse-time interpolation, corrupting the resolved hub path and breaking the launch in that
-    // pane. Guard it symmetrically with projectKey above; a real absolute checkout path never contains these
-    // (same defense-in-depth bar the team set for the projectKey side in DL-44).
-    if (/[${}]/.test(hubServerPath))
-        throw new Error(`hub server path ${JSON.stringify(hubServerPath)} contains '$', '{', or '}', which would nest a \${...} in the .mcp.json args that Claude Code mis-expands at parse-time interpolation, corrupting the resolved hub path (DL-66) — use a path without those characters`);
     const e = structuredClone(src);
     const args = (e.args ?? []);
     const idx = args.findIndex((a) => typeof a === "string" && a.endsWith("server.ts"));
-    if (idx < 0)
-        throw new Error(`template ${SERVER_NAME} entry has no server.ts arg to fill`);
-    args[idx] = hubServerPath; // the real absolute path, replacing the <ABS-PATH-TO-dev-loop>/... placeholder
+    if (idx >= 0) {
+        // DL-66: a legacy server path lands verbatim in an interpolated .mcp.json string position, so keep the
+        // old guard for old templates. Current `dev-loop serve` templates do not write this path at all.
+        if (/[${}]/.test(hubServerPath))
+            throw new Error(`hub server path ${JSON.stringify(hubServerPath)} contains '$', '{', or '}', which would nest a \${...} in the .mcp.json args that Claude Code mis-expands at parse-time interpolation, corrupting the resolved hub path (DL-66) — use a path without those characters`);
+        args[idx] = hubServerPath; // legacy placeholder replacement
+    }
     e.args = args;
     // env stays NAME-only; pin the project key as the DEVLOOP_PROJECT default (single-level, no nested ${...} — DL-44)
     e.env = { ...(e.env ?? {}), DEVLOOP_PROJECT: `\${DEVLOOP_PROJECT:-${projectKey}}` };

package/dist/mirrorstore.js

@@ -28,7 +28,7 @@ import { isEnvName } from "./channelstore.js";
 // mirror.push side-effect-free: it previews the would-push `ops`, hits NO network, and persists NO mirror_map
 // row (DL-11). Set it in the spawned process env (the MIRROR_OK suite + the agent-api/shim npm scripts do).
 const MIRROR_DRYRUN = process.env.DEVLOOP_MIRROR_DRYRUN === "1";
-const MIRROR_BANNER = "> 🤖 Mirrored from the dev-loop hub — edits here are IGNORED and overwritten on the next push. Give direction via the Director (conventions §25).";
+const MIRROR_BANNER = "> 🤖 Mirrored from the dev-loop hub — edits here are IGNORED and overwritten on the next push. Give direction by filing a Todo to PM (conventions §9a).";
 const toTicket = (r) => ({
     id: r.id, project_id: r.project_id, title: r.title, description: r.description, type: r.type,
     state: r.state, assignee: r.assignee, priority: r.priority,

package/dist/plugin/.claude-plugin/marketplace.json

@@ -0,0 +1,13 @@
+{
+  "name": "dev-loop",
+  "owner": { "name": "Shuai" },
+  "description": "Autonomous multi-agent SDLC loop with PM/QA/Dev, outward Ops/Architect/Communication roles, optional two-tier Dev, a Codex-portable service hub, and a built-in scheduler.",
+  "plugins": [
+    {
+      "name": "dev-loop",
+      "source": "./",
+      "version": "0.23.0",
+      "description": "Runs a software-development loop coordinated through ticket state. Supports Linear, a local file board, or a node:sqlite service hub with per-agent identity, localhost UI, Lark/Slack channel, one-way Linear mirror, Codex/opencode portability, and a scheduler that calls Claude/Codex CLI without using /loop. Includes Communication for daily public product article drafts."
+    }
+  ]
+}

package/dist/plugin/.claude-plugin/plugin.json

@@ -0,0 +1,11 @@
+{
+  "name": "dev-loop",
+  "displayName": "dev-loop — autonomous SDLC agents",
+  "description": "A multi-agent software delivery loop coordinated through ticket state. PM, QA, Dev, Sweep, Reflect, Ops, Architect, and Communication cover product discovery, testing, implementation, hygiene, retrospectives, production watch, technical-health audits, and public article drafts. The optional senior/junior Dev split lets a stronger model design while a cheaper model implements. Coordination can run on Linear, a local file board, or the service hub with per-agent identity, a localhost web UI, documents, Lark/Slack channel, one-way Linear mirror, Codex/opencode portability, and a built-in scheduler that shells out to Claude or Codex without relying on /loop.",
+  "version": "0.23.0",
+  "author": {
+    "name": "Shuai"
+  },
+  "keywords": ["linear", "agents", "pm", "qa", "dev", "automation", "sdlc", "workflow"],
+  "license": "MIT"
+}

package/dist/plugin/config/mcp.codex.toml.example

@@ -0,0 +1,33 @@
+# TEMPLATE for backend:"service" on the CODEX CLI (dev-loop P8 portability; see docs/PORTABILITY.md).
+# Recommended install: `npm i -g @dyzsasd/dev-loop`, then merge this into ~/.codex/config.toml.
+#
+# CERTIFIED 2026-06-25 on codex-cli 0.142.0 (docs/PORTABILITY.md §4a). KEY FINDING: Codex spawns the MCP
+# subprocess with ONLY this file's `env` block — it does NOT inherit the launching shell's process env.
+# So DEVLOOP_ACTOR canNOT ride the process env on Codex (the gate returns "operator"). Per-pane identity
+# rides a `-c` OVERRIDE instead, which MERGES a dotted key into the env table below:
+#   # one pane = one agent identity:
+#   codex exec -c 'mcp_servers.dev-loop-hub.env.DEVLOOP_ACTOR="dev"' \
+#     --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check "$PROMPT"
+#   → whoami returns {"actor":"dev","project":"dev-loop",…}  (project/db preserved from the static env).
+#   # communication-agent pane:
+#   codex exec -c 'mcp_servers.dev-loop-hub.env.DEVLOOP_ACTOR="communication"' \
+#     --dangerously-bypass-approvals-and-sandbox --skip-git-repo-check "$PROMPT"
+# Leave DEVLOOP_ACTOR ABSENT below (the -c override supplies it per pane). VERIFY the [mcp_servers.<name>]
+# schema against your Codex version (formats drift). Confirm with the §4 gate before trusting writes.
+
+# OPT-IN daemon transport (DL-55, P2): to route the core ticket tools through the ONE running daemon
+# instead of opening hub.db directly, change args to ["shim"] (from ["serve"]).
+# REQUIRES the per-project daemon up (DL-42 auto-start or `dev-loop daemon up`) + settings_json.hub.transport=
+# "daemon" (DL-43). The shim discovers the loopback port from the DL-41 runfile `~/.dev-loop/daemon-<key>.json`
+# (override with DEVLOOP_HUB_PORT) — never hardcodes 8787. Scope this increment: the 5 core ticket tools +
+# whoami; doc.*/topic.*/channel.* still need the default `serve` entry below.
+[mcp_servers.dev-loop-hub]
+command = "dev-loop"
+args = ["serve"]
+# STATIC, shared-across-panes vars ONLY. DEVLOOP_ACTOR is intentionally ABSENT — on Codex it does NOT ride
+# the process env (CERTIFIED above: Codex doesn't inherit it); supply it per-pane via the `-c` override.
+# Use an ABSOLUTE db path (TOML env is not shell-expanded).
+# DEVLOOP_PROJECT = "" (literal empty — TOML is NOT shell-expanded, so never use `${DEVLOOP_PROJECT:-}`,
+# which would be a literal string and fail the G2 phantom-project guard). Empty ⇒ the hub auto-resolves
+# the project from the spawned process's cwd (DL-13); set a non-empty value here to pin one explicitly.
+env = { DEVLOOP_PROJECT = "", DEVLOOP_HUB_DB = "/ABSOLUTE/PATH/.dev-loop/hub.db" }

package/dist/plugin/config/mcp.example.json

@@ -0,0 +1,15 @@
+{
+  "_comment": "TEMPLATE for backend:\"service\" (conventions §18; docs/HUB-ARCHITECTURE.md). Copy to your PRODUCT repo root as `.mcp.json` (or pass via `claude --mcp-config`). Recommended install: `npm i -g @dyzsasd/dev-loop`, then use command:\"dev-loop\", args:[\"serve\"]. The ${VAR} values are expanded by Claude Code at config-parse time from each pane's launching shell, so a per-pane `DEVLOOP_ACTOR` attributes writes to the right agent. Keep these single-level (`${VAR:-literal}`) — do NOT nest `${...}` inside a default (DL-44). DEVLOOP_PROJECT defaults to EMPTY (`:-`): when unset the hub auto-resolves the project from the spawned process's cwd (DL-13). To pin one explicitly, export DEVLOOP_PROJECT. The hub DB path is intentionally NOT set here: the server defaults to `~/.dev-loop/hub.db`; to point at a non-default DB, export DEVLOOP_HUB_DB in the launching shell. Source-checkout fallback for plugin developers: command:\"node\", args:[\"/abs/path/to/dev-loop/hub/src/server.ts\"].",
+  "_shim": "OPT-IN daemon transport (DL-55): to route the core ticket tools through the ONE running daemon instead of each pane opening hub.db directly, use args:[\"shim\"] instead of [\"serve\"] (or point a source checkout at hub/src/shim.ts). REQUIRES the per-project daemon running and settings_json.hub.transport=\"daemon\" (DL-43). Scope: the 5 core ticket tools + whoami — doc.*/topic.*/channel.*/mirror.*/list_events still need serve.",
+  "mcpServers": {
+    "dev-loop-hub": {
+      "type": "stdio",
+      "command": "dev-loop",
+      "args": ["serve"],
+      "env": {
+        "DEVLOOP_ACTOR": "${DEVLOOP_ACTOR:-operator}",
+        "DEVLOOP_PROJECT": "${DEVLOOP_PROJECT:-}"
+      }
+    }
+  }
+}

package/dist/plugin/config/mcp.opencode.json.example

@@ -0,0 +1,16 @@
+{
+  "_comment": "TEMPLATE for backend:\"service\" on OPENCODE (dev-loop P8 portability; see docs/PORTABILITY.md). Recommended install: `npm i -g @dyzsasd/dev-loop`, then merge the `mcp` entry into your opencode config (e.g. ~/.config/opencode/config.json or a repo-local opencode.json). VERIFY against your installed opencode version: (1) the exact `mcp` server schema (this uses type:\"local\" + a command ARRAY + an `environment` map), and (2) whether opencode propagates the launching process env to the MCP subprocess. Per-pane identity is load-bearing: DEVLOOP_ACTOR differs per agent pane, so it must ride the launcher/env or an opencode-specific override. Confirm with the identity gate in docs/PORTABILITY.md.",
+  "mcp": {
+    "dev-loop-hub": {
+      "type": "local",
+      "command": ["dev-loop", "serve"],
+      "environment": {
+        "DEVLOOP_PROJECT": "",
+        "DEVLOOP_HUB_DB": "/ABSOLUTE/PATH/.dev-loop/hub.db"
+      },
+      "_DEVLOOP_PROJECT_note": "literal empty (NOT shell-expanded here) ⇒ the hub auto-resolves the project from the spawned process's cwd (DL-13); set a non-empty value to pin one explicitly, or omit the key.",
+      "_shim_note": "OPT-IN daemon transport (DL-55): to route the core ticket tools through the running daemon instead of opening hub.db directly, change command to [\"dev-loop\", \"shim\"]. REQUIRES the per-project daemon up + settings_json.hub.transport=\"daemon\" (DL-43). Scope: the 5 core ticket tools + whoami — doc.*/topic.*/channel.* still need serve.",
+      "enabled": true
+    }
+  }
+}

package/dist/plugin/config/projects.example.json

@@ -0,0 +1,82 @@
+{
+  "defaultProject": "monpick",
+  "projects": {
+    "monpick": {
+      "linearTeam": "Citronetic",
+      "linearProject": "MonPick",
+      "repoPath": "/Users/shuai/workspace/citronetic/monpick",
+      "strategyDoc": "shopmy-analysis/15-parity-report.md",
+      "mode": "dry-run",
+      "autonomy": "ask",
+      "testEnv": {
+        "baseUrl": "https://monpick.vercel.app",
+        "setup": "python3 -m venv .venv && .venv/bin/pip install -q playwright && .venv/bin/playwright install chromium",
+        "testCommand": ".venv/bin/python3 tests/{suite}",
+        "notes": "Playwright Python suites in tests/. Run testEnv.setup once if the .venv/playwright harness is missing. Personas: demo-creator@monpick.dev / password123 (creator), demo-brand@monpick.dev / password123 (brand), demo-shopper@monpick.dev / password123 (shopper)."
+      },
+      "build": {
+        "typecheck": "npx tsc --noEmit",
+        "build": "pnpm build",
+        "test": "pnpm exec tsx tests/*.test.ts"
+      },
+      "git": {
+        "defaultBranch": "main",
+        "autoCommit": true,
+        "autoPush": true,
+        "autoDeploy": true
+      },
+      "deploy": {
+        "command": "vercel --prod --yes"
+      },
+      "codex": {
+        "_comment": "OPTIONAL Codex companion (conventions §24). Absent OR enabled:false OR codex CLI not on PATH ⇒ never invoked (100% unchanged). Needs the `codex` CLI (npm i -g @openai/codex; codex login) + the codex-plugin-cc plugin.",
+        "enabled": true,
+        "review": true,
+        "rescue": false,
+        "imageGen": true,
+        "assetsDir": "public/generated",
+        "model": null,
+        "effort": null
+      },
+      "communication": {
+        "_comment": "OPTIONAL communication-agent: drafts one public-facing product article per cadence. Draft-only: never publishes externally, never commits/pushes/deploys. Codex launch uses DEVLOOP_ACTOR=communication via the PORTABILITY.md identity recipe.",
+        "cadence": "daily",
+        "language": "en",
+        "audience": "current and prospective users",
+        "tone": "clear, concrete, human, and restrained",
+        "maxWords": 900,
+        "sourceWindowDays": 7,
+        "output": "data",
+        "outputDir": "communications",
+        "repoOutputDir": "docs/communications",
+        "includeUnreleased": false
+      },
+      "notify": {
+        "_comment": "OPTIONAL (conventions §9): ping the operator on a human-park (blocked+needs-pm+Bail-shape: external-prereq) via a Slack/Lark webhook. webhookEnv names an env var holding the webhook URL (a §16 secret — NEVER inline a real URL in a committed file). Absent => no-op. type: slack | lark.",
+        "type": "lark",
+        "webhookEnv": "DEVLOOP_NOTIFY_WEBHOOK",
+        "events": ["human-parked"]
+      },
+      "blockedStateName": null
+    },
+    "acme-suite": {
+      "_comment": "MULTI-REPO EXAMPLE (conventions §19). monpick above stays single-repo via top-level repoPath/build/git — back-compat. Here repos[] replaces a single repoPath; each ticket targets a repo via a repo:<name> label. role docs/primary picks the doc-home repo for strategyDoc; lang is informational; build/defaultBranch/deploy/contributorSkill resolve per-repo else top-level; autoCommit/autoPush/autoDeploy stay product-level in git.",
+      "linearTeam": "Acme",
+      "linearProject": "Acme Suite",
+      "repos": [
+        { "name": "web", "path": "/abs/path/to/acme-web", "role": "primary", "lang": "ts", "defaultBranch": "main", "deploy": { "command": "vercel --prod --yes", "healthCheck": "https://acme.example.com" } },
+        { "name": "api", "path": "/abs/path/to/acme-api", "role": "docs", "lang": "go", "defaultBranch": "main", "build": { "typecheck": "go build ./...", "test": "go test ./..." }, "deploy": { "command": "flyctl deploy", "healthCheck": "https://api.acme.example.com/healthz" } }
+      ],
+      "strategyDoc": "docs/strategy.md",
+      "mode": "dry-run",
+      "autonomy": "ask",
+      "testEnv": {
+        "baseUrl": "https://acme.example.com",
+        "notes": "One product baseUrl (conventions §19 limit: the api repo has no URL of its own). Personas in a vault — ask user."
+      },
+      "build": { "typecheck": "pnpm -r typecheck", "build": "pnpm -r build" },
+      "git": { "defaultBranch": "main", "autoCommit": true, "autoPush": true, "autoDeploy": false },
+      "blockedStateName": null
+    }
+  }
+}

package/dist/plugin/hooks/hooks.json

@@ -0,0 +1,16 @@
+{
+  "description": "dev-loop turnkey auto-start (DL-42, §17 operator-applied [pm-proposal]). On session start, ensure the per-project hub daemon + web UI is up via DL-41's idempotent `daemon up`. Safe-by-construction: `up` is cwd-resolved and a clean no-op for a non-service / Linear / local project (prints 'no project resolved … nothing to start', exit 0), so a project not using the hub is byte-for-byte unaffected. localhost-only (§16); output is swallowed and the exit forced 0 so a SessionStart never pollutes context or aborts startup.",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hub/src/server.ts\" daemon up >/dev/null 2>&1 || true",
+            "timeout": 15
+          }
+        ]
+      }
+    ]
+  }
+}