agent-lyceum 0.4.9

package/dist/format.d.ts

@@ -0,0 +1,33 @@
+import type { MessageType } from "./mailbox.js";
+import { type RunOutcome } from "./schema.js";
+/** Required `##` sections per message type. `done` and `failure` are exempt. */
+export declare const REQUIRED_SECTIONS: Partial<Record<MessageType, string[]>>;
+/** Required sections that have no Markdown heading in `body` (case-insensitive, any heading level). */
+export declare function missingSections(type: MessageType, body: string): string[];
+export declare function formatWarning(type: MessageType, missing: string[]): string;
+export interface Step {
+    text: string;
+    done: boolean;
+}
+/** Checklist items (`- [ ] x` / `- [x] x`). With `section`, only those under a `## Steps` heading; otherwise the whole text. */
+export declare function parseSteps(body: string, section?: boolean): Step[];
+/** One line saying what a message is about: the first line under Changes/Goal, else its first prose line. */
+export declare function briefOf(body: string): string | undefined;
+/** Text under the `##` heading `name` (case-insensitive) up to the next heading, or undefined if there is no such heading. */
+export declare function sectionText(body: string, name: string): string | undefined;
+/** Outcomes a lead may declare in `done`; `cancelled` is only ever the dispatcher's. */
+export declare const DECLARABLE_OUTCOMES: readonly ["completed", "partial", "blocked", "failed"];
+export interface DoneContract {
+    /** The declared outcome, when it is a valid one. */
+    outcome?: RunOutcome;
+    /** What the report lacks; empty when the contract is met. */
+    missing: string[];
+    /** First lines of `## Verification`, for display. */
+    verification?: string;
+}
+/**
+ * The completion contract of a `done` report: frontmatter `outcome`, and `## Result` and `## Not done`;
+ * a `completed` report must also carry `## Files` and `## Verification` and leave no checklist step unticked
+ * (the report's own `## Steps`, else the run's latest `stateSteps`).
+ */
+export declare function doneContract(meta: Record<string, unknown>, body: string, stateSteps?: Step[]): DoneContract;

package/dist/format.js

@@ -0,0 +1,100 @@
+/** Required `##` sections per message type. `done` and `failure` are exempt. */
+export const REQUIRED_SECTIONS = {
+    task: ["Goal", "Acceptance criteria", "Scope", "Upstream"],
+    reply: ["Changes", "Verification", "Open items", "Risks"],
+};
+/** Required sections that have no Markdown heading in `body` (case-insensitive, any heading level). */
+export function missingSections(type, body) {
+    const required = REQUIRED_SECTIONS[type];
+    if (!required)
+        return [];
+    const headings = new Set([...body.matchAll(/^#{1,6}[ \t]+(.+?)[ \t]*:?[ \t]*#*[ \t]*$/gm)].map((m) => m[1].trim().toLowerCase()));
+    return required.filter((s) => !headings.has(s.toLowerCase()));
+}
+export function formatWarning(type, missing) {
+    return `[agent-lyceum] Format warning: this ${type} is missing required section(s): ${missing.map((s) => `\`## ${s}\``).join(", ")}.`;
+}
+/** Checklist items (`- [ ] x` / `- [x] x`). With `section`, only those under a `## Steps` heading; otherwise the whole text. */
+export function parseSteps(body, section = true) {
+    let text = body;
+    if (section) {
+        const m = /^#{1,6}[ \t]+steps[ \t]*:?[ \t]*#*[ \t]*$/im.exec(body);
+        if (!m)
+            return [];
+        const rest = body.slice(m.index + m[0].length);
+        const next = /^#{1,6}[ \t]+\S/m.exec(rest);
+        text = next ? rest.slice(0, next.index) : rest;
+    }
+    return [...text.matchAll(/^[ \t]*[-*][ \t]+\[([ xX])\][ \t]+(.+?)[ \t]*$/gm)].map((m) => ({
+        text: m[2],
+        done: m[1] !== " ",
+    }));
+}
+/** One line saying what a message is about: the first line under Changes/Goal, else its first prose line. */
+export function briefOf(body) {
+    const lines = body.split(/\r?\n/);
+    const clean = (l) => l
+        .trim()
+        .replace(/^[-*]\s+(\[[ xX]\]\s+)?/, "")
+        .trim();
+    const usable = (l) => l !== "" && !l.startsWith("#") && !l.startsWith("[agent-lyceum]") && !/^none\.?$/i.test(l);
+    for (const want of ["changes", "goal"]) {
+        const i = lines.findIndex((l) => new RegExp(`^#{1,6}[ \\t]+${want}[ \\t]*:?[ \\t]*#*[ \\t]*$`, "i").test(l));
+        if (i < 0)
+            continue;
+        for (const l of lines.slice(i + 1)) {
+            if (l.trim().startsWith("#"))
+                break;
+            const c = clean(l);
+            if (usable(c))
+                return c;
+        }
+    }
+    return lines.map(clean).find(usable);
+}
+const HEADING = /^#{1,6}[ \t]+(.+?)[ \t]*:?[ \t]*#*[ \t]*$/gm;
+/** Text under the `##` heading `name` (case-insensitive) up to the next heading, or undefined if there is no such heading. */
+export function sectionText(body, name) {
+    const heads = [...body.matchAll(HEADING)];
+    const i = heads.findIndex((m) => m[1].trim().toLowerCase() === name.toLowerCase());
+    if (i < 0)
+        return undefined;
+    const start = heads[i].index + heads[i][0].length;
+    const end = heads[i + 1]?.index ?? body.length;
+    return body.slice(start, end).trim();
+}
+/** Outcomes a lead may declare in `done`; `cancelled` is only ever the dispatcher's. */
+export const DECLARABLE_OUTCOMES = ["completed", "partial", "blocked", "failed"];
+/**
+ * The completion contract of a `done` report: frontmatter `outcome`, and `## Result` and `## Not done`;
+ * a `completed` report must also carry `## Files` and `## Verification` and leave no checklist step unticked
+ * (the report's own `## Steps`, else the run's latest `stateSteps`).
+ */
+export function doneContract(meta, body, stateSteps) {
+    const missing = [];
+    const declared = String(meta.outcome ?? "").trim().toLowerCase();
+    const outcome = DECLARABLE_OUTCOMES.includes(declared) ? declared : undefined;
+    if (!outcome)
+        missing.push(`\`outcome: ${DECLARABLE_OUTCOMES.join("|")}\` in the frontmatter${declared ? ` (got "${declared}")` : ""}`);
+    const need = outcome === "completed" || !outcome ? ["Result", "Files", "Verification", "Not done"] : ["Result", "Not done"];
+    const have = new Set([...body.matchAll(HEADING)].map((m) => m[1].trim().toLowerCase()));
+    for (const h of need)
+        if (!have.has(h.toLowerCase()))
+            missing.push(`\`## ${h}\``);
+    if (outcome === "completed") {
+        const own = parseSteps(body);
+        const open = (own.length ? own : (stateSteps ?? [])).filter((x) => !x.done);
+        if (open.length)
+            missing.push(`unfinished steps: ${open.slice(0, 3).map((x) => `"${x.text}"`).join(", ")}${open.length > 3 ? ", ..." : ""} (finish and tick them, or report \`partial\`)`);
+    }
+    const v = sectionText(body, "Verification");
+    const verification = v
+        ? v
+            .split(/\r?\n/)
+            .map((l) => l.trim().replace(/^[-*]\s+/, ""))
+            .filter(Boolean)
+            .join(" ")
+            .slice(0, 400) || undefined
+        : undefined;
+    return { outcome, missing, verification };
+}

package/dist/fs-util.d.ts

@@ -0,0 +1,2 @@
+/** Atomic write: temp file in the same dir, then rename. */
+export declare function atomicWrite(file: string, content: string): void;

package/dist/fs-util.js

@@ -0,0 +1,9 @@
+import fs from "node:fs";
+import path from "node:path";
+/** Atomic write: temp file in the same dir, then rename. */
+export function atomicWrite(file, content) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = path.join(path.dirname(file), `.${path.basename(file)}.${process.pid}.tmp`);
+    fs.writeFileSync(tmp, content);
+    fs.renameSync(tmp, file);
+}

package/dist/guard.d.ts

@@ -0,0 +1,20 @@
+import type { ResolvedAgent, ResolvedProject } from "./config.js";
+export interface Violation {
+    file: string;
+    action: "restored" | "removed";
+    suspects: string[];
+}
+/**
+ * Detects (and reverts) changes to protected files made by agents that may not edit them.
+ * This is the runtime-independent safety net behind the OS/tool-level enforcement.
+ */
+export declare class ProtectedGuard {
+    private project;
+    private baseline;
+    constructor(project: ResolvedProject);
+    static protectedFiles(project: ResolvedProject): string[];
+    /** Copy the current protected files into `dir` for the audit trail. */
+    saveSnapshot(dir: string): void;
+    /** Compare against the baseline after `running` agents finished; revert unauthorized changes. */
+    check(running: ResolvedAgent[]): Violation[];
+}

package/dist/guard.js

@@ -0,0 +1,72 @@
+import fs from "node:fs";
+import path from "node:path";
+import { commonFile, mayEditProtected, repoInstructionFiles } from "./policy.js";
+/**
+ * Detects (and reverts) changes to protected files made by agents that may not edit them.
+ * This is the runtime-independent safety net behind the OS/tool-level enforcement.
+ */
+export class ProtectedGuard {
+    project;
+    baseline = new Map();
+    constructor(project) {
+        this.project = project;
+        for (const f of ProtectedGuard.protectedFiles(project))
+            this.baseline.set(f, read(f));
+    }
+    static protectedFiles(project) {
+        const files = new Set();
+        for (const a of Object.values(project.agents))
+            files.add(a.agentMd);
+        files.add(commonFile(project));
+        for (const f of repoInstructionFiles(project))
+            files.add(f);
+        return [...files];
+    }
+    /** Copy the current protected files into `dir` for the audit trail. */
+    saveSnapshot(dir) {
+        fs.mkdirSync(dir, { recursive: true });
+        for (const [file, buf] of this.baseline) {
+            if (!buf)
+                continue;
+            const safe = file.replace(/[\\/:]/g, "_").replace(/^_+/, "");
+            fs.writeFileSync(path.join(dir, safe), buf);
+        }
+    }
+    /** Compare against the baseline after `running` agents finished; revert unauthorized changes. */
+    check(running) {
+        const violations = [];
+        for (const [file, before] of this.baseline) {
+            const now = read(file);
+            if (same(before, now))
+                continue;
+            const authorized = running.some((a) => mayEditProtected(this.project, a, file));
+            if (authorized) {
+                this.baseline.set(file, now);
+                continue;
+            }
+            if (before === null) {
+                fs.rmSync(file, { force: true });
+                violations.push({ file, action: "removed", suspects: running.map((a) => a.name) });
+            }
+            else {
+                fs.mkdirSync(path.dirname(file), { recursive: true });
+                fs.writeFileSync(file, before);
+                violations.push({ file, action: "restored", suspects: running.map((a) => a.name) });
+            }
+        }
+        return violations;
+    }
+}
+function read(file) {
+    try {
+        return fs.readFileSync(file);
+    }
+    catch {
+        return null;
+    }
+}
+function same(a, b) {
+    if (a === null || b === null)
+        return a === b;
+    return a.equals(b);
+}

package/dist/mailbox.d.ts

@@ -0,0 +1,97 @@
+import type { ResolvedProject } from "./config.js";
+import { type Step } from "./format.js";
+import { atomicWrite } from "./fs-util.js";
+import { RouteJournal } from "./message-store.js";
+export { atomicWrite };
+export declare const MESSAGE_TYPES: readonly ["task", "reply", "failure", "done"];
+export type MessageType = (typeof MESSAGE_TYPES)[number];
+export interface MessageMeta {
+    id: string;
+    from: string;
+    to: string;
+    thread: string;
+    reply_to?: string;
+    type: MessageType;
+    subject: string;
+    created: string;
+    /** The run this mail belongs to. Stamped by the dispatcher; absent on mail of legacy runs. */
+    run_id?: string;
+}
+export interface Message {
+    meta: MessageMeta;
+    body: string;
+    file: string;
+}
+export declare function newId(): string;
+export declare function serialize(meta: MessageMeta, body: string): string;
+export declare function parseRaw(text: string): {
+    data: Record<string, unknown>;
+    body: string;
+};
+export declare function ensureProjectDirs(project: ResolvedProject): void;
+export interface DeliverInput {
+    from: string;
+    to: string;
+    type: MessageType;
+    subject: string;
+    body: string;
+    thread?: string;
+    reply_to?: string;
+}
+/** Deliver a message into `to`'s inbox (dispatcher-side; senders other than agents allowed). */
+export declare function deliver(project: ResolvedProject, input: DeliverInput & {
+    id?: string;
+    created?: string;
+    fileName?: string;
+}): Message;
+/**
+ * Deliver the mail identified by `(sourceKey, input.to)` at most once, even across crashes and restarts:
+ * the plan (id, file name, timestamp) is journaled before anything is written, a retry writes the identical file,
+ * and mail the recipient already read is never written again. Without a run (no journal) it just delivers.
+ */
+export declare function deliverOnce(project: ResolvedProject, journal: RouteJournal | undefined, sourceKey: string, input: DeliverInput): {
+    msg: Message;
+    fresh: boolean;
+};
+export declare function readMessage(file: string): Message;
+export declare function listUnread(project: ResolvedProject, agent: string): Message[];
+export declare function markRead(files: string[]): void;
+export interface RouteResult {
+    /** Mail delivered by this pass (mail a previous pass already delivered is not repeated). */
+    delivered: {
+        from: string;
+        to: string;
+        id: string;
+        file: string;
+        type: MessageType;
+        subject: string;
+    }[];
+    rejected: {
+        from: string;
+        file: string;
+        reason: string;
+    }[];
+    /** Mail that was delivered but lacks required sections (see format.ts). */
+    warnings: {
+        from: string;
+        id: string;
+        subject: string;
+        missing: string[];
+    }[];
+    /** The lead's `done`. Its file stays in the outbox until the caller has stored the result and calls `finishDone`. */
+    done?: {
+        from: string;
+        subject: string;
+        body: string;
+        file: string;
+        meta: Record<string, unknown>;
+    };
+    /** Latest `## Steps` checklist the lead sent, if any. */
+    steps?: Step[];
+}
+/** Move a handled `done` file out of the outbox (to `read/`). */
+export declare function finishDone(file: string): void;
+/** Set a `done` that broke the completion contract aside (in the outbox's `rejected/`). */
+export declare function rejectDone(file: string): void;
+/** Validate each agent's outbox and move accepted mail into recipients' inboxes. Safe to run again after a crash. */
+export declare function routeOutboxes(project: ResolvedProject): RouteResult;

package/dist/mailbox.js

@@ -0,0 +1,259 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { formatWarning, missingSections, parseSteps } from "./format.js";
+import { atomicWrite } from "./fs-util.js";
+import { deterministicId, fault, RouteJournal, sourceIdOf } from "./message-store.js";
+import { inboxDir, outboxDir } from "./policy.js";
+export { atomicWrite };
+export const MESSAGE_TYPES = ["task", "reply", "failure", "done"];
+export function newId() {
+    return crypto.randomBytes(3).toString("hex");
+}
+let lastStampMs = 0;
+/** UTC timestamp for filenames; strictly increasing so inbox order always equals delivery order. */
+function stamp() {
+    lastStampMs = Math.max(Date.now(), lastStampMs + 1);
+    return new Date(lastStampMs).toISOString().replace(/[-:.]/g, "");
+}
+export function serialize(meta, body) {
+    const fm = YAML.stringify(meta).trimEnd();
+    return `---\n${fm}\n---\n\n${body.trim()}\n`;
+}
+export function parseRaw(text) {
+    const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text);
+    if (!m)
+        throw new Error("missing frontmatter (--- ... ---)");
+    const data = YAML.parse(m[1]);
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        throw new Error("frontmatter is not a mapping");
+    return { data: data, body: m[2].trim() };
+}
+export function ensureProjectDirs(project) {
+    fs.mkdirSync(path.join(project.paths.shared, "common"), { recursive: true });
+    for (const name of Object.keys(project.agents)) {
+        fs.mkdirSync(path.join(inboxDir(project, name), "read"), { recursive: true });
+        fs.mkdirSync(path.join(outboxDir(project, name), "rejected"), { recursive: true });
+        const a = project.agents[name];
+        for (const m of [a.memory.global, a.memory.project, a.memory.task])
+            if (m)
+                fs.mkdirSync(m, { recursive: true });
+    }
+}
+/** Deliver a message into `to`'s inbox (dispatcher-side; senders other than agents allowed). */
+export function deliver(project, input) {
+    const id = input.id ?? newId();
+    const meta = {
+        id,
+        from: input.from,
+        to: input.to,
+        thread: input.thread ?? input.reply_to ?? id,
+        ...(input.reply_to ? { reply_to: input.reply_to } : {}),
+        type: input.type,
+        subject: input.subject,
+        created: input.created ?? new Date().toISOString(),
+        ...(project.run?.layout === "run" ? { run_id: project.run.id } : {}),
+    };
+    const file = path.join(inboxDir(project, input.to), input.fileName ?? `${stamp()}-${input.from}-${id}.md`);
+    atomicWrite(file, serialize(meta, input.body));
+    return { meta, body: input.body, file };
+}
+/**
+ * Deliver the mail identified by `(sourceKey, input.to)` at most once, even across crashes and restarts:
+ * the plan (id, file name, timestamp) is journaled before anything is written, a retry writes the identical file,
+ * and mail the recipient already read is never written again. Without a run (no journal) it just delivers.
+ */
+export function deliverOnce(project, journal, sourceKey, input) {
+    if (!journal)
+        return { msg: deliver(project, input), fresh: true };
+    const prior = journal.get(sourceKey, input.to);
+    const planned = prior ??
+        journal.intent({
+            source: sourceKey,
+            to: input.to,
+            msg_id: deterministicId(sourceKey, input.to),
+            file: `${stamp()}-${input.from}-${deterministicId(sourceKey, input.to)}.md`,
+            created: new Date().toISOString(),
+        });
+    fault("route:intent");
+    const dest = path.join(inboxDir(project, input.to), planned.file);
+    const meta = deliveredMeta(project, input, planned);
+    const want = serialize(meta, input.body);
+    const alreadyRead = fs.existsSync(path.join(path.dirname(dest), "read", planned.file));
+    // Write the planned file; if one is already there, verify it instead of trusting it. Mail already read is never written again.
+    if (!alreadyRead && (!fs.existsSync(dest) || fs.readFileSync(dest, "utf8") !== want))
+        atomicWrite(dest, want);
+    fault("route:written");
+    const fresh = !planned.delivered;
+    if (fresh)
+        journal.delivered(sourceKey, input.to);
+    fault("route:delivered");
+    return { msg: { meta, body: input.body, file: dest }, fresh };
+}
+function deliveredMeta(project, input, planned) {
+    return {
+        id: planned.msg_id,
+        from: input.from,
+        to: input.to,
+        thread: input.thread ?? input.reply_to ?? planned.msg_id,
+        ...(input.reply_to ? { reply_to: input.reply_to } : {}),
+        type: input.type,
+        subject: input.subject,
+        created: planned.created,
+        ...(project.run?.layout === "run" ? { run_id: project.run.id } : {}),
+    };
+}
+export function readMessage(file) {
+    const { data, body } = parseRaw(fs.readFileSync(file, "utf8"));
+    const meta = data;
+    return { meta, body, file };
+}
+export function listUnread(project, agent) {
+    const dir = inboxDir(project, agent);
+    if (!fs.existsSync(dir))
+        return [];
+    const files = fs
+        .readdirSync(dir, { withFileTypes: true })
+        .filter((e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("."))
+        .map((e) => path.join(dir, e.name))
+        .sort();
+    const out = [];
+    for (const f of files) {
+        try {
+            out.push(readMessage(f));
+        }
+        catch {
+            out.push({
+                meta: { id: path.basename(f), from: "?", to: agent, thread: "?", type: "reply", subject: "(unreadable message)", created: "" },
+                body: fs.readFileSync(f, "utf8"),
+                file: f,
+            });
+        }
+    }
+    return out;
+}
+export function markRead(files) {
+    for (const f of files) {
+        if (!fs.existsSync(f))
+            continue;
+        const dest = path.join(path.dirname(f), "read", path.basename(f));
+        fs.mkdirSync(path.dirname(dest), { recursive: true });
+        fs.renameSync(f, dest);
+    }
+}
+/** Move a handled `done` file out of the outbox (to `read/`). */
+export function finishDone(file) {
+    if (!fs.existsSync(file))
+        return;
+    const dest = path.join(path.dirname(file), "read", path.basename(file));
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.renameSync(file, dest);
+}
+/** Set a `done` that broke the completion contract aside (in the outbox's `rejected/`). */
+export function rejectDone(file) {
+    if (!fs.existsSync(file))
+        return;
+    const dest = path.join(path.dirname(file), "rejected", path.basename(file));
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    fs.renameSync(file, dest);
+}
+/** Validate each agent's outbox and move accepted mail into recipients' inboxes. Safe to run again after a crash. */
+export function routeOutboxes(project) {
+    const res = { delivered: [], rejected: [], warnings: [] };
+    const journal = project.run ? new RouteJournal(project.run.dir) : undefined;
+    for (const sender of Object.values(project.agents)) {
+        const dir = outboxDir(project, sender.name);
+        if (!fs.existsSync(dir))
+            continue;
+        const files = fs
+            .readdirSync(dir, { withFileTypes: true })
+            .filter((e) => e.isFile() && e.name.endsWith(".md") && !e.name.startsWith("."))
+            .map((e) => path.join(dir, e.name))
+            .sort((a, b) => fs.statSync(a).mtimeMs - fs.statSync(b).mtimeMs || a.localeCompare(b));
+        for (const file of files) {
+            const source = sourceIdOf(sender.name, file);
+            const reject = (reason) => {
+                deliverOnce(project, journal, `reject:${source}`, {
+                    from: "dispatcher",
+                    to: sender.name,
+                    type: "failure",
+                    subject: `Message ${path.basename(file)} was rejected`,
+                    body: `Your outbox message \`${path.basename(file)}\` was not delivered: ${reason}\n\nIt was moved to \`rejected/\`.`,
+                });
+                const dest = path.join(dir, "rejected", path.basename(file));
+                fs.mkdirSync(path.dirname(dest), { recursive: true });
+                fs.renameSync(file, dest);
+                fault("route:moved");
+                res.rejected.push({ from: sender.name, file: dest, reason });
+            };
+            let parsed;
+            try {
+                parsed = parseRaw(fs.readFileSync(file, "utf8"));
+            }
+            catch (e) {
+                reject(`invalid message format (${e.message}). Expected frontmatter with "to", "type", "subject".`);
+                continue;
+            }
+            const d = parsed.data;
+            if (project.run?.layout === "run" && d.run_id !== undefined && String(d.run_id) !== project.run.id) {
+                reject(`it is addressed to run "${String(d.run_id)}", but this is run "${project.run.id}"; mail never crosses runs.`);
+                continue;
+            }
+            const type = (d.type ?? "reply");
+            if (!MESSAGE_TYPES.includes(type) || type === "failure") {
+                reject(`unknown or not allowed message type "${String(d.type)}" (use task, reply or done).`);
+                continue;
+            }
+            const subject = String(d.subject ?? "(no subject)");
+            if (type === "done") {
+                if (sender.name !== project.lead) {
+                    reject(`only the lead ("${project.lead}") may send a "done" message.`);
+                    continue;
+                }
+                res.done = { from: sender.name, subject, body: parsed.body, file, meta: d };
+                const ds = parseSteps(parsed.body);
+                if (ds.length)
+                    res.steps = ds;
+                continue;
+            }
+            const targets = Array.isArray(d.to) ? d.to.map(String) : d.to ? [String(d.to)] : [];
+            if (targets.length === 0) {
+                reject(`missing "to".`);
+                continue;
+            }
+            const bad = targets.find((t) => !project.agents[t] || t === sender.name || (sender.canMessage !== "all" && !sender.canMessage.includes(t)));
+            if (bad !== undefined) {
+                const why = !project.agents[bad]
+                    ? `no such agent "${bad}"`
+                    : bad === sender.name
+                        ? "cannot message yourself"
+                        : `you may only message: ${sender.canMessage.join(", ") || "(nobody)"}`;
+                reject(why + ".");
+                continue;
+            }
+            const replyTo = d.reply_to ? String(d.reply_to) : undefined;
+            const thread = d.thread ? String(d.thread) : undefined;
+            const missing = missingSections(type, parsed.body);
+            const body = missing.length ? `${formatWarning(type, missing)}\n\n${parsed.body}` : parsed.body;
+            if (sender.name === project.lead) {
+                const st = parseSteps(parsed.body);
+                if (st.length)
+                    res.steps = st;
+            }
+            for (const to of targets) {
+                const { msg, fresh } = deliverOnce(project, journal, source, { from: sender.name, to, type, subject, body, thread, reply_to: replyTo });
+                if (!fresh)
+                    continue;
+                res.delivered.push({ from: sender.name, to, id: msg.meta.id, file: msg.file, type, subject });
+                if (missing.length)
+                    res.warnings.push({ from: sender.name, id: msg.meta.id, subject, missing });
+            }
+            fault("route:source-done");
+            fs.mkdirSync(path.join(dir, "sent"), { recursive: true });
+            fs.renameSync(file, path.join(dir, "sent", path.basename(file)));
+            fault("route:moved");
+        }
+    }
+    return res;
+}