omp-conductor 0.14.0 → 0.15.1

package/src/board.ts

@@ -7,6 +7,7 @@ import {
   codeGraphFromHealthz,
   fleetLayers,
   probeTelegramHealth,
+  workerPhasesFromHealthz,
   type FleetLayers,
   type TelegramHealth,
 } from "./fleet.ts";
@@ -922,36 +923,6 @@ export function renderBoard(
   ].join("\n");
 }
 
-export function workerPhasesFromHealthz(
-  body: string | undefined,
-  project: string,
-): ReadonlyMap<number, WorkerPausePhase> {
-  const phases = new Map<number, WorkerPausePhase>();
-  if (body === undefined) return phases;
-  try {
-    const payload = JSON.parse(body) as unknown;
-    if (payload === null || typeof payload !== "object") return phases;
-    if (Reflect.get(payload, "project") !== project) return phases;
-    const workers = Reflect.get(payload, "workers");
-    if (!Array.isArray(workers)) return phases;
-    for (const worker of workers) {
-      if (worker === null || typeof worker !== "object") continue;
-      const issue = Reflect.get(worker, "issue");
-      const phase = Reflect.get(worker, "phase");
-      if (
-        Number.isSafeInteger(issue) &&
-        (issue as number) > 0 &&
-        (phase === "pausing" || phase === "paused")
-      ) {
-        phases.set(issue as number, phase);
-      }
-    }
-  } catch {
-    // An unreadable health body means no trustworthy pause phase.
-  }
-  return phases;
-}
-
 async function probeBoardHealth(project: ProjectConfig): Promise<BoardHealthProbe> {
   const layers = fleetLayers(project.name);
   const record = livingDaemon();
@@ -966,8 +937,24 @@ async function probeBoardHealth(project: ProjectConfig): Promise<BoardHealthProb
   else if (health?.ok !== true) daemon = "unreachable";
   else {
     try {
-      const payload = JSON.parse(health.body ?? "null") as { project?: unknown };
-      daemon = payload.project === project.name ? "ok" : "other-project";
+      const payload = JSON.parse(health.body ?? "null") as unknown;
+      if (payload === null || typeof payload !== "object") {
+        daemon = "unreachable";
+      } else if (Reflect.get(payload, "project") === project.name) {
+        daemon = "ok";
+      } else {
+        const projects = Reflect.get(payload, "projects");
+        daemon =
+          Array.isArray(projects) &&
+          projects.some(
+            (entry) =>
+              entry !== null &&
+              typeof entry === "object" &&
+              Reflect.get(entry, "project") === project.name,
+          )
+            ? "ok"
+            : "other-project";
+      }
     } catch {
       daemon = "unreachable";
     }

package/src/brief-upgrade.ts

@@ -575,7 +575,7 @@ export function formatBriefReport(path: string, layout: BriefLayout, missing: re
     return [
       `brief ${path}`,
       "",
-      "No brief here yet. Run /conductor setup and say yes to writing ORCHESTRATOR.md;",
+      "No brief here yet. Run `omp-conductor setup brief` and say yes to writing ORCHESTRATOR.md;",
       "it writes POLICY.md beside it, which is the half you then own.",
     ].join("\n");
   }

package/src/briefs/orchestrator.md

@@ -16,8 +16,10 @@ Point the heartbeat at the workspace that holds `ORCHESTRATOR.md` /
 `POLICY.md` — a `.conductor-tick.json` whose default message re-reads both.
 
 This floor ships conservative so an unedited `POLICY.md` is still a safe fleet.
-To tailor Releases and Project context, ask an omp session to read
-`skill://conductor-onboarding` and onboard you.
+To tailor Releases and Project context, run `omp-conductor setup brief`: it asks
+the judgment questions no repo reading can answer, then reads your repos to draft
+the rest and shows each draft for confirmation. Editing `POLICY.md` by hand does
+the same job.
 
 ---
 
@@ -421,9 +423,11 @@ Four controls stop different work:
   spend a failure or continuation budget. Use it when the operator explicitly
   ends obsolete or already-delivered work. A salvage failure keeps the tree and
   names the path; recover that copy before any forced unblock.
-- **Fleet dispatch:** `omp-conductor pause` stops new claims and work-starting
-  mutations. Work admitted before the pause may still complete, and completion
-  verbs and releases remain available.
+- **Fleet dispatch:** `omp-conductor hold` stops new claims and work-starting
+  mutations. Work admitted before it may still complete, and completion verbs and
+  releases remain available. Note it also disarms ticks, so it silences *you*:
+  stopping the fleet is the operator's call, and the right move is to report that
+  it needs stopping rather than to run this yourself.
 - **Orchestrator ticks:** `omp-conductor disarm` removes the operator-owned
   `ARMED` marker so ticks skip. It does not pause workers or stop processes.
 

package/src/briefs/policy.md

@@ -52,10 +52,10 @@ propose the corrected steps.
 
 ## Project context (filled during onboarding)
 
-Empty until an onboarding session fills it in: the product in a paragraph, a map
-of which repo owns what, and the grooming guidance Duty 2 needs to judge priority
-and spot issues that would collide. Ask an omp session to read
-`skill://conductor-onboarding` to have it written.
+Empty until setup fills it in: the product in a paragraph, a map of which repo
+owns what, the grooming guidance Duty 2 needs to judge priority and spot issues
+that would collide, and where the roadmap lives. `omp-conductor setup` asks for
+the last of those and proposes the rest.
 
 ## Reporting
 

package/src/briefs/probes/gates.md

@@ -0,0 +1,51 @@
+You are reading one repository to answer a single question for an operator who is
+configuring an automated dispatcher. You have been given
+reading tools only: there is no shell, no editor and no verb here, so reading and
+answering is the whole of what you can do.
+
+## The question
+
+What are the **pre-push gates** for `{{REPO}}` (branch `{{BRANCH}}`)? A pre-push
+gate is a command a change must pass locally *before* it is pushed, and the answer
+is only useful if it matches what CI actually runs.
+
+## Where to look
+
+In this order, stopping when you have enough:
+
+1. CI workflow definitions — `.github/workflows/*.yml`, or the equivalent for
+   whatever CI this repo uses. This is the authority: it is what will fail a PR.
+2. `package.json` scripts, `Makefile`, `justfile`, `Taskfile.yml`, `tox.ini`,
+   `pyproject.toml`, `Cargo.toml`.
+3. Any `CONTRIBUTING.md` / `AGENTS.md` / `CLAUDE.md` that names a pre-push
+   routine.
+
+## Three traps, each of which produces a wrong answer
+
+- **Whole tree, not source directory.** If CI lints the repository and a script
+  lints only `src/`, the gate is the repository-wide command. A gate narrower than
+  CI is how a lint error reaches the runners with nobody watching.
+- **Cheap only.** Gates run on a shared host, many at once. Include type checks,
+  lint and unit tests. **Exclude** docker builds, image builds, production builds,
+  browser/e2e suites, and anything that needs a service or a credential — CI owns
+  those.
+- **An honest "no gates" is a real answer.** If this repo genuinely has no cheap
+  local check, say so with an empty list. Inventing a plausible `npm test` for a
+  repo that has no test script produces a gate that fails on every push.
+
+Each gate needs the **`cwd` it runs from**, relative to the repository root, as a
+monorepo's checks usually do not run from the top. Use `"."` for the root.
+
+## Answer
+
+One fenced JSON block, nothing else after it:
+
+```json
+{
+  "gates": [{ "cmd": "bun run check", "cwd": "." }],
+  "evidence": "one line naming the files you read that establish these"
+}
+```
+
+`evidence` is what lets the operator judge your answer without repeating your
+reading. Name files, not impressions.

package/src/briefs/probes/project-context.md

@@ -0,0 +1,59 @@
+You are reading one repository to draft a section of an operator's standing brief.
+You have been given reading tools only: there is no shell,
+no editor and no verb here, so reading and answering is the whole of what you can
+do.
+
+## What you are writing
+
+The `## Project context` section of `POLICY.md`, which a supervising orchestrator
+session re-reads on **every** tick. Keep it **under 40 lines**: a brief nobody
+finishes reading is a brief that gets skimmed.
+
+It needs exactly four things, in this order.
+
+1. **The product in one paragraph.** What it does, for whom. Not a feature list.
+2. **A repo map** — one line per routing key below, naming what that repo owns in
+   the operator's vocabulary. This is what turns a routing label into a judgement.
+3. **Grooming guidance.** Which repos ship together, so a change in one is known
+   to need a matching PR in the other. And which *kinds* of issue touch the same
+   files: those must not be queued concurrently, because two agents editing one
+   file produce two pull requests that cannot both merge.
+4. **Where the roadmap lives, and how to judge priority against it** — in one
+   line.
+
+## Where you are
+
+Your working directory holds **one directory per routing repo**, each a shallow
+clone, listed below. Read across all of them — that is what makes items 2 and 3
+answerable, and a draft written from one repo has to guess the rest.
+
+In each, read the `README` (what it is for, and who uses it), whatever top-level
+architecture doc exists (`docs/`, `ARCHITECTURE.md`, an ADR directory) for which
+repo owns which concern, and `AGENTS.md` / `CONTRIBUTING.md` for the repo's own
+rules — those outrank the brief.
+
+## Stated inputs — these are given, not yours to decide
+
+The routing keys this project dispatches to, and the directory each was cloned
+into. Refer to repos by their **routing key**, never by the directory name — the
+directory is scratch, the key is what an issue carries:
+
+{{REPOS}}
+
+The operator's own answer about the roadmap and the current priority:
+
+> {{ROADMAP}}
+
+**Item 4 must quote that answer.** You are reading a repository, which shows what
+is open and never what matters; the operator supplied the ranking and it is not
+yours to improve. If the quote above is empty, write item 4 as a single line
+saying the operator has not named a roadmap yet, and nothing more.
+
+## Answer
+
+One fenced markdown block containing the section and nothing else — start it at
+the `## Project context` heading. No preamble, no commentary after it.
+
+Write what the repository supports. Where you are guessing, say so in the text
+itself in a few words: the operator edits this file, and a marked guess is one
+they can correct, while a confident invention is one they will not notice.

package/src/briefs/probes/release-procedure.md

@@ -0,0 +1,81 @@
+You are reading one repository to turn an operator's stated release *intent* into
+that repository's own machinery. You have been given reading tools only: there is no shell,
+no editor and no verb here, so reading and answering is the whole of what you can
+do.
+
+## The one thing you must not do
+
+**You are not deciding the release policy.** The operator has already decided it,
+below. Your job is to find how this repository actually ships and express their
+intent in its terms. Do not widen the boundary, do not add a step they did not
+ask for, and do not write the procedure from the intent alone without reading the
+repository — an invented procedure reads exactly like a real one and fails the
+first time it is followed.
+
+## Stated intent — given, not yours to revise
+
+- **Where the orchestrator's leg ends:** {{BOUNDARY}}
+- **What may be released, and from which branch:** {{WHAT}}
+- **When — batched how, after which named checks:** {{WHEN}}
+- **Proof that must be held first:** {{PROOF}}
+- **What must still be asked, every time:** {{ASK}}
+- **Permanently forbidden:** {{FORBIDDEN}}
+- **A release worth cutting:** {{WORTH_CUTTING}}
+- **Rollback owner:** {{ROLLBACK_OWNER}}
+
+## Where you are, and what to read
+
+Your working directory holds **one directory per routing repo**, each a shallow
+clone. Release machinery does not always live in the repo you would expect, so look
+across all of them before writing: the repo that ships may not be the first one.
+
+Each routing key and the directory it was cloned into:
+
+{{REPOS}}
+
+**Name repos by their routing key, never by the directory.** The directory is
+scratch and will not exist when anyone reads your answer; the key is what an issue
+carries and what an orchestrator routes on.
+
+In each, read the release workflows (`.github/workflows/*release*`, `*publish*`,
+`*tag*`), the package manifest's version and publish configuration, any
+`RELEASING.md` / `CONTRIBUTING.md` release section, and how a version is bumped.
+
+For every workflow that publishes anything — a release, a tag, an image, a package,
+a deployment — **the trigger is the fact that matters**:
+
+- `workflow_dispatch` → the release is *dispatched*. That workflow is the authority,
+  and the instruction is "dispatch it with the planned version", never "do what it
+  does".
+- `on: push: tags:` → a pushed tag is the trigger, so **tagging is releasing**.
+- `on: release: published` → the GitHub Release is the trigger.
+
+Also record **what the workflow enforces** — many reject a tag unless several
+version files agree — because that is what turns a release attempt into a failure
+an operator has to unpick.
+
+Name the repo each step belongs to. A procedure that does not say where it runs is
+one an orchestrator applies in the wrong checkout.
+
+## What to write
+
+- **The named authority, and how it is invoked.** If shipping is a protected or
+  dispatchable workflow, the instruction is to *dispatch it and verify the run* —
+  never to reproduce what it does by hand, even when every step is visible. A
+  hand-rolled release skips the checks the workflow exists to enforce.
+- **The steps on the agent's side, each with the check that proves it.** A step
+  with no verifiable outcome is a step that silently did not happen.
+- **The forbidden list, with a file citation** — cite the file that says so
+  (`AGENTS.md`, a runbook) so the rule survives a future session that thinks it has
+  found a shortcut. Force-push, secrets and production data are forbidden
+  everywhere, always, whether or not this repository restates them.
+- **Where the leg ends**, restated as a concrete artefact or commit, matching the
+  boundary above.
+
+If the repository has no release machinery at all, say that in one line rather
+than inventing a plausible one. That is a finding the operator needs.
+
+## Answer
+
+One fenced markdown block containing the procedure and nothing else. No preamble,
+no commentary after it.