cozyclay 3.1.4 → 3.1.6

package/src/workflow/AgentPanel.jsx

@@ -44,6 +44,8 @@ import { TurnSteps } from "./AgentTurnSteps.jsx";
 import { PlanCard } from "./AgentPlanCard.jsx";
 import { ReplyText } from "./AgentReplyText.jsx";
 import { stepLabel, turnLayout } from "./agent-turn.js";
+import { connectAuthState, connectFinished, connectOpened, connectStarted, modelChanged } from "./connect-telemetry.js";
+import { noteChipDraft, noteDraftConsumed, noteDraftInput, stagePrompt } from "./prompt-telemetry.js";
 
 function relativeTime(value, now = Date.now()) {
 	const at = Date.parse(value || "");
@@ -243,7 +245,7 @@ function FailureCard({ failure, onRetry, onFixKey }) {
 		<div className="agent-failure-head"><FiAlertTriangle size={12} aria-hidden="true" /><span className="agent-failure-code">{failure.code}</span></div>
 		<p className="agent-failure-message">{failure.message || "The command did not complete."}</p>
 		<p className="agent-failure-recovery">{RECOVERY_COPY[failure.recovery?.action] || RECOVERY_COPY.none}{failure.preserved?.authoredState === "unchanged" ? " Nothing in the scene changed." : failure.preserved?.authoredState === "unknown" ? " Whether the scene changed is unknown." : ""}</p>
-		{failure.recovery?.retryAllowed && <div className="agent-error-actions">{failure.recovery.action === "fix_key" && onFixKey && <button type="button" className="agent-ghost-button agent-error-keys" onClick={onFixKey}>Log in again</button>}<button type="button" className="agent-ghost-button agent-error-retry" onClick={onRetry}>Retry</button></div>}
+		{failure.recovery?.retryAllowed && <div className="agent-error-actions">{failure.recovery.action === "fix_key" && onFixKey && <button type="button" className="agent-ghost-button agent-error-keys" onClick={onFixKey}>Log in again</button>}<button type="button" className="agent-ghost-button agent-error-retry" data-fid="agent_retry" onClick={onRetry}>Retry</button></div>}
 	</div>;
 }
 
@@ -311,7 +313,7 @@ export default function AgentPanel({
 	// Picking a model is a preference, not a per-session decision: the key is
 	// remembered so a reload does not quietly move the next turn to another
 	// provider's model.
-	const chooseModel = useCallback((id) => { setModel(id); setEffort(null); storeModel(id); }, []);
+	const chooseModel = useCallback((id) => { setModel(id); setEffort(null); storeModel(id); modelChanged(id); }, []);
 	// Task mode (parallel Studio tasks): the chat talks to the main agent, which answers at once and runs tasks on the board.
 	const [taskMode, setTaskMode] = useState(() => surface === "studio" && readStoredTaskMode());
 	const toggleTaskMode = useCallback(() => setTaskMode((current) => { storeTaskMode(!current); return !current; }), []);
@@ -639,9 +641,10 @@ export default function AgentPanel({
 		if (!event.defaultPrevented && takeTransfer(event.dataTransfer)) event.preventDefault();
 	}, [takeTransfer]);
 
-	const runTurn = useCallback((text) => {
-		setAttachNotice(null);
-		setSteerNotice("");
+	// `via`: how the prompt was sent, for agent:prompt_sent (prompt-telemetry.js keeps no text).
+	const runTurn = useCallback((text, via = "typed") => {
+		setAttachNotice(null); setSteerNotice("");
+		stagePrompt(text, { via, model, attached: attachFrame || store.getState().pendingAttachments.length > 0, taskMode });
 		return store.send(text, { attachFrame, model, effort: effort ?? undefined, tasks: taskMode });
 	}, [attachFrame, effort, model, store, taskMode]);
 	const taskStepLabel = useCallback((call) => stepLabel(call, presentation.toolLabels), [presentation.toolLabels]);
@@ -652,10 +655,10 @@ export default function AgentPanel({
 	// leaves the draft to be sent as a normal message.
 	const steerTurn = useCallback(async (text) => {
 		if (!String(text ?? "").trim()) return;
-		setAttachNotice(null);
-		setSteerNotice("");
+		setAttachNotice(null); setSteerNotice("");
 		const result = await store.steer(text);
-		if (!result.ok) setSteerNotice(result.message || "The running turn did not take that message.");
+		// An accepted steer consumed the draft: its typing time is not the next prompt's (prompt-telemetry.js).
+		if (result.ok) noteDraftConsumed(); else setSteerNotice(result.message || "The running turn did not take that message.");
 	}, [store]);
 
 	// A sign-in that succeeds is an authentication transition, not a status
@@ -664,13 +667,13 @@ export default function AgentPanel({
 	// that asked for them. Refreshing the account alone leaves the panel
 	// "ready" with nothing it may send (#379).
 	const signIn = useCallback(async () => {
-		setAuthState("signing-in");
+		connectStarted("openai-codex", "chatgpt"); setAuthState("signing-in");
 		setSignInError("");
 		try {
 			await transport.signIn();
 			await refreshProviderState();
 		} catch (error) {
-			if (agentServerUnavailable(error)) { setAuthState("offline"); return; }
+			connectFinished("failed"); if (agentServerUnavailable(error)) { setAuthState("offline"); return; }
 			setSignInError(error?.message || ko("Sign-in could not start.", "로그인을 시작하지 못했어요."));
 			setAuthState("signed-out");
 		}
@@ -718,15 +721,11 @@ export default function AgentPanel({
 
 	// The section is read when it opens; every write goes back through the
 	// refresh above, because a key changes the session, not just a row.
-	const toggleProviderKeys = useCallback(() => {
-		setMenuOpen(false);
-		setKeysOpen(!keysOpen);
-	}, [keysOpen]);
+	const toggleProviderKeys = useCallback(() => { setMenuOpen(false); if (!keysOpen) connectOpened("menu"); setKeysOpen(!keysOpen); }, [keysOpen]);
 	// Opens (never toggles) Connect a model, pi's login list: the signed-out card and a refused key both lead here.
-	const openProviderKeys = useCallback(() => {
-		setMenuOpen(false);
-		setKeysOpen(true);
-	}, []);
+	const openProviderKeys = useCallback((entry) => { setMenuOpen(false); connectOpened(entry); setKeysOpen(true); }, []);
+	// The connect funnel's ChatGPT attempt settles with the auth state (connect-telemetry.js).
+	useEffect(() => { connectAuthState(authState, account); }, [authState, account]);
 
 	// Clearing the transcript also retires the session, so what the author sees
 	// and what the model remembers cannot diverge.
@@ -842,7 +841,7 @@ export default function AgentPanel({
 						{resetLabel && <span className="agent-account-reset">resets in {resetLabel}</span>}
 					</div>}
 					<button type="button" role="menuitem" onClick={clearContext}>Clear context</button>
-					<button type="button" role="menuitem" className="agent-menu-keys" aria-expanded={keysOpen} onClick={toggleProviderKeys}
+					<button type="button" role="menuitem" className="agent-menu-keys" data-fid="agent_connect" aria-expanded={keysOpen} onClick={toggleProviderKeys}
 						disabled={authState === "offline"} title={authState === "offline" ? ko("The agent server is not running", "에이전트 서버가 실행 중이 아니에요") : undefined}>Connect a model…</button>
 					{account?.signedIn && <button type="button" role="menuitem" onClick={signOut}>Sign out</button>}
 				</div>}
@@ -863,7 +862,7 @@ export default function AgentPanel({
 				<p>Sign in with ChatGPT, or log in to another provider with a subscription, an API key, or your own proxy server. Sign-in happens in your browser — no token is ever stored in this page.</p>
 				<button type="button" className="agent-primary-button agent-signin" onClick={signIn}>Sign in with ChatGPT</button>
 				{signInError && <p className="agent-key-error agent-signin-error" role="alert">{signInError}</p>}
-				<button type="button" className="agent-ghost-button agent-use-key" onClick={openProviderKeys}>Log in with another provider</button>
+				<button type="button" className="agent-ghost-button agent-use-key" onClick={() => openProviderKeys("signed_out")}>Log in with another provider</button>
 			</div>}
 
 			{authState === "offline" && <OfflineCard probing={probing} onRetry={retryServer} />}
@@ -885,7 +884,7 @@ export default function AgentPanel({
 				<h3>{presentation.emptyTitle}</h3>
 				<p>{presentation.emptyHint(sceneName)}</p>
 				<div className="agent-suggestions">
-					{presentation.suggestions.map((chip) => <button type="button" key={chip} className="agent-chip" onClick={() => { store.setDraft(chip); composerRef.current?.focus(); }}>{chip}</button>)}
+					{presentation.suggestions.map((chip) => <button type="button" key={chip} className="agent-chip" onClick={() => { noteChipDraft(); store.setDraft(chip); composerRef.current?.focus(); }}>{chip}</button>)}
 				</div>
 			</div>}
 
@@ -893,7 +892,7 @@ export default function AgentPanel({
 			{layout.map((entry, index) => {
 				if (entry.type === "steps") return <Fragment key={entry.id}>
 					{entry.last && progressCard}
-					<div className="agent-row"><TurnSteps block={entry} now={activityNow} toolLabels={presentation.toolLabels} formatClock={formatTurnClock} onRetry={() => runTurn(chat.lastPrompt)} /></div>{taskMode && layout[index + 1]?.item?.kind !== "assistant" && <TaskRows steps={entry.steps} />}
+					<div className="agent-row"><TurnSteps block={entry} now={activityNow} toolLabels={presentation.toolLabels} formatClock={formatTurnClock} onRetry={() => runTurn(chat.lastPrompt, "retry_button")} /></div>{taskMode && layout[index + 1]?.item?.kind !== "assistant" && <TaskRows steps={entry.steps} />}
 				</Fragment>;
 				const { item } = entry;
 				if (item.kind === "user") return <div className="agent-row user" key={item.id}>
@@ -905,14 +904,14 @@ export default function AgentPanel({
 				if (item.kind === "assistant") return <Fragment key={item.id}><div className="agent-row assistant"><div className="agent-assistant-text"><ReplyText text={item.text} tail={streaming && <span className="agent-caret">▌</span>} /></div></div>{taskMode && layout[index - 1]?.type === "steps" && <TaskRows steps={layout[index - 1].steps} />}</Fragment>;
 				if (item.kind === "job") return <div className="agent-row" key={item.id}><JobCard job={item} onStop={stopTurn} onAccept={(job) => store.acceptJob(job.jobId)} /></div>;
 				if (item.kind === "receipt") return <div className="agent-row" key={item.id}><ReceiptCard item={item} /></div>;
-				if (item.kind === "failure") return <div className="agent-row" key={item.id}><FailureCard failure={item.failure} onRetry={() => runTurn(chat.lastPrompt)} onFixKey={openProviderKeys} /></div>;
-				if (item.kind === "supervisor") return <div className="agent-row" key={item.id}><SupervisorCard note={item} onSend={(text) => { store.setDraft(text); runTurn(text); }} /></div>;
+				if (item.kind === "failure") return <div className="agent-row" key={item.id}><FailureCard failure={item.failure} onRetry={() => runTurn(chat.lastPrompt, "retry_button")} onFixKey={() => openProviderKeys("failure_card")} /></div>;
+				if (item.kind === "supervisor") return <div className="agent-row" key={item.id}><SupervisorCard note={item} onSend={(text) => { store.setDraft(text); runTurn(text, "supervisor"); }} /></div>;
 				if (item.kind === "plan") return <PlanCard key={item.id} plan={item} live={streaming && !item.outcome} />;
-				return <div className="agent-row" key={item.id}><ImageResultCard image={item} onUse={(image) => store.applyImage(image.id)} onUndo={(image) => store.undoImage(image.id)} onRegenerate={() => runTurn(chat.lastPrompt)} onOpen={setLightbox} /></div>;
+				return <div className="agent-row" key={item.id}><ImageResultCard image={item} onUse={(image) => store.applyImage(image.id)} onUndo={(image) => store.undoImage(image.id)} onRegenerate={() => runTurn(chat.lastPrompt, "regenerate")} onOpen={setLightbox} /></div>;
 			})}
 
 			{!layout.some((entry) => entry.type === "steps" && entry.last) && progressCard}{taskMode && <TaskRows items={items} />}
-			{rateLimit && <PausedCard resetAt={rateLimit.resetAt} onRetry={() => { store.clearRateLimit(); runTurn(chat.lastPrompt); }} onSwitchModel={switchModel} />}
+			{rateLimit && <PausedCard resetAt={rateLimit.resetAt} onRetry={() => { store.clearRateLimit(); runTurn(chat.lastPrompt, "retry_button"); }} onSwitchModel={switchModel} />}
 		</div>
 		{surface === "studio" && taskMode && authenticated && <><Suspense fallback={null}><TaskBoard sessionId={chat.sessionId} pulse={chat.lastTurn?.endedAt ?? 0} labelOf={taskStepLabel} onMainNote={store.note} /></Suspense><TaskDetail /></>}
 
@@ -947,7 +946,7 @@ export default function AgentPanel({
 					placeholder={panelState === "rate-limited" ? "Composer is paused" : model ? presentation.composerPlaceholder : "Waiting for the model list…"}
 					value={draft}
 					disabled={composerDisabled}
-					onChange={(event) => store.setDraft(event.target.value)}
+					onChange={(event) => { noteDraftInput(); store.setDraft(event.target.value); }}
 					onKeyDown={onComposerKeyDown}
 					onDragOver={onComposerDragOver}
 					onDrop={onComposerDrop}
@@ -991,10 +990,10 @@ export default function AgentPanel({
 					    that can be steered, Send becomes the way INTO it. */}
 					{streaming
 						? <>
-							<button type="button" className="agent-send stop agent-stop" onClick={stopTurn}>Stop</button>
-							{presentation.steer && <button type="button" className="agent-send agent-steer" disabled={!draft.trim()} onClick={() => steerTurn(draft)}>Steer</button>}
+							<button type="button" data-fid="agent_stop" className="agent-send stop agent-stop" onClick={stopTurn}>Stop</button>
+							{presentation.steer && <button type="button" data-fid="agent_steer" className="agent-send agent-steer" disabled={!draft.trim()} onClick={() => steerTurn(draft)}>Steer</button>}
 						</>
-						: <button type="button" className="agent-send" aria-label="Send" title="Send (Enter)" disabled={composerDisabled || !draft.trim()} onClick={() => runTurn(draft)}><FiArrowUp size={14} aria-hidden="true" /></button>}
+						: <button type="button" data-fid="agent_send" className="agent-send" aria-label="Send" title="Send (Enter)" disabled={composerDisabled || !draft.trim()} onClick={() => runTurn(draft)}><FiArrowUp size={14} aria-hidden="true" /></button>}
 				</div>
 				<ModelRolesLine model={model} roles={selectedModelRoles(modelRoles, model)} />
 			</div>

package/src/workflow/CozySceneNode.jsx

@@ -1,5 +1,5 @@
 import { useEffect, useMemo, useState } from "react";
-import { startExportAttempt, track } from "../analytics.js";
+import { track } from "../analytics.js"; import { startExportAttempt } from "../export-attempt.js";
 import { downloadPack, requestKeyframePack } from "./keyframe-pack-request.js";
 import {
 	applyCozyScenePatch,

package/src/workflow/LoginPanel.jsx

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useRef, useState } from "react";
 import { FiX } from "react-icons/fi";
 import { answerLogin, cancelLogin, fetchLogins, logoutProvider, readLogin, startLogin } from "./login-client.js";
+import { connectFinished, connectPanelClosed, connectStarted, connectStep } from "./connect-telemetry.js";
 
 // "Connect a model": pi's own login (the coding agent's /login) inside the agent panel (#pi-login). The list
 // is what pi ships: each provider with its subscription sign-in and/or api-key login; picking one runs pi's
@@ -53,7 +54,14 @@ export function LoginPanel({ onClose, onChatGPT, onChanged }) {
 	const load = useCallback(async () => {
 		try { setProviders(await fetchLogins()); setError(""); } catch (failure) { setError(failure?.message || "The login list is unavailable."); }
 	}, []);
-	useEffect(() => { live.current = true; load(); return () => { live.current = false; }; }, [load]);
+	// Leaving the panel mid-flow abandons that attempt (a ChatGPT sign-in goes on in the agent panel).
+	useEffect(() => { live.current = true; load(); return () => { live.current = false; connectPanelClosed(); }; }, [load]);
+	// The attempt's funnel step follows the flow: waiting, a prompt to answer, then done.
+	useEffect(() => {
+		if (!flow?.flowId) return;
+		if (flow.done) connectFinished(flow.ok ? "ok" : "failed");
+		else connectStep(flow.prompt ? "prompt" : "waiting");
+	}, [flow?.flowId, flow?.done, flow?.ok, flow?.prompt]);
 	// Read the running flow until pi finishes it.
 	useEffect(() => {
 		if (!flow?.flowId || flow.done) return undefined;
@@ -83,12 +91,14 @@ export function LoginPanel({ onClose, onChatGPT, onChanged }) {
 
 	const begin = async (provider, method) => {
 		setError("");
-		// ChatGPT's own sign-in shows its waiting card in the panel body, so the list steps aside.
+		// ChatGPT's own sign-in shows its waiting card in the panel body, so the list steps aside;
+		// that sign-in reports its own connect attempt (AgentPanel signIn).
 		if (method.type === "chatgpt") { onChatGPT?.(); onClose?.(); return; }
+		connectStarted(provider.id, method.type);
 		try {
 			const flowId = await startLogin(provider.id, method.type);
 			setFlow({ flowId, name: provider.name, label: method.label, log: [], prompt: null, done: false });
-		} catch (failure) { setError(failure?.message || "That login could not start."); }
+		} catch (failure) { connectFinished("failed"); setError(failure?.message || "That login could not start."); }
 	};
 	const answer = async (value) => {
 		const prompt = flow?.prompt;
@@ -97,7 +107,7 @@ export function LoginPanel({ onClose, onChatGPT, onChanged }) {
 		try { await answerLogin(flow.flowId, prompt.promptId, value); } catch (failure) { setError(failure?.message || "That answer was not taken."); }
 	};
 	const cancel = async () => {
-		if (flow && !flow.done) await cancelLogin(flow.flowId).catch(() => {});
+		if (flow && !flow.done) { connectFinished("cancelled"); await cancelLogin(flow.flowId).catch(() => {}); }
 		setFlow(null);
 	};
 	const logout = async (provider) => {
@@ -108,7 +118,7 @@ export function LoginPanel({ onClose, onChatGPT, onChanged }) {
 	return <section className="agent-keys agent-login" aria-label="Connect a model" data-agent-keys="true">
 		<div className="agent-keys-head">
 			<h3 className="agent-keys-title">Connect a model</h3>
-			<button type="button" className="agent-icon-button agent-keys-close" aria-label="Close" onClick={async () => { await cancel(); onClose?.(); }}><FiX size={11} aria-hidden="true" /></button>
+			<button type="button" className="agent-icon-button agent-keys-close" aria-label="Close" onClick={async () => { connectFinished("abandoned"); await cancel(); onClose?.(); }}><FiX size={11} aria-hidden="true" /></button>
 		</div>
 		{error && <p className="agent-key-error" role="alert">{error}</p>}
 		{flow ? <div className="agent-login-flow" data-login-flow={flow.done ? (flow.ok ? "connected" : "failed") : "running"}>

package/src/workflow/agent-client.js

@@ -23,11 +23,12 @@
 //   POST /agent/jobs/<jobId>/accept          -> explicit "Apply with warnings"
 //   GET  /agent/turn/<turnId>/supervisor     -> 200 supervisor note | 204 none (#728)
 
-import { bucketMs, track } from "../analytics.js";
+import { track } from "../analytics.js";
 import { appendAttachments, ATTACHMENT_MAX_COUNT } from "./attachment-image.js";
 import { ko } from "../locale.js";
-import { AGENT_TOOL_CATEGORIES, EXECUTION_TELEMETRY_VALUES } from "../execution-telemetry.js";
+import { startAgentTurn, trackAgentTurns } from "./agent-turn-telemetry.js";
 import { STUDIO_VARIANTS, validateReceipt } from "../studio-agent-protocol.js";
+import { refusalFailureCode, transportFailureCode } from "./agent-failure-codes.js";
 import { requestAgentImage, sidecarRequest, sidecarUrl } from "../agent-image-client.js"; import { clearSculptSketch, sculptSketchFrame } from "../sculpt-sketch-state.js";
 import { actionLabelsOf, changedLine, scriptNow, stepFields, thinkingLine, withCompose, withThinking, withToolStart, withTurnEnd } from "./agent-turn.js";
 import { isPlanFrame, restoredPlans, withPlanEnd, withPlanFrame } from "./agent-plan.js";
@@ -489,13 +490,7 @@ export function parseSseChunk(buffer) {
 	return { events, tail };
 }
 
-const validTelemetryId = (value) => typeof value === "string" && /^[a-f0-9]{32}$/.test(value);
-const AGENT_FAILURE_CODES = new Set(["aborted", "auth", "rate_limited", "tool_failed", "upstream", "unknown"]);
-const exactKeys = (value, keys) => value && typeof value === "object" && !Array.isArray(value)
-	&& Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
 const advisory = (read, fallback) => { try { return read(); } catch { return fallback; } };
-const transportFailureCode = (error) => advisory(() => error?.status === 401 || error?.code === "auth" ? "auth"
-	: error?.status === 429 || error?.code === "rate_limit" ? "rate_limited" : "upstream", "upstream");
 
 const UI_ERROR_CODES = new Set(["auth", "entitlement", "rate_limit", "overloaded", "upstream"]);
 
@@ -523,86 +518,6 @@ export async function refusalEvent(response) {
 	};
 }
 
-// The real browser request owns the attempt, including HTTP refusal and Stop.
-// These IDs never use panel session IDs, model call IDs or authored content.
-function startAgentTurn({ surface, capture, now, correlationId = null }) {
-	const turnId = advisory(() => {
-		const bytes = new Uint8Array(16);
-		globalThis.crypto.getRandomValues(bytes);
-		return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-	}, null);
-	const clock = () => advisory(() => { const value = now(); return Number.isFinite(value) ? value : NaN; }, NaN);
-	// A Studio turn already has a host-owned id and its frozen envelope has no
-	// room for a second one, so the sidecar names its frames with THAT id. The
-	// analytics id stays the local hex one: it is the only id analytics accepts.
-	const matchId = correlationId ?? turnId;
-	const startedAt = clock();
-	const hostSurface = advisory(() => ["studio", "workflow"].includes(surface) ? surface
-		: /^\/workflow(?:\/|$)/.test(globalThis.location?.pathname || "") ? "workflow" : "studio", "studio");
-	let terminal = false;
-	let applied = false;
-	const tools = new Map();
-	const seenTools = new Set();
-	const emit = (event, props) => {
-		if (!turnId) return;
-		try { Promise.resolve(capture(event, props)).catch(() => {}); } catch { /* telemetry is advisory */ }
-	};
-	const finish = (outcome, failureCode) => {
-		if (terminal) return;
-		terminal = true;
-		if (outcome === "cancelled") {
-			for (const [id, tool] of tools) {
-				if (!seenTools.has(id)) emit("agent:tool_executed", { turn_id: turnId, tool_category: tool.category, outcome: "cancelled", duration_bucket: bucketMs(clock() - tool.startedAt) });
-			}
-		}
-		tools.clear();
-		emit(`agent:turn_${outcome}`, { turn_id: turnId, duration_bucket: bucketMs(clock() - startedAt), ...(outcome !== "succeeded" ? { failure_code: failureCode } : {}) });
-	};
-	emit("agent:turn_requested", { surface: hostSurface, turn_id: turnId });
-	return {
-		turnId,
-		cancel: () => finish("cancelled", "aborted"),
-		fail: (code) => finish("failed", AGENT_FAILURE_CODES.has(code) ? code : "upstream"),
-		frame(frame) {
-			// Local sidecar frames are still an untrusted boundary. Reject the whole
-			// frame, including extra fields, before dedupe or analytics capture.
-			try {
-				if (!turnId || terminal) return;
-				if (frame.type === "execution_tool_started") {
-					if (!exactKeys(frame, ["type", "turn_id", "telemetry_id", "tool_category"]) || frame.turn_id !== matchId
-						|| !validTelemetryId(frame.telemetry_id) || !AGENT_TOOL_CATEGORIES.includes(frame.tool_category)) return;
-					if (!tools.has(frame.telemetry_id) && !seenTools.has(frame.telemetry_id)) tools.set(frame.telemetry_id, { category: frame.tool_category, startedAt: clock() });
-					return;
-				}
-				const { event, props } = frame;
-				if (props?.turn_id !== matchId) return;
-				if (event === "agent:tool_executed") {
-					if (!exactKeys(frame, ["type", "event", "props", "telemetry_id"]) || !validTelemetryId(frame.telemetry_id)
-						|| !exactKeys(props, ["turn_id", "tool_category", "outcome", "duration_bucket"])
-						|| !AGENT_TOOL_CATEGORIES.includes(props.tool_category) || !["succeeded", "failed", "cancelled"].includes(props.outcome)
-						|| !EXECUTION_TELEMETRY_VALUES.duration_bucket.has(props.duration_bucket) || seenTools.has(frame.telemetry_id)) return;
-					seenTools.add(frame.telemetry_id);
-					tools.delete(frame.telemetry_id);
-					emit(event, { turn_id: turnId, tool_category: props.tool_category, outcome: props.outcome, duration_bucket: props.duration_bucket });
-					return;
-				}
-				if (!exactKeys(frame, ["type", "event", "props"])) return;
-				if (event === "agent:result_applied") {
-					if (!applied && exactKeys(props, ["turn_id"])) { applied = true; emit(event, { turn_id: turnId }); }
-					return;
-				}
-				if (!["agent:turn_succeeded", "agent:turn_failed", "agent:turn_cancelled"].includes(event)) return;
-				const outcome = event.slice("agent:turn_".length);
-				const hasFailure = Object.hasOwn(props, "failure_code");
-				if (!exactKeys(props, ["turn_id", "duration_bucket", ...(hasFailure ? ["failure_code"] : [])])
-					|| !EXECUTION_TELEMETRY_VALUES.duration_bucket.has(props.duration_bucket)
-					|| (hasFailure && (outcome === "succeeded" || !AGENT_FAILURE_CODES.has(props.failure_code)))) return;
-				finish(outcome, outcome === "cancelled" ? "aborted" : props.failure_code || "unknown");
-			} catch { /* foreign getters and malformed telemetry cannot affect a turn */ }
-		},
-	};
-}
-
 const RESUME_ATTEMPTS = 3;
 
 /** The environment variables the sidecar reads a provider key from (the `env`
@@ -732,7 +647,10 @@ export function createHttpTransport({ fetchImpl = globalThis.fetch?.bind(globalT
 			const attached = Array.isArray(attachments) && attachments.length ? { attachments } : {};
 			const studio = turnRequest.surface === "studio";
 			const turnId = studio ? turnRequest.turnId : null;
-			const telemetry = startAgentTurn({ surface, capture, now, correlationId: turnId });
+			// The host's own surface wins over the URL (an embedded Studio panel on a /workflow path is still Studio).
+			const hostSurface = advisory(() => ["studio", "workflow"].includes(surface) ? surface
+				: /^\/workflow(?:\/|$)/.test(globalThis.location?.pathname || "") ? "workflow" : "studio", "studio");
+			const telemetry = startAgentTurn({ surface: hostSurface, capture, now, correlationId: turnId });
 			// The steer route is keyed by the id THIS request is known by upstream:
 			// the Studio envelope's turnId, or the hex id the dock mints for its own
 			// turn. The caller cannot know it any other way.
@@ -755,6 +673,7 @@ export function createHttpTransport({ fetchImpl = globalThis.fetch?.bind(globalT
 				}
 				if (event?.type === "error") failureCode = transportFailureCode(event);
 				if (event?.type === "done") terminal = true;
+				if (event?.type === "tool.start" || event?.type === "tool.done") telemetry.tool(event);
 				onEvent(event);
 			};
 			const readStream = async (response) => {
@@ -795,7 +714,7 @@ export function createHttpTransport({ fetchImpl = globalThis.fetch?.bind(globalT
 					signal,
 				});
 				if (!response.ok || !response.body) {
-					telemetry.fail(transportFailureCode(response));
+					telemetry.fail(await refusalFailureCode(response));
 					// A refused turn carries the only explanation there is. Forward the
 					// status and whatever short detail the sidecar sanitized for us
 					// instead of the panel inventing "something went wrong".
@@ -1134,7 +1053,7 @@ export function createAgentTransport(options = {}) {
 	const config = options.mockConfig !== undefined ? options.mockConfig : mockConfigFromSearch();
 	// The surface is the host's own prop, never a guess from the URL: an
 	// embedded Studio panel is a Studio panel wherever it is mounted.
-	return config ? createMockTransport({ surface: options.surface, ...config }) : createHttpTransport(options);
+	return trackAgentTurns(config ? createMockTransport({ surface: options.surface, ...config }) : createHttpTransport(options));
 }
 
 // One conversation: session identity, transcript, motion jobs, receipts and

package/src/workflow/agent-failure-codes.js

@@ -0,0 +1,47 @@
+// The closed `agent:turn_failed.failure_code` vocabulary, browser side. The
+// sidecar keeps an identical table in bin/agent/agent-failure-codes.mjs (it
+// cannot import src/); test/verify-agent-execution.mjs holds both to the same
+// answers. Only the structured code and HTTP status are read, never a message.
+//
+//   key_refused         the model provider rejected the credentials (provider
+//                       401/403, structured or message-only: runner `unauthorized`)
+//   auth                the sidecar itself has no usable sign-in, or refused the
+//                       session's ownership (AUTH_REQUIRED, `auth`, refusal 401/403)
+//   rate_limited        provider or sidecar 429 (`rate_limit`, RATE_LIMITED)
+//   stale_scene         the scene moved under the turn (STALE_SCENE/TARGET/ENVIRONMENT)
+//   capability_missing  the sidecar cannot run this turn here (CAPABILITY_MISSING:
+//                       Studio runtime absent, live hub port in use;
+//                       LIVE_HUB_UNAVAILABLE: no connected editor)
+//   busy                a turn is already running, or the target is busy
+//   invalid_request     the sidecar rejected the request (400, INVALID_*, other 4xx)
+//   upstream            provider outage, overload, 5xx, network or unclassified
+//   aborted / tool_failed / unknown  are assigned by the turn, not by this table
+export const AGENT_FAILURE_CODES = new Set(["aborted", "auth", "rate_limited", "tool_failed", "upstream", "unknown",
+	"key_refused", "stale_scene", "capability_missing", "busy", "invalid_request"]);
+
+const BY_CODE = {
+	unauthorized: "key_refused", auth: "auth", AUTH_REQUIRED: "auth", rate_limit: "rate_limited", RATE_LIMITED: "rate_limited",
+	STALE_SCENE: "stale_scene", STALE_TARGET: "stale_scene", STALE_ENVIRONMENT: "stale_scene",
+	CAPABILITY_MISSING: "capability_missing", LIVE_HUB_UNAVAILABLE: "capability_missing",
+	busy: "busy", TARGET_BUSY: "busy", SCOPE_BUSY: "busy", TARGET_NOT_READY: "busy",
+};
+
+/** `{ code, status }` -> failure code. Foreign getters fall back to upstream. */
+export function transportFailureCode(error) {
+	try {
+		const code = typeof error?.code === "string" ? error.code : "";
+		const status = error?.status;
+		if (Object.hasOwn(BY_CODE, code)) return BY_CODE[code];
+		if (code.startsWith("INVALID_")) return "invalid_request";
+		if (status === 401 || status === 403) return "auth";
+		if (status === 429) return "rate_limited";
+		return Number.isInteger(status) && status >= 400 && status < 500 ? "invalid_request" : "upstream";
+	} catch { return "upstream"; }
+}
+
+/** A refused turn: the sidecar's `{ error: { code } }` body plus the HTTP status. */
+export async function refusalFailureCode(response) {
+	let code;
+	try { const body = await response.clone().json(); code = typeof body?.error?.code === "string" ? body.error.code : undefined; } catch { /* status alone */ }
+	try { return transportFailureCode({ code, status: response?.status }); } catch { return "upstream"; }
+}