@agentswf/engine 0.1.0-beta.4 → 0.1.0

package/src/emit-command.ts

@@ -1,14 +1,27 @@
 import type { EmitResultJson } from "@agentswf/contract/records";
 import { isEventWorkflow, type JsonValue } from "@agentswf/contract/workflow";
-import { EmitError, emitEvent } from "./emit";
+import { type Out, parsePlace, type ReadPlace } from "./command-line";
+import { EmitError, emitEvent, emitToRun } from "./emit";
 import { messageOf } from "./errors";
 import help from "./help/emit.txt" with { type: "text" };
-import type { Out } from "./run-commands";
-import type { Launch } from "./wake";
+import { asksJson, printRefusal, readFailureCode } from "./refusals";
+import { findRunByRef } from "./run-state";
+import type { Launch, Woken } from "./wake";
 import { loadWorkflowFile } from "./workflow-loader";
 
+/** `awf emit --json`'s `"v"`, which its refusals carry too. */
+export const EMIT_V = 1 satisfies EmitResultJson["v"];
+
 export const emitUsage = help.trimEnd();
 
+type Event = { name: string; data: JsonValue; id?: string; source?: string };
+
+/** `--target {file} --id {id}`, which may start the run; or a run that is there, by its ref. */
+type Parsed = Event & { json: boolean } & (
+    | { target: string; run: string; ref?: undefined }
+    | { ref: string; place: ReadPlace; target?: undefined }
+  );
+
 export async function emitCommand(
   argv: readonly string[],
   shellCwd: string,
@@ -19,91 +32,101 @@ export async function emitCommand(
     launch?: Launch;
   },
 ): Promise<number> {
-  if (argv.includes("-h") || argv.includes("--help")) {
-    out.stdout(emitUsage);
-    return 0;
-  }
-  let parsed: {
-    target: string;
-    run: string;
-    name: string;
-    data: JsonValue;
-    id?: string;
-    json: boolean;
-  };
+  let parsed: Parsed;
   try {
-    parsed = parse(argv);
+    parsed = parse(argv, shellCwd);
   } catch (error) {
-    out.stderr(`awf: ${messageOf(error)}\n\n${emitUsage}`);
+    printRefusal(out, { json: asksJson(argv), v: EMIT_V }, error, "usage", emitUsage);
     return 2;
   }
+  const json = { json: parsed.json, v: EMIT_V };
+  const event = {
+    name: parsed.name,
+    data: parsed.data,
+    ...(parsed.id === undefined ? {} : { id: parsed.id }),
+    ...(parsed.source === undefined ? {} : { source: parsed.source }),
+  };
   let result: EmitResultJson;
   try {
-    const loaded = await loadWorkflowFile(parsed.target, shellCwd);
-    if (!isEventWorkflow(loaded.workflow)) {
-      out.stderr(`awf: ${loaded.file} declares no events; awf run starts it`);
-      return 2;
+    if (parsed.ref !== undefined) {
+      const status = await findRunByRef(parsed.ref, parsed.place, context.home);
+      result = await emitToRun(status, event, context);
+    } else {
+      const loaded = await loadWorkflowFile(parsed.target, shellCwd, context.home);
+      if (!isEventWorkflow(loaded.workflow)) {
+        printRefusal(out, json, `${loaded.file} declares no events; awf run starts it`, "event");
+        return 2;
+      }
+      result = await emitEvent(
+        loaded.workflow,
+        { run: parsed.run, ...event },
+        { from: "operator", ...context },
+      );
     }
-    result = await emitEvent(
-      loaded.workflow,
-      {
-        run: parsed.run,
-        name: parsed.name,
-        data: parsed.data,
-        ...(parsed.id === undefined ? {} : { id: parsed.id }),
-      },
-      { from: "operator", ...context },
-    );
   } catch (error) {
-    out.stderr(`awf: ${messageOf(error)}`);
+    printRefusal(out, json, error, readFailureCode(error));
     return error instanceof EmitError ? 2 : 1;
   }
   return printEmit(result, parsed.json, out);
 }
 
-/** Prints an emit's result, as `awf emit` and `awf send` do: 1 when the run's attempt didn't start. */
-export function printEmit(result: EmitResultJson, json: boolean, out: Out): number {
-  out.stdout(json ? JSON.stringify(result) : emitLine(result));
-  if (result.why !== "launch-failed") return 0;
-  out.stderr(`awf: the run's attempt did not start: ${result.error}`);
-  return 1;
+/** Prints an emit's result, `accepted dd-case/kombo: started`: 1 when the run's attempt didn't start. */
+function printEmit(result: EmitResultJson, json: boolean, out: Out): number {
+  out.stdout(json ? JSON.stringify(result) : `${result.outcome} ${result.ref}${didOf(result)}`);
+  return launchExit(result, out);
+}
+
+/** What waking a run did, `: started`, or why it did nothing; empty when neither is said. */
+export function didOf(woken: Pick<Woken, "did" | "why">): string {
+  const did = woken.did === "none" ? woken.why : woken.did;
+  return did === undefined ? "" : `: ${did}`;
 }
 
-/** `accepted dd-case/kombo: started`. */
-function emitLine(result: EmitResultJson): string {
-  const did = result.did === "none" ? result.why : result.did;
-  return `${result.outcome} ${result.ref}${did === undefined ? "" : `: ${did}`}`;
+/** 0; or 1, said on stderr, when the run's attempt did not start. */
+export function launchExit(woken: Pick<Woken, "why" | "error">, out: Out): number {
+  if (woken.why !== "launch-failed") return 0;
+  out.stderr(`awf: the run's attempt did not start: ${woken.error}`);
+  return 1;
 }
 
-function parse(argv: readonly string[]): {
-  target: string;
-  run: string;
-  name: string;
-  data: JsonValue;
-  id?: string;
-  json: boolean;
-} {
+function parse(argv: readonly string[], shellCwd: string): Parsed {
+  const { place, json, rest } = parsePlace(argv, shellCwd);
   let target: string | undefined;
   let run: string | undefined;
   let id: string | undefined;
-  let json = false;
+  let source: string | undefined;
   const words: string[] = [];
-  for (let i = 0; i < argv.length; i++) {
-    const word = argv[i]!;
+  for (let i = 0; i < rest.length; i++) {
+    const word = rest[i]!;
     const value = () => {
-      const next = argv[++i];
+      const next = rest[++i];
       if (next === undefined) throw new Error(`${word} needs a value`);
       return next;
     };
     if (word === "--target") target = value();
     else if (word === "--id") run = value();
     else if (word === "--event-id") id = value();
-    else if (word === "--json") json = true;
+    else if (word === "--source") source = value();
     else if (word.startsWith("--")) throw new Error(`unknown option ${word}`);
     else words.push(word);
   }
-  if (target === undefined) throw new Error("--target names the workflow file the event is for");
-  if (run === undefined) throw new Error("--id names the run the event is for, by its id");
+  let form: { target: string; run: string } | { ref: string; place: ReadPlace };
+  if (target !== undefined) {
+    if (run === undefined) throw new Error("--id names the run the event is for, by its id");
+    if (place.repeat.length > 0)
+      throw new Error(
+        "--cwd and --run-root find a run by its ref; --target's file names its project",
+      );
+    form = { target, run };
+  } else {
+    if (run !== undefined) throw new Error("--id goes with --target; a run's ref names it alone");
+    const ref = words.shift();
+    if (ref === undefined)
+      throw new Error(
+        "name the run, <workflow>/<id> or <id>, or the workflow by --target and --id",
+      );
+    form = { ref, place };
+  }
   const [name, text, ...more] = words;
   if (name === undefined) throw new Error("the event's name is missing");
   if (more.length > 0) throw new Error(`one event at a time; also given: ${more.join(" ")}`);
@@ -115,5 +138,12 @@ function parse(argv: readonly string[]): {
       throw new Error(`the event's data is not JSON: ${messageOf(error)}`);
     }
   }
-  return { target, run, name, data, ...(id === undefined ? {} : { id }), json };
+  return {
+    ...form,
+    name,
+    data,
+    ...(id === undefined ? {} : { id }),
+    ...(source === undefined ? {} : { source }),
+    json,
+  };
 }

package/src/emit.ts

@@ -1,26 +1,58 @@
 import { randomBytes } from "node:crypto";
 import { isAbsolute, join } from "node:path";
-import { type EmitResultJson, MAILBOX_RECORD_VERSION } from "@agentswf/contract/records";
+import type { ClientErrorCode } from "@agentswf/contract/client";
+import {
+  type EmitResultJson,
+  type EventLine,
+  emitOk,
+  type RunPanes,
+} from "@agentswf/contract/records";
 import { parseJsonSchema, validate } from "@agentswf/contract/schema";
 import {
   AWF_ID_PREFIX,
+  awfEventOf,
   eventWorkflowProblem,
+  isEventWorkflow,
   type JsonValue,
   nameProblem,
+  ParticipantReply,
 } from "@agentswf/contract/workflow";
 import { messageOf } from "./errors";
 import { exists } from "./files";
-import { appendMailbox, foldMailbox, readMailbox } from "./mailbox";
+import { appendIn, readIn } from "./in-lines";
+import { checkProjectEngine, EngineRefused } from "./project-engine";
 import { projectOf, projectRunRoot, recordProject } from "./projects";
 import { runLockFile, withRunLock } from "./run-lock";
 import { prepareArgs } from "./run-prepare";
-import { createRun, idProblem, openRun, type Run, readAttempts } from "./runs";
+import type { RunStatus } from "./run-state";
+import {
+  createRun,
+  idProblem,
+  openRun,
+  panesChanged,
+  type Run,
+  RunTaken,
+  readAttempts,
+} from "./runs";
 import { type WakeContext, type Woken, wake } from "./wake";
-import type { EventWorkflow } from "./workflow-loader";
+import { type EventWorkflow, loadWorkflowFile, WorkflowFileError } from "./workflow-loader";
+
+/**
+ * What an `EmitError` is about, as a program's `ClientError` names it: the event, an id, the
+ * target's `prepare` or `id(args)`, its file, its project, the project's engine, or a run there
+ * started with other arguments or options.
+ */
+export type EmitCode = Extract<
+  ClientErrorCode,
+  "event" | "id" | "prepare" | "file" | "project" | "other-engine" | "no-engine" | "other-args"
+>;
 
 /** An event awf refuses to take at all: a name, shape or id no run of the target could have. */
 export class EmitError extends Error {
-  constructor(message: string) {
+  constructor(
+    message: string,
+    readonly code: EmitCode = "event",
+  ) {
     super(message);
     this.name = "EmitError";
   }
@@ -37,41 +69,113 @@ export type EmitContext = Omit<WakeContext, "file"> & {
  */
 export async function emitEvent(
   target: EventWorkflow,
-  event: { run: string; name: string; data: JsonValue; id?: string },
+  event: { run: string; name: string; data: JsonValue; id?: string; source?: string },
   context: EmitContext,
 ): Promise<EmitResultJson> {
   const workflow = target.meta.name;
-  const { name, data } = event;
+  const { name, data, source } = event;
   checkEvent(target, event);
+  const badSource = source === undefined ? undefined : nameProblem(source);
+  if (badSource) throw new EmitError(`the source ${JSON.stringify(source)}: ${badSource}`);
+  const file = fileOf(target);
   const id = event.id ?? `${AWF_ID_PREFIX}${randomBytes(8).toString("hex")}`;
   const at = new Date(context.now?.() ?? Date.now()).toISOString();
   const runId = event.run;
   const problem = idProblem(runId);
-  if (problem) throw new EmitError(`the run's id: ${problem}`);
-  const project = await projectOf(target.file, context.home).catch((error: unknown) => {
-    throw new EmitError(messageOf(error));
-  });
+  if (problem) throw new EmitError(`the run's id: ${problem}`, "id");
+  const project = await targetProject(file, context.home);
   const starts = target.starts?.includes(name) ?? true;
   return deliver(
     {
       runRoot: projectRunRoot(project),
       workflow,
       runId,
-      event: { id, name, data, from: context.from, at },
+      event: {
+        id,
+        name,
+        data,
+        from: context.from,
+        ...(source === undefined ? {} : { source }),
+        at,
+      },
       deduplicate: event.id !== undefined,
-      file: target.file,
+      file,
       ...(starts ? { start: { project, target } } : {}),
     },
     context,
   );
 }
 
+/**
+ * `awf emit {ref} {key}:reply …`: a participant's message to the code of a run that is there,
+ * checked against the definition in the file a wake would run, its last attempt's, and delivered.
+ * It never starts a run, and doesn't ask whether the participant has connected: one sent before
+ * the run connects it waits in `in.jsonl` for the run's next wait.
+ */
+export async function emitToRun(
+  status: RunStatus,
+  event: { name: string; data: JsonValue; id?: string; source?: string },
+  context: Omit<WakeContext, "file">,
+): Promise<EmitResultJson> {
+  const { run, ref } = status;
+  const reply = awfEventOf(event.name);
+  if (reply?.kind !== "reply")
+    throw new EmitError(
+      `awf emit {run} sends a participant's message to the code, {key}:reply, not ${event.name}; the workflow's own events go by --target {file} --id {id}`,
+    );
+  if (!run.record.events) throw new EmitError(`${ref} is a run of a workflow without events`);
+  // A returned run takes nothing, so its file, since moved or changed, is not read: a late reply is
+  // refused as returned, not failed for a retry that never ends.
+  if (status.attempts.at(-1)?.outcome === "completed")
+    return deliverReply(status, reply.key, event, context);
+  const file = status.attempts.at(-1)?.file ?? run.record.file;
+  if (file === undefined)
+    throw new WorkflowFileError(`${ref} has no file to check the event against`);
+  const { workflow } = await loadWorkflowFile(file, run.record.cwd, context.home);
+  if (!isEventWorkflow(workflow) || workflow.meta.name !== run.record.workflow)
+    throw new WorkflowFileError(
+      `${file} is no longer ${run.record.workflow} with events, which ${ref} ran`,
+    );
+  checkEvent(workflow, event, true);
+  return deliverReply(status, reply.key, event, context);
+}
+
+/**
+ * `{key}:reply` appended to a run that is there, and the run woken: a duplicate id is a duplicate.
+ * The caller has checked it.
+ */
+export function deliverReply(
+  status: Pick<RunStatus, "run">,
+  key: string,
+  event: { data: JsonValue; id?: string; source?: string },
+  context: Omit<WakeContext, "file">,
+): Promise<EmitResultJson> {
+  const { run } = status;
+  const problem = event.source === undefined ? undefined : nameProblem(event.source);
+  if (problem) throw new EmitError(`the source ${JSON.stringify(event.source)}: ${problem}`);
+  const at = new Date(context.now?.() ?? Date.now()).toISOString();
+  const id = event.id ?? `${AWF_ID_PREFIX}${randomBytes(8).toString("hex")}`;
+  return deliver(
+    {
+      runRoot: run.root,
+      workflow: run.record.workflow,
+      runId: run.record.id,
+      event: {
+        ...replyRecord(key, id, event.data, at),
+        ...(event.source === undefined ? {} : { source: event.source }),
+      },
+      deduplicate: event.id !== undefined,
+    },
+    context,
+  );
+}
+
 /** An event for a run of a workflow with events, as `deliver` takes it. */
 export type Delivery = {
   runRoot: string;
   workflow: string;
   runId: string;
-  event: { id: string; name: string; data: JsonValue; from: string; at: string };
+  event: { id: string; name: string; data: JsonValue; from: string; source?: string; at: string };
   /** False for an id awf made at random, which nothing repeats. */
   deduplicate: boolean;
   /** Given when the event may start the run: what a new run records, and the workflow it prepares. */
@@ -82,10 +186,10 @@ export type Delivery = {
 
 /**
  * The one way in, for every event a run of a workflow with events gets: a sender's, a participant's reply, or awf's
- * own. Under the run's lock it finds a duplicate, refuses the event, or creates the run, appends
- * the event and wakes the run.
+ * own. Under the run's lock it finds a duplicate, refuses the event, or appends the event, to a run
+ * there or into a new one's `in.jsonl` before the run exists, and wakes the run.
  */
-export async function deliver(
+async function deliver(
   delivery: Delivery,
   context: Omit<WakeContext, "file">,
 ): Promise<EmitResultJson> {
@@ -98,27 +202,46 @@ export async function deliver(
       : undefined;
     // What was due is `awf tick`'s to say; an emit's caller knows it sent an event.
     const result = (outcome: EmitResultJson["outcome"], { cause: _, ...woken }: Woken) =>
-      ({ v: 1, outcome, ref, eventId: event.id, ...woken }) satisfies EmitResultJson;
+      ({
+        v: 1,
+        ok: emitOk(outcome, woken.why),
+        outcome,
+        ref,
+        eventId: event.id,
+        ...woken,
+      }) satisfies EmitResultJson;
     if (run) {
+      // A disk that doesn't tell case apart opens another run for an id differing only in case.
+      if (run.record.id !== runId)
+        throw new EmitError(
+          `${ref} differs only in case from ${run.record.id}, which is there`,
+          "id",
+        );
+      if (!run.record.events)
+        throw new EmitError(`${ref} is a run of a workflow without events, which take none`);
       // Not appended again, but it still wakes the run: a sender retrying after a launch that failed
       // sends the same id.
-      if (delivery.deduplicate && foldMailbox(await readMailbox(run.dir)).events.has(event.id))
+      if (delivery.deduplicate && (await readIn(run.dir)).some((line) => line.id === event.id))
         return result("duplicate", await wake(run, { ...woken, nudgeLive: false }));
       if ((await readAttempts(run)).at(-1)?.outcome === "completed")
         return result("refused", { did: "none", why: "returned" });
     }
-    const starts = !run;
-    if (!run) {
+    if (run) await appendIn(run.dir, event);
+    else {
       if (!start) return result("refused", { did: "none", why: "not-a-start" });
       checkStartArgs(start.target, start.project);
-      run = await createEventRun(runRoot, workflow, runId, start.project, file, context);
+      // In the folder before it is renamed into place: no run exists without its first event.
+      const first: EventLine = { ...event, starts: true };
+      try {
+        run = await createEventRun(runRoot, workflow, runId, start.project, file, context, [], {
+          first,
+        });
+      } catch (error) {
+        // A disk that tells case apart: another case's run is found only as the folder is claimed.
+        if (error instanceof RunTaken) throw new EmitError(messageOf(error), "id");
+        throw error;
+      }
     }
-    await appendMailbox(run.dir, {
-      version: MAILBOX_RECORD_VERSION,
-      kind: "event",
-      ...event,
-      ...(starts ? { starts: true as const } : {}),
-    });
     return result("accepted", await wake(run, woken));
   });
 }
@@ -133,6 +256,7 @@ function checkStartArgs(target: EventWorkflow, project: string): void {
   } catch (error) {
     throw new EmitError(
       `${target.meta.name}: a run an event starts has no arguments, which its prepare refuses: ${messageOf(error)}`,
+      "prepare",
     );
   }
 }
@@ -146,18 +270,31 @@ async function createEventRun(
   file: string | undefined,
   context: Pick<WakeContext, "home" | "environment">,
   argv: readonly string[] = [],
+  given: { panes?: RunPanes; first?: EventLine } = {},
 ): Promise<Run> {
-  const run = await createRun(runRoot, {
-    id,
-    workflow,
-    argv: [...argv],
-    cwd: project,
-    sandbox: null,
-    events: true,
-    env: { PATH: context.environment.PATH ?? "" },
-    ...(file ? { file } : {}),
-  });
-  await recordProject(context.home, project);
+  const { panes, first } = given;
+  const run = await createRun(
+    runRoot,
+    {
+      id,
+      workflow,
+      argv: [...argv],
+      cwd: project,
+      sandbox: null,
+      events: true,
+      env: { PATH: context.environment.PATH ?? "" },
+      ...(file ? { file } : {}),
+      ...(panes ? { panes } : {}),
+    },
+    undefined,
+    first,
+  );
+  try {
+    await recordProject(context.home, project);
+  } catch (error) {
+    // awf's own record of projects, not the run's: `internal-error`, as `awf run` refuses it.
+    throw new Error(`~/.awf/projects was not written: ${messageOf(error)}`);
+  }
   return run;
 }
 
@@ -167,61 +304,122 @@ export type Opened = { run: string; created: boolean } & Woken;
 /**
  * `awf run --id` for a workflow with events: creates the run with no event, under its lock, and
  * starts it, so it runs to its first wait and parks there. One already there is only woken, as
- * `awf tick` would; one that returned is refused, as its events are.
+ * `awf tick` would; one that returned is refused, as its events are. `panes`, the operator's
+ * `--workspace` and `--keep-panes`, are recorded with a new run, and may not change one there.
  */
 export async function openEventRun(
   target: EventWorkflow,
   id: string,
   argv: readonly string[],
   context: Omit<WakeContext, "file">,
+  panes?: RunPanes,
 ): Promise<Opened> {
   const workflow = target.meta.name;
   const problem = idProblem(id);
-  if (problem) throw new EmitError(problem);
-  const project = await projectOf(target.file, context.home).catch((error: unknown) => {
-    throw new EmitError(messageOf(error));
-  });
+  if (problem) throw new EmitError(problem, "id");
+  const file = fileOf(target);
+  const project = await targetProject(file, context.home);
   const runRoot = projectRunRoot(project);
   const ref = `${workflow}/${id}`;
   return withRunLock(runLockFile(runRoot, workflow, id), async () => {
-    const woken = { ...context, file: target.file };
+    const woken = { ...context, file };
     if (await exists(join(runRoot, workflow, id, "run.json"))) {
       const run = await openRun(runRoot, workflow, id);
       if ((await readAttempts(run)).at(-1)?.outcome === "completed")
         return { run: ref, created: false, did: "none", why: "returned" };
       if (argv.length > 0 && JSON.stringify(argv) !== JSON.stringify(run.record.argv))
         throw new EmitError(
-          `${ref} is there already, started with ${run.record.argv.length > 0 ? "arguments of its own" : "none"}; awf run --id ${id} with none wakes it`,
+          `${ref} is there already, started with ${run.record.argv.length > 0 || run.record.args !== undefined ? "arguments of its own" : "none"}; awf run --id ${id} with none wakes it`,
+          "other-args",
         );
+      const changed = panesChanged(run.record, panes);
+      if (changed) throw new EmitError(changed, "other-args");
       return { run: ref, created: false, ...(await wake(run, woken)) };
     }
     try {
       prepareArgs(target, argv, project);
     } catch (error) {
-      throw new EmitError(`prepare: ${messageOf(error)}`);
+      throw new EmitError(`prepare: ${messageOf(error)}`, "prepare");
     }
-    const run = await createEventRun(runRoot, workflow, id, project, target.file, context, argv);
+    const run = await createEventRun(runRoot, workflow, id, project, file, context, argv, {
+      ...(panes ? { panes } : {}),
+    });
     return { run: ref, created: true, ...(await wake(run, woken)) };
   });
 }
 
-/** The event's name, shape and id, as the target declares them; an `EmitError` when they don't fit. */
+/** The project `file`'s runs live in, which must run on this engine (ADR 0015). */
+async function targetProject(file: string, home: string): Promise<string> {
+  const project = await projectOf(file, home).catch((error: unknown) => {
+    throw new EmitError(messageOf(error), "project");
+  });
+  try {
+    checkProjectEngine(project, { file });
+  } catch (error) {
+    if (error instanceof EngineRefused) throw new EmitError(error.message, error.code);
+    throw error;
+  }
+  return project;
+}
+
+/**
+ * The target's file, which says which project its runs live in and which a start or wake runs:
+ * `file`, or the path awf loaded it from. Only a sender holding the workflow itself, as `wf.emit`
+ * does, can be without one.
+ */
+function fileOf(target: EventWorkflow): string {
+  if (target.file === undefined)
+    throw new EmitError(
+      `${target.meta.name} gives no file, by which a sender holding it finds it: file: import.meta.path`,
+      "file",
+    );
+  return target.file;
+}
+
+/**
+ * `{key}:reply`'s event as `in.jsonl` records it: `participant:reply` from its key, whatever the
+ * workflow declares it as, so a wait takes it by one name.
+ */
+export function replyRecord(
+  key: string,
+  id: string,
+  data: JsonValue,
+  at: string,
+): Delivery["event"] {
+  return { id, name: "participant:reply", data, from: key, at };
+}
+
+/**
+ * The event's name, shape and id, as the target declares them; an `EmitError` when they don't fit.
+ * A name with a colon is awf's: only `{key}:reply`, from the operator (`replies`), is sent.
+ */
 export function checkEvent(
   target: EventWorkflow,
   event: { name: string; data: JsonValue; id?: string },
+  replies = false,
 ): void {
   const workflow = target.meta.name;
   const problem = eventWorkflowProblem(target);
   if (problem) throw new EmitError(`${workflow}: ${problem}`);
-  if (!isAbsolute(target.file))
-    throw new EmitError(`${workflow}: its file, ${target.file}, is import.meta.path, absolute`);
-  if (event.name.includes(":"))
-    throw new EmitError(`${event.name}: a name with a colon is awf's own, and not sent`);
-  const schema = target.events[event.name];
-  if (!schema)
+  if (target.file !== undefined && !isAbsolute(target.file))
+    throw new EmitError(
+      `${workflow}: its file, ${target.file}, is import.meta.path, absolute`,
+      "file",
+    );
+  const reply = awfEventOf(event.name)?.kind === "reply";
+  if (event.name.includes(":") && !(replies && reply))
+    throw new EmitError(
+      reply
+        ? `${event.name}: a participant's message goes to a run that is there, awf emit ${workflow}/{id} ${event.name} '{"text":…}'`
+        : `${event.name}: a name with a colon is awf's own, and not sent`,
+    );
+  const declared = target.events[event.name];
+  if (!declared)
     throw new EmitError(
       `${workflow} declares no event ${event.name}; its events are ${Object.keys(target.events).join(", ")}`,
     );
+  // A reply is checked against awf's own schema, not the workflow's copy, which may be older.
+  const schema = reply ? ParticipantReply : declared;
   let parsed: ReturnType<typeof parseJsonSchema>;
   try {
     parsed = parseJsonSchema(schema);
@@ -234,7 +432,7 @@ export function checkEvent(
       `${event.name}'s data does not fit its schema: ${errors.map((e) => `${e.path || "/"}: ${e.message}`).join("; ")}`,
     );
   const badId = event.id === undefined ? undefined : eventIdProblem(event.id);
-  if (badId) throw new EmitError(`the id ${JSON.stringify(event.id)}: ${badId}`);
+  if (badId) throw new EmitError(`the id ${JSON.stringify(event.id)}: ${badId}`, "id");
 }
 
 /** What is wrong with an id a sender gives an event, if anything: ids starting `awf.` are awf's. */