@vercel/factory 0.0.14 → 0.0.16

package/docs/recipes/dependent-tasks.md

@@ -0,0 +1,207 @@
+# Coordinate dependent Eve agents
+
+Use graph dependencies when one Eve agent must finish before another can run. The application
+creates the graph and owns the parent workflow. A scheduled `sweepQueued` pass starts only ready
+route-bound Tasks; each agent then reads its inputs and completes its own Task through authenticated
+Eve tools.
+
+## Run the recipe
+
+Save this as `dependent-tasks.mts` in an ESM project with `@vercel/factory`, `eve`, and `zod`
+installed. Injected `fetch` responses stand in for Eve accepting each session.
+
+<!-- runnable-example:start -->
+
+```ts
+import type { ToolContext } from "eve/tools";
+import { z } from "zod";
+import {
+  createTaskTools,
+  factoryTaskAttemptAttribute,
+  factoryTaskAttribute,
+  startEveSession,
+  taskHeaders,
+} from "@vercel/factory";
+import { sweepQueued, type TaskLauncher } from "@vercel/factory/execution";
+import { createInMemoryDriver, createStores } from "@vercel/factory/storage";
+import { taskIdSchema, type Task } from "@vercel/factory/tasks";
+import { parseAgentRouteBinding, routeKey, taskWork } from "@vercel/factory/workflows";
+
+const stores = createStores({ driver: createInMemoryDriver() });
+const repository = await stores.repositories.put({
+  schemaVersion: 1,
+  id: "repo_recipe02",
+  slug: "example/project",
+  defaultBranch: "main",
+  enabled: true,
+  dependsOn: [],
+  connectedAt: new Date().toISOString(),
+});
+const prepareRoute = parseAgentRouteBinding({ id: "preparer", version: 1 });
+const consumeRoute = parseAgentRouteBinding({ id: "consumer", version: 1 });
+const consumeInputSchema = z.strictObject({ dependencyTaskId: taskIdSchema });
+const taskOutputSchema = z.strictObject({ summary: z.string().min(1) });
+const launchedAgents: string[] = [];
+
+function launchEveAgent(agent: string): TaskLauncher {
+  return (claimed) =>
+    startEveSession({
+      agentUrl: `https://factory.example/eve/agents/${agent}`,
+      message: `Work Task ${claimed.id}`,
+      operationId: `factory-task:${claimed.id}:${claimed.attempt}`,
+      headers: taskHeaders({ taskId: claimed.id, attempt: claimed.attempt }),
+      fetch: async () => {
+        launchedAgents.push(agent);
+        return Response.json({ sessionId: `ses_${agent}_${claimed.attempt}` });
+      },
+    });
+}
+
+function toolContext(task: Task): ToolContext {
+  if (task.execution?.provider !== "eve") throw new Error("Expected an Eve execution");
+  return {
+    session: {
+      id: task.execution.sessionId,
+      auth: {
+        initiator: {
+          attributes: {
+            [factoryTaskAttribute]: task.id,
+            [factoryTaskAttemptAttribute]: String(task.attempt),
+          },
+        },
+      },
+    },
+  } as unknown as ToolContext;
+}
+
+const base = {
+  repositoryIds: [repository.id] as const,
+  kind: "example",
+  origin: { operator: "local:recipe" },
+  replyTo: { channel: "local", address: "dependent-tasks" },
+} as const;
+const root = await stores.tasks.create({
+  ...base,
+  work: taskWork({ title: "Coordinate two agents" }),
+  dedupeKey: "dependency-root",
+});
+await stores.tasks.transition(root.id, "running");
+const prepare = await stores.tasks.create({
+  ...base,
+  parentTaskId: root.id,
+  work: { ...taskWork({ title: "Prepare input" }), route: prepareRoute },
+  dedupeKey: "prepare",
+});
+const consume = await stores.tasks.create({
+  ...base,
+  parentTaskId: root.id,
+  work: {
+    ...taskWork({
+      title: "Consume prepared input",
+      input: { dependencyTaskId: prepare.id },
+    }),
+    route: consumeRoute,
+  },
+  dependencies: [prepare.id],
+  dedupeKey: "consume",
+});
+const launchers = {
+  [routeKey(prepareRoute)]: launchEveAgent("preparer"),
+  [routeKey(consumeRoute)]: launchEveAgent("consumer"),
+};
+
+const firstSweep = await sweepQueued(stores, {
+  launchers,
+  tasks: [prepare, consume],
+});
+const runningPrepare = await stores.tasks.get(prepare.id);
+if (
+  runningPrepare?.state !== "running" ||
+  firstSweep.dispatched[0] !== prepare.id ||
+  firstSweep.skipped.find((item) => item.taskId === consume.id)?.reasonCode !==
+    "dependencies_unsatisfied"
+) {
+  throw new Error("The first sweep did not launch only the ready preparer");
+}
+
+const tools = createTaskTools(stores);
+const prepared = await tools.finish_task.execute(
+  { taskId: prepare.id, summary: "Prepared incident context" },
+  toolContext(runningPrepare),
+);
+if (!prepared.finished) throw new Error(prepared.reason);
+
+const secondSweep = await sweepQueued(stores, { launchers });
+const runningConsume = await stores.tasks.get(consume.id);
+if (
+  runningConsume?.state !== "running" ||
+  secondSweep.dispatched[0] !== consume.id ||
+  launchedAgents.join(",") !== "preparer,consumer"
+) {
+  throw new Error("The consumer did not launch after its dependency succeeded");
+}
+
+const consumerAssignment = await tools.get_task.execute(
+  { taskId: runningConsume.id },
+  toolContext(runningConsume),
+);
+if (!("id" in consumerAssignment)) throw new Error("The consumer assignment is missing");
+const { dependencyTaskId } = consumeInputSchema.parse(consumerAssignment.work.input);
+const dependency = await tools.get_task.execute(
+  { taskId: dependencyTaskId },
+  toolContext(runningConsume),
+);
+if (
+  !("id" in dependency) ||
+  dependency.state !== "succeeded" ||
+  dependency.id !== dependencyTaskId
+) {
+  throw new Error("The consumer could not read the dependency result");
+}
+const preparedOutput = taskOutputSchema.parse(dependency.workResult?.output);
+const consumed = await tools.finish_task.execute(
+  { taskId: consume.id, summary: `Used: ${preparedOutput.summary}` },
+  toolContext(runningConsume),
+);
+if (!consumed.finished) throw new Error(consumed.reason);
+const consumedTask = await stores.tasks.get(consume.id);
+const consumedOutput = taskOutputSchema.parse(consumedTask?.workResult?.output);
+
+const completedRoot = await stores.work.complete({
+  task: { taskId: root.id, attempt: root.attempt },
+  output: {
+    prepared: preparedOutput.summary,
+    consumed: consumedOutput.summary,
+  },
+});
+const graph = await stores.graphs.get(root.id);
+const consumeNode = graph?.nodes.find((node) => node.taskId === consume.id);
+if (
+  completedRoot.state !== "succeeded" ||
+  consumeNode?.sealed !== true ||
+  consumeNode.dependencies[0] !== prepare.id
+) {
+  throw new Error("Expected a completed parent and sealed dependency edge");
+}
+
+console.log(
+  JSON.stringify({
+    root: completedRoot.state,
+    dependency: (await stores.tasks.get(prepare.id))?.state,
+    dependent: (await stores.tasks.get(consume.id))?.state,
+    launchedAgents,
+  }),
+);
+```
+
+<!-- runnable-example:end -->
+
+The scheduler calls `sweepQueued`; applications provide exact launchers keyed by `routeKey` and
+run another pass after completion, recovery, approval, or human input can make queued work ready.
+Overlapping sweeps are safe because dispatch uses a single-winner transition.
+
+The consumer first reads its own assignment, takes the persisted dependency Task ID from
+`work.input`, and then reads that Task's validated result through `get_task`. Its completion and the
+parent's aggregate output are derived from that result. Parentage defines the graph hierarchy;
+dependencies define execution order inside that graph, but dependency edges alone do not tell the
+model which result to read.

package/docs/recipes/eve-agent.md

@@ -0,0 +1,277 @@
+# Run an Eve agent as a Factory Task
+
+Use this pattern for the normal Factory execution path: an application creates a
+route-bound Task, Factory starts an Eve session for that route, and the Eve agent uses Factory
+hooks and tools to report progress and finish the Task.
+
+Factory does not replace the agent definition in `agent.ts`. Eve still owns the model loop,
+prompts, tools, and session. Factory adds durable work state around that session: routing,
+attempts, dependencies, budgets, receipts, and a validated result.
+
+## Mount Factory in the Eve agent
+
+Keep the runtime pieces in the normal Eve filesystem layout, all importing the same application
+store singleton:
+
+```text
+agents/worker/
+  agent.ts
+  instructions.md
+  channels/eve.ts
+  hooks/factory.ts
+  tools/get_task.ts
+  tools/finish_task.ts
+lib/stores.ts
+lib/launchers.ts
+schedules/dispatch.ts
+```
+
+`agent.ts` selects the Eve model. `instructions.md` tells the model to read its Task before acting
+and to finish only after satisfying the stored completion criteria:
+
+```ts
+// agents/worker/agent.ts
+import { defineAgent } from "eve";
+
+export default defineAgent({ model: "anthropic/claude-sonnet-5" });
+```
+
+The channel authenticates the Task headers that the trusted launcher sends when it starts the
+session:
+
+```ts
+// agents/worker/channels/eve.ts
+import { withFactoryTask } from "@vercel/factory";
+import { localDev, vercelOidc } from "eve/channels/auth";
+import { eveChannel } from "eve/channels/eve";
+
+export default eveChannel({
+  auth: [withFactoryTask(vercelOidc()), withFactoryTask(localDev())],
+});
+```
+
+Mount the Factory hook beside the agent's other Eve hooks:
+
+```ts
+// agents/worker/hooks/factory.ts
+import { createFactoryHooks } from "@vercel/factory";
+import { stores } from "../../../lib/stores";
+
+export default createFactoryHooks(stores, {
+  presentQuestion: async (input) => {
+    // Send input.question to the operator surface used by this application.
+  },
+}).factory;
+```
+
+Expose the Task tools that the agent needs. The exact set is an application policy; most workers
+need `get_task` and `finish_task`:
+
+```ts
+// agents/worker/tools/get_task.ts
+import { createTaskTools } from "@vercel/factory";
+import { stores } from "../../../lib/stores";
+
+export default createTaskTools(stores).get_task;
+```
+
+```ts
+// agents/worker/tools/finish_task.ts
+import { createTaskTools } from "@vercel/factory";
+import { stores } from "../../../lib/stores";
+
+export default createTaskTools(stores).finish_task;
+```
+
+`withFactoryTask` binds the Eve session to one exact Task attempt. Mutating tools such as
+`finish_task` and `request_human_input` recheck that binding against the current persisted Eve
+execution. `get_task` is a read API that accepts a Task ID; expose it only when the agent is allowed
+to inspect Tasks in the application. `lib/stores.ts` must create one Blob- or Postgres-backed store
+configuration shared by the launcher, hooks, and tools; the in-memory store below is only for the
+self-checking example.
+
+## Dispatch the route and start Eve
+
+The application maps each route binding to an Eve agent URL. `dispatchTask` claims the Task attempt
+before calling `startEveSession`, then records the returned Eve session ID on the Task.
+
+The following self-checking program uses an injected `fetch` response, so it proves the public
+integration contract without credentials or a running Eve server.
+
+<!-- runnable-example:start -->
+
+```ts
+import { defineAgent } from "eve";
+import type { AuthFn } from "eve/channels/auth";
+import { eveChannel } from "eve/channels/eve";
+import type { ToolContext } from "eve/tools";
+import {
+  createFactoryHooks,
+  createTaskTools,
+  factoryTaskAttemptAttribute,
+  factoryTaskAttribute,
+  startEveSession,
+  taskHeaders,
+  withFactoryTask,
+} from "@vercel/factory";
+import { dispatchTask } from "@vercel/factory/execution";
+import { createInMemoryDriver, createStores } from "@vercel/factory/storage";
+import { parseAgentRouteBinding, taskWork } from "@vercel/factory/workflows";
+
+const stores = createStores({ driver: createInMemoryDriver() });
+const route = parseAgentRouteBinding({ id: "worker", version: 1 });
+const task = await stores.tasks.create({
+  repositoryIds: ["repo_eve001"],
+  kind: "example",
+  origin: { operator: "local:recipe" },
+  replyTo: { channel: "local", address: "eve-agent" },
+  work: {
+    ...taskWork({
+      title: "Summarize the incident",
+      input: { incidentId: "inc_123" },
+    }),
+    route,
+  },
+});
+const otherTask = await stores.tasks.create({
+  repositoryIds: ["repo_eve001"],
+  kind: "example",
+  origin: { operator: "local:recipe" },
+  replyTo: { channel: "local", address: "eve-agent" },
+  work: taskWork({ title: "A different assignment" }),
+});
+
+const baseAuth: AuthFn<Request> = () => ({
+  attributes: {},
+  authenticator: "recipe",
+  principalId: "factory",
+  principalType: "runtime",
+});
+const workerAgent = defineAgent({ model: "anthropic/claude-sonnet-5" });
+const workerChannel = eveChannel({ auth: [withFactoryTask(baseAuth)] });
+let authenticatedTaskId: unknown;
+let authenticatedAttempt: unknown;
+
+const running = await dispatchTask(stores, {
+  taskId: task.id,
+  route,
+  launch: (claimed) =>
+    startEveSession({
+      agentUrl: "https://factory.example/eve/agents/worker",
+      message: `Work Task ${claimed.id}`,
+      operationId: `factory-task:${claimed.id}:${claimed.attempt}`,
+      headers: taskHeaders({
+        taskId: claimed.id,
+        attempt: claimed.attempt,
+      }),
+      fetch: async (input, init) => {
+        const request = new Request(input, init);
+        const authenticated = await withFactoryTask(baseAuth)(request);
+        authenticatedTaskId = authenticated?.attributes[factoryTaskAttribute];
+        authenticatedAttempt = authenticated?.attributes[factoryTaskAttemptAttribute];
+        return Response.json({ sessionId: "ses_recipe" });
+      },
+    }),
+});
+
+const tools = createTaskTools(stores);
+const hooks = createFactoryHooks(stores, {
+  presentQuestion: async () => {},
+});
+
+if (
+  running.state !== "running" ||
+  running.execution?.provider !== "eve" ||
+  running.execution.sessionId !== "ses_recipe"
+) {
+  throw new Error("Dispatch did not record the Eve session");
+}
+if (authenticatedTaskId !== task.id || authenticatedAttempt !== String(running.attempt)) {
+  throw new Error("The Eve channel did not authenticate the Task attempt");
+}
+if (hooks.factory.events?.["turn.failed"] === undefined) {
+  throw new Error("The Factory lifecycle hook was not created");
+}
+if (workerAgent === undefined || workerChannel === undefined) {
+  throw new Error("The Eve agent and authenticated channel were not assembled");
+}
+
+const toolContext = {
+  session: {
+    id: running.execution.sessionId,
+    auth: {
+      initiator: {
+        attributes: {
+          [factoryTaskAttribute]: running.id,
+          [factoryTaskAttemptAttribute]: String(running.attempt),
+        },
+      },
+    },
+  },
+} as unknown as ToolContext;
+const assignment = await tools.get_task.execute({ taskId: running.id }, toolContext);
+if (!("id" in assignment) || assignment.id !== running.id) {
+  throw new Error("The Eve agent could not read its assignment");
+}
+
+let foreignCompletionRejected = false;
+try {
+  await tools.finish_task.execute(
+    { taskId: otherTask.id, summary: "Completed a different Task" },
+    toolContext,
+  );
+} catch {
+  foreignCompletionRejected = true;
+}
+const finish = await tools.finish_task.execute(
+  { taskId: running.id, summary: "Incident inc_123 was summarized" },
+  toolContext,
+);
+const completed = await stores.tasks.get(running.id);
+if (
+  !foreignCompletionRejected ||
+  !finish.finished ||
+  completed?.state !== "succeeded" ||
+  JSON.stringify(completed.workResult?.output) !==
+    JSON.stringify({ summary: "Incident inc_123 was summarized" })
+) {
+  throw new Error("Expected authenticated, attempt-fenced Task completion");
+}
+
+console.log(
+  JSON.stringify({
+    taskId: completed.id,
+    attempt: completed.attempt,
+    sessionId: running.execution.sessionId,
+    state: completed.state,
+  }),
+);
+```
+
+<!-- runnable-example:end -->
+
+In production, omit the injected `fetch`. Eve accepts the session, runs the agent, and invokes the
+mounted hooks. The agent reads its assignment with `get_task` and submits the generic `task@1`
+output with `finish_task`. Factory rejects mutating tool calls whose authenticated session, Task ID,
+or attempt no longer matches the current Task. Use the
+[typed Eve result recipe](./typed-eve-result.md) when a workflow has its own output schema.
+
+`taskHeaders(...)` supplies only the Factory Task binding. A protected Vercel deployment commonly
+needs both an `Authorization: Bearer <OIDC token>` header for the Eve channel's `vercelOidc()`
+authentication and `x-vercel-protection-bypass` to pass Deployment Protection. The bypass is not an
+Eve identity. Add whichever layers the deployment actually requires in the trusted launcher, and
+never expose either credential to the agent or its tools.
+
+## Let hooks own session lifecycle events
+
+`createFactoryHooks` translates Eve events into durable Task changes:
+
+- step events record Task usage, and terminal turn events settle measured cost;
+- a completed turn that leaves work unresolved creates a QuestionTask, suspends the Task, and calls
+  `presentQuestion`;
+- `turn.failed` and `session.failed` requeue eligible Tasks with a new attempt;
+- `turn.cancelled` cancels the matching Task attempt.
+
+The application must run its recovery launcher after a Task is requeued. See
+[Retry and recover a failed attempt](./retry-recovery.md) for the attempt-fencing rules, and
+[Coordinate dependent Eve agents](./dependent-tasks.md) for multi-agent work.

package/docs/recipes/human-input.md

@@ -0,0 +1,204 @@
+# Pause an Eve Task for human input
+
+An Eve specialist asks through `request_human_input`. Factory persists a QuestionTask, moves the
+specialist Task to `needs_human`, and calls the application's presenter. A reply from the same
+authenticated conversation completes the QuestionTask and queues a fresh specialist attempt.
+
+## Run the recipe
+
+Save this as `human-input.mts` in an ESM project with `@vercel/factory`, `eve`, and `zod`
+installed.
+
+<!-- runnable-example:start -->
+
+```ts
+import type { ToolContext } from "eve/tools";
+import {
+  createTaskTools,
+  factoryReplyAddressAttribute,
+  factoryReplyChannelAttribute,
+  factoryTaskAttemptAttribute,
+  factoryTaskAttribute,
+  startEveSession,
+  taskHeaders,
+} from "@vercel/factory";
+import { sweepQueued } from "@vercel/factory/execution";
+import { createInMemoryDriver, createStores } from "@vercel/factory/storage";
+import type { Task } from "@vercel/factory/tasks";
+import { parseAgentRouteBinding, routeKey, taskWork } from "@vercel/factory/workflows";
+
+const stores = createStores({ driver: createInMemoryDriver() });
+const repository = await stores.repositories.put({
+  schemaVersion: 1,
+  id: "repo_human01",
+  slug: "example/project",
+  defaultBranch: "main",
+  enabled: true,
+  dependsOn: [],
+  connectedAt: new Date().toISOString(),
+});
+const route = parseAgentRouteBinding({ id: "worker", version: 1 });
+const startedSessions: string[] = [];
+const assignmentMessages: string[] = [];
+const launchers = {
+  [routeKey(route)]: async (claimed: Task) => {
+    const answers = (
+      await Promise.all((claimed.answerEventIds ?? []).map((id) => stores.answers.get(id)))
+    ).flatMap((event) => (event === null ? [] : [`${event.question}\nAnswer: ${event.answer}`]));
+    const message = [
+      `Work Task ${claimed.id}`,
+      answers.length === 0 ? undefined : `Human answers:\n${answers.join("\n\n")}`,
+    ]
+      .filter((part) => part !== undefined)
+      .join("\n\n");
+    assignmentMessages.push(message);
+    return startEveSession({
+      agentUrl: "https://factory.example/eve/agents/worker",
+      message,
+      operationId: `factory-task:${claimed.id}:${claimed.attempt}`,
+      headers: taskHeaders({ taskId: claimed.id, attempt: claimed.attempt }),
+      fetch: async () => {
+        const sessionId = `ses_human_${claimed.attempt}`;
+        startedSessions.push(sessionId);
+        return Response.json({ sessionId });
+      },
+    });
+  },
+};
+const task = await stores.tasks.create({
+  repositoryIds: [repository.id],
+  kind: "example",
+  origin: { operator: "local:recipe" },
+  replyTo: { channel: "github", address: "example/project#42" },
+  work: {
+    ...taskWork({ title: "Deploy to the selected environment" }),
+    route,
+  },
+});
+await sweepQueued(stores, { launchers });
+const firstAttempt = await stores.tasks.get(task.id);
+if (firstAttempt?.state !== "running" || firstAttempt.execution?.provider !== "eve") {
+  throw new Error("The first Eve attempt did not start");
+}
+
+function workerContext(running: Task): ToolContext {
+  if (running.execution?.provider !== "eve") throw new Error("Expected an Eve execution");
+  return {
+    session: {
+      id: running.execution.sessionId,
+      auth: {
+        initiator: {
+          attributes: {
+            [factoryTaskAttribute]: running.id,
+            [factoryTaskAttemptAttribute]: String(running.attempt),
+          },
+        },
+      },
+    },
+  } as unknown as ToolContext;
+}
+
+const presented: string[] = [];
+const tools = createTaskTools(stores, {
+  presentQuestion: async (questionTask) => {
+    presented.push(questionTask.id);
+  },
+});
+const question = await tools.request_human_input.execute(
+  {
+    parentTaskId: firstAttempt.id,
+    question: {
+      text: "Which environment should receive the deployment?",
+      options: ["staging", "production"],
+    },
+  },
+  workerContext(firstAttempt),
+);
+const waiting = await stores.tasks.get(task.id);
+if (
+  question.state !== "needs_human" ||
+  waiting?.state !== "needs_human" ||
+  waiting.questionTaskId !== question.id ||
+  presented[0] !== question.id
+) {
+  throw new Error("The question was not persisted and presented");
+}
+
+const conversationContext = {
+  session: {
+    id: "ses_operator_reply",
+    auth: {
+      initiator: {
+        principalId: "operator",
+        attributes: {
+          [factoryReplyChannelAttribute]: task.replyTo.channel,
+          [factoryReplyAddressAttribute]: task.replyTo.address,
+        },
+      },
+      current: {
+        principalId: "operator",
+        attributes: {
+          [factoryReplyChannelAttribute]: task.replyTo.channel,
+          [factoryReplyAddressAttribute]: task.replyTo.address,
+        },
+      },
+    },
+  },
+} as unknown as ToolContext;
+const answered = await tools.answer_question.execute(
+  { questionTaskId: question.id, answer: "staging" },
+  conversationContext,
+);
+if (
+  answered.questionTask.state !== "succeeded" ||
+  answered.parentTask?.state !== "queued" ||
+  answered.parentTask.attempt !== 2
+) {
+  throw new Error("The authenticated answer did not queue a replacement attempt");
+}
+
+await sweepQueued(stores, { launchers });
+const replacement = await stores.tasks.get(task.id);
+const resumedAssignment = assignmentMessages[1];
+if (
+  replacement?.state !== "running" ||
+  replacement.attempt !== 2 ||
+  resumedAssignment === undefined ||
+  !resumedAssignment.includes("Which environment should receive the deployment?") ||
+  !resumedAssignment.includes("Answer: staging")
+) {
+  throw new Error("The resumed Eve attempt did not start");
+}
+const selectedEnvironment = resumedAssignment.match(/Answer: (staging|production)/u)?.[1];
+if (selectedEnvironment === undefined)
+  throw new Error("The replacement assignment lost the answer");
+const finish = await tools.finish_task.execute(
+  { taskId: replacement.id, summary: `Deployed to ${selectedEnvironment}` },
+  workerContext(replacement),
+);
+if (!finish.finished) throw new Error(finish.reason);
+const completed = await stores.tasks.get(task.id);
+if (completed?.state !== "succeeded" || startedSessions.length !== 2) {
+  throw new Error("The resumed Task did not complete");
+}
+
+console.log(
+  JSON.stringify({
+    answer: answered.answerEvent.answer,
+    attempts: completed.attempt,
+    state: completed.state,
+  }),
+);
+```
+
+<!-- runnable-example:end -->
+
+The original Eve session cannot resume the Task: answering increments the attempt, and the next
+`sweepQueued` pass starts a replacement session on the same exact route. Build every replacement
+assignment from the parent's immutable `answerEventIds`, as shown here, so the new Eve session sees
+the question and authenticated answer. Present the persisted QuestionTask through the parent
+Task's `replyTo` channel, and invoke `answer_question` only from that conversation's authenticated
+callback.
+
+Use `closingOptions` for answers that mean retrying cannot help. Choosing one cancels the parent
+instead of queuing another attempt.