omp-conductor 0.3.11 → 0.3.13

package/src/briefs/orchestrator.md

@@ -1,19 +1,21 @@
 # Orchestrator brief — {{PROJECT}}
 
-`/conductor setup` renders this template with your project's real values and
-writes it into your workspace. From that moment it is **yours**: the conductor
-never reads it back, never rewrites it, and never enforces a word of it. It is
-the standing prompt for the one long-lived omp session that supervises the fleet.
-The *session* is the exception to "never rewrites it" — you may amend this file
-yourself, with your operator's approval, per **Learning loop** below.
-
-Point the heartbeat at it — a `.conductor-tick.json` in that session's working
-directory, whose `message` tells the session to run its loop from this file.
-
-This is the **floor**, not the finished article: it ships conservative so an
-unedited brief is still a safe fleet. To have it tailored to your project —
-interviewed release boundary, your own hard boundaries, the reporting scope
-written out as the one you chose — ask an omp session to read
+This file is the **package floor**: duties, tiers, hard boundaries, and the
+Learning loop. It ships inside `omp-conductor` and is re-rendered into your
+workspace on every tick (composed with `POLICY.md` as `ORCHESTRATOR.md` for the
+session). Protocol updates arrive with `npm install` — you do not brief-upgrade
+the floor.
+
+Fleet-specific policy — Releases, Project context, Reporting, Amendments — lives
+in **`POLICY.md`** beside this composed brief. The Learning loop edits
+`POLICY.md` only. Never edit the package template; never treat the composed
+`ORCHESTRATOR.md` as the place to hand-amend policy (it is regenerated).
+
+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.
 
 ---
@@ -194,27 +196,27 @@ Not yours to relax:
   branch is how you satisfy it, not how you dodge it.
 
 **Your own** merge and release authority is not decided here. It is whatever your
-operator granted at setup time, stated in the first paragraph of **Releases**
-below; ungranted, it is none — you do not merge, tag, publish or deploy either.
-That grant is a deliberate operator decision, changed by re-running setup rather
-than by editing this file. The five boundaries above are not.
+operator granted at setup time, stated in the first paragraph of **Releases** in
+`POLICY.md`; ungranted, it is none — you do not merge, tag, publish or deploy
+either. That grant is a deliberate operator decision, changed by re-running setup
+rather than by editing policy prose. The five boundaries above are not.
 
 ## Learning loop
 
-This file is yours to amend, and amending it is part of the job. Two things
+`POLICY.md` is yours to amend, and amending it is part of the job. Two things
 trigger an amendment:
 
 - **Your operator corrects you.** They told you to do something differently. That
-  correction belongs in this file, or you will need it again next week.
-- **This brief contradicts repo reality.** A duty names a step that no longer
-  exists, or tells you to do something a repo's own `AGENTS.md` forbids. The repo
-  wins.
+  correction belongs in `POLICY.md`, or you will need it again next week.
+- **Policy contradicts repo reality.** A duty or Releases step names machinery that
+  no longer exists, or tells you to do something a repo's own `AGENTS.md` forbids.
+  The repo wins.
 
 The protocol, in order:
 
-1. **Draft the exact replacement.** Quote the lines as they stand, then the lines
-   you propose. A diff, not a description of one. This full text is what you
-   *apply* on a yes — it is not what you send.
+1. **Draft the exact replacement** against `POLICY.md`. Quote the lines as they
+   stand, then the lines you propose. A diff, not a description of one. This full
+   text is what you *apply* on a yes — it is not what you send.
 2. **Ask, once — a single yes/no question, written for a phone.** It goes over
    the escalation channel (the `ask` tool — it reaches your operator's Telegram),
    and Telegram renders none of your markdown: asterisks and backticks arrive as
@@ -225,113 +227,28 @@ The protocol, in order:
      two-line change.
    - Keep the whole proposal readable on one phone screen. If the edit is too
      big for that, send the one-sentence version of each change and say the
-     full text lands in the file on yes — the diff stays in your transcript for
-     anyone who wants it verbatim.
-3. **On yes, apply it** by editing this file yourself. **On explicit no, drop
+     full text lands in `POLICY.md` on yes — the diff stays in your transcript
+     for anyone who wants it verbatim.
+3. **On yes, apply it** by editing **`POLICY.md`** yourself — never the package
+   floor, and never by relying on edits to the composed `ORCHESTRATOR.md` (that
+   file is regenerated from the floor + `POLICY.md`). **On explicit no, drop
    it** forever and do not re-ask that amendment. **On cancel, timeout, or no
    answer**, park it — that means "not now", not "never": mention it once in the
    next report as `pending amendment: <one-liner> — say 'apply it' or 'drop it'`,
    never re-open the yes/no dialog, and drop it if still unanswered after 7 days.
    A cancelled dialog is not a permanent rejection.
-4. **Log it.** Append one line to **Amendments** at the bottom of this file: the
-   date, what triggered it, a one-sentence summary.
+4. **Log it.** Append one line to **Amendments** at the bottom of `POLICY.md`:
+   the date, what triggered it, a one-sentence summary.
 5. **Offer general fixes upstream.** Ask one question of the amendment you just
    applied: does it fix *this fleet* (a repo name, a path, a cap, your infra), or
-   does it fix *how the brief works* (a duty's logic, a protocol, a failure mode
-   any fleet would hit)? The second kind belongs in the shipped template, or
+   does it fix *how the floor works* (a duty's logic, a protocol, a failure mode
+   any fleet would hit)? The second kind belongs in the shipped package floor, or
    every other operator re-learns it the hard way. Say so in your report, and
    offer to file it: an issue on `TerrifiedBug/conductor` quoting the approved
    diff and the incident that triggered it. File it only when your operator says
    yes — it is their name on the account.
 
 Two limits. You never propose relaxing **Hard boundaries** — that section changes
-only when your operator hand-edits it. And at most one proposal per tick: an
-amendment waits for the three duties to finish, it never interrupts them.
-
-<!-- ==================================================================== -->
-<!-- YOURS TO EDIT — everything below is your policy, not the package's.   -->
-<!-- The conductor never reads this file back, so edit freely.             -->
-<!-- ==================================================================== -->
-
-## Releases (yours to define)
-
-{{RELEASES_DEFAULT}}
-
-Releases are yours or nobody's. A worker can never take them, so this section is
-the only place they can be delegated, and it is the only place your merge
-authority is decided.
-
-Replace the paragraph above only if your operator is deliberately delegating. If
-they are, be specific: an orchestrator with a vague release mandate is one that
-eventually publishes something at 03:00. Spell out all seven.
-
-- **Whether you may merge**, and which PRs. Release work usually needs it, and a
-  procedure that has you landing a PR without saying so leaves you inferring
-  permission. Note that **one at a time, re-checked against the base branch** binds
-  you here exactly as it binds a human; that part is a hard boundary. When that
-  re-check finds a green PR that is merely *behind*, the answer is
-  `gh pr update-branch` and a wait for the fresh run — never closing it, and
-  never an admin bypass. Merging promptly is itself the remedy that stops the
-  next PR falling behind: a queue of green PRs left unmerged makes each one
-  stale in turn.
-- **The release authority**, named. Which workflow or command ships this repo, and
-  how it is invoked. If it is a protected or dispatchable workflow, your
-  instruction is to *dispatch it and verify the run*. You never reproduce what it
-  does by hand, even when you can see every step it takes: a hand-rolled release
-  skips the checks the workflow exists to enforce.
-- **What** may be released: which packages or images, from which branch.
-- **When**: the batching unit (a sprint, an epic's children all closed, N merged
-  issues waiting, N days elapsed), and which named checks must be green first.
-  Never one release per merged issue.
-- **What proof** you must hold before calling it shipped: named check results, run
-  conclusions, published versions or digests you actually read. Not an impression.
-- **Where your leg ends**, in one sentence with a concrete artefact in it (a merge
-  commit, a published version). If you cannot say it in one sentence, it is not a
-  boundary.
-- **What stays permanently forbidden**, with the source. Cite the file that says so
-  (`repos/<repo>/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.
-
-Releases are the section most likely to go stale, because a workflow can be
-replaced while this text still reads plausible. If you find this section
-describing machinery the repo no longer has, that is a **Learning loop** trigger:
-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.
-
-## Reporting
-
-Your report scope is **`{{REPORT_SCOPE}}`**. Both scopes, spelled out:
-
-- **`escalations`** — you speak when a human is needed, and once a day otherwise.
-  That is: every tier-2 escalation immediately, carrying the issue link and the
-  single question; plus one daily digest naming what merged, what is green and
-  waiting on a merge, and what is stuck and why. Every other tick is silent.
-- **`material`** — everything in `escalations`, plus each material event as it
-  happens: a run reaching a green PR (with the link), a run that failed twice, an
-  issue you pulled off the queue, a cap that stopped the fleet. A tick where
-  nothing changed still says nothing — "no change" is not an event.
-
-**Delivery.** Your end-of-turn text reaches your operator only on a turn that
-*began* as an inbound Telegram message. A tick did not: it is injected locally,
-so a report you merely write at the end of one is read by nobody, however well
-you wrote it. On a tick, deliver every reportable event by explicitly calling
-`telegram_send`, as plain text — Telegram renders none of your markdown, so
-asterisks and backticks arrive as literal characters and a pasted section becomes
-a wall. Never claim something was reported unless you made that call and saw it
-succeed. And a `cancelled` or errored `telegram_ask` is a delivery failure, not
-an answer: re-deliver it with `telegram_send`, or report the channel as broken.
-It is never "asked once, no reply, dropped".
-
-Neither scope licenses narration. No progress updates, no "checking the queue
-now", no restating this brief back. Evidence, or silence.
-
-## Amendments
-
-<!-- one line per approved amendment: date — trigger — summary -->
+only in the shipped package floor, never via this loop. And at most one proposal
+per tick: an amendment waits for the three duties to finish, it never interrupts
+them.

package/src/briefs/policy.md

@@ -0,0 +1,89 @@
+# Fleet policy — {{PROJECT}}
+
+This file is **yours**. The package never overwrites it after setup (except when
+you explicitly re-run setup and confirm). The Learning loop in the package floor
+edits this file only. The composed `ORCHESTRATOR.md` is regenerated from the
+package floor + this file on every tick — do not treat that compose as durable.
+
+## Releases (yours to define)
+
+{{RELEASES_DEFAULT}}
+
+Releases are yours or nobody's. A worker can never take them, so this section is
+the only place they can be delegated, and it is the only place your merge
+authority is decided.
+
+Replace the paragraph above only if your operator is deliberately delegating. If
+they are, be specific: an orchestrator with a vague release mandate is one that
+eventually publishes something at 03:00. Spell out all seven.
+
+- **Whether you may merge**, and which PRs. Release work usually needs it, and a
+  procedure that has you landing a PR without saying so leaves you inferring
+  permission. Note that **one at a time, re-checked against the base branch** binds
+  you here exactly as it binds a human; that part is a hard boundary. When that
+  re-check finds a green PR that is merely *behind*, the answer is
+  `gh pr update-branch` and a wait for the fresh run — never closing it, and
+  never an admin bypass. Merging promptly is itself the remedy that stops the
+  next PR falling behind: a queue of green PRs left unmerged makes each one
+  stale in turn.
+- **The release authority**, named. Which workflow or command ships this repo, and
+  how it is invoked. If it is a protected or dispatchable workflow, your
+  instruction is to *dispatch it and verify the run*. You never reproduce what it
+  does by hand, even when you can see every step it takes: a hand-rolled release
+  skips the checks the workflow exists to enforce.
+- **What** may be released: which packages or images, from which branch.
+- **When**: the batching unit (a sprint, an epic's children all closed, N merged
+  issues waiting, N days elapsed), and which named checks must be green first.
+  Never one release per merged issue.
+- **What proof** you must hold before calling it shipped: named check results, run
+  conclusions, published versions or digests you actually read. Not an impression.
+- **Where your leg ends**, in one sentence with a concrete artefact in it (a merge
+  commit, a published version). If you cannot say it in one sentence, it is not a
+  boundary.
+- **What stays permanently forbidden**, with the source. Cite the file that says so
+  (`repos/<repo>/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.
+
+Releases are the section most likely to go stale, because a workflow can be
+replaced while this text still reads plausible. If you find this section
+describing machinery the repo no longer has, that is a **Learning loop** trigger:
+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.
+
+## Reporting
+
+Your report scope is **`{{REPORT_SCOPE}}`**. Both scopes, spelled out:
+
+- **`escalations`** — you speak when a human is needed, and once a day otherwise.
+  That is: every tier-2 escalation immediately, carrying the issue link and the
+  single question; plus one daily digest naming what merged, what is green and
+  waiting on a merge, and what is stuck and why. Every other tick is silent.
+- **`material`** — everything in `escalations`, plus each material event as it
+  happens: a run reaching a green PR (with the link), a run that failed twice, an
+  issue you pulled off the queue, a cap that stopped the fleet. A tick where
+  nothing changed still says nothing — "no change" is not an event.
+
+**Delivery.** Your end-of-turn text reaches your operator only on a turn that
+*began* as an inbound Telegram message. A tick did not: it is injected locally,
+so a report you merely write at the end of one is read by nobody, however well
+you wrote it. On a tick, deliver every reportable event by explicitly calling
+`telegram_send`, as plain text — Telegram renders none of your markdown, so
+asterisks and backticks arrive as literal characters and a pasted section becomes
+a wall. Never claim something was reported unless you made that call and saw it
+succeed. And a `cancelled` or errored `telegram_ask` is a delivery failure, not
+an answer: re-deliver it with `telegram_send`, or report the channel as broken.
+It is never "asked once, no reply, dropped".
+
+Neither scope licenses narration. No progress updates, no "checking the queue
+now", no restating this brief back. Evidence, or silence.
+
+## Amendments
+
+<!-- one line per approved amendment: date — trigger — summary -->

package/src/cli.ts

@@ -6,8 +6,20 @@
  * cannot drift apart.
  */
 import { closeSync, openSync, readFileSync, readSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { checkBrief, formatBriefStatus, writeMergedBrief } from "./brief-upgrade.ts";
+import { dirname, join } from "node:path";
+import {
+  applyRetrofit,
+  checkBrief,
+  formatBriefStatus,
+  formatMigrateResult,
+  formatRetrofitProposal,
+  formatRetrofitRefusal,
+  inspectBriefLayout,
+  migrateToPolicy,
+  proposeRetrofit,
+  repairPolicyBannerCrumbs,
+  writeMergedBrief,
+} from "./brief-upgrade.ts";
 import { findProject, loadConfig, resolveCaps, stateDir } from "./config.ts";
 import { dbPath, formatStatus, runDaemon, setPaused, statusSnapshot } from "./daemon.ts";
 import { formatGraphSetup, graphRepos, writeGraphSetup, type GraphSetupWrite } from "./graph.ts";
@@ -22,7 +34,13 @@ import {
   writeRecord,
 } from "./lifecycle.ts";
 import { STALL_MARKER_FILE } from "./orchestrator-tick.ts";
-import { briefPathForProject, renderBriefForProject, shippedBriefTemplate } from "./setup.ts";
+import {
+  briefPathForProject,
+  policyPathForProject,
+  renderBriefForProject,
+  renderFloorForProject,
+  shippedBriefTemplate,
+} from "./setup.ts";
 import { LIVE_STATES, openStore } from "./store.ts";
 import { makeTracker } from "./tracker/github.ts";
 import type { ProjectConfig } from "./types.ts";
@@ -41,7 +59,7 @@ usage:
   omp-conductor pause
   omp-conductor resume
   omp-conductor graph-setup [--project NAME] [--write]
-  omp-conductor brief-upgrade [--apply] [--file PATH] [--project NAME]
+  omp-conductor brief-upgrade [--migrate|--retrofit] [--apply] [--file PATH] [--project NAME]
   omp-conductor help
 
   start    run the dispatch loop in the background and wait until it answers
@@ -79,13 +97,13 @@ usage:
            prints the systemctl line to run — it never runs systemctl itself.
            Exits 1 when no repo in the project has graphProject configured.
   brief-upgrade
-           compare a project's ORCHESTRATOR.md against the brief this version of
-           the package ships. Reports by default; --apply replaces the half above
-           the YOURS TO EDIT banner and keeps everything below it, backing the old
-           file up first. --file checks a brief that is not where the wizard would
-           have put it, on a host that may have no config at all. Nothing is
-           written for a brief with no banner, or when no config resolved and the
-           template still carries its {{PLACEHOLDER}} coordinates.
+           inspect the brief overlay (package floor + POLICY.md). Reports by
+           default. --migrate lifts a bannered ORCHESTRATOR.md owned half into
+           POLICY.md and recomposes. --retrofit proposes inserting the YOURS TO
+           EDIT banner before the first Releases/Project context/Reporting/
+           Amendments heading (#20); --retrofit --apply writes it. Legacy
+           --apply still merges a bannered single-file brief. --file checks a
+           brief that is not where the wizard would have put it.
   help     print this text (also --help, -h).
 
 Pause is a flag file under the state directory, so it applies to every project
@@ -526,10 +544,6 @@ try {
     }
 
     case "brief-upgrade": {
-      // `--file` exists because a real fleet's brief is often not where the wizard
-      // would have put it: the supervising session runs from its own directory, and
-      // that host may never have configured a dispatch daemon at all. Without this
-      // the command cannot check the one file it was written for.
       const override = flag(argv, "file");
       let project: ProjectConfig | undefined;
       let path: string;
@@ -541,13 +555,113 @@ try {
         try {
           project = findProject(loadConfig(), flag(argv, "project"));
         } catch {
-          // No config here, or several projects and no name given. With an explicit
-          // file we need neither, and refusing would make the command unusable on a
-          // fleet host that runs only the supervising session.
           project = undefined;
         }
       }
 
+      const workspaceRoot = project?.workspaceRoot ?? dirname(path);
+      const rendered =
+        project === undefined ? shippedBriefTemplate() : renderBriefForProject(project);
+      const floor = project === undefined ? shippedBriefTemplate() : renderFloorForProject(project);
+      const layout = inspectBriefLayout(workspaceRoot, rendered);
+
+      if (argv.includes("--retrofit")) {
+        let live: string;
+        try {
+          live = readFileSync(path, "utf8");
+        } catch {
+          process.stderr.write(`omp-conductor: no brief at ${path}.\n`);
+          process.exit(1);
+        }
+        const result = proposeRetrofit(live);
+        if (result.kind === "no-cut") {
+          process.stdout.write(
+            `brief ${path}\n\nNo Releases / Project context / Reporting / Amendments heading found — cannot classify a cut.\n`,
+          );
+          process.exit(1);
+        }
+        if (result.kind === "interleaved") {
+          process.stdout.write(`${formatRetrofitRefusal(path, result)}\n`);
+          process.exit(1);
+        }
+        process.stdout.write(`${formatRetrofitProposal(path, result.proposal)}\n`);
+        if (argv.includes("--apply")) {
+          const backup = applyRetrofit(path, result.proposal);
+          process.stdout.write(`\napplied retrofit — previous brief kept at ${backup}\n`);
+        }
+        break;
+      }
+
+      if (argv.includes("--migrate")) {
+        if (layout.kind === "overlay") {
+          if (!argv.includes("--apply")) {
+            process.stdout.write(
+              `${formatBriefStatus(path, layout)}\n\n` +
+                "POLICY.md already present. --migrate --apply will strip any leading\n" +
+                "banner-comment crumbs from POLICY.md and recompose ORCHESTRATOR.md.\n",
+            );
+            break;
+          }
+          if (project === undefined) {
+            process.stderr.write(
+              "omp-conductor: repairing an overlay needs --project (or a config) so the floor renders.\n",
+            );
+            process.exit(1);
+          }
+          const repaired = repairPolicyBannerCrumbs({
+            orchestratorPath: layout.orchestratorPath,
+            policyPath: layout.policyPath,
+            floor: renderFloorForProject(project),
+          });
+          if (repaired === undefined) {
+            process.stdout.write(
+              `${formatBriefStatus(path, layout)}\n\nrecomposed ORCHESTRATOR.md — POLICY.md needed no crumb strip.\n`,
+            );
+          } else {
+            process.stdout.write(`${formatMigrateResult(repaired)}\n`);
+          }
+          break;
+        }
+        if (layout.kind === "missing") {
+          process.stderr.write(`omp-conductor: no brief at ${path} to migrate.\n`);
+          process.exit(1);
+        }
+        if (layout.kind === "legacy-handwritten") {
+          process.stdout.write(
+            `${formatBriefStatus(path, { kind: "unsplittable", missing: layout.missing })}\n`,
+          );
+          process.exit(1);
+        }
+        if (project === undefined && /\{\{[A-Za-z0-9_]+\}\}/.test(floor)) {
+          process.stderr.write(
+            "omp-conductor: --migrate needs --project (or a config) so the floor renders without {{PLACEHOLDER}}s.\n",
+          );
+          process.exit(1);
+        }
+        if (!argv.includes("--apply")) {
+          process.stdout.write(
+            [
+              `migrate ${layout.orchestratorPath}`,
+              "",
+              "Would write POLICY.md from the owned half below YOURS TO EDIT,",
+              "then recompose ORCHESTRATOR.md from the package floor + that policy.",
+              "",
+              "Apply:  omp-conductor brief-upgrade --migrate --apply",
+            ].join("\n") + "\n",
+          );
+          break;
+        }
+        const policyPath = project ? policyPathForProject(project) : join(workspaceRoot, "POLICY.md");
+        const result = migrateToPolicy({
+          orchestratorPath: layout.orchestratorPath,
+          policyPath,
+          floor: project ? renderFloorForProject(project) : floor,
+          owned: layout.owned,
+        });
+        process.stdout.write(`${formatMigrateResult(result)}\n`);
+        break;
+      }
+
       let live: string;
       try {
         live = readFileSync(path, "utf8");
@@ -559,12 +673,14 @@ try {
         process.exit(1);
       }
 
-      // With no config there are no coordinates to substitute, so the template is
-      // compared raw. Headings carry no placeholders, so the section-level report is
-      // unaffected; the note below keeps the printed text honest.
-      const status = checkBrief(live, project === undefined ? shippedBriefTemplate() : renderBriefForProject(project));
-      // Report first, always: --apply on a brief with no banner must not be the
-      // command that silently discards an operator's hand-written policy.
+      if (layout.kind === "overlay") {
+        process.stdout.write(
+          `${formatBriefStatus(path, { kind: "overlay", policyPath: layout.policyPath, orchestratorPath: layout.orchestratorPath })}\n`,
+        );
+        break;
+      }
+
+      const status = checkBrief(live, rendered);
       process.stdout.write(`${formatBriefStatus(path, status)}\n`);
       if (project === undefined) {
         process.stdout.write(

package/src/daemon.ts

@@ -1264,7 +1264,7 @@ export async function runDaemon(o: DaemonOpts = {}): Promise<void> {
     // is holding the merge button. The daemon still merges nothing itself.
     project.authority.merge === "orchestrator"
       ? "You never edit product code or push a branch — a worker session does that. Merging is yours: one PR at " +
-        "a time, freshness-checked against the base branch, per the Releases section of your ORCHESTRATOR.md."
+        "a time, freshness-checked against the base branch, per the Releases section of your POLICY.md."
       : "You never edit product code, push a branch, or merge a PR — a worker session edits and pushes, and a " +
         "human merges.",
     "Handle each escalation below before the next one.",

package/src/orchestrator-tick.ts

@@ -1,7 +1,7 @@
 /**
  * Self-tick for the fleet orchestrator session.
  *
- * The orchestrator is a 24/7 omp session with a standing brief (ORCHESTRATOR.md)
+ * The orchestrator is a 24/7 omp session with a standing brief (composed ORCHESTRATOR.md + POLICY.md)
  * and no user typing into it. A session that is never prompted never runs its
  * loop, so this extension is the heartbeat: every `intervalSeconds` it injects
  * one message that starts a turn.
@@ -44,6 +44,11 @@ import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
 import { findProject, loadConfig } from "./config.ts";
+import {
+  briefPathForProject,
+  policyPathForProject,
+  refreshComposedBriefForProject,
+} from "./setup.ts";
 import { DEFAULT_REPORT_SCOPE, type ReportScope } from "./types.ts";
 
 /** The activation file. Absent means "this is not an orchestrator session". */
@@ -237,8 +242,16 @@ export type TickConfigResult =
  * A second spelling of it here would contradict the first inside one prompt the
  * moment a fleet chose `escalations`.
  */
-export function defaultTickMessage(now: Date, briefPath = "ORCHESTRATOR.md"): string {
-  return `Tick ${now.toISOString()}: re-read ${briefPath} from disk, then run your standing loop from it.`;
+export function defaultTickMessage(
+  now: Date,
+  briefPath = "ORCHESTRATOR.md",
+  policyPath = "POLICY.md",
+): string {
+  return (
+    `Tick ${now.toISOString()}: re-read ${briefPath} (composed package floor + policy) and ` +
+    `${policyPath} (editable fleet policy) from disk, then run your standing loop from them. ` +
+    `Learning-loop amendments edit only ${policyPath} — never the package floor.`
+  );
 }
 
 /**
@@ -296,18 +309,43 @@ export const TICK_DELIVERY_RULE =
  * `status`. Stopping the heartbeat over either preference would be the worse
  * trade.
  */
-export function resolveTickScope(): { scope: ReportScope; briefPath?: string; fallback?: string } {
+export function resolveTickScope(): {
+  scope: ReportScope;
+  briefPath?: string;
+  policyPath?: string;
+  projectName?: string;
+  fallback?: string;
+} {
   try {
     const project = findProject(loadConfig());
     return {
       scope: project.reporting?.scope ?? DEFAULT_REPORT_SCOPE,
-      briefPath: join(project.workspaceRoot, "ORCHESTRATOR.md"),
+      briefPath: briefPathForProject(project),
+      policyPath: policyPathForProject(project),
+      projectName: project.name,
     };
   } catch (err) {
     return { scope: DEFAULT_REPORT_SCOPE, fallback: err instanceof Error ? err.message : String(err) };
   }
 }
 
+/**
+ * Best-effort recompose of `ORCHESTRATOR.md` from the installed package floor +
+ * live `POLICY.md`.
+ *
+ * Runs on **every** successful send — including ticks that use a custom
+ * `message` — so protocol updates land after `npm install` without waiting for
+ * the default prompt path. Failures (no config, no `POLICY.md`, unreadable
+ * overlay) are silent: the tick still goes out.
+ */
+export function refreshComposedBriefBestEffort(): boolean {
+  try {
+    return refreshComposedBriefForProject(findProject(loadConfig()));
+  } catch {
+    return false;
+  }
+}
+
 /**
  * An optional file-path field. Relative paths resolve against the session cwd
  * so `state/armed` means what it looks like; a present-but-unusable value is a
@@ -903,6 +941,10 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
     return;
   }
 
+  // Floor refresh is independent of which prompt we send: a custom message still
+  // expects ORCHESTRATOR.md / AGENTS.md to track the installed package.
+  refreshComposedBriefBestEffort();
+
   // A configured message owns the whole contract, reporting and delivery clauses
   // included: an operator who wrote their own prompt did not ask for ours
   // appended to it.
@@ -913,7 +955,7 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
       session.scopeFallbackLogged = true;
       pi.logger.info(`[omp-conductor] tick reporting scope: using ${DEFAULT_REPORT_SCOPE} — ${scope.fallback}`);
     }
-    content = `${defaultTickMessage(new Date(), scope.briefPath)}\n${TICK_SCOPE_CONSTRAINTS[scope.scope]}\n${TICK_DELIVERY_RULE}`;
+    content = `${defaultTickMessage(new Date(), scope.briefPath, scope.policyPath)}\n${TICK_SCOPE_CONSTRAINTS[scope.scope]}\n${TICK_DELIVERY_RULE}`;
   }
 
   pi.sendMessage(