omp-conductor 0.9.1 → 0.12.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}/`);
 }

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) {
+          // A category this policy defers does not page now: it is held here so
+          // the digest is the delivery authority for it (#229). A missing
+          // `reporting` block means the default (page everything); an explicit
+          // list decides each escalation by its category, defaulting `tier2`.
+          const category = e.category ?? "tier2";
+          const interruptOn = p.reporting?.interruptOn;
+          if (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

@@ -113,6 +113,47 @@ export function startFailure(lastError: string | undefined): string | undefined
   return hit === undefined ? undefined : lastError.split("\n")[0]?.trim();
 }
 
+/**
+ * Provider messages that mean "this key is out of money", matched on the text
+ * the provider itself prints.
+ */
+const CREDIT_REFUSAL_SIGNATURES = [
+  "requires more credits",
+  "insufficient credits",
+  "insufficient_quota",
+  "exceeded your current quota",
+  "credit balance is too low",
+] as const;
+
+/**
+ * Evidence that a model provider refused this run for credit, or `undefined`
+ * when it did not.
+ *
+ * Two independent signals, either sufficient: HTTP 402, which means exactly
+ * this and nothing else, and the refusal text providers print when a key is out
+ * of allowance without using 402. Deliberately narrow — a generic 429 is rate
+ * limiting, which is a different failure with a different remedy.
+ */
+export function providerCreditRefusal(error: {
+  status?: number;
+  message: string;
+}): string | undefined {
+  const text = error.message.toLowerCase();
+  const named = CREDIT_REFUSAL_SIGNATURES.some((signature) => text.includes(signature));
+  if (error.status !== 402 && !named) return undefined;
+  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.
  *
@@ -201,6 +242,37 @@ export function classifyRun(run: RunRecord, facts: ClassifyFacts): Classificatio
     };
   }
 
+  // A billing state, not an implementation failure. Its own class because it is
+  // the one outage an operator fixes with a card rather than a diagnosis, and
+  // because burying a self-describing provider error in `unknown` erodes what
+  // `unknown` means (#220). Ahead of `neverStarted` on purpose: a 402 on the
+  // 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 });
+    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 = run.lastError === undefined ? undefined : providerTransientFault({ message: run.lastError });
+    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

@@ -1062,6 +1062,7 @@ export function formatFleetStatus(
 function formatProjectBody(s: StatusSnapshot): string {
   const lines = [
     `project   ${s.project}${s.paused ? "  (PAUSED)" : ""}`,
+    ...(s.pauseReason === undefined ? [] : [`paused    ${s.pauseReason}`]),
     `config    ${s.configPath}`,
     `state     ${s.stateDir}`,
     "",
@@ -1380,7 +1381,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

@@ -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;
 }
@@ -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.
@@ -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,6 +672,14 @@ 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);
           break;
@@ -693,6 +716,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

@@ -68,17 +68,20 @@ import {
   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 +389,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}.`;
@@ -404,6 +417,37 @@ export const TICK_SCOPE_CONSTRAINTS: { readonly [K in ReportScope]: string } = {
     "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).
+ *
+ * A legacy `scopePreset` keeps its exact words — those are what the policy
+ * tests and the fleet already read — with a DUE/not-due clause appended only
+ * when the digest is actually scheduled (`daily` + `at`). An explicit
+ * non-preset policy derives one sentence naming its allowed interrupt
+ * categories and stating that everything else accumulates for the digest.
+ */
+export function tickReportingConstraint(
+  policy: ReportingPolicy | undefined,
+  digest: { due: boolean; scheduled: boolean; at?: string; timezone?: string },
+  held: number,
+): string {
+  const preset = policy?.scopePreset;
+  let base: string;
+  if (preset !== undefined) {
+    base = TICK_SCOPE_CONSTRAINTS[preset];
+  } else {
+    const allowed = policy?.interruptOn ?? [];
+    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.scheduled) return base;
+  return digest.due
+    ? `${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.`
+    : `${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 +616,7 @@ export function formatFrictionDigest(signals: readonly FrictionSignal[]): string
  */
 export function resolveTickScope(): {
   scope: ReportScope;
+  policy?: ReportingPolicy;
   briefPath?: string;
   policyPath?: string;
   projectName?: string;
@@ -580,7 +625,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 +1373,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 scheduled = digestPolicy.cadence === "daily" && digestPolicy.at !== undefined;
+      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),
+            scheduled,
+            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[] = [];

package/src/plugin.ts

@@ -91,6 +91,7 @@ import {
   type ProjectPolicy,
   type ReleaseRequirement,
   type ReportScope,
+  type ReportScopeChoice,
   type ResolvedGrants,
 } from "./types.ts";
 
@@ -309,7 +310,7 @@ async function askGates(
  * means silence. The cursor starts on the current setting so Enter re-affirms
  * it, the same contract every other prompt here has.
  */
-async function askReportScope(ctx: CommandContext, current: ReportScope): Promise<ReportScope> {
+async function askReportScope(ctx: CommandContext, current: ReportScopeChoice): Promise<ReportScopeChoice> {
   const options = REPORT_SCOPE_CHOICES.map((c) => ({ label: c.label, description: c.description }));
   const at = REPORT_SCOPE_CHOICES.findIndex((c) => c.scope === current);
   const picked = await ctx.ui.select("What should the orchestrator report unprompted?", options, {
@@ -898,7 +899,22 @@ const askEscalation: AreaAsker = async (ctx, a) => {
 };
 
 /** How loud the orchestrator is when nobody asked it anything. */
-const askReporting: AreaAsker = async (ctx, a) => ({ ...a, reportScope: await askReportScope(ctx, a.reportScope) });
+const askReporting: AreaAsker = async (ctx, a) => {
+  const reportScope = await askReportScope(ctx, a.reportScope);
+  if (reportScope !== "quiet") return { ...a, reportScope };
+  // `quiet` picks the explicit form, whose only free parameter is when the
+  // daily rollup happens. Blank = whenever the orchestrator composes it.
+  const at = await ctx.ui.input(
+    "Daily rollup time, 24h HH:MM (blank = whenever the orchestrator composes it):",
+    a.quietDigestAt,
+  );
+  const trimmed = at?.trim() ?? "";
+  if (trimmed !== "" && !/^([01]\d|2[0-3]):[0-5]\d$/.test(trimmed)) {
+    ctx.ui.notify(`"${trimmed}" is not a 24h HH:MM time — leaving the digest model-timed.`, "warning");
+    return { ...a, reportScope };
+  }
+  return { ...a, reportScope, ...(trimmed === "" ? {} : { quietDigestAt: trimmed }) };
+};
 
 /** The operator's own brief. Asked last in the full interview, because the
  *  question quotes the path the rest of the answers derive. */

package/src/reports.ts

@@ -37,6 +37,7 @@
  */
 
 import { readTelegramToken, sendTelegram, TelegramSendError } from "./escalate.ts";
+import { localDayKey } from "./digest-schedule.ts";
 import type { Escalation, ProjectConfig, ReportRecord, Store } from "./types.ts";
 
 /**
@@ -120,13 +121,11 @@ export interface ReportOutboxDeps {
 /**
  * Local day, matching how a human reads "one daily digest" and how the
  * dispatcher's own `startOfToday` reads "today". A UTC key would roll the
- * digest over mid-evening for anyone west of Greenwich.
+ * digest over mid-evening for anyone west of Greenwich; the zone is the
+ * project's `reporting.digest.timezone` when set, else the host zone (#229).
  */
-export function digestDedupeKey(at: number): string {
-  const d = new Date(at);
-  const month = `${d.getMonth() + 1}`.padStart(2, "0");
-  const day = `${d.getDate()}`.padStart(2, "0");
-  return `digest:${d.getFullYear()}-${month}-${day}`;
+export function digestDedupeKey(at: number, timezone?: string): string {
+  return `digest:${localDayKey(at, timezone)}`;
 }
 
 /** Exponential, capped. `attempts` is attempts *started*, so the first failure

package/src/session-host.ts

@@ -9,14 +9,14 @@
  * fleet, and what makes a kill a real kill.
  *
  * This file is the far side: it loads the harness, runs the real session, and
- * speaks a five-verb protocol back over a unix socket to the
+ * speaks a small protocol back over a unix socket to the
  * {@link AgentSessionLike} proxy in `omp.ts`. It holds no conductor state, opens
  * no database, and reads no config — everything it needs arrives in
  * {@link SessionHostSpec}, so the child's inputs are data a caller can see
  * rather than ambient state it inherits.
  *
- * The protocol is deliberately tiny. `AgentSessionLike` has five members, so
- * there are five things to carry, and every one of them is data.
+ * The protocol deliberately mirrors the narrow session surface and carries
+ * only data.
  */
 
 import { connect } from "node:net";
@@ -53,6 +53,7 @@ export interface SessionHostSpec {
 /** Parent → child. */
 export type ParentToHost =
   | { t: "prompt"; id: number; text: string; opts?: Record<string, unknown> }
+  | { t: "park"; id: number }
   | { t: "abort" }
   | { t: "dispose" };
 
@@ -63,6 +64,7 @@ export type HostToParent =
   | { t: "event"; event: unknown }
   | { t: "session-file"; path: string }
   | { t: "prompt-result"; id: number; ok: boolean; error?: string }
+  | { t: "park-result"; id: number; ok: boolean; error?: string }
   | { t: "release-blocked"; shape: ReleaseShape };
 
 /**
@@ -240,6 +242,20 @@ export async function runSessionHost(
         );
         continue;
       }
+      if (message.t === "park") {
+        const id = message.id;
+        void live.park().then(
+          () => send({ t: "park-result", id, ok: true }),
+          (err: unknown) =>
+            send({
+              t: "park-result",
+              id,
+              ok: false,
+              error: err instanceof Error ? err.message : String(err),
+            }),
+        );
+        continue;
+      }
       if (message.t === "abort") {
         live.abort();
         continue;