@camox/api-contract 0.65.1 → 0.67.0

package/dist/drafts.d.ts

@@ -49,6 +49,20 @@ export declare const LOOK_LOCALE_PARAM = "locale";
 export declare const LOOK_BLOCK_DEFINITION_PARAM = "blockDefinition";
 export declare const LOOK_CONTENT_PARAM = "content";
 export declare 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
+ * 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.
+ */
+export declare const LOOK_LAYOUT_DEFINITION_PARAM = "layoutDefinition";
+export declare const LOOK_BLOCKS_PARAM = "blocks";
+export declare const LOOK_PLACEHOLDER_PARAM = "placeholder";
+/** A short placeholder shows whether the footer rises up the screen; a tall one, scrolling. */
+export declare const LOOK_PLACEHOLDER_HEIGHTS: readonly ["short", "tall"];
+export type LookPlaceholderHeight = (typeof LOOK_PLACEHOLDER_HEIGHTS)[number];
 /**
  * The id of a block shown without being placed, as the look document's Block Definition mode
  * shows it: never a stored block's, which are UUIDs. Its element is

package/dist/drafts.js

@@ -50,6 +50,19 @@ const LOOK_BLOCK_DEFINITION_PARAM = "blockDefinition";
 const LOOK_CONTENT_PARAM = "content";
 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
+* 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.
+*/
+const LOOK_LAYOUT_DEFINITION_PARAM = "layoutDefinition";
+const LOOK_BLOCKS_PARAM = "blocks";
+const LOOK_PLACEHOLDER_PARAM = "placeholder";
+/** A short placeholder shows whether the footer rises up the screen; a tall one, scrolling. */
+const LOOK_PLACEHOLDER_HEIGHTS = ["short", "tall"];
+/**
 * The id of a block shown without being placed, as the look document's Block Definition mode
 * shows it: never a stored block's, which are UUIDs. Its element is
 * `[data-camox-viewport-block="unplaced"]`.
@@ -223,4 +236,4 @@ function isContentWrite(path) {
 }
 
 //#endregion
-export { CAMOX_ACTOR, CAMOX_NAME, CHECKS_RUNNING_ERROR, CONFLICTS_CHANGED_ERROR, DRAFT_CREATE_HEADER, DRAFT_ENDED_ERROR_CODE, DRAFT_HEADER, DRAFT_SEARCH_PARAM, FINDINGS_OPEN_ERROR, LIVE_READ_ONLY_ERROR, LOCALE_HEADER, LOOK_BLOCK_DEFINITION_PARAM, LOOK_CONTENT_PARAM, LOOK_DOCUMENT_PATH, LOOK_LOCALE_PARAM, LOOK_PATH_PARAM, LOOK_SETTINGS_PARAM, LOOK_TOKEN_COOKIE, LOOK_TOKEN_HEADER, NOT_PUBLISHED_CODES, PUBLISHING_DRAFT_HEADER, PUBLISHING_DRAFT_VAR, PUBLISH_ABORT_REASONS, PUBLISH_BLOCKED_ERROR, REVISION_CHANGED_ERROR, TRANSLATIONS_PENDING_ERROR, UNPLACED_BLOCK_ID, isContentWrite };
+export { CAMOX_ACTOR, CAMOX_NAME, CHECKS_RUNNING_ERROR, CONFLICTS_CHANGED_ERROR, DRAFT_CREATE_HEADER, DRAFT_ENDED_ERROR_CODE, DRAFT_HEADER, DRAFT_SEARCH_PARAM, FINDINGS_OPEN_ERROR, LIVE_READ_ONLY_ERROR, LOCALE_HEADER, LOOK_BLOCKS_PARAM, LOOK_BLOCK_DEFINITION_PARAM, LOOK_CONTENT_PARAM, LOOK_DOCUMENT_PATH, LOOK_LAYOUT_DEFINITION_PARAM, LOOK_LOCALE_PARAM, LOOK_PATH_PARAM, LOOK_PLACEHOLDER_HEIGHTS, LOOK_PLACEHOLDER_PARAM, LOOK_SETTINGS_PARAM, LOOK_TOKEN_COOKIE, LOOK_TOKEN_HEADER, NOT_PUBLISHED_CODES, PUBLISHING_DRAFT_HEADER, PUBLISHING_DRAFT_VAR, PUBLISH_ABORT_REASONS, PUBLISH_BLOCKED_ERROR, REVISION_CHANGED_ERROR, TRANSLATIONS_PENDING_ERROR, UNPLACED_BLOCK_ID, isContentWrite };

package/dist/patrol.d.ts

@@ -5,14 +5,14 @@
  * 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 declare const PATROLLER_IDS: readonly ["translator", "seoManager", "linkChecker", "proofreader"];
+export declare const PATROLLER_IDS: readonly ["translator", "seoManager", "linkChecker"];
 /** A patroller's stable id. */
 export type PatrollerId = (typeof PATROLLER_IDS)[number];
 /**
  * What a structured report says was done. Each has a failed form, by the report's outcome. A
  * merge with Live's localization reads as a translation.
  */
-export type ReportVerb = "translated" | "mergedWithLive" | "wroteSeo" | "describedFile" | "publishedCatchUp" | "removedLink" | "fixedLink" | "fixedMistake";
+export type ReportVerb = "translated" | "mergedWithLive" | "wroteSeo" | "describedFile" | "publishedCatchUp" | "removedLink" | "fixedLink";
 /** What a report can be about. */
 export type ReportEntity = "page" | "block" | "sharedContent" | "repeatableItem" | "record" | "file";
 /** A report's subject, named as the Canvas names it, read when the Patrol is. */
@@ -84,7 +84,6 @@ 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.
- * - `misspelling`, `grammar`: the flagged text, in the sentence it's in.
  * A link's `url` is as content stores it: a page link's is `camox:page:<id>`, and `text` is what
  * the link reads.
  */
@@ -98,10 +97,6 @@ export type FindingAbout = {
   url: string;
   text: string;
   failure: LinkFailure;
-} | {
-  kind: "misspelling" | "grammar";
-  text: string;
-  sentence: string;
 };
 /** How a link failed: an HTTP error status, no connection (DNS included), or no answer in time. */
 export type LinkFailure = {
@@ -113,15 +108,9 @@ export type LinkFailure = {
   kind: "timeout";
 };
 export type FindingKind = FindingAbout["kind"];
-/**
- * The fix a finding suggests, which applying makes: removing the link, keeping its text, or
- * replacing the flagged text with `replacement` in its sentence, keeping its formatting.
- */
+/** The fix a finding suggests, which applying makes: removing the link, keeping its text. */
 export type FindingFix = {
   kind: "removeLink";
-} | {
-  kind: "replaceText";
-  replacement: string;
 };
 /** A finding, open, in the scope viewed. */
 export type FindingView = {
@@ -136,6 +125,8 @@ export type FindingView = {
   locale: string;
   /** The content field it's in, by name. */
   field: string;
+  /** That field's kind, such as "String" or "Link", or null when unknown. */
+  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. */
@@ -148,6 +139,11 @@ export type FindingView = {
  * Footer links to About, a page that no longer exists".
  */
 export declare function findingSentence(finding: Pick<FindingView, "about" | "subject">): string;
+/**
+ * A finding as one sentence where its content is already shown, as the studio's sidebar shows it
+ * by its field: "“About us” links to About, a page that no longer exists".
+ */
+export declare function findingSentenceInPlace(finding: Pick<FindingView, "about">): string;
 /** A member's dismissal of what a finding was about: no finding like it is raised again. */
 export type DismissalView = {
   id: number;

package/dist/patrol.js

@@ -8,8 +8,7 @@
 const PATROLLER_IDS = [
 	"translator",
 	"seoManager",
-	"linkChecker",
-	"proofreader"
+	"linkChecker"
 ];
 /** The locale a summary's work was in: a structured summary's, if any. A text summary has none. */
 const reportLocale = (summary) => summary.kind === "structured" ? summary.locale : null;
@@ -22,8 +21,6 @@ function aboutSentence(about) {
 			const how = failure.kind === "status" ? `answers with an error (${failure.status})` : failure.kind === "timeout" ? "doesn't answer in time" : "can't be reached";
 			return `links to ${about.url}, which ${how}`;
 		}
-		case "misspelling": return "may be misspelled";
-		case "grammar": return "may be a grammar mistake";
 	}
 }
 /**
@@ -33,8 +30,15 @@ function aboutSentence(about) {
 function findingSentence(finding) {
 	return `“${finding.about.text}” in ${finding.subject.name} ${aboutSentence(finding.about)}`;
 }
+/**
+* A finding as one sentence where its content is already shown, as the studio's sidebar shows it
+* by its field: "“About us” links to About, a page that no longer exists".
+*/
+function findingSentenceInPlace(finding) {
+	return `“${finding.about.text}” ${aboutSentence(finding.about)}`;
+}
 /** How many reports the Patrol shows of each patroller; the rest are counted. */
 const REPORTS_SHOWN = 5;
 
 //#endregion
-export { PATROLLER_IDS, REPORTS_SHOWN, findingSentence, reportLocale };
+export { PATROLLER_IDS, REPORTS_SHOWN, findingSentence, findingSentenceInPlace, reportLocale };

package/dist/router.d.ts

@@ -2298,6 +2298,25 @@ declare const schema: {
       }, {}, {
         length: number | undefined;
       }>;
+      overviewName: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+        name: "overview_name";
+        tableName: "drafts";
+        dataType: "string";
+        columnType: "SQLiteText";
+        data: string;
+        driverParam: string;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: [string, ...string[]];
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {
+        length: number | undefined;
+      }>;
       overviewBullets: import("drizzle-orm/sqlite-core").SQLiteColumn<{
         name: "overview_bullets";
         tableName: "drafts";
@@ -9948,9 +9967,9 @@ type CheckJob = {
 };
 /**
  * A run of patrollers' patrols of a project's Live content (ADR 0034), keyed by project: the cron
- * trigger requests one of every patroller patrolling Live for every project every 6 hours, and a
- * release no draft published requests the Proofreader's. Requesting one while another is pending
- * joins it: one run patrols for both, so its new findings are told of once.
+ * trigger requests one of every patroller patrolling Live for every project every 6 hours.
+ * Requesting one while another is pending joins it: one run patrols for both, so its new findings
+ * are told of once.
  */
 type PatrolJob = {
   kind: "patrol";
@@ -10357,10 +10376,12 @@ type Overview =
 } |
 /**
  * Written. A `stale` one describes an older version of the draft's changes: it's still shown
- * while a new one is written.
+ * while a new one is written. `name` is the short name AI suggests keeping the draft under,
+ * null for an overview written before overviews had one.
  */
 {
   status: "ready";
+  name: string | null;
   headline: string;
   bullets: string[];
   stale: boolean;
@@ -14493,6 +14514,177 @@ declare const router: {
       structuredData: BlockStructuredData;
       recordStructuredData: import("@camox/api-contract").RecordStructuredData;
     }>, Record<never, never>, Record<never, never>>;
+    getUnplaced: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("@orpc/server").MergedInitialContext<BaseContext & Record<never, never>, BaseContext, BaseContext>, import("@orpc/server").MergedCurrentContext<BaseContext, Record<never, never>>, import("@orpc/server").MergedCurrentContext<BaseContext, Record<never, never>>>, import("@orpc/server").MergedCurrentContext<import("@orpc/server").MergedCurrentContext<BaseContext, Record<never, never>>, {
+      draft: DraftRequest | null;
+      locale: string | undefined;
+      publishingDraft: string | undefined;
+      look: LookGrant | undefined;
+    }>, import("zod").ZodObject<{
+      projectUuid: import("zod").ZodUUID;
+      layoutId: import("zod").ZodString;
+      blocks: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        content: import("zod").ZodOptional<import("zod").ZodUnknown>;
+        settings: import("zod").ZodOptional<import("zod").ZodUnknown>;
+      }, import("zod/v4/core").$strip>>>;
+    }, import("zod/v4/core").$strip>, import("@orpc/server").Schema<{
+      projectName: string;
+      project: {
+        id: number;
+        updatedAt: number;
+        analytics: AnalyticsProviders;
+        socialProfiles: string[];
+      };
+      layout: {
+        layoutId: string;
+        contentUpdatedAt: number;
+        updatedAt: number;
+        beforeBlockIds: string[];
+        afterBlockIds: string[];
+      };
+      blocks: (Omit<{
+        baseVersion: number | null;
+        content: unknown;
+        createdAt: number;
+        deleted: boolean;
+        draftId: string | null;
+        firstPublishedAt: number | null;
+        id: string;
+        layoutId: string | null;
+        locale: string;
+        pageId: string | null;
+        position: string;
+        projectId: number;
+        publishedAt: number | null;
+        publishedBy: string | null;
+        rowId: number;
+        settings: unknown;
+        slot: "after" | "before" | null;
+        type: string;
+        updatedAt: number;
+        version: number;
+      }, "content"> & {
+        content: Record<string, unknown>;
+      } & {
+        summary: string;
+        title: string;
+        artifactHashes: Record<string, string>;
+      } & {
+        references: ResolvedReferences;
+      })[];
+      repeatableItems: (Omit<{
+        baseVersion: number | null;
+        blockId: string | null;
+        content: unknown;
+        createdAt: number;
+        deleted: boolean;
+        draftId: string | null;
+        fieldName: string;
+        firstPublishedAt: number | null;
+        id: string;
+        locale: string;
+        parentItemId: string | null;
+        position: string;
+        projectId: number | null;
+        publishedAt: number | null;
+        publishedBy: string | null;
+        rowId: number;
+        settings: unknown;
+        sharedContentType: string | null;
+        updatedAt: number;
+        version: number;
+      }, "content"> & {
+        content: Record<string, unknown>;
+      } & {
+        blockId: string;
+        summary: string;
+        title: string;
+        artifactHashes: Record<string, string>;
+      } & {
+        references: ResolvedReferences;
+      })[];
+      files: FileView[];
+      structuredData: BlockStructuredData;
+      recordStructuredData: import("@camox/api-contract").RecordStructuredData;
+    }, {
+      projectName: string;
+      project: {
+        id: number;
+        updatedAt: number;
+        analytics: AnalyticsProviders;
+        socialProfiles: string[];
+      };
+      layout: {
+        layoutId: string;
+        contentUpdatedAt: number;
+        updatedAt: number;
+        beforeBlockIds: string[];
+        afterBlockIds: string[];
+      };
+      blocks: (Omit<{
+        baseVersion: number | null;
+        content: unknown;
+        createdAt: number;
+        deleted: boolean;
+        draftId: string | null;
+        firstPublishedAt: number | null;
+        id: string;
+        layoutId: string | null;
+        locale: string;
+        pageId: string | null;
+        position: string;
+        projectId: number;
+        publishedAt: number | null;
+        publishedBy: string | null;
+        rowId: number;
+        settings: unknown;
+        slot: "after" | "before" | null;
+        type: string;
+        updatedAt: number;
+        version: number;
+      }, "content"> & {
+        content: Record<string, unknown>;
+      } & {
+        summary: string;
+        title: string;
+        artifactHashes: Record<string, string>;
+      } & {
+        references: ResolvedReferences;
+      })[];
+      repeatableItems: (Omit<{
+        baseVersion: number | null;
+        blockId: string | null;
+        content: unknown;
+        createdAt: number;
+        deleted: boolean;
+        draftId: string | null;
+        fieldName: string;
+        firstPublishedAt: number | null;
+        id: string;
+        locale: string;
+        parentItemId: string | null;
+        position: string;
+        projectId: number | null;
+        publishedAt: number | null;
+        publishedBy: string | null;
+        rowId: number;
+        settings: unknown;
+        sharedContentType: string | null;
+        updatedAt: number;
+        version: number;
+      }, "content"> & {
+        content: Record<string, unknown>;
+      } & {
+        blockId: string;
+        summary: string;
+        title: string;
+        artifactHashes: Record<string, string>;
+      } & {
+        references: ResolvedReferences;
+      })[];
+      files: FileView[];
+      structuredData: BlockStructuredData;
+      recordStructuredData: import("@camox/api-contract").RecordStructuredData;
+    }>, Record<never, never>, Record<never, never>>;
     list: import("@orpc/server").DecoratedProcedure<import("@orpc/server").MergedInitialContext<import("@orpc/server").MergedInitialContext<BaseContext & Record<never, never>, BaseContext, BaseContext>, import("@orpc/server").MergedCurrentContext<BaseContext, Record<never, never>>, import("@orpc/server").MergedCurrentContext<BaseContext, Record<never, never>>>, import("@orpc/server").MergedCurrentContext<import("@orpc/server").MergedCurrentContext<BaseContext, Record<never, never>>, {
       draft: DraftRequest | null;
       locale: string | undefined;
@@ -18103,16 +18295,17 @@ declare const router: {
         subject: import("@camox/api-contract/patrol").ReportSubject;
         locale: string;
         field: string;
+        fieldKind: string | null;
         raisedAt: number;
         live: boolean;
         place: import("@camox/api-contract/patrol").ReportPlace | null;
         patroller: {
-          id: "linkChecker" | "proofreader" | "seoManager" | "translator";
+          id: "linkChecker" | "seoManager" | "translator";
           role: string;
         };
       }[];
       checking: {
-        id: "linkChecker" | "proofreader" | "seoManager" | "translator";
+        id: "linkChecker" | "seoManager" | "translator";
         role: string;
       }[];
       defaultLocale: string | null;
@@ -18121,6 +18314,7 @@ declare const router: {
         status: "pending";
       } | {
         status: "ready";
+        name: string | null;
         headline: string;
         bullets: string[];
         stale: boolean;
@@ -18144,16 +18338,17 @@ declare const router: {
         subject: import("@camox/api-contract/patrol").ReportSubject;
         locale: string;
         field: string;
+        fieldKind: string | null;
         raisedAt: number;
         live: boolean;
         place: import("@camox/api-contract/patrol").ReportPlace | null;
         patroller: {
-          id: "linkChecker" | "proofreader" | "seoManager" | "translator";
+          id: "linkChecker" | "seoManager" | "translator";
           role: string;
         };
       }[];
       checking: {
-        id: "linkChecker" | "proofreader" | "seoManager" | "translator";
+        id: "linkChecker" | "seoManager" | "translator";
         role: string;
       }[];
       defaultLocale: string | null;
@@ -18162,6 +18357,7 @@ declare const router: {
         status: "pending";
       } | {
         status: "ready";
+        name: string | null;
         headline: string;
         bullets: string[];
         stale: boolean;

package/dist/threads.d.ts

@@ -45,6 +45,13 @@ export declare const BRIEF_ENTRY = "camox.brief";
  * it at the end of the conversation; editors never see it, since the draft's card says so.
  */
 export declare 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.
+ */
+export declare const DRAFT_CARD_ENTRY = "camox.draft-card";
 /**
  * The kind of the transcript entry recording a member's push to the draft's code from their own
  * checkout (ADR 0026), with a `pushDataSchema` as data. The model reads it as context, never
@@ -67,6 +74,43 @@ export declare const START_DRAFT_TOOL = "startDraft";
 export declare const BUILD_TOOL = "build";
 /** The agent's tool rendering the draft in a browser and returning screenshots to the model. */
 export declare const LOOK_TOOL = "look";
+/**
+ * The agent's tool handing an artifact's source to its Artifact Agent, which writes and changes
+ * it in a conversation of its own and answers the agent (ADR 0035).
+ */
+export declare const ARTIFACT_TOOL = "artifact";
+/**
+ * The kind of the entry recording a request the agent sent an Artifact Agent, in the Artifact
+ * Agent's own conversation, which editors never see: who the run acts for and the operation ids
+ * of its messages, as data (`artifactRequestDataSchema`).
+ */
+export declare const ARTIFACT_REQUEST_ENTRY = "camox.artifact-request";
+/** What an Artifact Agent's request records: the member the run acts for, and its messages. */
+export declare const artifactRequestDataSchema: z.ZodObject<{
+  member: z.ZodString;
+  operationIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type ArtifactRequestData = z.infer<typeof artifactRequestDataSchema>;
+/**
+ * The agent's tool handing code work to the draft thread's Code Agent, which reads and writes the
+ * website's code in a conversation of its own and answers the agent.
+ */
+export declare const CODE_TOOL = "code";
+/**
+ * The kind of the entry recording a request the agent sent the Code Agent, in the Code Agent's
+ * own conversation, which editors never see: who the run acts for, the operation ids of its
+ * messages, and whether it's Camox's reconcile turn, as data (`codeRequestDataSchema`).
+ */
+export declare const CODE_REQUEST_ENTRY = "camox.code-request";
+/** What a Code Agent's request records: as an Artifact Agent's, and whether Camox reconciles. */
+export declare const codeRequestDataSchema: z.ZodObject<{
+  member: z.ZodString;
+  operationIds: z.ZodArray<z.ZodString>;
+  reconciling: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CodeRequestData = z.infer<typeof codeRequestDataSchema>;
+/** Whether `name` is a tool handing work to an agent of its own (`HANDING_OFF_TOOLS`). */
+export declare const handsOff: (name: string) => boolean;
 /**
  * The tools whose calls change a draft: the content tools that write, and the code tools that
  * write files. The model calls the code tools, and code mode scripts call both. A test in the API
@@ -155,16 +199,12 @@ export declare const pushDataSchema: z.ZodObject<{
   }>;
 }, z.core.$strip>;
 export type PushData = z.infer<typeof pushDataSchema>;
-/**
- * What an editor's message entry records: who sent it, the operation id it was sent with, and for
- * a message sent on Live as the agent handed the request off, the draft it went to with it.
- */
+/** What an editor's message entry records: who sent it, and the operation id it was sent with. */
 export declare const editorMessageDataSchema: z.ZodObject<{
   id: z.ZodString;
   name: z.ZodString;
   image: z.ZodNullable<z.ZodString>;
   operationId: z.ZodOptional<z.ZodString>;
-  handedOffTo: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
  * A draft the agent on Live started with `startDraft`, and the operation ids of the messages of
@@ -344,7 +384,35 @@ export type ThreadMessage = {
  * - `fixing`: the end of the turn's build failed, and the agent fixes it.
  * - `startingDraft`: on Live, its `startDraft` call runs.
  */
-export type AgentActivity = "thinking" | "exploring" | "changing" | "building" | "checking" | "fixing" | "startingDraft";
+export declare const agentActivitySchema: z.ZodEnum<{
+  building: "building";
+  changing: "changing";
+  checking: "checking";
+  exploring: "exploring";
+  fixing: "fixing";
+  startingDraft: "startingDraft";
+  thinking: "thinking";
+}>;
+export type AgentActivity = z.infer<typeof agentActivitySchema>;
+/**
+ * What the result of a call handing work off (`handsOff`), such as `artifact` or `code`, carries
+ * for the studio: the other agent's answer, whether it's the agent's answer to the turn too,
+ * which then ends on it, and while it works, what the other agent is doing.
+ */
+export declare const handOffDetailsSchema: z.ZodObject<{
+  answer: z.ZodOptional<z.ZodString>;
+  final: z.ZodOptional<z.ZodBoolean>;
+  activity: z.ZodOptional<z.ZodEnum<{
+    building: "building";
+    changing: "changing";
+    checking: "checking";
+    exploring: "exploring";
+    fixing: "fixing";
+    startingDraft: "startingDraft";
+    thinking: "thinking";
+  }>>;
+}, z.core.$strip>;
+export type HandOffDetails = z.infer<typeof handOffDetailsSchema>;
 /** Everything the studio shows for a thread. */
 export type ThreadView = {
   messages: readonly ThreadMessage[];
@@ -376,6 +444,11 @@ export type ThreadState = {
   changing?: boolean;
   /** Whether the model's latest round calls `look`: from writing the call until it's called again. */
   checking?: boolean;
+  /**
+   * What the agent a running call handing work off (`handsOff`) waits for is doing, as it last
+   * said.
+   */
+  handedOffActivity?: AgentActivity;
   /** The drafts the thread's cards name, as the thread last looked them up. */
   drafts?: DraftCardStates;
 };
@@ -387,8 +460,6 @@ type ThreadStep = {
   type: "editor";
   sender: ThreadSender;
   text: string;
-  /** The draft the message went to, as the agent on Live handed the request off. */
-  handedOffTo?: string;
 } | {
   type: "connectedAgent";
   member: ThreadSender;
@@ -566,7 +637,7 @@ export declare const editorTextOf: (content: Message["content"]) => string;
  * run is over, or a later message started another run after its last model call came back
  * unfinished. While Pi retries a failed call, the run goes on, so the turn shows as working.
  */
-export declare function threadViewOf({ steps, running, toolCalls, callingTools, changing, checking, drafts }: ThreadState): ThreadView;
+export declare function threadViewOf({ steps, running, toolCalls, callingTools, changing, checking, handedOffActivity, drafts }: ThreadState): ThreadView;
 /** Folds one of Pi's agent events into the thread's state. */
 export declare function reduceThreadState(state: ThreadState, event: AgentEvent): ThreadState;
 /** Folds a batch of Pi's agent events into the thread's state. */

package/dist/threads.js

@@ -44,6 +44,13 @@ const BRIEF_ENTRY = "camox.brief";
 */
 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.
+*/
+const DRAFT_CARD_ENTRY = "camox.draft-card";
+/**
 * The kind of the transcript entry recording a member's push to the draft's code from their own
 * checkout (ADR 0026), with a `pushDataSchema` as data. The model reads it as context, never
 * answering it, and editors see who pushed, their commits, and whether they built.
@@ -65,6 +72,42 @@ const BUILD_TOOL = "build";
 /** The agent's tool rendering the draft in a browser and returning screenshots to the model. */
 const LOOK_TOOL = "look";
 /**
+* The agent's tool handing an artifact's source to its Artifact Agent, which writes and changes
+* it in a conversation of its own and answers the agent (ADR 0035).
+*/
+const ARTIFACT_TOOL = "artifact";
+/**
+* The kind of the entry recording a request the agent sent an Artifact Agent, in the Artifact
+* Agent's own conversation, which editors never see: who the run acts for and the operation ids
+* of its messages, as data (`artifactRequestDataSchema`).
+*/
+const ARTIFACT_REQUEST_ENTRY = "camox.artifact-request";
+/** What an Artifact Agent's request records: the member the run acts for, and its messages. */
+const artifactRequestDataSchema = z.object({
+	member: z.string(),
+	operationIds: z.array(z.string())
+});
+/**
+* The agent's tool handing code work to the draft thread's Code Agent, which reads and writes the
+* website's code in a conversation of its own and answers the agent.
+*/
+const CODE_TOOL = "code";
+/**
+* The kind of the entry recording a request the agent sent the Code Agent, in the Code Agent's
+* own conversation, which editors never see: who the run acts for, the operation ids of its
+* messages, and whether it's Camox's reconcile turn, as data (`codeRequestDataSchema`).
+*/
+const CODE_REQUEST_ENTRY = "camox.code-request";
+/** What a Code Agent's request records: as an Artifact Agent's, and whether Camox reconciles. */
+const codeRequestDataSchema = artifactRequestDataSchema.extend({ reconciling: z.boolean().optional() });
+/**
+* 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.
+*/
+const HANDING_OFF_TOOLS = /* @__PURE__ */ new Set([ARTIFACT_TOOL, CODE_TOOL]);
+/** Whether `name` is a tool handing work to an agent of its own (`HANDING_OFF_TOOLS`). */
+const handsOff = (name) => HANDING_OFF_TOOLS.has(name);
+/**
 * The tools whose calls change a draft: the content tools that write, and the code tools that
 * write files. The model calls the code tools, and code mode scripts call both. A test in the API
 * keeps this in step with the tools themselves.
@@ -132,14 +175,8 @@ const pushDataSchema = z.object({
 	subjects: z.array(z.string()),
 	outcome: pushOutcomeSchema
 });
-/**
-* What an editor's message entry records: who sent it, the operation id it was sent with, and for
-* a message sent on Live as the agent handed the request off, the draft it went to with it.
-*/
-const editorMessageDataSchema = threadSenderSchema.extend({
-	operationId: z.string().optional(),
-	handedOffTo: z.string().optional()
-});
+/** What an editor's message entry records: who sent it, and the operation id it was sent with. */
+const editorMessageDataSchema = threadSenderSchema.extend({ operationId: z.string().optional() });
 /**
 * A draft the agent on Live started with `startDraft`, and the operation ids of the messages of
 * the run that started it: the studio that sent one of them enters the draft, if it still shows
@@ -193,6 +230,37 @@ const touchedBatchSchema = z.object({
 	operationIds: z.array(z.string()),
 	touches: z.array(touchSchema)
 });
+/**
+* What the agent is doing during a run, as editors see it, without the details of how it works:
+* - `thinking`: the model is called, and hasn't started writing a tool call.
+* - `exploring`: it uses tools that only read, from writing a call until the model is called again.
+* - `changing`: a call of that round changes the draft (`CHANGING_TOOLS`), as soon as it's written
+*   or, in a code mode script, as soon as the script calls one.
+* - `building`: its `build` call runs, or the end of the turn builds its code changes.
+* - `checking`: it looks at what it designed, from writing a `look` call until the model is
+*   called again.
+* - `fixing`: the end of the turn's build failed, and the agent fixes it.
+* - `startingDraft`: on Live, its `startDraft` call runs.
+*/
+const agentActivitySchema = z.enum([
+	"thinking",
+	"exploring",
+	"changing",
+	"building",
+	"checking",
+	"fixing",
+	"startingDraft"
+]);
+/**
+* What the result of a call handing work off (`handsOff`), such as `artifact` or `code`, carries
+* for the studio: the other agent's answer, whether it's the agent's answer to the turn too,
+* which then ends on it, and while it works, what the other agent is doing.
+*/
+const handOffDetailsSchema = z.object({
+	answer: z.string().optional(),
+	final: z.boolean().optional(),
+	activity: agentActivitySchema.optional()
+});
 const EMPTY_THREAD_VIEW = {
 	messages: [],
 	running: false
@@ -307,19 +375,23 @@ function threadStepOf(entry) {
 			...push
 		};
 	}
+	if (entry.kind === "camox.draft-card") {
+		const card = startedDraftCardSchema.safeParse(entry.data).data;
+		return card && {
+			id,
+			type: "draft",
+			...card
+		};
+	}
 	const message = entry.model?.find((candidate) => candidate.role !== "system");
 	if (!message) return void 0;
 	if (message.role === "user") {
-		if (entry.kind === "camox.editor-message") {
-			const handedOffTo = editorMessageDataSchema.safeParse(entry.data).data?.handedOffTo;
-			return sender && {
-				id,
-				type: "editor",
-				sender,
-				text: editorTextOf(message.content),
-				...handedOffTo && { handedOffTo }
-			};
-		}
+		if (entry.kind === "camox.editor-message") return sender && {
+			id,
+			type: "editor",
+			sender,
+			text: editorTextOf(message.content)
+		};
 		if (entry.kind === "camox.connected-agent-message") {
 			const data = connectedAgentMessageDataSchema.safeParse(entry.data).data;
 			return data && {
@@ -353,6 +425,14 @@ function threadStepOf(entry) {
 	}
 	if (message.role === "assistant") return assistantStep(id, message);
 	if (message.role === "toolResult") {
+		if (handsOff(message.toolName) && !message.isError) {
+			const details = handOffDetailsSchema.safeParse(message.details).data;
+			if (details?.final && details.answer) return {
+				id,
+				type: "answer",
+				text: details.answer
+			};
+		}
 		const card = message.toolName === "startDraft" && !message.isError ? startedDraftCardSchema.safeParse(message.details).data : void 0;
 		return card ? {
 			id,
@@ -373,7 +453,7 @@ function threadStepOf(entry) {
 * run is over, or a later message started another run after its last model call came back
 * unfinished. While Pi retries a failed call, the run goes on, so the turn shows as working.
 */
-function threadViewOf({ steps, running, toolCalls = [], callingTools = false, changing = false, checking = false, drafts = {} }) {
+function threadViewOf({ steps, running, toolCalls = [], callingTools = false, changing = false, checking = false, handedOffActivity, drafts = {} }) {
 	const messages = [];
 	let waiting;
 	let unfinished = false;
@@ -395,17 +475,7 @@ function threadViewOf({ steps, running, toolCalls = [], callingTools = false, ch
 		endTurn();
 	};
 	for (const step of steps) switch (step.type) {
-		case "editor": {
-			const card = step.handedOffTo ? messages.findLastIndex((message) => message.from === "draft" && message.draftId === step.handedOffTo) : -1;
-			if (card !== -1) {
-				messages.splice(card, 0, {
-					id: step.id,
-					from: "editor",
-					sender: step.sender,
-					text: step.text
-				});
-				break;
-			}
+		case "editor":
 			if (unfinished) fail();
 			messages.push({
 				id: step.id,
@@ -415,7 +485,6 @@ function threadViewOf({ steps, running, toolCalls = [], callingTools = false, ch
 			});
 			waiting = step.id;
 			break;
-		}
 		case "connectedAgent":
 			if (unfinished) fail();
 			messages.push({
@@ -496,6 +565,7 @@ function threadViewOf({ steps, running, toolCalls = [], callingTools = false, ch
 			break;
 		case "tools":
 			unfinished = false;
+			status = void 0;
 			break;
 		case "unfinished": unfinished = true;
 	}
@@ -512,16 +582,18 @@ function threadViewOf({ steps, running, toolCalls = [], callingTools = false, ch
 			toolCalls,
 			callingTools,
 			changing,
-			checking
+			checking,
+			handedOffActivity
 		})
 	};
 }
 /** What the agent is doing during a run, from where the turn's build stands and its tool calls. */
-function activityOf({ status, toolCalls, callingTools, changing, checking }) {
+function activityOf({ status, toolCalls, callingTools, changing, checking, handedOffActivity }) {
 	const calling = (name) => toolCalls.some((call) => call.name === name);
 	if (status === "building" || calling("build")) return "building";
-	if (checking) return "checking";
 	if (status === "fixing") return "fixing";
+	if (toolCalls.some((call) => handsOff(call.name))) return handedOffActivity ?? "changing";
+	if (checking) return "checking";
 	if (calling("startDraft")) return "startingDraft";
 	if (changing) return "changing";
 	if (callingTools || toolCalls.length > 0) return "exploring";
@@ -533,8 +605,22 @@ const changes = (name) => CHANGING_TOOLS.has(name);
 const callsChangingTool = (block) => block.type === "toolCall" && changes(block.name);
 /** Whether a block of the model's message is a call of `look`. */
 const callsLook = (block) => block.type === "toolCall" && block.name === "look";
+/**
+* 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
+* snapshots do.
+*/
 const append = (state, entry) => {
-	const step = entry && threadStepOf(entry);
+	if (!entry) return state;
+	const step = threadStepOf(entry);
+	if (entry.head !== void 0) {
+		const head = Number(entry.head);
+		const kept = state.steps.filter((known) => Number(known.id) >= head && known.id !== String(entry.id));
+		return {
+			...state,
+			steps: step ? [step, ...kept] : kept
+		};
+	}
 	if (!step || state.steps.some((known) => known.id === step.id)) return state;
 	return {
 		...state,
@@ -550,9 +636,11 @@ function reduceThreadState(state, event) {
 				name: tool.name
 			}]);
 			const generated = event.generation?.message?.content ?? [];
+			const handingOff = event.tools.find((tool) => handsOff(tool.name) && tool.status !== "done");
 			return {
 				...state,
 				steps: event.entries.flatMap((entry) => threadStepOf(entry) ?? []),
+				handedOffActivity: handOffDetailsSchema.safeParse(handingOff?.details).data?.activity,
 				running: event.run !== void 0,
 				toolCalls,
 				callingTools: generated.some((part) => part.type === "toolCall"),
@@ -570,7 +658,8 @@ function reduceThreadState(state, event) {
 			toolCalls: [],
 			callingTools: false,
 			changing: false,
-			checking: false
+			checking: false,
+			handedOffActivity: void 0
 		};
 		case "message_start": return event.message.role === "assistant" ? {
 			...state,
@@ -604,9 +693,18 @@ function reduceThreadState(state, event) {
 				}]
 			};
 		}
+		case "tool_execution_update": {
+			if (!handsOff(event.toolName) || event.parentToolCallId !== void 0) return state;
+			const activity = handOffDetailsSchema.safeParse(event.details).data?.activity;
+			return activity ? {
+				...state,
+				handedOffActivity: activity
+			} : state;
+		}
 		case "tool_execution_end": return append({
 			...state,
-			toolCalls: state.toolCalls?.filter((call) => call.callId !== event.toolCallId)
+			toolCalls: state.toolCalls?.filter((call) => call.callId !== event.toolCallId),
+			...handsOff(event.toolName) && event.parentToolCallId === void 0 && { handedOffActivity: void 0 }
 		}, event.entry);
 		case "message_end":
 		case "entry_appended": return append(state, event.entry);
@@ -628,4 +726,4 @@ function reduceThreadFrame(state, frame) {
 }
 
 //#endregion
-export { BRIEF_ENTRY, BUILD_STATUS_ENTRY, BUILD_TOOL, CHANGING_TOOLS, CONNECTED_AGENT_MESSAGE_ENTRY, DRAFT_ENDED_ENTRY, EDITOR_MESSAGE_ENTRY, EMPTY_THREAD_STATE, EMPTY_THREAD_VIEW, LOOK_TOOL, PUSH_ENTRY, RECONCILE_ENTRY, RUN_STOPPED_ENTRY, START_DRAFT_TOOL, THREAD_ENDED_CLOSE_CODE, buildStatusDataSchema, buildStatusSchema, connectedAgentClientSchema, connectedAgentMessageDataSchema, editorMessageDataSchema, editorSelectionSchema, editorTextOf, editorWhereSchema, isSender, pushDataSchema, pushOutcomeSchema, reconcileDataSchema, reduceThreadEvents, reduceThreadFrame, reduceThreadState, startedDraftCardSchema, startedDraftSchema, textOf, threadClientMessageSchema, threadSenderSchema, threadViewOf, touchKindSchema, touchSchema, touchedBatchSchema };
+export { ARTIFACT_REQUEST_ENTRY, ARTIFACT_TOOL, BRIEF_ENTRY, BUILD_STATUS_ENTRY, BUILD_TOOL, CHANGING_TOOLS, CODE_REQUEST_ENTRY, CODE_TOOL, CONNECTED_AGENT_MESSAGE_ENTRY, DRAFT_CARD_ENTRY, DRAFT_ENDED_ENTRY, EDITOR_MESSAGE_ENTRY, EMPTY_THREAD_STATE, EMPTY_THREAD_VIEW, LOOK_TOOL, PUSH_ENTRY, RECONCILE_ENTRY, RUN_STOPPED_ENTRY, START_DRAFT_TOOL, THREAD_ENDED_CLOSE_CODE, agentActivitySchema, artifactRequestDataSchema, buildStatusDataSchema, buildStatusSchema, codeRequestDataSchema, connectedAgentClientSchema, connectedAgentMessageDataSchema, editorMessageDataSchema, editorSelectionSchema, editorTextOf, editorWhereSchema, handOffDetailsSchema, handsOff, isSender, pushDataSchema, pushOutcomeSchema, reconcileDataSchema, reduceThreadEvents, reduceThreadFrame, reduceThreadState, startedDraftCardSchema, startedDraftSchema, textOf, threadClientMessageSchema, threadSenderSchema, threadViewOf, touchKindSchema, touchSchema, touchedBatchSchema };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camox/api-contract",
-  "version": "0.65.1",
+  "version": "0.67.0",
   "license": "MIT",
   "files": [
     "src",

package/src/drafts.ts

@@ -58,6 +58,21 @@ export const LOOK_BLOCK_DEFINITION_PARAM = "blockDefinition";
 export const LOOK_CONTENT_PARAM = "content";
 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
+ * 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.
+ */
+export const LOOK_LAYOUT_DEFINITION_PARAM = "layoutDefinition";
+export const LOOK_BLOCKS_PARAM = "blocks";
+export const LOOK_PLACEHOLDER_PARAM = "placeholder";
+/** A short placeholder shows whether the footer rises up the screen; a tall one, scrolling. */
+export const LOOK_PLACEHOLDER_HEIGHTS = ["short", "tall"] as const;
+export type LookPlaceholderHeight = (typeof LOOK_PLACEHOLDER_HEIGHTS)[number];
+
 /**
  * The id of a block shown without being placed, as the look document's Block Definition mode
  * shows it: never a stored block's, which are UUIDs. Its element is

package/src/patrol.ts

@@ -5,7 +5,7 @@
  */
 
 /** Every patroller's stable id. The registry in the API lists them all. */
-export const PATROLLER_IDS = ["translator", "seoManager", "linkChecker", "proofreader"] as const;
+export const PATROLLER_IDS = ["translator", "seoManager", "linkChecker"] as const;
 
 /** A patroller's stable id. */
 export type PatrollerId = (typeof PATROLLER_IDS)[number];
@@ -21,8 +21,7 @@ export type ReportVerb =
   | "describedFile"
   | "publishedCatchUp"
   | "removedLink"
-  | "fixedLink"
-  | "fixedMistake";
+  | "fixedLink";
 
 /** What a report can be about. */
 export type ReportEntity =
@@ -92,14 +91,12 @@ 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.
- * - `misspelling`, `grammar`: the flagged text, in the sentence it's in.
  * 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: "misspelling" | "grammar"; text: string; sentence: string };
+  | { kind: "brokenLink"; url: string; text: string; failure: LinkFailure };
 
 /** How a link failed: an HTTP error status, no connection (DNS included), or no answer in time. */
 export type LinkFailure =
@@ -109,11 +106,8 @@ export type LinkFailure =
 
 export type FindingKind = FindingAbout["kind"];
 
-/**
- * The fix a finding suggests, which applying makes: removing the link, keeping its text, or
- * replacing the flagged text with `replacement` in its sentence, keeping its formatting.
- */
-export type FindingFix = { kind: "removeLink" } | { kind: "replaceText"; replacement: string };
+/** The fix a finding suggests, which applying makes: removing the link, keeping its text. */
+export type FindingFix = { kind: "removeLink" };
 
 /** A finding, open, in the scope viewed. */
 export type FindingView = {
@@ -128,6 +122,8 @@ export type FindingView = {
   locale: string;
   /** The content field it's in, by name. */
   field: string;
+  /** That field's kind, such as "String" or "Link", or null when unknown. */
+  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. */
@@ -153,10 +149,6 @@ function aboutSentence(about: FindingAbout): string {
             : "can't be reached";
       return `links to ${about.url}, which ${how}`;
     }
-    case "misspelling":
-      return "may be misspelled";
-    case "grammar":
-      return "may be a grammar mistake";
   }
 }
 
@@ -168,6 +160,14 @@ export function findingSentence(finding: Pick<FindingView, "about" | "subject">)
   return `“${finding.about.text}” in ${finding.subject.name} ${aboutSentence(finding.about)}`;
 }
 
+/**
+ * A finding as one sentence where its content is already shown, as the studio's sidebar shows it
+ * 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)}`;
+}
+
 /** A member's dismissal of what a finding was about: no finding like it is raised again. */
 export type DismissalView = {
   id: number;

package/src/threads.ts

@@ -57,6 +57,14 @@ export const BRIEF_ENTRY = "camox.brief";
  */
 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.
+ */
+export const DRAFT_CARD_ENTRY = "camox.draft-card";
+
 /**
  * The kind of the transcript entry recording a member's push to the draft's code from their own
  * checkout (ADR 0026), with a `pushDataSchema` as data. The model reads it as context, never
@@ -80,6 +88,54 @@ export const BUILD_TOOL = "build";
 /** The agent's tool rendering the draft in a browser and returning screenshots to the model. */
 export const LOOK_TOOL = "look";
 
+/**
+ * The agent's tool handing an artifact's source to its Artifact Agent, which writes and changes
+ * it in a conversation of its own and answers the agent (ADR 0035).
+ */
+export const ARTIFACT_TOOL = "artifact";
+
+/**
+ * The kind of the entry recording a request the agent sent an Artifact Agent, in the Artifact
+ * Agent's own conversation, which editors never see: who the run acts for and the operation ids
+ * of its messages, as data (`artifactRequestDataSchema`).
+ */
+export const ARTIFACT_REQUEST_ENTRY = "camox.artifact-request";
+
+/** What an Artifact Agent's request records: the member the run acts for, and its messages. */
+export const artifactRequestDataSchema = z.object({
+  member: z.string(),
+  operationIds: z.array(z.string()),
+});
+export type ArtifactRequestData = z.infer<typeof artifactRequestDataSchema>;
+
+/**
+ * The agent's tool handing code work to the draft thread's Code Agent, which reads and writes the
+ * website's code in a conversation of its own and answers the agent.
+ */
+export const CODE_TOOL = "code";
+
+/**
+ * The kind of the entry recording a request the agent sent the Code Agent, in the Code Agent's
+ * own conversation, which editors never see: who the run acts for, the operation ids of its
+ * messages, and whether it's Camox's reconcile turn, as data (`codeRequestDataSchema`).
+ */
+export const CODE_REQUEST_ENTRY = "camox.code-request";
+
+/** What a Code Agent's request records: as an Artifact Agent's, and whether Camox reconciles. */
+export const codeRequestDataSchema = artifactRequestDataSchema.extend({
+  reconciling: z.boolean().optional(),
+});
+export type CodeRequestData = z.infer<typeof codeRequestDataSchema>;
+
+/**
+ * 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.
+ */
+const HANDING_OFF_TOOLS: ReadonlySet<string> = new Set([ARTIFACT_TOOL, CODE_TOOL]);
+
+/** Whether `name` is a tool handing work to an agent of its own (`HANDING_OFF_TOOLS`). */
+export const handsOff = (name: string) => HANDING_OFF_TOOLS.has(name);
+
 /**
  * The tools whose calls change a draft: the content tools that write, and the code tools that
  * write files. The model calls the code tools, and code mode scripts call both. A test in the API
@@ -172,13 +228,9 @@ export const pushDataSchema = z.object({
 });
 export type PushData = z.infer<typeof pushDataSchema>;
 
-/**
- * What an editor's message entry records: who sent it, the operation id it was sent with, and for
- * a message sent on Live as the agent handed the request off, the draft it went to with it.
- */
+/** What an editor's message entry records: who sent it, and the operation id it was sent with. */
 export const editorMessageDataSchema = threadSenderSchema.extend({
   operationId: z.string().optional(),
-  handedOffTo: z.string().optional(),
 });
 
 /**
@@ -284,14 +336,28 @@ export type ThreadMessage =
  * - `fixing`: the end of the turn's build failed, and the agent fixes it.
  * - `startingDraft`: on Live, its `startDraft` call runs.
  */
-export type AgentActivity =
-  | "thinking"
-  | "exploring"
-  | "changing"
-  | "building"
-  | "checking"
-  | "fixing"
-  | "startingDraft";
+export const agentActivitySchema = z.enum([
+  "thinking",
+  "exploring",
+  "changing",
+  "building",
+  "checking",
+  "fixing",
+  "startingDraft",
+]);
+export type AgentActivity = z.infer<typeof agentActivitySchema>;
+
+/**
+ * What the result of a call handing work off (`handsOff`), such as `artifact` or `code`, carries
+ * for the studio: the other agent's answer, whether it's the agent's answer to the turn too,
+ * which then ends on it, and while it works, what the other agent is doing.
+ */
+export const handOffDetailsSchema = z.object({
+  answer: z.string().optional(),
+  final: z.boolean().optional(),
+  activity: agentActivitySchema.optional(),
+});
+export type HandOffDetails = z.infer<typeof handOffDetailsSchema>;
 
 /** Everything the studio shows for a thread. */
 export type ThreadView = {
@@ -323,6 +389,11 @@ export type ThreadState = {
   changing?: boolean;
   /** Whether the model's latest round calls `look`: from writing the call until it's called again. */
   checking?: boolean;
+  /**
+   * What the agent a running call handing work off (`handsOff`) waits for is doing, as it last
+   * said.
+   */
+  handedOffActivity?: AgentActivity;
   /** The drafts the thread's cards name, as the thread last looked them up. */
   drafts?: DraftCardStates;
 };
@@ -331,13 +402,7 @@ 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;
-      /** The draft the message went to, as the agent on Live handed the request off. */
-      handedOffTo?: string;
-    }
+  | { type: "editor"; sender: ThreadSender; text: string }
   | { type: "connectedAgent"; member: ThreadSender; client: ConnectedAgentClient; text: string }
   /** Camox starting a turn of its own, saying why. */
   | { type: "camox"; text: string }
@@ -495,20 +560,16 @@ 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 };
+  }
   const message = entry.model?.find((candidate) => candidate.role !== "system");
   if (!message) return undefined;
   if (message.role === "user") {
     if (entry.kind === EDITOR_MESSAGE_ENTRY) {
-      const handedOffTo = editorMessageDataSchema.safeParse(entry.data).data?.handedOffTo;
-      return (
-        sender && {
-          id,
-          type: "editor",
-          sender,
-          text: editorTextOf(message.content),
-          ...(handedOffTo && { handedOffTo }),
-        }
-      );
+      return sender && { id, type: "editor", sender, text: editorTextOf(message.content) };
     }
     if (entry.kind === CONNECTED_AGENT_MESSAGE_ENTRY) {
       const data = connectedAgentMessageDataSchema.safeParse(entry.data).data;
@@ -533,6 +594,12 @@ function threadStepOf(entry: EntryRecord): ThreadStep | undefined {
   }
   if (message.role === "assistant") return assistantStep(id, message);
   if (message.role === "toolResult") {
+    // An Artifact Agent's or the Code Agent's answer that ends the turn is the agent's: editors
+    // never see it apart.
+    if (handsOff(message.toolName) && !message.isError) {
+      const details = handOffDetailsSchema.safeParse(message.details).data;
+      if (details?.final && details.answer) return { id, type: "answer", text: details.answer };
+    }
     const card =
       message.toolName === START_DRAFT_TOOL && !message.isError
         ? startedDraftCardSchema.safeParse(message.details).data
@@ -558,6 +625,7 @@ export function threadViewOf({
   callingTools = false,
   changing = false,
   checking = false,
+  handedOffActivity,
   drafts = {},
 }: ThreadState): ThreadView {
   const messages: ThreadMessage[] = [];
@@ -583,24 +651,7 @@ export function threadViewOf({
 
   for (const step of steps) {
     switch (step.type) {
-      case "editor": {
-        // A message sent as the agent on Live handed the request off went to the draft with it:
-        // it belongs to the turn ending on that draft's card, which it shows just before. Pi
-        // placed it after the card, which leaves the transcript the model read as it was.
-        const card = step.handedOffTo
-          ? messages.findLastIndex(
-              (message) => message.from === "draft" && message.draftId === step.handedOffTo,
-            )
-          : -1;
-        if (card !== -1) {
-          messages.splice(card, 0, {
-            id: step.id,
-            from: "editor",
-            sender: step.sender,
-            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
         // an editor's message after an unfinished call means that call's turn is over.
@@ -608,7 +659,6 @@ export function threadViewOf({
         messages.push({ id: step.id, from: "editor", sender: step.sender, text: step.text });
         waiting = step.id;
         break;
-      }
       case "connectedAgent":
         // Like an editor's message: it starts a turn, or steers the one going.
         if (unfinished) fail();
@@ -680,6 +730,8 @@ export function threadViewOf({
         break;
       case "tools":
         unfinished = false;
+        // The Code Agent's build status ends with its request, whose answer is a tool result.
+        status = undefined;
         break;
       case "unfinished":
         unfinished = true;
@@ -691,7 +743,14 @@ export function threadViewOf({
   return {
     messages,
     running,
-    activity: activityOf({ status, toolCalls, callingTools, changing, checking }),
+    activity: activityOf({
+      status,
+      toolCalls,
+      callingTools,
+      changing,
+      checking,
+      handedOffActivity,
+    }),
   };
 }
 
@@ -702,19 +761,24 @@ function activityOf({
   callingTools,
   changing,
   checking,
+  handedOffActivity,
 }: {
   status: BuildStatus | undefined;
   toolCalls: NonNullable<ThreadState["toolCalls"]>;
   callingTools: boolean;
   changing: boolean;
   checking: boolean;
+  handedOffActivity: AgentActivity | undefined;
 }): AgentActivity {
   const calling = (name: string) => toolCalls.some((call) => call.name === name);
   // Fixing a build error takes thinking, reading and writing, which all read as fixing, but its
   // builds show as building.
   if (status === "building" || calling(BUILD_TOOL)) return "building";
-  if (checking) return "checking";
   if (status === "fixing") return "fixing";
+  // An Artifact Agent or the Code Agent works on the agent's behalf: editors see what it does as
+  // the agent's.
+  if (toolCalls.some((call) => handsOff(call.name))) return handedOffActivity ?? "changing";
+  if (checking) return "checking";
   if (calling(START_DRAFT_TOOL)) return "startingDraft";
   if (changing) return "changing";
   if (callingTools || toolCalls.length > 0) return "exploring";
@@ -732,8 +796,21 @@ const callsChangingTool = (block: AssistantMessage["content"][number]) =>
 const callsLook = (block: AssistantMessage["content"][number]) =>
   block.type === "toolCall" && block.name === LOOK_TOOL;
 
+/**
+ * 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
+ * snapshots do.
+ */
 const append = (state: ThreadState, entry: EntryRecord | undefined): ThreadState => {
-  const step = entry && threadStepOf(entry);
+  if (!entry) return state;
+  const step = threadStepOf(entry);
+  if (entry.head !== undefined) {
+    const head = Number(entry.head);
+    const kept = state.steps.filter(
+      (known) => Number(known.id) >= head && known.id !== String(entry.id),
+    );
+    return { ...state, steps: step ? [step, ...kept] : kept };
+  }
   if (!step || state.steps.some((known) => known.id === step.id)) return state;
   return { ...state, steps: [...state.steps, step] };
 };
@@ -746,9 +823,11 @@ export function reduceThreadState(state: ThreadState, event: AgentEvent): Thread
         tool.status === "done" ? [] : [{ callId: tool.callId, name: tool.name }],
       );
       const generated = event.generation?.message?.content ?? [];
+      const handingOff = event.tools.find((tool) => handsOff(tool.name) && tool.status !== "done");
       return {
         ...state,
         steps: event.entries.flatMap((entry) => threadStepOf(entry) ?? []),
+        handedOffActivity: handOffDetailsSchema.safeParse(handingOff?.details).data?.activity,
         running: event.run !== undefined,
         toolCalls,
         callingTools: generated.some((part) => part.type === "toolCall"),
@@ -778,6 +857,7 @@ export function reduceThreadState(state: ThreadState, event: AgentEvent): Thread
         callingTools: false,
         changing: false,
         checking: false,
+        handedOffActivity: undefined,
       };
     case "message_start":
       // The model is called again: it thinks until it writes a tool call.
@@ -811,11 +891,18 @@ export function reduceThreadState(state: ThreadState, event: AgentEvent): Thread
         toolCalls: [...(state.toolCalls ?? []), { callId: event.toolCallId, name: event.toolName }],
       };
     }
+    case "tool_execution_update": {
+      if (!handsOff(event.toolName) || event.parentToolCallId !== undefined) return state;
+      const activity = handOffDetailsSchema.safeParse(event.details).data?.activity;
+      return activity ? { ...state, handedOffActivity: activity } : state;
+    }
     case "tool_execution_end":
       return append(
         {
           ...state,
           toolCalls: state.toolCalls?.filter((call) => call.callId !== event.toolCallId),
+          ...(handsOff(event.toolName) &&
+            event.parentToolCallId === undefined && { handedOffActivity: undefined }),
         },
         event.entry,
       );