@camox/api-contract 0.65.1 → 0.66.0

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";
@@ -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;
@@ -18121,6 +18142,7 @@ declare const router: {
         status: "pending";
       } | {
         status: "ready";
+        name: string | null;
         headline: string;
         bullets: string[];
         stale: boolean;
@@ -18162,6 +18184,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,23 @@ 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 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 +179,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 +364,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 an `artifact` call's result carries for the studio: the Artifact 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
+ * Artifact Agent is doing.
+ */
+export declare const artifactDetailsSchema: 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 ArtifactDetails = z.infer<typeof artifactDetailsSchema>;
 /** Everything the studio shows for a thread. */
 export type ThreadView = {
   messages: readonly ThreadMessage[];
@@ -376,6 +424,8 @@ 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 Artifact Agent the running `artifact` call waits for is doing, as it last said. */
+  artifactActivity?: AgentActivity;
   /** The drafts the thread's cards name, as the thread last looked them up. */
   drafts?: DraftCardStates;
 };
@@ -387,8 +437,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 +614,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, artifactActivity, 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,22 @@ 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 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 +155,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 +210,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 an `artifact` call's result carries for the studio: the Artifact 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
+* Artifact Agent is doing.
+*/
+const artifactDetailsSchema = z.object({
+	answer: z.string().optional(),
+	final: z.boolean().optional(),
+	activity: agentActivitySchema.optional()
+});
 const EMPTY_THREAD_VIEW = {
 	messages: [],
 	running: false
@@ -307,19 +355,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 +405,14 @@ function threadStepOf(entry) {
 	}
 	if (message.role === "assistant") return assistantStep(id, message);
 	if (message.role === "toolResult") {
+		if (message.toolName === "artifact" && !message.isError) {
+			const details = artifactDetailsSchema.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 +433,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, artifactActivity, drafts = {} }) {
 	const messages = [];
 	let waiting;
 	let unfinished = false;
@@ -395,17 +455,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 +465,6 @@ function threadViewOf({ steps, running, toolCalls = [], callingTools = false, ch
 			});
 			waiting = step.id;
 			break;
-		}
 		case "connectedAgent":
 			if (unfinished) fail();
 			messages.push({
@@ -512,14 +561,16 @@ function threadViewOf({ steps, running, toolCalls = [], callingTools = false, ch
 			toolCalls,
 			callingTools,
 			changing,
-			checking
+			checking,
+			artifactActivity
 		})
 	};
 }
 /** 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, artifactActivity }) {
 	const calling = (name) => toolCalls.some((call) => call.name === name);
 	if (status === "building" || calling("build")) return "building";
+	if (calling("artifact")) return artifactActivity ?? "changing";
 	if (checking) return "checking";
 	if (status === "fixing") return "fixing";
 	if (calling("startDraft")) return "startingDraft";
@@ -533,8 +584,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 +615,11 @@ function reduceThreadState(state, event) {
 				name: tool.name
 			}]);
 			const generated = event.generation?.message?.content ?? [];
+			const artifact = event.tools.find((tool) => tool.name === "artifact" && tool.status !== "done");
 			return {
 				...state,
 				steps: event.entries.flatMap((entry) => threadStepOf(entry) ?? []),
+				artifactActivity: artifactDetailsSchema.safeParse(artifact?.details).data?.activity,
 				running: event.run !== void 0,
 				toolCalls,
 				callingTools: generated.some((part) => part.type === "toolCall"),
@@ -570,7 +637,8 @@ function reduceThreadState(state, event) {
 			toolCalls: [],
 			callingTools: false,
 			changing: false,
-			checking: false
+			checking: false,
+			artifactActivity: void 0
 		};
 		case "message_start": return event.message.role === "assistant" ? {
 			...state,
@@ -604,9 +672,18 @@ function reduceThreadState(state, event) {
 				}]
 			};
 		}
+		case "tool_execution_update": {
+			if (event.toolName !== "artifact" || event.parentToolCallId !== void 0) return state;
+			const activity = artifactDetailsSchema.safeParse(event.details).data?.activity;
+			return activity ? {
+				...state,
+				artifactActivity: 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),
+			...event.toolName === "artifact" && event.parentToolCallId === void 0 && { artifactActivity: void 0 }
 		}, event.entry);
 		case "message_end":
 		case "entry_appended": return append(state, event.entry);
@@ -628,4 +705,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, 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, artifactDetailsSchema, artifactRequestDataSchema, buildStatusDataSchema, buildStatusSchema, connectedAgentClientSchema, connectedAgentMessageDataSchema, editorMessageDataSchema, editorSelectionSchema, editorTextOf, editorWhereSchema, 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.66.0",
   "license": "MIT",
   "files": [
     "src",

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,26 @@ 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 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 +200,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 +308,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 an `artifact` call's result carries for the studio: the Artifact 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
+ * Artifact Agent is doing.
+ */
+export const artifactDetailsSchema = z.object({
+  answer: z.string().optional(),
+  final: z.boolean().optional(),
+  activity: agentActivitySchema.optional(),
+});
+export type ArtifactDetails = z.infer<typeof artifactDetailsSchema>;
 
 /** Everything the studio shows for a thread. */
 export type ThreadView = {
@@ -323,6 +361,8 @@ 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 Artifact Agent the running `artifact` call waits for is doing, as it last said. */
+  artifactActivity?: AgentActivity;
   /** The drafts the thread's cards name, as the thread last looked them up. */
   drafts?: DraftCardStates;
 };
@@ -331,13 +371,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 +529,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 +563,11 @@ function threadStepOf(entry: EntryRecord): ThreadStep | undefined {
   }
   if (message.role === "assistant") return assistantStep(id, message);
   if (message.role === "toolResult") {
+    // An Artifact Agent's answer that ends the turn is the agent's: editors never see it apart.
+    if (message.toolName === ARTIFACT_TOOL && !message.isError) {
+      const details = artifactDetailsSchema.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 +593,7 @@ export function threadViewOf({
   callingTools = false,
   changing = false,
   checking = false,
+  artifactActivity,
   drafts = {},
 }: ThreadState): ThreadView {
   const messages: ThreadMessage[] = [];
@@ -583,24 +619,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 +627,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();
@@ -691,7 +709,7 @@ export function threadViewOf({
   return {
     messages,
     running,
-    activity: activityOf({ status, toolCalls, callingTools, changing, checking }),
+    activity: activityOf({ status, toolCalls, callingTools, changing, checking, artifactActivity }),
   };
 }
 
@@ -702,17 +720,21 @@ function activityOf({
   callingTools,
   changing,
   checking,
+  artifactActivity,
 }: {
   status: BuildStatus | undefined;
   toolCalls: NonNullable<ThreadState["toolCalls"]>;
   callingTools: boolean;
   changing: boolean;
   checking: boolean;
+  artifactActivity: 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";
+  // An Artifact Agent works on the agent's behalf: editors see what it does as the agent's.
+  if (calling(ARTIFACT_TOOL)) return artifactActivity ?? "changing";
   if (checking) return "checking";
   if (status === "fixing") return "fixing";
   if (calling(START_DRAFT_TOOL)) return "startingDraft";
@@ -732,8 +754,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 +781,13 @@ export function reduceThreadState(state: ThreadState, event: AgentEvent): Thread
         tool.status === "done" ? [] : [{ callId: tool.callId, name: tool.name }],
       );
       const generated = event.generation?.message?.content ?? [];
+      const artifact = event.tools.find(
+        (tool) => tool.name === ARTIFACT_TOOL && tool.status !== "done",
+      );
       return {
         ...state,
         steps: event.entries.flatMap((entry) => threadStepOf(entry) ?? []),
+        artifactActivity: artifactDetailsSchema.safeParse(artifact?.details).data?.activity,
         running: event.run !== undefined,
         toolCalls,
         callingTools: generated.some((part) => part.type === "toolCall"),
@@ -778,6 +817,7 @@ export function reduceThreadState(state: ThreadState, event: AgentEvent): Thread
         callingTools: false,
         changing: false,
         checking: false,
+        artifactActivity: undefined,
       };
     case "message_start":
       // The model is called again: it thinks until it writes a tool call.
@@ -811,11 +851,18 @@ export function reduceThreadState(state: ThreadState, event: AgentEvent): Thread
         toolCalls: [...(state.toolCalls ?? []), { callId: event.toolCallId, name: event.toolName }],
       };
     }
+    case "tool_execution_update": {
+      if (event.toolName !== ARTIFACT_TOOL || event.parentToolCallId !== undefined) return state;
+      const activity = artifactDetailsSchema.safeParse(event.details).data?.activity;
+      return activity ? { ...state, artifactActivity: activity } : state;
+    }
     case "tool_execution_end":
       return append(
         {
           ...state,
           toolCalls: state.toolCalls?.filter((call) => call.callId !== event.toolCallId),
+          ...(event.toolName === ARTIFACT_TOOL &&
+            event.parentToolCallId === undefined && { artifactActivity: undefined }),
         },
         event.entry,
       );