@camox/api-contract 0.71.0 → 0.74.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camox/api-contract",
-  "version": "0.71.0",
+  "version": "0.74.1",
   "license": "MIT",
   "files": [
     "src",
@@ -44,9 +44,9 @@
       "types": "./dist/locales.d.ts",
       "default": "./dist/locales.js"
     },
-    "./patrol": {
-      "types": "./dist/patrol.d.ts",
-      "default": "./dist/patrol.js"
+    "./specialists": {
+      "types": "./dist/specialists.d.ts",
+      "default": "./dist/specialists.js"
     },
     "./router": {
       "types": "./dist/router.d.ts",
@@ -55,6 +55,10 @@
     "./layout-routes": {
       "types": "./dist/layout-routes.d.ts",
       "default": "./dist/layout-routes.js"
+    },
+    "./claim-links": {
+      "types": "./dist/claim-links.d.ts",
+      "default": "./dist/claim-links.js"
     }
   },
   "dependencies": {

package/src/claim-links.ts

@@ -0,0 +1,23 @@
+import { projectWebsiteUrl } from "./projects";
+
+/** URL search param carrying a Claim Link's token on the website it links to. */
+export const CLAIM_LINK_SEARCH_PARAM = "camox-claim";
+
+/**
+ * Where a Claim Link stands: `open` until it's claimed, revoked by an operator, or blocked, when a
+ * claim was refused because someone who isn't an operator joined its organization (ADR 0041).
+ */
+export type ClaimLinkState = "open" | "claimed" | "revoked" | "blocked";
+
+/**
+ * A Claim Link: the project's address, its Custom Domain if it has one, else its `camox.site`
+ * subdomain, with the link's token.
+ */
+export function claimLinkUrl(
+  project: { slug: string; customDomain: string | null },
+  token: string,
+) {
+  const url = new URL("/", projectWebsiteUrl(project));
+  url.searchParams.set(CLAIM_LINK_SEARCH_PARAM, token);
+  return url.toString();
+}

package/src/drafts.ts

@@ -50,9 +50,9 @@ export const LOOK_LOCALE_PARAM = "locale";
 
 /**
  * The look document's Block Definition mode: instead of a page, the block of the Block Definition
- * `LOOK_BLOCK_DEFINITION_PARAM` names, alone in the site's shell, with its default content and
- * Block Settings and the overrides `LOOK_CONTENT_PARAM` and `LOOK_SETTINGS_PARAM` give as JSON, in
- * the shape the content tools take.
+ * `LOOK_BLOCK_DEFINITION_PARAM` names, alone in the site's shell, with empty fields and the
+ * content and Block Settings `LOOK_CONTENT_PARAM` and `LOOK_SETTINGS_PARAM` give as JSON merged
+ * on, in the shape the content tools take.
  */
 export const LOOK_BLOCK_DEFINITION_PARAM = "blockDefinition";
 export const LOOK_CONTENT_PARAM = "content";
@@ -60,8 +60,8 @@ export const LOOK_SETTINGS_PARAM = "settings";
 
 /**
  * The look document's Layout Definition mode: instead of a page, the curated Layout
- * `LOOK_LAYOUT_DEFINITION_PARAM` names, alone in the site's shell, its blocks with their default
- * content and Block Settings and the overrides `LOOK_BLOCKS_PARAM` gives as JSON, by Block
+ * `LOOK_LAYOUT_DEFINITION_PARAM` names, alone in the site's shell, its blocks with empty fields
+ * and the content and Block Settings `LOOK_BLOCKS_PARAM` gives as JSON merged on, by Block
  * Definition name (`{ navbar: { content, settings } }`), around a labelled placeholder where a
  * page's content goes, as tall as `LOOK_PLACEHOLDER_PARAM` says: one of `LOOK_PLACEHOLDER_HEIGHTS`,
  * the first without.
@@ -164,12 +164,6 @@ export type EndedDraft = {
  */
 export const DRAFT_ENDED_ERROR_CODE = "DRAFT_ENDED";
 
-/**
- * oRPC error code for a publish whose token no longer matches Live: Live changed since the
- * preview, so nothing was applied and the caller reviews the new preview.
- */
-export const CONFLICTS_CHANGED_ERROR = "CONFLICTS_CHANGED";
-
 /**
  * oRPC error code for a publish of a draft with code whose revision isn't the one the review
  * showed: the agent left a newer one, or the draft is already publishing. The caller reviews
@@ -179,15 +173,16 @@ export const REVISION_CHANGED_ERROR = "REVISION_CHANGED";
 
 /**
  * Why a publish with code went back to the review instead of landing: the agent left a revision
- * after the one the review showed, Live's conflicts changed, the draft got a blocker, Live's code
- * moved and the draft's merge of it clashed (the "doesn't merge with Live's" blocker, which
- * Camox's turn fixes), Live's code moved and the draft took too long to merge it, or the publish
- * failed on Camox's side.
+ * after the one the review showed, the draft got a blocker, Live's code moved and the draft's
+ * merge of it clashed (the "doesn't merge with Live's" blocker, which Camox's turn fixes), Live's
+ * code moved and the draft took too long to merge it, or the publish failed on Camox's side.
+ * `conflictsChanged` is only stored by publishes before ADR 0043, which aborted when Live changed.
  */
 export const PUBLISH_ABORT_REASONS = [
   "revisionChanged",
   "conflictsChanged",
   "blocked",
+  "codeDoesNotBuild",
   "codeDoesNotMerge",
   "liveCodeMoved",
   "failed",
@@ -198,36 +193,13 @@ export type PublishAbortReason = (typeof PUBLISH_ABORT_REASONS)[number];
 /** oRPC error code for a publish refused because the draft still has blockers. */
 export const PUBLISH_BLOCKED_ERROR = "PUBLISH_BLOCKED";
 
-/**
- * oRPC error code for a publish refused because the draft still has pending translations: every
- * locale goes live together, and there is no publishing anyway (ADR 0033).
- */
-export const TRANSLATIONS_PENDING_ERROR = "TRANSLATIONS_PENDING";
-
-/**
- * oRPC error code for a publish refused because the draft has open findings, each to fix or for a
- * member to dismiss: there is no publishing past them (ADR 0033).
- */
-export const FINDINGS_OPEN_ERROR = "FINDINGS_OPEN";
-
-/**
- * oRPC error code for a publish refused because a patroller's check at publish hasn't read the
- * draft's latest changes yet: publishing waits for it (ADR 0033).
- */
-export const CHECKS_RUNNING_ERROR = "CHECKS_RUNNING";
-
 /**
  * Why the publish tool published nothing of a draft with changes, and returned a fresh preview to
- * review again, by the error code of each: Live changed since the preview, the draft has blockers,
- * translations are still running, the draft has open findings, a check at publish is still
- * running, or the draft's code changed since the preview.
+ * review again, by the error code of each: the draft has blockers, or the draft's code changed
+ * since the preview.
  */
 export const NOT_PUBLISHED_CODES = {
-  conflictsChanged: CONFLICTS_CHANGED_ERROR,
   blocked: PUBLISH_BLOCKED_ERROR,
-  translating: TRANSLATIONS_PENDING_ERROR,
-  findings: FINDINGS_OPEN_ERROR,
-  checking: CHECKS_RUNNING_ERROR,
   revisionChanged: REVISION_CHANGED_ERROR,
 } as const;
 
@@ -339,7 +311,7 @@ const LOCALE_WRITES: Record<keyof Router["locales"], boolean> = {
 
 // Applying a finding's fix edits content as the member would; dismissing one is the project's,
 // never content (ADR 0034).
-const PATROL_WRITES: Record<keyof Router["patrol"], boolean> = {
+const SPECIALISTS_WRITES: Record<keyof Router["specialists"], boolean> = {
   get: false,
   applyFix: true,
   dismissFinding: false,
@@ -352,7 +324,9 @@ const CONTENT_WRITES: Partial<Record<keyof Router, Record<string, boolean>>> = {
   collectionDefinitions: COLLECTION_WRITES,
   files: FILE_WRITES,
   pages: PAGE_WRITES,
-  patrol: PATROL_WRITES,
+  specialists: SPECIALISTS_WRITES,
+  // The old name of `specialists`, for studios not yet upgraded (ADR 0019).
+  patrol: SPECIALISTS_WRITES,
   repeatableItems: ITEM_WRITES,
 };
 

package/src/empty-values.ts

@@ -0,0 +1,52 @@
+/**
+ * What a field holds before anyone writes it: the empty value of its kind. Fields declare no
+ * default, so content missing a field, or holding a value of the wrong kind, reads as this.
+ * Shared by the SDK (rendering, new repeatable items, authoring forms) and the API (creating
+ * content, conforming it on read), so both agree on what an unset field is.
+ */
+
+/** A link that goes nowhere yet. */
+export const EMPTY_LINK = { type: "external", text: "", href: "", newTab: false } as const;
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * The empty value of a field, from its stored JSON Schema (`fieldType` and, for an enum, its
+ * options): `""` for text, a link to nowhere, `false`, an enum's first option, `null` for one
+ * asset or record, and `[]` for lists and repeaters. A fresh copy each call.
+ */
+export function emptyFieldValue(fieldSchema: unknown): unknown {
+  const schema = isObject(fieldSchema) ? fieldSchema : {};
+  switch (schema.fieldType) {
+    case "Link":
+      return { ...EMPTY_LINK };
+    case "Boolean":
+      return false;
+    case "Enum": {
+      const options = Array.isArray(schema.enum) ? schema.enum : [];
+      const first = options.find((option) => typeof option === "string");
+      return first ?? "";
+    }
+    case "Image":
+    case "File":
+    case "Reference":
+      return null;
+    case "ImageList":
+    case "FileList":
+    case "ReferenceList":
+    case "Repeater":
+      return [];
+    default:
+      return "";
+  }
+}
+
+/** The empty value of every field of a content or settings schema, by name. */
+export function emptyFieldValues(schema: unknown): Record<string, unknown> {
+  const properties = isObject(schema) && isObject(schema.properties) ? schema.properties : {};
+  return Object.fromEntries(
+    Object.entries(properties).map(([name, field]) => [name, emptyFieldValue(field)]),
+  );
+}

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from "./artifact.ts";
+export * from "./empty-values.ts";
 export * from "./icons.ts";
 export * from "./ids.ts";
 export * from "./record-templates.ts";

package/src/query-keys.ts

@@ -59,7 +59,11 @@ export const queryKeys = {
     // The draft a viewer is in, scoped to it like content.
     get: ["camox", "drafts", "get"],
   },
-  // The Patrol of a scope: its reports and its patrollers' pending work.
+  // The Specialists of a scope: their reports and pending work.
+  specialists: {
+    get: ["camox", "specialists"],
+  },
+  // Where studios not yet upgraded to the specialists cache them (ADR 0019).
   patrol: {
     get: ["camox", "patrol"],
   },

package/src/{patrol.ts → specialists.ts}

@@ -1,14 +1,14 @@
 /**
- * The Patrol (ADR 0024): every patroller of a project, the work each did as reports, as the
+ * The Specialists (ADR 0024): every specialist of a project, the work each did as reports, as the
  * studio shows it at the top of the Agent Sidebar. The API reads it for one scope, a draft or
  * Live, and names each report's subject, so the studio needs no entity loaded to show it.
  */
 
-/** Every patroller's stable id. The registry in the API lists them all. */
-export const PATROLLER_IDS = ["translator", "seoManager", "linkChecker"] as const;
+/** Every specialist's stable id. The registry in the API lists them all. */
+export const SPECIALIST_IDS = ["translator", "seoManager", "linkChecker"] as const;
 
-/** A patroller's stable id. */
-export type PatrollerId = (typeof PATROLLER_IDS)[number];
+/** A specialist's stable id. */
+export type SpecialistId = (typeof SPECIALIST_IDS)[number];
 
 /**
  * What a structured report says was done. Each has a failed form, by the report's outcome. A
@@ -32,7 +32,7 @@ export type ReportEntity =
   | "record"
   | "file";
 
-/** A report's subject, named as the Canvas names it, read when the Patrol is. */
+/** A report's subject, named as the Canvas names it, read when the Specialists is. */
 export type ReportSubject = { entity: ReportEntity; id: string; name: string };
 
 /**
@@ -57,10 +57,10 @@ export const reportLocale = (
 export type ReportOutcome = "done" | "failed";
 
 /**
- * Where a patroller is on duty, in drafts or on Live: it works as you go, checks when you
- * publish, or is off there (ADR 0034).
+ * Where a specialist is on duty, in drafts or on Live: it works as you go, or is off there (ADR
+ * 0034). None checks when you publish: publishing never waits on Camox (ADR 0043).
  */
-export type PatrollerDuty = "asYouGo" | "atPublish" | "off";
+export type SpecialistDuty = "asYouGo" | "off";
 
 /**
  * Where the studio shows a report's subject: a page on the Canvas, with the block and repeatable
@@ -72,7 +72,7 @@ export type ReportPlace =
   | { kind: "file"; fileId: string };
 
 export type ReportView = {
-  /** Unique among the patroller's reports in the view. */
+  /** Unique among the specialist's reports in the view. */
   id: string;
   summary: ReportSummary;
   outcome: ReportOutcome;
@@ -91,12 +91,14 @@ export type ReportView = {
  * What a finding is about (ADR 0034), by its kind:
  * - `missingPage`: a link to a page that doesn't exist, the page's name as it was last known.
  * - `brokenLink`: an external link that failed, and how.
+ * - `missingMetaTitle`: a page whose meta title is written by hand, and empty.
  * A link's `url` is as content stores it: a page link's is `camox:page:<id>`, and `text` is what
  * the link reads.
  */
 export type FindingAbout =
   | { kind: "missingPage"; url: string; text: string; page: string | null }
-  | { kind: "brokenLink"; url: string; text: string; failure: LinkFailure };
+  | { kind: "brokenLink"; url: string; text: string; failure: LinkFailure }
+  | { kind: "missingMetaTitle" };
 
 /** How a link failed: an HTTP error status, no connection (DNS included), or no answer in time. */
 export type LinkFailure =
@@ -126,14 +128,17 @@ export type FindingView = {
   fieldKind: string | null;
   /** When it was first raised, in milliseconds since the epoch. */
   raisedAt: number;
-  /** Whether it's Live's. Live's are fixed in the Patrol Draft. */
+  /**
+   * Whether it's Live's. A draft shows Live's findings on the content it still holds, and fixes
+   * them there.
+   */
   live: boolean;
   /** Where its content shows, as for reports. */
   place: ReportPlace | null;
 };
 
-/** What a finding is about, after where it is: "links to About, a page that no longer exists". */
-function aboutSentence(about: FindingAbout): string {
+/** What a link finding is about, after where it is: "links to About, a page that no longer exists". */
+function linkSentence(about: Exclude<FindingAbout, { kind: "missingMetaTitle" }>): string {
   switch (about.kind) {
     case "missingPage":
       return about.page === null
@@ -154,10 +159,12 @@ function aboutSentence(about: FindingAbout): string {
 
 /**
  * A finding as one sentence, as the studio, emails, Briefs and refusals word it: "“About us” in
- * Footer links to About, a page that no longer exists".
+ * Footer links to About, a page that no longer exists", or "Pricing has no meta title".
  */
 export function findingSentence(finding: Pick<FindingView, "about" | "subject">): string {
-  return `“${finding.about.text}” in ${finding.subject.name} ${aboutSentence(finding.about)}`;
+  const { about, subject } = finding;
+  if (about.kind === "missingMetaTitle") return `${subject.name} has no meta title`;
+  return `“${about.text}” in ${subject.name} ${linkSentence(about)}`;
 }
 
 /**
@@ -165,7 +172,9 @@ export function findingSentence(finding: Pick<FindingView, "about" | "subject">)
  * by its field: "“About us” links to About, a page that no longer exists".
  */
 export function findingSentenceInPlace(finding: Pick<FindingView, "about">): string {
-  return `“${finding.about.text}” ${aboutSentence(finding.about)}`;
+  const { about } = finding;
+  if (about.kind === "missingMetaTitle") return "The page has no meta title";
+  return `“${about.text}” ${linkSentence(about)}`;
 }
 
 /** A member's dismissal of what a finding was about: no finding like it is raised again. */
@@ -180,26 +189,26 @@ export type DismissalView = {
 /** What applying a finding's fix did: applied it, or found its content changed and rechecked. */
 export type ApplyResult = { applied: boolean };
 
-/** How many subjects a patroller is on in one locale, a locale's tag. */
+/** How many subjects a specialist is on in one locale, a locale's tag. */
 export type LocaleCount = { locale: string; count: number };
 
 /**
- * What a patroller is on: the one subject when there's one, and how many subjects in each
+ * What a specialist is on: the one subject when there's one, and how many subjects in each
  * locale, the most first. A subject in several locales counts in each.
  */
-export type PatrollerWorking = {
+export type SpecialistWorking = {
   subject: ReportSubject | null;
   locales: LocaleCount[];
 };
 
-export type PatrollerView = {
-  id: PatrollerId;
+export type SpecialistView = {
+  id: SpecialistId;
   /** Its role, as editors know it: "Translator", "SEO manager". */
   role: string;
   /** Its duty in the scope viewed. Off there, it still has its reports. */
-  duty: PatrollerDuty;
+  duty: SpecialistDuty;
   /** Null when it isn't working in the scope. */
-  working: PatrollerWorking | null;
+  working: SpecialistWorking | null;
   /**
    * When it last finished a check in the scope, whether it found anything or not, or null when it
    * never checked there.
@@ -220,14 +229,14 @@ export type PatrollerView = {
   dismissals: DismissalView[];
 };
 
+/** Every specialist of the registry, the latest activity first; never-worked ones last. */
+export type SpecialistsView = { specialists: SpecialistView[] };
+
 /**
- * Every patroller of the registry, the latest activity first; never-worked ones last. With the
- * project's open Patrol Draft, where Live's findings are fixed, if any.
+ * URL search param the studio opens a specialist's findings from, by its id, as the email about
+ * Live's new findings links to them. The studio drops it once opened.
  */
-export type PatrolView = {
-  patrollers: PatrollerView[];
-  patrolDraft: { id: string; name: string | null } | null;
-};
+export const SPECIALIST_SEARCH_PARAM = "camox-specialist";
 
-/** How many reports the Patrol shows of each patroller; the rest are counted. */
+/** How many reports the Specialists shows of each specialist; the rest are counted. */
 export const REPORTS_SHOWN = 5;

package/src/threads.ts

@@ -44,9 +44,8 @@ export const RECONCILE_ENTRY = "camox.reconcile";
 
 /**
  * The kind of the transcript entry opening a draft's thread a Live thread handed a request off
- * to: the Brief, which the model reads and editors see as from Camox, ahead of the editor's
- * messages. In a draft Camox opened, such as its Patrol Draft, Camox's own messages are Briefs
- * too, with their `operationId` as data, and start the agent's run, which acts for Camox.
+ * to: the Brief, which the model reads ahead of the editor's messages, and editors see collapsed
+ * after them, so the request reads on as they sent it.
  */
 export const BRIEF_ENTRY = "camox.brief";
 
@@ -60,8 +59,8 @@ export const DRAFT_ENDED_ENTRY = "camox.draft-ended";
 /**
  * The kind of the transcript entry a Live thread starts afresh from once its agent handed a
  * request off to a draft (ADR 0036): a reset of Pi's context, with a `startedDraftCardSchema` as
- * data. Editors see it as the draft's card, alone, and the model reads a note naming the draft.
- * Everything before it is left out of both.
+ * data. Editors see an empty thread, and the model reads a note naming the draft. Everything
+ * before it is left out of both.
  */
 export const DRAFT_CARD_ENTRY = "camox.draft-card";
 
@@ -127,6 +126,30 @@ export const codeRequestDataSchema = artifactRequestDataSchema.extend({
 });
 export type CodeRequestData = z.infer<typeof codeRequestDataSchema>;
 
+/**
+ * The draft thread's agent's tool asking the Connected Agents following its turn questions, which
+ * their waiting calls come back with as the agent works on (ADR 0042). The model calls it itself,
+ * never from a script.
+ */
+export const ASK_TOOL = "askConnectedAgent";
+
+/**
+ * The kind of the transcript entry recording questions the agent asked the Connected Agents
+ * following its turn, with a `questionsDataSchema` as data. Neither the model nor editors read
+ * it: questions are never a thread's messages, and never end its turn.
+ */
+export const QUESTIONS_ENTRY = "camox.questions";
+
+/**
+ * What a questions entry records: the questions, in the order the agent asked them, and the
+ * Connected Agents they were asked of, each by its member's id and client id.
+ */
+export const questionsDataSchema = z.object({
+  questions: z.array(z.string()).min(1),
+  to: z.array(z.object({ memberId: z.string(), clientId: z.string() })),
+});
+export type QuestionsData = z.infer<typeof questionsDataSchema>;
+
 /**
  * The agent's tools handing work to an agent of its own, in a conversation beside the thread's,
  * whose answer they return: editors see what that agent does as the agent's.
@@ -210,13 +233,14 @@ export const connectedAgentClientSchema = z.object({ name: z.string(), verified:
 export type ConnectedAgentClient = z.infer<typeof connectedAgentClientSchema>;
 
 /**
- * What a Connected Agent's message entry records: the member it acts as, its client, and the
- * operation id it was sent with.
+ * What a Connected Agent's message entry records: the member it acts as, its client, the
+ * operation id it was sent with, and whether it answers the agent's questions (ADR 0042).
  */
 export const connectedAgentMessageDataSchema = z.object({
   member: threadSenderSchema,
   client: connectedAgentClientSchema,
   operationId: z.string().optional(),
+  answer: z.boolean().optional(),
 });
 export type ConnectedAgentMessageData = z.infer<typeof connectedAgentMessageDataSchema>;
 
@@ -291,7 +315,9 @@ export type ThreadMessage =
   | { id: string; from: "editor"; sender: ThreadSender; text: string }
   /**
    * A member's Connected Agent's message: the member's own AI, in its client, writing as itself.
-   * Never shown as the member's own words.
+   * Never shown as the member's own words. An answer to the agent's questions shows as the
+   * context the draft was built on, collapsed, as a Brief does, rather than as a request
+   * (ADR 0042).
    */
   | {
       id: string;
@@ -299,9 +325,15 @@ export type ThreadMessage =
       member: ThreadSender;
       client: ConnectedAgentClient;
       text: string;
+      answer: boolean;
     }
   /** Camox's own message, starting a turn it began itself: why it did. */
   | { id: string; from: "camox"; text: string }
+  /**
+   * The Brief the agent on Live wrote as it handed the request off to the draft, shown after the
+   * editor's messages it opened the thread with, though the model reads it before them.
+   */
+  | { id: string; from: "brief"; text: string }
   /** The agent's final message of a turn, in Markdown. */
   | { id: string; from: "agent"; text: string }
   /**
@@ -403,9 +435,17 @@ export const EMPTY_THREAD_STATE: ThreadState = { steps: [], running: false };
 /** One transcript entry, as far as the studio's view is concerned. */
 type ThreadStep = { id: string } & (
   | { type: "editor"; sender: ThreadSender; text: string }
-  | { type: "connectedAgent"; member: ThreadSender; client: ConnectedAgentClient; text: string }
+  | {
+      type: "connectedAgent";
+      member: ThreadSender;
+      client: ConnectedAgentClient;
+      text: string;
+      answer: boolean;
+    }
   /** Camox starting a turn of its own, saying why. */
   | { type: "camox"; text: string }
+  /** The Brief opening a draft's thread a Live thread handed a request off to. */
+  | { type: "brief"; text: string }
   | { type: "answer"; text: string }
   /** A round of tool calls, or their results: the run goes on after it. */
   | { type: "tools" }
@@ -560,11 +600,8 @@ function threadStepOf(entry: EntryRecord): ThreadStep | undefined {
     const push = pushDataSchema.safeParse(entry.data).data;
     return push && { id, type: "push", ...push };
   }
-  // The model reads a note: editors see the card it starts the Live thread afresh with.
-  if (entry.kind === DRAFT_CARD_ENTRY) {
-    const card = startedDraftCardSchema.safeParse(entry.data).data;
-    return card && { id, type: "draft", ...card };
-  }
+  // Only the model reads it, as a note naming the draft: editors see the Live thread start empty.
+  if (entry.kind === DRAFT_CARD_ENTRY) return undefined;
   const message = entry.model?.find((candidate) => candidate.role !== "system");
   if (!message) return undefined;
   if (message.role === "user") {
@@ -580,10 +617,16 @@ function threadStepOf(entry: EntryRecord): ThreadStep | undefined {
           member: senderOf(data.member)!,
           client: { name: data.client.name, verified: data.client.verified },
           text: editorTextOf(message.content),
+          answer: data.answer ?? false,
         }
       );
     }
-    if (entry.kind === BRIEF_ENTRY) return { id, type: "camox", text: textOf(message.content) };
+    if (entry.kind === BRIEF_ENTRY) {
+      // Only Camox's own messages, in a draft it opened, carry an operation id: a hand-off's
+      // Brief is written ahead of the editor's messages, which start the run.
+      const own = z.object({ operationId: z.string() }).safeParse(entry.data).success;
+      return { id, type: own ? "camox" : "brief", text: textOf(message.content) };
+    }
     if (entry.kind === RECONCILE_ENTRY) {
       const reconcile = reconcileDataSchema.safeParse(entry.data).data;
       return reconcile && { id, type: "camox", text: reconcile.message };
@@ -648,9 +691,19 @@ export function threadViewOf({
     if (waiting !== undefined) messages.push({ id: `${waiting}:failed`, from: "failed" });
     endTurn();
   };
+  /** A hand-off's Brief, shown once the editors' messages it opened the thread with are. */
+  let brief: Extract<ThreadMessage, { from: "brief" }> | undefined;
+  const showBrief = () => {
+    if (brief) messages.push(brief);
+    brief = undefined;
+  };
 
   for (const step of steps) {
+    if (step.type !== "editor" && step.type !== "connectedAgent") showBrief();
     switch (step.type) {
+      case "brief":
+        brief = { id: step.id, from: "brief", text: step.text };
+        break;
       case "editor":
         // Pi places a steering message only once a model call is settled: after a round of tool
         // calls, or with the answer ending the run. Never between a failed call and its retry, so
@@ -668,6 +721,7 @@ export function threadViewOf({
           member: step.member,
           client: step.client,
           text: step.text,
+          answer: step.answer,
         });
         waiting = step.id;
         break;
@@ -738,6 +792,7 @@ export function threadViewOf({
         break;
     }
   }
+  showBrief();
   if (!running) fail();
   if (!running) return { messages, running };
   return {
@@ -798,7 +853,7 @@ const callsLook = (block: AssistantMessage["content"][number]) =>
 
 /**
  * Adds an entry to the thread's state as Pi places it. An entry heading a new context, such as
- * the card a Live thread starts afresh from, leaves out every step before its head, as Pi's
+ * the one a Live thread starts afresh from, leaves out every step before its head, as Pi's
  * snapshots do.
  */
 const append = (state: ThreadState, entry: EntryRecord | undefined): ThreadState => {