trantor 0.17.76 → 0.17.78

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "trantor",
-  "version": "0.17.76",
+  "version": "0.17.78",
   "description": "Trantor — the hub-world for AI agent crews: live message bus, presence, project Kanban/flow board + crew orchestration for independent AI coding agents (Claude, Codex, Gemini, Kimi, DeepSeek)",
   "mcpServers": {
     "relay": {

package/README.md

@@ -51,7 +51,7 @@ heartbeats, inbox delivery, handoff/baton pass, sub-agent cards):
        "relay": {
          "command": "node",
          "args": ["<absolute-path-to-trantor>/mcp.mjs"],
-         "env": { "RELAY_URL": "http://127.0.0.1:4477", "RELAY_AGENT": "kimi-orch" },
+         "env": { "RELAY_AGENT": "kimi-orch" },
          "startupTimeoutMs": 15000,
          "toolTimeoutMs": 150000
        }
@@ -62,6 +62,13 @@ heartbeats, inbox delivery, handoff/baton pass, sub-agent cards):
 2. In the Kimi TUI: `/plugins install <absolute-path-to-trantor>` (or the GitHub URL), then
    `/reload`, then start a new session.
 
+Since 0.17.76 the Kimi hooks are a **dialect bridge**, not a fork: `kimi/bridge.mjs` runs the
+canonical hooks as children and translates Kimi's input/output conventions at the edges
+(SessionStart context is stashed and delivered on the first prompt). Kimi hooks therefore sign
+their hub calls, follow per-project hub pins, and inherit every future hook fix automatically.
+Do **not** set `RELAY_URL` in MCP configs — a hardcoded URL overrides the per-project pin and
+splits the project across hubs; the pin decides the hub.
+
 Notes: Kimi plugin installs are **snapshots** (`~/.kimi-code/plugins/managed/trantor/`) — after
 updating trantor, re-run `/plugins install` to refresh the skills/hooks. The MCP entry above always
 runs your live checkout, so the relay server itself never goes stale. Invoke the skills with
@@ -260,6 +267,24 @@ Every session registers automatically — **crew or not** — and a solo session
 shows up on the board as cards, so the dashboard reflects *all* the work on a project, not just
 crew runs.
 
+## The board keeps itself honest
+
+Cards carry their **story on the card**: every `note` lands in a permanent per-card log (last 40
+entries) that survives restarts, retention, and id remaps — the drawer shows it as the card's
+narrative, so clicking an old card tells you what actually happened, not a one-line status trail.
+The `todo` lane has a lifecycle: cards untouched for 14 days (`RELAY_TODO_STALE_MS`) move to
+STALE with an "aged out" note instead of rotting silently, and todo tiles wear an age badge from
+day 7. A commit closes the session's focus card and the two link both ways. `trantor doctor`
+cross-checks every hub you know about against the per-project pins and reports any **split-brain**
+(a project live on two hubs) with the exact fix — and `trantor adopt <project>` migrates a project
+between hubs in one verified step, telling stale sessions to restart.
+
+Crew output is gated mechanically, too: `bin/slop-gate.mjs` runs the vendored
+[anti-slop](https://github.com/dmmulroy/anti-slop) Oxlint rules over an agent's **changed files
+only** — unexplained type assertions, `unknown` laundering, runtime `typeof`, Reflect tricks and
+friends fail the card before it can reach done, while legacy debt burns down on its own card
+instead of blocking everyone.
+
 ## The brain — plan-aware economics
 
 Trantor's economics engine ([Scrooge](https://github.com/sashabogi/token-scrooge) — installed
@@ -326,8 +351,8 @@ rate, not work rate.
 | `relay_send(to, text)` / `relay_inbox` / `relay_wait(t)` | Live messaging: direct, read-new, long-poll wake |
 | `relay_peers` / `relay_status(text)` / `relay_whoami` | Presence: who's alive (honest, heartbeat-backed), doing what |
 | `relay_project_brief(text)` | The project's what/why on the dashboard |
-| `relay_task_add(title, …, difficulty, model, deps, project?)` | Cards with difficulty/model badges + DAG edges; `project` targets another board when you orchestrate from elsewhere |
-| `relay_task_move(id, status)` | `todo → doing → testing → done` (the gate), `failed`, `blocked` |
+| `relay_task_add(title, …, difficulty, model, deps, note?, project?)` | Cards with difficulty/model badges + DAG edges; `note` seeds the card's **permanent log**; `project` targets another board when you orchestrate from elsewhere |
+| `relay_task_move(id, status, note?)` | `todo → doing → testing → done` (the gate), `failed`, `blocked` — moves to testing/done should carry a `note`: what you did + the evidence, stored on the card forever |
 | `relay_board` | The project's full board, as text |
 | `relay_scrooge(prompt, task?, difficulty?)` | Fractal cheap-model delegation, with the ledger receipt |
 | `relay_lesson(text, scope?)` | Record a failure lesson — auto-injected into all future crews |
@@ -338,6 +363,7 @@ rate, not work rate.
 ```
 trantor setup | doctor | connect | profile | provider | models
         | up <agents…> | swap <old> <new> | down | ui | advise | hub | watch
+        | adopt <project> | reconcile | duty | orchestrate | patrol | app | backfill | init-hooks
 ```
 
 - **`trantor provider`** — `list` every crew seat (built-in + brought) with availability + tier ·
@@ -355,9 +381,12 @@ trantor setup | doctor | connect | profile | provider | models
 
 ## Works with any MCP agent
 
-Claude Code, Codex CLI, Kimi Code CLI, and **OpenCode** (the universal adapter — DeepSeek, GLM,
-OpenRouter, and any provider you bring) are wired by `trantor connect` automatically (idempotent,
-backed-up, never overwrites your customizations). Anything else that speaks MCP: point it at
+Claude Code, Codex CLI, Kimi Code CLI, **DeepSeek Harness (`dsh`)**, and **OpenCode** (the
+universal adapter — DeepSeek, GLM, OpenRouter, and any provider you bring) are wired by
+`trantor connect` automatically (idempotent, backed-up, never overwrites your customizations).
+For `dsh`, connect builds a full profile (`~/.dsh/profiles/trantor`): DeepSeek's own Claude Code
+hooks bridge running the trantor hooks, plus their MCP client running the relay server — then
+`trantor up dsh` runs it as a crew seat (fresh session per turn; uses `DEEPSEEK_API_KEY`). Anything else that speaks MCP: point it at
 `mcp.mjs` with `RELAY_AGENT=<brand>` — loading the server auto-registers the session, so presence
 works before the model says a word.
 

package/bin/crew-runner.mjs

@@ -161,7 +161,7 @@ if (!CLI[AGENT]) log(`'${AGENT}' is not a built-in seat — running it as an ope
 
 // RUNNER_RULES / RUNNER_KICKOFF env overrides: the runner is also the substrate for non-crew
 // always-on seats (the fleet DUTY agent, bin/duty.mjs) whose doctrine is not "work your card".
-const RULES = process.env.RUNNER_RULES || `Rules: you are ${SESSION} on the trantor crew. Before starting a card, query the board for related PAST cards and lessons (relay_board — 1900+ cards of tribal knowledge; prior work may already answer half of it). Work your assigned file(s), report on the bus (relay_send, <280 chars), move your Kanban card as you go (doing -> testing -> done; run the tests in 'testing', use 'failed' + a report if they break). If you need something from another session, message THAT SESSION (relay_peers to find its id, relay_send to reach it) — never ask the human to pass it along; carrying messages between agents is the job this bus exists to remove. When your work for THIS message is finished, END YOUR TURN — do NOT park, do NOT loop relay_wait; the runner waits for you and will wake you with the next message.`;
+const RULES = process.env.RUNNER_RULES || `Rules: you are ${SESSION} on the trantor crew. Before starting a card, query the board for related PAST cards and lessons (relay_board — 1900+ cards of tribal knowledge; prior work may already answer half of it). Work your assigned file(s), report on the bus (relay_send, <280 chars), move your Kanban card as you go with a NOTE saying what you did (doing -> testing -> done; in 'testing' run YOUR OWN test file — never the full npm test, suites collide across seats — plus \`node bin/slop-gate.mjs\` when the repo has one: it lints ONLY your changed files against the anti-slop rules, and a card must not reach done with slop-gate failing; use 'failed' + a report if anything breaks). If you need something from another session, message THAT SESSION (relay_peers to find its id, relay_send to reach it) — never ask the human to pass it along; carrying messages between agents is the job this bus exists to remove. When your work for THIS message is finished, END YOUR TURN — do NOT park, do NOT loop relay_wait; the runner waits for you and will wake you with the next message.`;
 
 // ---- the pulse (Scape's Lloyd/Argus loop, Trantor-shaped) --------------------
 // A message-driven seat is DEAF between messages. An orchestrator seat with a mission needs a

package/bin/slop-gate.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+// trantor slop-gate — the anti-slop lint, scoped to YOUR CHANGES.
+//
+//   node bin/slop-gate.mjs           # lint changed + untracked lintable files (the crew gate)
+//   node bin/slop-gate.mjs --all     # lint the whole configured surface (advisory audit)
+//
+// The rules are the vendored dmmulroy/anti-slop set (tools/oxlint/anti-slop — ours to tune):
+// they mechanically reject low-evidence AI patterns — unexplained type assertions, unknown
+// laundering, runtime typeof instead of boundary decoding, Reflect tricks, module mocking.
+// Diff-scoped ON PURPOSE: the legacy surface carries known debt (carded), and a gate that fails
+// on code you didn't touch teaches agents to ignore the gate. New work meets the bar; old debt
+// burns down on its own card. Stock eslint warnings stay ADVISORY — only anti-slop errors gate.
+import { execSync, spawnSync } from "node:child_process";
+
+const ALL = process.argv.includes("--all");
+const LINTABLE = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+
+function sh(cmd) {
+  try { return execSync(cmd, { encoding: "utf8", maxBuffer: 16 * 1024 * 1024 }).trim(); }
+  catch { return ""; }
+}
+
+let args;
+if (ALL) {
+  args = ["."];
+} else {
+  const changed = sh("git diff --name-only HEAD");
+  const untracked = sh("git ls-files --others --exclude-standard");
+  const files = [...new Set([...changed.split("\n"), ...untracked.split("\n")])]
+    .filter(f => f && LINTABLE.test(f));
+  if (!files.length) { console.log("slop-gate: no lintable changes — pass."); process.exit(0); }
+  args = files;
+}
+
+// oxlint applies oxlint.config.ts ignorePatterns even to explicitly-passed files (verified), so
+// excluded legacy files (hub.mjs, mcp.mjs) stay excluded here too.
+const r = spawnSync("npx", ["oxlint", ...args], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024 });
+const out = (r.stdout || "") + (r.stderr || "");
+const hits = out.split("\n").filter(l => /error\s+anti-slop\(/.test(l));
+
+if (hits.length) {
+  console.log(hits.join("\n"));
+  console.log(`\nslop-gate: ${hits.length} anti-slop error(s) in your changes — fix them (or state the SAFETY invariant) before moving the card to testing.`);
+  process.exit(1);
+}
+const warnings = out.split("\n").filter(l => /\bwarning\b/.test(l)).length;
+console.log(`slop-gate: clean${warnings ? ` (${warnings} advisory warning(s) — not gating)` : ""}.`);
+process.exit(0);

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "trantor",
-  "version": "0.17.76",
+  "version": "0.17.78",
   "type": "module",
   "bin": {
     "trantor": "bin/cli.mjs"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "zod": "^4.4.3",
-    "pg": "^8.22.0"
+    "pg": "^8.22.0",
+    "zod": "^4.4.3"
   },
   "scripts": {
     "test": "node test.mjs && node test-scenarios.mjs && node test-failure.mjs && node test-redelivery.mjs && node test-handoff.mjs && node test-agents.mjs && node test-update.mjs && node test-handoff-guard.mjs && node test-balances.mjs && node test-subagent-cost.mjs && node test-inbox.mjs && node test-inflight.mjs && node test-notify.mjs && node test-focus.mjs && node test-cardlog.mjs && node test-relay-note.mjs && node test-reaper.mjs && node test-events.mjs && node test-proposals.mjs && node test-scrub.mjs && node test-store-delta.mjs && node test-claims.mjs && node test-adopt.mjs && node test-summarize.mjs && node test-identity-core.mjs && node test-identity.mjs && node test-identity-instances.mjs && node test-duty.mjs && node test-discovery.mjs && node test-doctor.mjs && node test-splitbrain.mjs && node test-overseer.mjs && node test-overseer-lib.mjs && node test-overseer-warn.mjs && node test-provider-keys.mjs && node test-inbox-delivery.mjs && node test-hub-routing.mjs && node test-hook-routing.mjs && node test-relay-wait.mjs && node test-dsh-seat.mjs && node test-kimi-bridge.mjs && node test-kimi-events.mjs && python3 engine/test-routing.py && node test-reconcile.mjs && node test-resources.mjs && node test-patrol.mjs && node test-bridge.mjs && bash test-crew.sh"
@@ -53,5 +53,9 @@
   "license": "MIT",
   "engines": {
     "node": ">=18"
+  },
+  "devDependencies": {
+    "@oxlint/plugins": "^1.79.0",
+    "oxlint": "^1.79.0"
   }
 }

package/skills/crew/SKILL.md

@@ -51,6 +51,7 @@ EXACT launch spec per provider (do not improvise these):
 | DeepSeek | `deepseek:deepseek` | runs via opencode; `deepseek` alone = CLI default |
 | **GLM (Z.ai)** | **`glm:zai-coding-plan`** | **runs via opencode, NOT a bare `glm`/`zai` terminal command.** `glm:zai-coding-plan/glm-5.2` pins a model; `glm:zai-coding-plan` live-selects. (Legacy `opencode:zai-coding-plan` still works.) |
 | **OpenRouter (BYOM)** | **`openrouter`** | **the bring-your-own-model on-ramp — one key fronts hundreds of vendors (incl. ones with no CLI).** Bare `openrouter` live-selects the best OpenRouter model for the difficulty; pin one with `openrouter:openrouter/<vendor>/<model>`. Its own bus identity `openrouter:<project>` (never collides with the GLM `opencode` seat). |
+| **DeepSeek Harness** | **`dsh`** | DeepSeek's own open-source harness as a seat (API-billed via `DEEPSEEK_API_KEY`). `trantor connect` builds its profile (their CC-hooks bridge running trantor's hooks + their MCP client running the relay). **Fresh session per turn — no resume** — so the seat relies on the wake prompt + the board, not conversation memory; give it self-contained contracts. |
 
 `agent:provider` live-selects the best model now; `agent:provider/model` pins one. Example:
 `trantor up codex kimi deepseek:deepseek glm:zai-coding-plan --task code --difficulty hard`.
@@ -97,8 +98,12 @@ Loop until the board is done — you are a foreman, not a mailbox:
    they auto-inject into every future crew's prompts.
 
 ## Phase 5 — verification gate + integration
-Card flow is `todo → doing → testing → done`; `testing` runs the project's tests/typecheck;
-`done` only green; `failed` (+ bus report) pulses red on the board until you bounce it.
+Card flow is `todo → doing → testing → done`; `testing` runs the seat's OWN test file (never the
+full suite from a seat — suites spawn hubs on fixed ports and collide across seats; the
+orchestrator runs the full suite at integration) plus `node bin/slop-gate.mjs` where the repo has
+one (the anti-slop lint over the seat's changed files — a card must not reach done failing it);
+`done` only green, and moves to testing/done carry a `note` with the evidence — the note is the
+card's permanent story; `failed` (+ bus report) pulses red on the board until you bounce it.
 Enforce the gate — bounce anything that skipped it (bounces are visible: "↩ bounced" on the
 card, history in its tooltip). When all report done: integrate, fix contract mismatches
 YOURSELF, move your card through testing → done, broadcast "🚀 <thing> is live", and when the