omp-conductor 0.15.9 → 0.15.11

package/src/commands/event.ts

@@ -0,0 +1,62 @@
+/**
+ * `event` — persist one ordinary material outcome without sending it.
+ *
+ * Moved out of cli.ts's switch by the per-verb module split (#462);
+ * only the case wrapper, the injected `ctx` lookups and the imports
+ * changed from the original bodies.
+ */
+
+import type { CommandContext } from "./context.ts";
+import { findProject, loadConfig } from "../config.ts";
+import { dbPath, openStore } from "../store.ts";
+
+export async function eventCommand(ctx: CommandContext): Promise<void> {
+if (ctx.argv[1] !== "record") {
+  process.stderr.write("omp-conductor: event needs the record subcommand\n");
+  process.exit(2);
+}
+const category = ctx.flag("category");
+const summary = ctx.flag("summary")?.replace(/\s+/g, " ").trim();
+const evidence = ctx.flag("evidence")?.replace(/\s+/g, " ").trim();
+if (
+  category === undefined ||
+  !/^[a-z0-9][a-z0-9-]{0,31}$/.test(category) ||
+  summary === undefined ||
+  summary.length === 0 ||
+  summary.length > 240 ||
+  summary.startsWith("--") ||
+  evidence === undefined ||
+  evidence.length === 0 ||
+  evidence.length > 500 ||
+  evidence.startsWith("--")
+) {
+  process.stderr.write(
+    "omp-conductor: event record needs --category with a lowercase slug, --summary (1-240 chars), and --evidence (1-500 chars)\n",
+  );
+  process.exit(2);
+}
+const rawOccurredAt = ctx.flag("occurred-at");
+const recordedAt = Date.now();
+const occurredAt = rawOccurredAt === undefined ? recordedAt : Date.parse(rawOccurredAt);
+if (!Number.isFinite(occurredAt)) {
+  process.stderr.write("omp-conductor: event record --occurred-at needs an ISO timestamp\n");
+  process.exit(2);
+}
+const project = findProject(loadConfig(), ctx.projectFlag);
+const store = openStore(dbPath());
+try {
+  const event = store.recordMaterialEvent({
+    project: project.name,
+    category,
+    summary,
+    evidence,
+    occurredAt,
+    recordedAt,
+  });
+  process.stdout.write(
+    `event ${event.id} recorded for ${project.name} (${event.category}, ${new Date(event.occurredAt).toISOString()}) — nothing sent\n`,
+  );
+} finally {
+  store.close();
+}
+}

package/src/commands/extend.ts

@@ -0,0 +1,64 @@
+/**
+ * `extend` — raise a live run's turn ceiling, or set a bounded one-shot ceiling after a failed, killed, orphaned or blocked run.
+ *
+ * Moved out of cli.ts's switch by the per-verb module split (#462);
+ * only the case wrapper, the injected `ctx` lookups and the imports
+ * changed from the original bodies.
+ */
+
+import type { CommandContext } from "./context.ts";
+import { findProject, loadConfig } from "../config.ts";
+import { livingDaemon } from "../lifecycle.ts";
+
+export async function extendCommand(ctx: CommandContext): Promise<void> {
+const issue = ctx.issueArg("extend", ctx.argv[1]);
+const maxTurns = ctx.turnsFlag();
+const project = findProject(loadConfig(), ctx.projectFlag);
+const daemon = livingDaemon();
+if (daemon === undefined) throw new Error("daemon is not running");
+if (daemon.project !== undefined && daemon.project !== project.name) {
+  throw new Error(
+    `daemon serves project "${daemon.project}", not requested project "${project.name}"`,
+  );
+}
+const response = await fetch(
+  `http://127.0.0.1:${daemon.port}/runs/${issue}/turn-limit`,
+  {
+    method: "PUT",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ project: project.name, maxTurns }),
+  },
+);
+const payload = (await response.json()) as {
+  error?: unknown;
+  kind?: unknown;
+  runId?: unknown;
+  maxTurns?: unknown;
+  issue?: unknown;
+  nextAttemptMaxTurns?: unknown;
+  baseMaxTurns?: unknown;
+};
+if (!response.ok) {
+  throw new Error(
+    typeof payload.error === "string" ? payload.error : `daemon returned HTTP ${response.status}`,
+  );
+}
+if (
+  payload.kind === "next-attempt" &&
+  payload.issue === issue &&
+  typeof payload.nextAttemptMaxTurns === "number" &&
+  typeof payload.baseMaxTurns === "number"
+) {
+  process.stdout.write(
+    `#${issue} next attempt turn ceiling set to ${payload.nextAttemptMaxTurns} ` +
+      `(project base ${payload.baseMaxTurns})\n`,
+  );
+  return;
+}
+if (typeof payload.runId !== "string" || typeof payload.maxTurns !== "number") {
+  throw new Error("daemon returned an invalid turn-extension response");
+}
+process.stdout.write(
+  `#${issue} turn ceiling extended to ${payload.maxTurns} (run ${payload.runId})\n`,
+);
+}

package/src/commands/friction.ts

@@ -0,0 +1,56 @@
+/**
+ * `friction` — record a bounded observation the daemon cannot classify itself.
+ *
+ * Moved out of cli.ts's switch by the per-verb module split (#462);
+ * only the case wrapper, the injected `ctx` lookups and the imports
+ * changed from the original bodies.
+ */
+
+import type { CommandContext } from "./context.ts";
+import { findProject, loadConfig } from "../config.ts";
+import { dbPath, openStore } from "../store.ts";
+
+const FRICTION_FEEDBACK_KINDS = {
+  "escalation-digest": "feedback:escalation-should-digest",
+  "report-noise": "feedback:report-noise",
+  "report-surprise": "feedback:report-surprise",
+} as const;
+
+type FrictionFeedbackName = keyof typeof FRICTION_FEEDBACK_KINDS;
+
+export async function frictionCommand(ctx: CommandContext): Promise<void> {
+const name = ctx.argv[1] as FrictionFeedbackName | undefined;
+if (name === undefined || !Object.hasOwn(FRICTION_FEEDBACK_KINDS, name)) {
+  process.stderr.write(
+    "omp-conductor: friction needs one of: escalation-digest, report-noise, report-surprise\n",
+  );
+  process.exit(2);
+}
+const rawDetail = ctx.flag("detail");
+const detail = rawDetail?.replace(/\s+/g, " ").trim();
+if (
+  detail === undefined ||
+  detail.length === 0 ||
+  detail.length > 160 ||
+  rawDetail?.startsWith("--") === true
+) {
+  process.stderr.write("omp-conductor: friction needs --detail with 1-160 characters\n");
+  process.exit(2);
+}
+const issueText = ctx.flag("issue");
+const issue = issueText === undefined ? undefined : ctx.issueArg("friction --issue", issueText);
+const project = findProject(loadConfig(), ctx.projectFlag);
+const store = openStore(dbPath());
+try {
+  store.recordFriction(project.name, {
+    kind: FRICTION_FEEDBACK_KINDS[name],
+    occurrences: 1,
+    ...(issue === undefined ? {} : { issue }),
+    sample: detail,
+    at: Date.now(),
+  });
+} finally {
+  store.close();
+}
+process.stdout.write(`friction recorded for ${project.name}: ${name} — ${detail}\n`);
+}

package/src/commands/help.ts

@@ -0,0 +1,9 @@
+/**
+ * `help` / `--help` / `-h`: print the shared usage text. The text itself stays
+ * in cli.ts as `USAGE` — the contract of the per-verb module split (#462) keeps
+ * the shared usage text next to the registration table, so it is passed in
+ * rather than re-exported.
+ */
+export function helpCommand(usage: string): void {
+  process.stdout.write(`${usage}\n`);
+}

package/src/commands/hold.ts

@@ -0,0 +1,26 @@
+/**
+ * `hold` — soft stop: pause claiming AND disarm ticks; daemon and pane stay up.
+ *
+ * Moved out of cli.ts's switch by the per-verb module split (#462);
+ * only the case wrapper, the injected `ctx` lookups and the imports
+ * changed from the original bodies.
+ */
+
+import type { CommandContext } from "./context.ts";
+import { hold } from "../fleet.ts";
+
+export async function holdCommand(ctx: CommandContext): Promise<void> {
+const keepTicks = ctx.argv.includes("--keep-ticks");
+for (const project of ctx.targetProjects()) {
+  const r = hold(project.name, "hold", keepTicks ? { keepTicks: true } : {});
+  process.stdout.write(
+    `held — claiming paused` +
+      `${r.wasPaused ? " (already paused)" : ""}` +
+      (r.disarmed === undefined
+        ? "; ticks left armed — resume restores the fleet with no new arm challenge"
+        : `; ticks disarmed at ${r.disarmed.path}` +
+          `${r.disarmed.wasArmed ? "" : " (was already disarmed)"}`) +
+      `\ndaemon and pane left running; stop to stop the daemon too\n`,
+  );
+}
+}

package/src/commands/intake.ts

@@ -0,0 +1,134 @@
+/**
+ * `intake` — capture a raw idea durably before it becomes anything (#298).
+ *
+ * The store is the point of the verb: an idea captured at 02:00 is still there
+ * after a restart, and `status` counts what is still pending so a backlog
+ * cannot quietly empty itself. This surface only records, lists and dismisses;
+ * turning an idea into an issue is #300, which uses `resolveIntake`'s
+ * `groomed` path.
+ */
+
+import type { CommandContext } from "./context.ts";
+import { findProject, loadConfig } from "../config.ts";
+import { dbPath, openStore } from "../store.ts";
+
+const INTAKE_USAGE = `omp-conductor intake — capture raw ideas durably.
+
+usage:
+  omp-conductor intake "<text>" [--project NAME]
+  omp-conductor intake list [--project NAME]
+  omp-conductor intake dismiss <id> [--project NAME]
+
+Captures one raw idea into the local store and prints its id. list shows what
+is still pending (id, age, text), oldest first; dismiss drops one by id. The
+capture is durable — it lives in the sqlite store, not in a session — so it
+survives daemon restarts, and an idea can later be groomed into an issue.`;
+
+/** Flags the intake surface understands. `--project` is consumed by
+ *  {@link CommandContext.projectFlag}; the value token stays in argv. */
+const INTAKE_FLAGS: Record<string, true> = { "--project": true };
+
+/** Every remaining token after the subverb must be one of the known flags
+ *  (or its value), otherwise the operator typo'd something that would be
+ *  silently ignored — the same exit-2 scan `stats` runs (#462). */
+function assertKnownArgs(ctx: CommandContext, from: number): void {
+  for (let i = from; i < ctx.argv.length; i++) {
+    const token = ctx.argv[i];
+    if (token === undefined) continue;
+    if (INTAKE_FLAGS[token] === true) {
+      i += 1;
+      continue;
+    }
+    if (token.startsWith("--project=")) continue;
+    process.stderr.write(`omp-conductor: intake: unexpected argument "${token}"\n`);
+    process.exit(2);
+  }
+}
+
+export async function intakeCommand(ctx: CommandContext): Promise<void> {
+  const sub = ctx.argv[1];
+  if (sub === "--help" || sub === "-h") {
+    process.stdout.write(INTAKE_USAGE);
+    return;
+  }
+  const project = findProject(loadConfig(), ctx.projectFlag);
+  const store = openStore(dbPath());
+  try {
+    if (sub === "list") {
+      assertKnownArgs(ctx, 2);
+      const pending = store.pendingIntake(project.name);
+      if (pending.length === 0) {
+        process.stdout.write("no pending ideas\n");
+        return;
+      }
+      const now = Date.now();
+      for (const item of pending) {
+        // Age at capture granularity: minutes for a fresh idea, hours once it
+        // has been waiting a while — the unit the operator actually cares about.
+        const minutes = Math.max(0, Math.round((now - item.createdAt) / 60_000));
+        const age = minutes < 60 ? `${minutes}m` : `${Math.floor(minutes / 60)}h`;
+        process.stdout.write(`${item.id}  ${age.padStart(5)}  ${item.text}\n`);
+      }
+      return;
+    }
+
+    if (sub === "dismiss") {
+      assertKnownArgs(ctx, 3);
+      const id = ctx.argv[2];
+      if (id === undefined || id.startsWith("--")) {
+        process.stderr.write("omp-conductor: intake dismiss needs the idea id\n");
+        process.exit(2);
+      }
+      if (!store.resolveIntake(id, "dismissed")) {
+        process.stderr.write(
+          `omp-conductor: no intake item ${id} for ${project.name} — it was already resolved, or the id is wrong\n`,
+        );
+        process.exit(1);
+      }
+      process.stdout.write(`intake ${id} dismissed\n`);
+      return;
+    }
+
+    if (sub !== undefined && sub.startsWith("--") && INTAKE_FLAGS[sub] !== true) {
+      process.stderr.write(`omp-conductor: intake: unexpected argument "${sub}"\n`);
+      process.exit(2);
+    }
+
+    // Capture: the text is the first non-flag token, wherever it sits. Flags
+    // may come before or after it; anything beyond one text token is a typo.
+    let text: string | undefined;
+    for (let i = 1; i < ctx.argv.length; i++) {
+      const token = ctx.argv[i];
+      if (token === undefined) continue;
+      if (INTAKE_FLAGS[token] === true) {
+        i += 1;
+        continue;
+      }
+      if (token.startsWith("--project=")) continue;
+      if (token.startsWith("--")) {
+        process.stderr.write(`omp-conductor: intake: unexpected argument "${token}"\n`);
+        process.exit(2);
+      }
+      if (text !== undefined) {
+        process.stderr.write(`omp-conductor: intake: unexpected argument "${token}"\n`);
+        process.exit(2);
+      }
+      text = token;
+    }
+    const trimmed = text?.trim();
+    if (trimmed === undefined || trimmed.length === 0) {
+      process.stderr.write(
+        "omp-conductor: intake needs a non-empty idea text — e.g. omp-conductor intake \"ship the intake command\"\n",
+      );
+      process.exit(2);
+    }
+    const item = store.recordIntake({
+      project: project.name,
+      text: trimmed,
+      at: Date.now(),
+    });
+    process.stdout.write(`intake ${item.id} recorded — see it with: omp-conductor intake list\n`);
+  } finally {
+    store.close();
+  }
+}

package/src/commands/ledger.ts

@@ -0,0 +1,69 @@
+/**
+ * `ledger` — every conductor-verb call and how the daemon decided it, plus the durable per-issue turn budgets.
+ *
+ * Moved out of cli.ts's switch by the per-verb module split (#462);
+ * only the case wrapper, the injected `ctx` lookups and the imports
+ * changed from the original bodies.
+ */
+
+import type { CommandContext } from "./context.ts";
+import { findProject, loadConfig } from "../config.ts";
+import { dbPath, openStore } from "../store.ts";
+import { formatVerbLedgerEntry } from "../verbs/ledger.ts";
+
+export async function ledgerCommand(ctx: CommandContext): Promise<void> {
+const cfg = loadConfig();
+const p = findProject(cfg, ctx.projectFlag);
+const issueFlag = ctx.flag("issue");
+const issue = issueFlag === undefined ? undefined : ctx.issueArg("ledger", issueFlag);
+const limitFlag = ctx.flag("limit");
+const limit = limitFlag === undefined ? 50 : Number.parseInt(limitFlag, 10);
+if (!Number.isSafeInteger(limit) || limit < 1) {
+  process.stderr.write(`omp-conductor: ledger --limit needs a positive integer, got "${limitFlag ?? ""}"\n`);
+  process.exitCode = 1;
+  return;
+}
+// Read-only, WAL, same as `tail`: this never contends with the daemon
+// writing the rows it is printing.
+const store = openStore(dbPath());
+try {
+  const entries = store.verbLedger(p.name, {
+    ...(issue === undefined ? {} : { issue }),
+    limit,
+  });
+  const overrides = store.turnOverrideLedger(p.name, {
+    ...(issue === undefined ? {} : { issue }),
+    limit,
+  });
+  if (entries.length === 0 && overrides.length === 0) {
+    process.stdout.write(
+      `no conductor actions recorded for ${p.name}` +
+        `${issue === undefined ? "" : ` on #${String(issue)}`}\n`,
+    );
+    return;
+  }
+  const blocks: string[] = [];
+  if (entries.length > 0) {
+    const refused = entries.filter((e) => e.decision === "refused").length;
+    blocks.push(
+      `${p.name} — ${entries.length} verb call(s), ${refused} refused (newest first)\n` +
+        entries.flatMap(formatVerbLedgerEntry).join("\n"),
+    );
+  }
+  if (overrides.length > 0) {
+    blocks.push(
+      `${p.name} — ${overrides.length} turn override(s) (newest first)\n` +
+        overrides
+          .map(
+            (entry) =>
+              `  ${new Date(entry.setAt).toISOString()}  #${entry.issue}  ` +
+              `${entry.maxTurns} turns`,
+          )
+          .join("\n"),
+    );
+  }
+  process.stdout.write(`${blocks.join("\n\n")}\n`);
+} finally {
+  store.close();
+}
+}

package/src/commands/message.ts

@@ -0,0 +1,48 @@
+/**
+ * `message` — deliver one direct Telegram message to the project's own chat and forum topic, applying the same availability policy as a tick.
+ *
+ * Moved out of cli.ts's switch by the per-verb module split (#462);
+ * only the case wrapper, the injected `ctx` lookups and the imports
+ * changed from the original bodies.
+ */
+
+import type { CommandContext } from "./context.ts";
+import { randomUUID } from "node:crypto";
+import { findProject, loadConfig } from "../config.ts";
+import { deliverOperatorMessage, type OperatorMessageOutcome } from "../reports.ts";
+import { dbPath, openStore } from "../store.ts";
+
+export async function messageCommand(ctx: CommandContext): Promise<void> {
+const rawText = ctx.flag("text");
+const body = rawText?.trim();
+if (body === undefined || body.length === 0 || rawText?.startsWith("--") === true) {
+  process.stderr.write("omp-conductor: message needs --text with the message to deliver\n");
+  process.exit(2);
+}
+const project = findProject(loadConfig(), ctx.projectFlag);
+const store = openStore(dbPath());
+let outcome: OperatorMessageOutcome;
+try {
+  outcome = await deliverOperatorMessage(project, body, {
+    store,
+    at: Date.now(),
+    noticeId: randomUUID(),
+  });
+} catch (err) {
+  process.stderr.write(
+    `omp-conductor: message: ${err instanceof Error ? err.message : String(err)}\n`,
+  );
+  process.exit(2);
+} finally {
+  store.close();
+}
+process.stdout.write(
+  outcome.kind === "sent"
+    ? // Not "into the topic": a stale topic degrades to the flat chat with
+      // its own warning on stderr, and this line must not contradict it.
+      `message delivered to ${project.name}'s configured Telegram target (${outcome.category})\n`
+    : `held notice ${outcome.noticeId} queued for ${project.name} (${outcome.category}; ` +
+        `${outcome.reason === "availability" ? "outside the availability window" : "a digest-only category"})\n` +
+        "nothing was sent; the daemon releases it with the next digest or working-hours catch-up\n",
+);
+}

package/src/commands/report.ts

@@ -0,0 +1,170 @@
+/**
+ * `report` — hand a rendered report to the daemon's durable outbox; the daemon owns delivery with bounded retries.
+ *
+ * Moved out of cli.ts's switch by the per-verb module split (#462);
+ * only the case wrapper, the injected `ctx` lookups and the imports
+ * changed from the original bodies.
+ */
+
+import type { CommandContext } from "./context.ts";
+import { randomUUID } from "node:crypto";
+import { interruptDisposition } from "../availability.ts";
+import { findProject, loadConfig } from "../config.ts";
+import { digestDue } from "../digest-schedule.ts";
+import { dbPath, openStore } from "../store.ts";
+import { digestDedupeKey } from "../reports.ts";
+import { DEFAULT_REPORT_POLICY, REPORT_KINDS, type InterruptCategory, type ReportKind } from "../types.ts";
+
+export async function reportCommand(ctx: CommandContext): Promise<void> {
+const rawText = ctx.flag("text");
+const body = rawText?.trim();
+if (body === undefined || body.length === 0 || rawText?.startsWith("--") === true) {
+  process.stderr.write("omp-conductor: report needs --text with the rendered report\n");
+  process.exit(2);
+}
+const rawKind = ctx.flag("kind") ?? "material";
+// Fail closed on an unknown kind rather than defaulting to `material`: a
+// typo'd `--kind diggest` that silently became a material report would
+// bypass the daily-digest guard, which is the one thing the kind is for.
+if (!(REPORT_KINDS as readonly string[]).includes(rawKind)) {
+  process.stderr.write(
+    `omp-conductor: report --kind must be one of: ${REPORT_KINDS.join(", ")}\n`,
+  );
+  process.exit(2);
+}
+const kind = rawKind as ReportKind;
+if (kind !== "digest" && (ctx.argv.includes("--events") || ctx.argv.includes("--notices"))) {
+  process.stderr.write(
+    "omp-conductor: report --events and --notices are valid only with --kind digest\n",
+  );
+  process.exit(2);
+}
+const project = findProject(loadConfig(), ctx.projectFlag);
+const store = openStore(dbPath());
+try {
+  const at = Date.now();
+  // #229: the policy decides what may interrupt the phone. A kind the
+  // policy defers is refused here rather than silently turning into a
+  // page, or a digest going out off-schedule.
+  const policy = project.reporting;
+  const digestPolicy = policy?.digest ?? { cadence: "per-tick" };
+  if (kind === "digest") {
+    if (digestPolicy.cadence === "none") {
+      process.stderr.write(`omp-conductor: report: digest cadence is "none" for this project\n`);
+      process.exit(2);
+    }
+    if (digestPolicy.cadence === "daily" && digestPolicy.at !== undefined) {
+      const lastKey = store.lastDigestDedupeKey(project.name);
+      const lastDay = lastKey === undefined ? undefined : lastKey.slice("digest:".length);
+      if (!digestDue(policy ?? DEFAULT_REPORT_POLICY, lastDay, at)) {
+        process.stderr.write(
+          `omp-conductor: report: the daily digest is not due until ${digestPolicy.at}` +
+            `${digestPolicy.timezone === undefined ? "" : ` ${digestPolicy.timezone}`}\n`,
+        );
+        process.exit(2);
+      }
+    }
+  }
+  // Every non-digest kind is an interrupt category, and the caller's kind
+  // IS the category: admission runs the shared interruptDisposition with
+  // that category, so a `fleet-stopped` report under scope=escalations is
+  // admitted while `material` stays digest-only under that same policy.
+  if (kind !== "digest") {
+    const category: InterruptCategory = kind;
+    const disposition = interruptDisposition(policy, category, at);
+    if (disposition === "digest") {
+      process.stderr.write(
+        `omp-conductor: report: ${category} updates are digest-only under this reporting policy; fold this into the next digest (--kind digest)\n`,
+      );
+      process.exit(2);
+    }
+    // One escalation handoff per event while the first has not landed.
+    // Material reports describe one ordinary outcome each time, so they
+    // keep their historical no-dedup behaviour. The escalation categories
+    // refuse an identical retry only while the earlier handoff is still
+    // owed — an outbox report awaiting delivery or a held notice not yet
+    // digested (#453). The notifications ledger cannot decide this: its
+    // rows are permanent, so a same-text recurrence would be refused
+    // forever once the first occurrence was marked; a delivered handoff
+    // means the identical text is a new event, not a double-send.
+    if (category !== "material") {
+      if (store.hasOpenEscalationHandoff(project.name, category, body)) {
+        process.stderr.write(
+          `omp-conductor: report: an identical ${category} handoff for ${project.name} is still queued undelivered ` +
+            "— this retry was refused so the operator is not paged twice; nothing new was queued, " +
+            "check `omp-conductor status` for what is still awaiting delivery\n",
+        );
+        process.exit(2);
+      }
+      if (disposition === "availability") {
+        const noticeId = randomUUID();
+        store.addHeldNotice({
+          id: noticeId,
+          project: project.name,
+          category,
+          summary: body.split("\n", 1)[0]!.slice(0, 240),
+          detail: body,
+          createdAt: at,
+          releaseOnAvailable: true,
+        });
+        process.stdout.write(
+          `held notice ${noticeId} queued for ${project.name} (${category}; quiet hours)\n` +
+            "the daemon will include it in the next digest or working-hours catch-up\n",
+        );
+        return;
+      }
+      const { report } = store.enqueueReport({ project: project.name, kind, body, at });
+      process.stdout.write(
+        `report ${report.id} queued for ${project.name} (${kind})\n` +
+          "the daemon owns delivery from here; omp-conductor status shows it until it lands\n",
+      );
+      return;
+    }
+    if (disposition === "availability") {
+      const noticeId = randomUUID();
+      store.addHeldNotice({
+        id: noticeId,
+        project: project.name,
+        category: "material",
+        summary: body.split("\n", 1)[0]!.slice(0, 240),
+        detail: body,
+        createdAt: at,
+        releaseOnAvailable: true,
+      });
+      process.stdout.write(
+        `held notice ${noticeId} queued for ${project.name} (material; quiet hours)\n` +
+          "the daemon will include it in the next digest or working-hours catch-up\n",
+      );
+      return;
+    }
+  }
+  const draft = {
+    project: project.name,
+    kind,
+    body,
+    // Only a daily digest is at-most-once. Per-tick digests and material
+    // reports describe new outcomes each time, so they carry no daily key.
+    ...(kind === "digest" && digestPolicy.cadence === "daily"
+      ? { dedupeKey: digestDedupeKey(at, digestPolicy.timezone) }
+      : {}),
+    at,
+  };
+  const { report, deduped } =
+    kind === "digest"
+      ? store.enqueueDigestReport(
+          draft,
+          ctx.digestIdsFlag("events"),
+          ctx.digestIdsFlag("notices"),
+        )
+      : store.enqueueReport(draft);
+  process.stdout.write(
+    deduped
+      ? `today's digest was already handed over as report ${report.id} (${report.state}) — nothing queued\n` +
+          "the ledger decides this, not your memory of the last tick; newly named rows remain owed for a later digest\n"
+      : `report ${report.id} queued for ${project.name} (${kind})\n` +
+          "the daemon owns delivery from here; omp-conductor status shows it until it lands\n",
+  );
+} finally {
+  store.close();
+}
+}