omp-conductor 0.10.0 → 0.13.0

package/src/diff-flags.ts

@@ -266,17 +266,49 @@ const CHANGED_LINE = /^[ \t>]*changed:[ \t]*(.*)$/im;
  */
 const CLAIMED_PATH = /^(?:[\w.@~+-]+\/)+[\w.@~*+-]*$|^[\w.@~+-]*\.[A-Za-z][A-Za-z0-9]{1,7}$/;
 
+/** A Python dotted module: `services.rule_purge`, `omp.routing`. Not a path —
+ *  segments joined by `.` — but a legitimate way for a report to name the file
+ *  it touched without disclosing the directory it lives in (#224).
+ *
+ *  Every segment is at least two characters so prose abbreviations (`e.g`,
+ *  `i.e.`, `a.k.a`) stay commentary: they are exactly the prose the path
+ *  heuristic exists to reject, and each one that slipped through would become
+ *  an "you claimed a file you never touched" flag on an honest report. */
+const DOTTED_MODULE = /^[A-Za-z_]\w+(?:\.[A-Za-z_]\w+)+$/;
+
+/** One-level brace expansion: `a/{b,c}.py` → [`a/b.py`, `a/c.py`]. Braces are
+ *  how a report compresses adjacent files into one token; each comma-separated
+ *  alternative is substituted into the skeleton. Nesting is deliberately
+ *  unsupported — one level matches the spellings reports actually produce. */
+function expandBraces(token: string): string[] {
+  const group = /\{[^{}]*\}/.exec(token);
+  if (group === null) return [token];
+  const alternatives = group[0].slice(1, -1).split(",").filter((a) => a.length > 0);
+  if (alternatives.length === 0) return [token];
+  const prefix = token.slice(0, group.index);
+  const suffix = token.slice(group.index + group[0].length);
+  return alternatives.map((alt) => prefix + alt + suffix);
+}
+
 /** Every path-shaped token on the report's `changed:` line. An absent line and
  *  a line naming nothing are the same answer: nothing was disclosed. */
 export function claimedPaths(report: string): string[] {
   const line = CHANGED_LINE.exec(report)?.[1] ?? "";
   const seen = new Set<string>();
-  for (const raw of line.split(/[\s,;]+/)) {
+  // Split on whitespace and semicolons, and on commas *outside* a brace group:
+  // the comma in `a/{b,c}.py` is an alternative separator, not a token
+  // separator, so a brace-compressed token must survive whole (#224).
+  for (const raw of line.split(/[\s;]+|,(?![^{}]*\})/)) {
     const token = raw.replace(/^[`'"([*-]+/, "").replace(/[`'")\].,:;]+$/, "");
     if (token === "" || token === "none") continue;
     const normalised = token.replace(/^\.?\//, "");
-    if (!CLAIMED_PATH.test(normalised)) continue;
-    seen.add(normalised);
+    // Expansion happens here so every downstream consumer — both `covers`
+    // directions — sees plain paths: a brace token dies earlier at the
+    // CLAIMED_PATH filter if it is never opened up (#224).
+    for (const expanded of expandBraces(normalised)) {
+      if (!CLAIMED_PATH.test(expanded) && !DOTTED_MODULE.test(expanded)) continue;
+      seen.add(expanded);
+    }
   }
   return [...seen];
 }
@@ -305,6 +337,15 @@ function covers(claim: string, path: string): boolean {
     return pattern.test(path) || pattern.test(basename(path));
   }
   if (path.endsWith(`/${claim}`) || claim.endsWith(`/${path}`)) return true;
+  // A Python dotted module names a file by import path, not by location:
+  // `services.rule_purge` covers `backend/app/services/rule_purge.py`. Only
+  // consulted after the path rules, because `foo.bar` is also a valid filename
+  // and a literal match must win. Matching several changed files is fine — the
+  // check wants evidence the worker knew, not a unique index (#224).
+  if (DOTTED_MODULE.test(claim)) {
+    const fragment = `${claim.replaceAll(".", "/")}.py`;
+    if (path === fragment || path.endsWith(`/${fragment}`)) return true;
+  }
   const last = claim.slice(claim.lastIndexOf("/") + 1);
   return !last.includes(".") && path.startsWith(`${claim}/`);
 }
@@ -704,6 +745,10 @@ export function formatSettlementFlags(
       pooledHeading(diff.attempts),
   ];
   for (const flag of flags.slice(0, RENDERED_FLAGS)) {
+    if (flag.kind === "pr-adopted") {
+      lines.push(`  ${flag.kind} — ${flag.detail}`);
+      continue;
+    }
     lines.push(
       `  ${flag.kind}  ${flag.file}${flag.line === undefined ? "" : `:${flag.line}`} — ${flag.detail}` +
         (flag.unattributed === true ? "  [unattributed: the dispatching issue never names this file]" : ""),

package/src/digest-schedule.ts

@@ -0,0 +1,59 @@
+/**
+ * When the daily digest is due, in the zone the operator reads it (#229).
+ *
+ * Pure by construction: every fact arrives as a timestamp and the policy, and
+ * nothing here reads a clock or a file. The digest is "one per day" in the
+ * IANA zone it is configured with (host zone when none) — a UTC key would roll
+ * the digest over mid-evening for anyone west of Greenwich.
+ */
+
+import type { ReportingPolicy } from "./types.ts";
+
+/** `YYYY-MM-DD` in an IANA timezone (host zone when `timezone` is absent). */
+export function localDayKey(at: number, timezone?: string): string {
+  const parts = new Intl.DateTimeFormat("en-CA", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+  }).formatToParts(new Date(at));
+  const get = (type: "year" | "month" | "day"): string =>
+    parts.find((p) => p.type === type)?.value ?? "00";
+  return `${get("year")}-${get("month")}-${get("day")}`;
+}
+
+/** `HH:MM` wall-clock in the zone, 24h and zero-padded. */
+function localClockAt(at: number, timezone?: string): string {
+  return new Intl.DateTimeFormat("en-GB", {
+    timeZone: timezone,
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23",
+  }).format(new Date(at));
+}
+
+/**
+ * Whether the digest is due now.
+ *
+ * - `none` → never.
+ * - `per-tick` → always (the orchestrator sends it with every report).
+ * - `daily` without `at` → once per day in the configured zone.
+ * - `daily` with `at` → on a day it has not already run, once the local clock
+ *   has passed `at`. A restart after `at` still finds today unsent → one
+ *   catch-up; a fully missed day is skipped, never sent late.
+ */
+export function digestDue(
+  policy: Pick<ReportingPolicy, "digest">,
+  lastDigestDayKey: string | undefined,
+  now: number,
+): boolean {
+  const { cadence, at, timezone } = policy.digest;
+  if (cadence === "none") return false;
+  if (cadence === "per-tick") return true;
+  // daily
+  if (at === undefined) {
+    return lastDigestDayKey !== localDayKey(now, timezone);
+  }
+  if (lastDigestDayKey === localDayKey(now, timezone)) return false;
+  return localClockAt(now, timezone) >= at;
+}

package/src/escalate.ts

@@ -213,6 +213,23 @@ export function createEscalator(
       if (e.tier === 2 && chatId) {
         const token = readTelegramToken();
         if (token) {
+          // The digest can own deferred delivery only while its orchestrator
+          // loop is alive. An urgent escalation says that loop is the failed
+          // component, so waiting for its digest would park the only warning
+          // behind the failure it reports (#246).
+          const category = e.category ?? "tier2";
+          const interruptOn = p.reporting?.interruptOn;
+          if (!e.urgent && interruptOn !== undefined && !interruptOn.includes(category)) {
+            store.addHeldNotice({
+              project: p.name,
+              category,
+              summary: e.summary,
+              detail: text,
+              createdAt: Date.now(),
+            });
+            store.markNotified(key);
+            return;
+          }
           // A send failure throws: `markNotified` stays uncalled so the next
           // poll retries instead of writing the event off as delivered. No
           // backoff in here — the dispatcher tick *is* the retry, and an

package/src/failure-class.ts

@@ -22,6 +22,9 @@ export interface ClassifyFacts {
   pr?: "open" | "merged" | "closed";
   mergeable?: "conflicting" | "clean" | "unknown";
   checks?: { name: string; state: string; link?: string }[];
+  /** Full session error recovered from the transcript. Kept as a fact so a
+   *  classification retry does not lose an HTTP status the run row cannot store. */
+  sessionError?: { status?: number; message: string };
   /** Tail (ANSI-stripped) of the first failed check's log, when one was
    *  reachable. Lets the table tell an infrastructure outage (#177) from a
    *  deterministic test failure by the log's own words. */
@@ -144,6 +147,16 @@ export function providerCreditRefusal(error: {
   return error.message.split("\n")[0]?.trim() ?? error.message;
 }
 
+/** Provider text that names a per-request stream fault. Deliberately narrow:
+ *  a 429 is rate limiting and a 402 is credit — different remedies (#220). */
+const TRANSIENT_FAULT_SIGNATURES = ["stream stalled"] as const;
+
+export function providerTransientFault(error: { status?: number; message: string }): string | undefined {
+  const text = error.message.toLowerCase();
+  if (!TRANSIENT_FAULT_SIGNATURES.some((s) => text.includes(s))) return undefined;
+  return error.message.split("\n")[0]?.trim() ?? error.message;
+}
+
 /**
  * Evidence that this run never started, or `undefined` when something did happen.
  *
@@ -211,6 +224,8 @@ const DISPATCH_GIT_ERROR = /^(?:Error: )?git .+ exited \d+/s;
 
 export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classification {
   const hasArtifacts = run.prUrl !== undefined || run.headSha !== undefined || run.salvageSha !== undefined;
+  const providerError =
+    facts.sessionError ?? (run.lastError === undefined ? undefined : { message: run.lastError });
 
   // The PR landed while the row says otherwise. Whatever else is true about this
   // run, it succeeded, and the recovery is bookkeeping.
@@ -239,15 +254,27 @@ export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classificatio
   // first request produces a turn-0 row with no artifacts, which
   // `env-start-failure` would otherwise absorb and lose the cause.
   if (run.state === "failed" || run.state === "killed") {
-    const credit =
-      run.lastError === undefined
-        ? undefined
-        : providerCreditRefusal({ message: run.lastError });
+    const credit = providerError === undefined ? undefined : providerCreditRefusal(providerError);
     if (credit !== undefined) {
       return { cls: "provider-credit", recovery: "requeue", evidence: credit };
     }
   }
 
+  // A per-request stream fault: the provider aborted mid-stream — the session
+  // records "OpenAI responses stream stalled while waiting for the next event",
+  // but the attempt never produced a verdict and 0 tokens were billed. Not the
+  // work's fault, so it must not charge an implementation attempt; requeued, but
+  // bounded by PROVIDER_TRANSIENT_MAX_STRIKES so a provider that keeps aborting
+  // escalates to a human instead of looping (#220). Ahead of `neverStarted` for
+  // the same reason as the credit branch: a turn-0 stall would otherwise be
+  // absorbed by `env-start-failure` and lose its cause.
+  if (run.state === "failed" || run.state === "killed") {
+    const transient = providerError === undefined ? undefined : providerTransientFault(providerError);
+    if (transient !== undefined) {
+      return { cls: "provider-transient", recovery: "requeue", evidence: transient };
+    }
+  }
+
   // A run that never started is the most classifiable failure there is, and the
   // least deserving of an implementation attempt: the session did not get as far
   // as reading the issue. See {@link neverStarted} for the two shapes and why the

package/src/fleet.ts

@@ -38,6 +38,7 @@ import { settlementFlagSummary } from "./diff-flags.ts";
 import { probeCodeGraph, type CodeGraphHealth } from "./graph-health.ts";
 import { formatOpenReports } from "./reports.ts";
 import {
+  formatBaseChecks,
   formatDispatchSummary,
   formatReleaseGrants,
   formatSalvagedRuns,
@@ -1026,7 +1027,7 @@ export function formatFleetStatus(
   // a halt) answers "who stopped the fleet" without opening a file (#185). An
   // unparseable sentinel — paused but with no datable line 1 — is itself news:
   // it means a run admitted before an *unknown* pause cannot prove innocence
-  // (#174), so every mutation is refused.
+  // (#174), so completion mutations fail closed while release gates remain usable.
   const dispatchLine =
     layers.dispatch === "paused"
       ? (() => {
@@ -1036,7 +1037,7 @@ export function formatFleetStatus(
             return `dispatch  paused (source: ${prov.source}${reason})`;
           }
           return isPaused() && pausedAt() === undefined
-            ? "dispatch  paused (unparseable sentinel — all mutations refused)"
+            ? "dispatch  paused (unparseable sentinel — new work and completion mutations refused; release gates remain available)"
             : "dispatch  paused";
         })()
       : `dispatch  ${layers.dispatch}`;
@@ -1110,6 +1111,9 @@ function formatProjectBody(s: StatusSnapshot): string {
           })`,
         ]),
     `  new worker turns   ${s.caps.workerMaxTurns}`,
+    ...s.turnOverrides.map(
+      ({ issue, maxTurns }) => `  turn override      #${issue} → ${maxTurns} (next attempt)`,
+    ),
     `  worker wall clock  ${Math.round(s.caps.workerWallClockMs / 60_000)}m`,
     `  failed attempts    ${s.caps.maxAttemptsPerIssue}`,
     `  continuations      ${s.caps.maxContinuationsPerIssue}`,
@@ -1136,6 +1140,7 @@ function formatProjectBody(s: StatusSnapshot): string {
       if (flagged !== undefined) lines.push(`      ${flagged}`);
     }
   }
+  lines.push(...formatBaseChecks(s.baseChecks));
   lines.push(...formatSalvagedRuns(s.salvagedRuns));
   lines.push(...formatOpenReports(s.openReports));
   if (s.liveWorkers > 0) {
@@ -1381,7 +1386,7 @@ export async function probeTelegramHealth(
       detail: `${username}; inbound configured; interactive profile relays assistant text — /telegram set profile daemon`,
     };
   }
-  return { kind: "ok", detail: `${username}; inbound configured; telegram_ask available` };
+  return { kind: "ok", detail: `${username}; inbound configured; telegram_ask expected per config (mounted per turn by omp-telegram — a tick that finds it missing falls back to telegram_send and says so)` };
 }
 
 export function sessionDirForCwd(cwd: string): string {

package/src/gitops.ts

@@ -19,7 +19,9 @@
 
 import { join } from "node:path";
 
+import { parseChainSource, type ChainEntry } from "./chain-check.ts";
 import type { ProjectConfig, RepoTarget } from "./types.ts";
+import { ensureMirror } from "./worktree.ts";
 
 /**
  * One process run, captured. Injected everywhere in this module so the
@@ -190,3 +192,50 @@ export async function openRunPr(
   }
   return { ok: true, url };
 }
+
+// ------------------------------------------------- the migration-chain guard
+
+/**
+ * The base branch's ordered migration chain, read at the tip — not from a
+ * checkout that might be stale, but from the live mirror `ensureMirror`
+ * refreshes every call, which is the same freshness contract the dispatch path
+ * relies on. Alembic fields only; files without a `revision` line are skipped.
+ */
+export async function readBaseChain(
+  project: Pick<ProjectConfig, "mirrorRoot">,
+  repo: RepoTarget,
+  dir: string,
+  exec: Exec = spawnCaptured,
+): Promise<{ ok: true; entries: ChainEntry[] } | { ok: false; stderr: string }> {
+  try {
+    const mirror = await ensureMirror(repo, project.mirrorRoot);
+    const env = credentialedEnv();
+    const listed = await exec(
+      ["git", "--git-dir", mirror, "ls-tree", "-r", "--name-only", repo.defaultBranch, "--", dir],
+      { env },
+    );
+    if (listed.code !== 0) {
+      return {
+        ok: false,
+        stderr: scrubUserinfo(listed.stderr.trim() || listed.stdout.trim() || `git ls-tree exited ${String(listed.code)}`),
+      };
+    }
+    const entries: ChainEntry[] = [];
+    for (const rel of listed.stdout.split("\n")) {
+      const path = rel.trim();
+      if (path === "" || !path.endsWith(".py")) continue;
+      const shown = await exec(["git", "--git-dir", mirror, "show", `${repo.defaultBranch}:${path}`], { env });
+      if (shown.code !== 0) {
+        return {
+          ok: false,
+          stderr: scrubUserinfo(shown.stderr.trim() || `git show ${path} exited ${String(shown.code)}`),
+        };
+      }
+      const parsed = parseChainSource(path, shown.stdout);
+      if (parsed !== undefined) entries.push(parsed);
+    }
+    return { ok: true, entries };
+  } catch (err) {
+    return { ok: false, stderr: err instanceof Error ? err.message : String(err) };
+  }
+}

package/src/omp.ts

@@ -19,7 +19,7 @@ import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 
 import { worktreeConfinement } from "./confinement.ts";
-import { releasePolicyTripwire } from "./release-policy.ts";
+import { releasePolicyTripwire, type ReleaseBlockContext } from "./release-policy.ts";
 import type {
   HostToParent,
   ParentToHost,
@@ -46,6 +46,12 @@ export interface AgentSessionLike {
    */
   on(event: string, cb: (e: unknown) => void): void;
   abort(): void;
+  /**
+   * Cooperative operator park: abort the active turn and resolve when the
+   * harness is idle (#238). Distinct from `abort()`, which is the
+   * fire-and-forget kill path and must stay cheap for cap kills.
+   */
+  park(): Promise<void>;
   /**
    * Absolute transcript path the harness opened, so a human — and the
    * arm/monitor tooling — can read what the worker actually did. `undefined`
@@ -93,7 +99,11 @@ interface OmpModule {
 interface RawSession {
   prompt(text: string, opts?: unknown): Promise<unknown>;
   subscribe(listener: (event: unknown) => void): unknown;
-  abort(opts?: unknown): void;
+  abort(opts?: {
+    goalReason?: "interrupted" | "internal";
+    reason?: string;
+    preserveCompaction?: boolean;
+  }): Promise<void> | void;
   dispose?(opts?: unknown): Promise<unknown>;
   readonly sessionFile?: string;
 }
@@ -148,7 +158,7 @@ export async function createLocalSession(opts: {
   /** Install the release/deploy tool-call gate with these per-shape grants. */
   releaseGrants?: ResolvedGrants;
   /** Durable audit callback invoked only when that gate rejects a call. */
-  onReleaseBlocked?: (shape: ReleaseShape) => void;
+  onReleaseBlocked?: (shape: ReleaseShape, context: ReleaseBlockContext) => void;
   /**
    * The conductor verb socket this session's mutation tools call (#126).
    *
@@ -262,6 +272,11 @@ export async function createLocalSession(opts: {
     abort() {
       raw.abort();
     },
+    park() {
+      return Promise.resolve(
+        raw.abort({ goalReason: "interrupted", reason: "operator pause" }),
+      ).then(() => undefined);
+    },
     // The path the session actually opened, never one we asked for: the
     // arm/monitor tooling reads this file as proof of activity, so a path
     // nothing ever writes to is worse than no path at all.
@@ -378,7 +393,7 @@ export interface CreateSessionOptions {
   resume?: boolean;
   role: SessionRole;
   releaseGrants?: ResolvedGrants;
-  onReleaseBlocked?: (shape: ReleaseShape) => void;
+  onReleaseBlocked?: (shape: ReleaseShape, context: ReleaseBlockContext) => void;
 
   /**
    * Where the control socket is bound. The daemon puts it beside the run's own
@@ -421,10 +436,10 @@ export interface CreateSessionOptions {
  * Start one omp coding session in a **child process** and return a proxy for it.
  *
  * The proxy is the whole of `omp-conductor`'s view of a session, and it is
- * deliberately thin: {@link AgentSessionLike} has five members, so there are
- * five things to forward and nothing else belongs here. `prompt` and `abort`
- * go out over a unix socket, harness events come back and are re-emitted to the
- * same `on()` subscribers the in-process version served, and `sessionFile` is
+ * deliberately thin: {@link AgentSessionLike} is the entire forwarded
+ * surface. `prompt`, `park`, and `abort` go out over a unix socket, harness
+ * events come back and are re-emitted to the same `on()` subscribers the
+ * in-process version served, and `sessionFile` is
  * whatever path the child reports the session actually opened — never one this
  * side invented.
  *
@@ -657,8 +672,20 @@ export async function createSession(opts: CreateSessionOptions): Promise<AgentSe
           else waiter.reject(new Error(message.error ?? "session prompt failed"));
           break;
         }
+        case "park-result": {
+          const waiter = pending.get(message.id);
+          if (waiter === undefined) break;
+          pending.delete(message.id);
+          if (message.ok) waiter.resolve();
+          else waiter.reject(new Error(message.error ?? "session park failed"));
+          break;
+        }
         case "release-blocked":
-          opts.onReleaseBlocked?.(message.shape);
+          opts.onReleaseBlocked?.(message.shape, {
+            tool: message.tool,
+            reason: message.reason,
+            args: message.args,
+          });
           break;
       }
     }
@@ -693,6 +720,14 @@ export async function createSession(opts: CreateSessionOptions): Promise<AgentSe
       // would make this seam depend on a shape it deliberately does not name.
       return promise.then(() => undefined);
     },
+    park() {
+      promptSeq += 1;
+      const id = promptSeq;
+      const { promise, resolve, reject } = Promise.withResolvers<void>();
+      pending.set(id, { resolve, reject });
+      write({ t: "park", id });
+      return promise.then(() => undefined);
+    },
     on(event, cb) {
       const list = handlers.get(event);
       if (list) list.push(cb);

package/src/orchestrator-tick.ts

@@ -62,23 +62,27 @@ import {
 } from "./setup.ts";
 import {
   recordReleaseBlock,
+  redactReleaseArgs,
   releaseDriftDigestLine,
   releaseRefusal,
   releaseShapeFromTool,
   type ReleaseDecision,
 } from "./release-policy.ts";
 import {
+  DEFAULT_REPORT_POLICY,
   DEFAULT_REPORT_SCOPE,
   DENIED_RELEASE_GRANTS,
   type DispatchSummary,
   type FrictionSignal,
   type ReportScope,
+  type ReportingPolicy,
   type ResolvedGrants,
   type Store,
 } from "./types.ts";
 import { formatDecisionDigest } from "./decisions.ts";
 import type { RunRecord } from "./types.ts";
 import { dbPath, openStore } from "./store.ts";
+import { digestDue } from "./digest-schedule.ts";
 
 /** The activation file. Absent means "this is not an orchestrator session". */
 export const TICK_CONFIG_FILE = ".conductor-tick.json";
@@ -386,7 +390,17 @@ export function queueDigestLine(
     return `Queue: empty — nothing carries "${queueLabel}". Groom the backlog (Duty 2): promote or file the next issues, or say in this tick's report why there is nothing to do.`;
   }
   if (summary.routed === 0) {
-    return `Queue: ${summary.ready} ready but 0 routable — each needs exactly one "${labelPrefix}<repo>" label before dispatch can ever see it.`;
+    // `ready` counts claimed (in-flight) issues too; route() drops those with a
+    // state label silently, so "0 routable" must not blanket-blame missing
+    // `repo:` labels (#228). Spare depth is what dispatch can actually claim.
+    const claimed = summary.claimed ?? 0;
+    const unroutable = summary.holds
+      .filter((h) => h.reason.startsWith("unroutable:"))
+      .reduce((n, h) => n + h.count, 0);
+    if (unroutable === 0) {
+      return `Queue: ${summary.ready} ready, 0 spare — ${claimed} in flight. Spare depth is what dispatch can actually claim: groom the backlog (Duty 2) before the live runs settle.`;
+    }
+    return `Queue: ${summary.ready} ready, 0 spare — ${claimed} in flight, ${unroutable} unroutable (each unroutable issue needs exactly one "${labelPrefix}<repo>" label).`;
   }
   if (summary.routed >= groomBelow) return undefined;
   let line = `Queue: running low — ${summary.routed} routable candidate(s), below the grooming trigger of ${groomBelow}.`;
@@ -399,11 +413,51 @@ export function queueDigestLine(
 export const TICK_SCOPE_CONSTRAINTS: { readonly [K in ReportScope]: string } = {
   material: "Report material events per your brief.",
   escalations:
-    "Report NOTHING this turn except a Tier 1 or Tier 2 escalation; everything else -- releases included -- waits for the daily digest.",
+    "Interrupt only for: tier2, fleet-stopped; everything else — releases included — waits for the daily digest.",
   decisions:
     "Reporting scope decisions: interrupt only for a decision you need (tier-2) or a condition that stops the fleet. Every other material event accumulates and ships as ONE message with this tick's report via omp-conductor report -- a merge, a green PR, a pulled issue wait for the tick; nothing between ticks.",
 };
 
+/**
+ * The reporting constraint appended to a default tick prompt (#229, #242).
+ *
+ * Material and decisions keep their legacy preset words. The escalations
+ * preset instead names the policy's actual interrupt categories, so the prompt
+ * cannot drift from the gate. Every daily cadence gets an explicit due state:
+ * model-timed digests need that instruction just as scheduled digests do.
+ */
+export function tickReportingConstraint(
+  policy: ReportingPolicy | undefined,
+  digest: {
+    due: boolean;
+    cadence: ReportingPolicy["digest"]["cadence"];
+    at?: string;
+    timezone?: string;
+  },
+  held: number,
+): string {
+  const preset = policy?.scopePreset;
+  const allowed = policy?.interruptOn ?? [];
+  let base: string;
+  if (preset === "escalations") {
+    base = `Interrupt only for: ${allowed.join(", ")}; everything else — releases included — waits for the daily digest.`;
+  } else if (preset !== undefined) {
+    base = TICK_SCOPE_CONSTRAINTS[preset];
+  } else {
+    base =
+      allowed.length === 0
+        ? "Report nothing that would interrupt this turn; everything else accumulates for the digest."
+        : `Interrupt only for: ${allowed.join(", ")}. Everything else accumulates for the digest.`;
+  }
+  if (digest.cadence !== "daily") return base;
+  if (digest.due) {
+    return `${base} The daily digest is DUE now — compose it from this tick's accumulated events and the ${held} held notice(s) below, then send via omp-conductor report --kind digest.`;
+  }
+  return digest.at === undefined
+    ? `${base} The daily digest was already sent today; do not send another.`
+    : `${base} The daily digest is not due (scheduled ${digest.at}${digest.timezone === undefined ? "" : ` ${digest.timezone}`}); do not send one.`;
+}
+
 /**
  * The delivery clause, appended to every default tick prompt.
  *
@@ -572,6 +626,7 @@ export function formatFrictionDigest(signals: readonly FrictionSignal[]): string
  */
 export function resolveTickScope(): {
   scope: ReportScope;
+  policy?: ReportingPolicy;
   briefPath?: string;
   policyPath?: string;
   projectName?: string;
@@ -580,7 +635,8 @@ export function resolveTickScope(): {
   try {
     const project = findProject(loadConfig());
     return {
-      scope: project.reporting?.scope ?? DEFAULT_REPORT_SCOPE,
+      scope: project.reporting?.scopePreset ?? DEFAULT_REPORT_SCOPE,
+      policy: project.reporting,
       briefPath: briefPathForProject(project),
       policyPath: policyPathForProject(project),
       projectName: project.name,
@@ -1327,7 +1383,31 @@ function tick(pi: TickApi, ctx: TickContext, config: TickConfig, session: TickSe
       pi.logger.info(`[omp-conductor] tick reporting scope: using ${DEFAULT_REPORT_SCOPE} — ${scope.fallback}`);
     }
     const bridged = approval?.kind === "ready" && approval.notifyMode === "always" && profile?.kind === "interactive";
-    content = `${defaultTickMessage(new Date(), scope.briefPath, scope.policyPath)}\n${TICK_SCOPE_CONSTRAINTS[scope.scope]}\n${bridged ? TICK_DELIVERY_RULE_BRIDGED : TICK_DELIVERY_RULE}`;
+    let reportingConstraint = TICK_SCOPE_CONSTRAINTS[scope.scope];
+    if (scope.projectName !== undefined) {
+      const policy = scope.policy;
+      const digestPolicy = policy?.digest ?? DEFAULT_REPORT_POLICY.digest;
+      const cadence = digestPolicy.cadence;
+      const at = Date.now();
+      const store = openStore(dbPath());
+      try {
+        const lastKey = store.lastDigestDedupeKey(scope.projectName);
+        const lastDay = lastKey === undefined ? undefined : lastKey.slice("digest:".length);
+        reportingConstraint = tickReportingConstraint(
+          policy,
+          {
+            due: digestDue(policy ?? DEFAULT_REPORT_POLICY, lastDay, at),
+            cadence,
+            at: digestPolicy.at,
+            timezone: digestPolicy.timezone,
+          },
+          store.undigestedNotices(scope.projectName).length,
+        );
+      } finally {
+        store.close();
+      }
+    }
+    content = `${defaultTickMessage(new Date(), scope.briefPath, scope.policyPath)}\n${reportingConstraint}\n${bridged ? TICK_DELIVERY_RULE_BRIDGED : TICK_DELIVERY_RULE}`;
   }
   let frictionStore: Store | undefined;
   let frictionSignals: FrictionSignal[] = [];
@@ -1613,9 +1693,17 @@ export default function orchestratorTickExtension(pi: TickApi): void {
       // `createSession`; suppress this second copy only after this session has
       // proved it owns the external heartbeat.
       if (releaseAuthorityAccepted && !external) return undefined;
+      // Before ownership is proved this session holds no grant at all, so a
+      // covered shape still refuses with the deny-all wording.
+      const decision = refusal ?? releaseRefusal(DENIED_RELEASE_GRANTS, "orchestrator", shape);
+      if (decision === undefined) return undefined;
       if (projectName !== undefined) {
         try {
-          recordReleaseBlock(projectName, "orchestrator", shape);
+          recordReleaseBlock(projectName, "orchestrator", shape, {
+            tool: event.toolName,
+            reason: decision.reason,
+            args: redactReleaseArgs(event.input),
+          });
         } catch (err) {
           pi.logger.error(
             `[omp-conductor] could not record release-policy block: ${
@@ -1624,10 +1712,7 @@ export default function orchestratorTickExtension(pi: TickApi): void {
           );
         }
       }
-      // Before ownership is proved this session holds no grant at all, so a
-      // covered shape still refuses — with the wording it would get from a
-      // deny-all map rather than a claim about a grant it cannot yet use.
-      return refusal ?? releaseRefusal(DENIED_RELEASE_GRANTS, "orchestrator", shape);
+      return decision;
     });
   };
 

package/src/orchestrator.ts

@@ -33,6 +33,7 @@ import { stateDir } from "./config.ts";
 import { formatEscalation } from "./escalate.ts";
 import { createSession, disposeSession } from "./omp.ts";
 import type { AgentSessionLike } from "./omp.ts";
+import type { ReleaseBlockContext } from "./release-policy.ts";
 import type { Escalation, ReleaseShape, ResolvedGrants, SessionRole } from "./types.ts";
 
 /**
@@ -46,7 +47,7 @@ export type CreateSessionFn = (opts: {
   resume?: boolean;
   role: SessionRole;
   releaseGrants?: ResolvedGrants;
-  onReleaseBlocked?: (shape: ReleaseShape) => void;
+  onReleaseBlocked?: (shape: ReleaseShape, context: ReleaseBlockContext) => void;
   onSpawn?: (pid: number) => void;
   socketPath?: string;
   verbSocketPath?: string;
@@ -84,7 +85,7 @@ export interface OrchestratorOpts {
   sessionDir?: string;
   model?: string;
   releaseGrants?: ResolvedGrants;
-  onReleaseBlocked?: (shape: ReleaseShape) => void;
+  onReleaseBlocked?: (shape: ReleaseShape, context: ReleaseBlockContext) => void;
   /** The child's pid, the instant it exists. See {@link VerbListener.bindPid}. */
   onSpawn?: (pid: number) => void;
   /** Control socket for the session child, beside its own working directory. */