cozyclay 3.0.3 → 3.1.1

package/src/workflow/task-board.css

@@ -0,0 +1,98 @@
+/* Task mode in the chat (TaskInline.jsx): one quiet line per task, a count line under the header, the open task's
+   view over the chat, and the outliner mark on rows inside a running task. Studio tokens first, agent tokens after. */
+.task-rows {
+	display: grid;
+	margin: 2px 0 2px 2px;
+	padding-left: 6px;
+	border-left: 2px solid var(--hairline, var(--agent-border, rgba(127, 127, 127, 0.25)));
+	min-width: 0;
+}
+.task-row {
+	display: flex;
+	align-items: center;
+	gap: 6px;
+	min-width: 0;
+	height: 24px;
+	padding: 0 6px;
+	border: 0;
+	border-radius: 6px;
+	background: none;
+	color: inherit;
+	font: inherit;
+	font-size: 12px;
+	text-align: left;
+	cursor: pointer;
+}
+.task-row:hover, .task-row:focus-visible { background: var(--chip-fill, rgba(127, 127, 127, 0.1)); outline: none; }
+.task-row-title { flex: 0 1 auto; min-width: 0; overflow: hidden; white-space: nowrap; text-overflow: ellipsis; font-weight: 550; }
+.task-row-line { flex: 1 1 0; min-width: 64px; overflow: hidden; white-space: nowrap; text-overflow: ellipsis; color: var(--text-2, var(--agent-text-muted)); }
+.task-row[data-status="failed"] .task-row-line { color: var(--danger, var(--agent-alert)); }
+.task-row[data-status="cancelled"], .task-row[data-status="done"] .task-row-title { opacity: 0.8; }
+
+.task-dot { flex: none; width: 7px; height: 7px; border-radius: 50%; background: var(--text-3, var(--agent-text-dim)); }
+[data-status="running"] > .task-dot, [data-status="starting"] > .task-dot { background: var(--select, var(--agent-accent)); animation: task-dot-pulse 1.2s ease-in-out infinite; }
+[data-status="waiting"] > .task-dot, [data-status="queued"] > .task-dot { background: none; box-shadow: inset 0 0 0 1.5px var(--text-3, var(--agent-text-dim)); }
+[data-status="done"] > .task-dot { background: var(--ok, var(--agent-ok)); }
+[data-status="failed"] > .task-dot, [data-status="paused"] > .task-dot { background: var(--danger, var(--agent-alert)); }
+@keyframes task-dot-pulse { 50% { opacity: 0.35; } }
+@media (prefers-reduced-motion: reduce) { [data-status] > .task-dot { animation: none; } }
+
+.task-strip { flex: none; border-bottom: 1px solid var(--hairline, var(--agent-border, rgba(127, 127, 127, 0.2))); padding: 0 8px; }
+.task-strip-head {
+	display: flex;
+	align-items: center;
+	gap: 10px;
+	width: 100%;
+	height: 26px;
+	padding: 0 6px;
+	border: 0;
+	background: none;
+	color: var(--text-2, var(--agent-text-muted));
+	font: inherit;
+	font-size: 11.5px;
+	cursor: pointer;
+}
+.task-strip-count { display: inline-flex; align-items: center; gap: 5px; white-space: nowrap; }
+.task-strip-caret { margin-left: auto; transition: transform 0.15s; }
+.task-strip[data-expanded="true"] .task-strip-caret { transform: rotate(180deg); }
+.task-strip-list { margin: 0 0 6px; max-height: 168px; overflow-y: auto; }
+
+.task-detail {
+	position: absolute;
+	inset: 0;
+	z-index: 6;
+	display: flex;
+	flex-direction: column;
+	background: var(--surface-raised, var(--agent-bg));
+	border-radius: inherit;
+}
+.task-detail-head { display: flex; align-items: center; gap: 6px; height: 44px; padding: 0 10px; border-bottom: 1px solid var(--hairline, var(--agent-border)); }
+.task-detail-back { display: inline-flex; align-items: center; gap: 2px; flex: none; }
+.task-detail-title { min-width: 0; overflow: hidden; white-space: nowrap; text-overflow: ellipsis; font-weight: 600; }
+.task-detail-body { flex: 1; min-height: 0; overflow-y: auto; display: grid; align-content: start; gap: 6px; padding: 10px 14px; font-size: 12px; }
+.task-detail-meta { display: flex; align-items: center; gap: 6px; color: var(--text-2, var(--agent-text-muted)); }
+.task-detail-meta .agent-ghost-button { margin-left: auto; }
+.task-detail-scope, .task-detail-reason, .task-detail-note, .task-detail-summary, .task-detail-notice { margin: 0; overflow-wrap: anywhere; }
+.task-detail-scope, .task-detail-reason, .task-detail-note, .task-detail-notice { color: var(--text-2, var(--agent-text-muted)); }
+.task-detail-steer { padding: 8px 10px 10px; border-top: 1px solid var(--hairline, var(--agent-border)); }
+.task-detail-steer input {
+	width: 100%;
+	box-sizing: border-box;
+	padding: 7px 10px;
+	border: 1px solid var(--hairline, var(--agent-border));
+	border-radius: 10px;
+	background: transparent;
+	color: inherit;
+	font: inherit;
+}
+.task-frames { margin: 4px 0 0; padding-left: 18px; display: grid; gap: 2px; }
+.task-frames li[data-kind="error"] { color: var(--danger, var(--agent-alert)); }
+.task-frames li[data-kind="reply"], .task-frames li[data-kind="said"] { list-style: none; margin-left: -18px; }
+.task-frames-empty { margin: 0; color: var(--text-3, var(--agent-text-dim)); }
+
+[data-task-scope]::after {
+	content: "●";
+	margin-left: 6px;
+	color: var(--select, var(--agent-accent));
+	font-size: 9px;
+}

package/src/workflow/task-board.js

@@ -0,0 +1,169 @@
+// The Studio task board in the agent panel (parallel tasks, P3). Task mode is a per-browser switch (the panel's Tasks
+// toggle) or the server's COZYCLAY_STUDIO_TASKS flag: the chat then talks to the main agent (POST /agent/main), which
+// answers at once and dispatches tasks; this board shows them. Pure parts here (the reducer, labels, the switch's
+// storage); the network side is createTaskBoardClient; the view is TaskBoard.jsx.
+//   server events (GET /agent/main/<sessionId>/events): task.queued|waiting|started|resumed|paused|done|failed|cancelled
+//     carry the task's view { taskId, title, status, scope, reason?, turnId?, usage, summary? }; task.sceneChanged
+//     { taskId, keys, midCommand }; main.turn { turnId } (the main agent reporting on its own)
+//   editor events (the command bus): task.userEdit { taskId, keys } (the user changed something in its scope)
+//   compile activity (motion3-compile.js): { running, waiting } of { taskId, characterId }
+import { ko } from "../locale.js";
+import { sidecarUrl } from "../agent-image-client.js";
+import { parseSseChunk } from "./agent-client.js";
+
+const TASKS_KEY = "cozyclay.agent.tasks";
+export function readStoredTaskMode(storage = globalThis.localStorage) {
+	try { return storage?.getItem(TASKS_KEY) === "on"; } catch { return false; }
+}
+export function storeTaskMode(enabled, storage = globalThis.localStorage) {
+	try { storage?.setItem(TASKS_KEY, enabled ? "on" : "off"); } catch { /* storage may be unavailable */ }
+}
+
+export const TASK_STATUS_COPY = {
+	queued: ko("Queued", "대기열"),
+	waiting: ko("Waiting for scope", "영역 대기"),
+	starting: ko("Starting", "시작 중"),
+	running: ko("Running", "작업 중"),
+	paused: ko("Paused: Studio lost", "일시정지: Studio 연결 끊김"),
+	done: ko("Done", "완료"),
+	failed: ko("Failed", "실패"),
+	cancelled: ko("Cancelled", "취소됨"),
+};
+export const ACTIVE_STATUSES = new Set(["queued", "waiting", "starting", "running", "paused"]);
+
+export const emptyBoard = () => ({ order: [], tasks: {}, after: 0 });
+
+/** The board after one event (server, editor or compile). Unknown events leave it as it is. */
+export function reduceBoard(board, event) {
+	if (!event || typeof event !== "object") return board;
+	const after = Number.isFinite(event.eventSeq) ? Math.max(board.after, event.eventSeq) : board.after;
+	const patch = (taskId, change) => {
+		const known = board.tasks[taskId];
+		if (!known && !change.title) return { ...board, after };
+		const task = { notes: [], ...known, ...change, taskId };
+		return { ...board, after, order: known ? board.order : [...board.order, taskId], tasks: { ...board.tasks, [taskId]: task } };
+	};
+	const note = (taskId, text) => (board.tasks[taskId] ? patch(taskId, { notes: [...board.tasks[taskId].notes, text].slice(-4) }) : { ...board, after });
+	if (event.type === "task.sceneChanged") return note(event.taskId, ko(`The scene changed during a reload: ${event.keys.join(", ")}`, `새로고침 중에 장면이 바뀜: ${event.keys.join(", ")}`));
+	if (event.type === "task.userEdit") return note(event.taskId, ko(`You changed ${event.keys.join(", ")}; the task reads it again`, `${event.keys.join(", ")}을(를) 직접 바꿈: 작업이 다시 읽어요`));
+	if (event.type === "task.undone") return board.tasks[event.taskId] ? patch(event.taskId, { undone: true }) : board;
+	if (typeof event.type === "string" && event.type.startsWith("task.") && event.taskId && event.status) {
+		const { type, at, eventSeq, ...view } = event;
+		return patch(event.taskId, { ...view, ...(type === "task.started" || type === "task.resumed" ? { progress: "" } : {}) });
+	}
+	return { ...board, after };
+}
+
+/** A board read (GET .../board) merged under what the events already said. */
+export function seedBoard(board, tasks = []) {
+	return tasks.reduce((acc, view) => (acc.tasks[view.taskId] ? acc : reduceBoard(acc, { type: "task.seed", ...view })), board);
+}
+
+/** The line a running card shows: the last tool it started, or the compile it waits for. */
+export function progressLine(frame, labelOf = call => call.name) {
+	if (frame?.type === "tool.start") return labelOf(frame);
+	if (frame?.type === "error") return ko(`Error: ${frame.message ?? frame.code}`, `오류: ${frame.message ?? frame.code}`);
+	return null;
+}
+
+/** A task's wait or failure reason in the author's words: the server names the blocking task by id and title. */
+export function taskReason(reason) {
+	// Greedy to the last ")": a title may hold parentheses of its own.
+	const after = /(?:waits for|held by) task \S+ \((.+)\)/.exec(String(reason ?? ""))?.[1];
+	if (after) return ko(`Starts after "${after}"`, `'${after}' 끝나면 시작`);
+	if (/scope is held/.test(String(reason ?? ""))) return ko("Starts when another task frees its part", "다른 작업이 끝나면 시작");
+	return reason ?? "";
+}
+
+/** The one line a task row shows after its title. */
+export function taskLine(task) {
+	if (task.status === "running") return task.progress || ko("Working…", "작업 중…");
+	if (task.status === "done") return task.undone ? ko("Undone", "되돌림") : String(task.summary?.reply ?? "").split(/(?<=[.!?。])\s/)[0] || TASK_STATUS_COPY.done;
+	if (task.reason) return taskReason(task.reason);
+	return TASK_STATUS_COPY[task.status] ?? task.status;
+}
+
+const SCOPE_NAMES = { timeline: ko("timeline", "타임라인"), stage: ko("stage", "무대"), scene: ko("scene", "장면"), object: ko("object", "오브젝트"), character: ko("character", "캐릭터"), shot: ko("shot", "샷") };
+/** A scope key (object:<id>, timeline, ...) as a word; the raw key stays in the tooltip. */
+export const scopeLabel = key => SCOPE_NAMES[String(key).split(":")[0]] ?? String(key);
+
+/** Rows by state for the status line: what needs a look first, then what runs, waits and ended. */
+export function boardGroups(board) {
+	const groups = { failed: [], running: [], waiting: [], done: [] };
+	for (const id of board.order) {
+		const task = board.tasks[id];
+		const group = task.status === "failed" || task.status === "paused" ? "failed" : task.status === "running" || task.status === "starting" ? "running" : ACTIVE_STATUSES.has(task.status) ? "waiting" : "done";
+		groups[group].push(task);
+	}
+	return groups;
+}
+
+/** The task ids a turn's dispatch_task steps started, in order (a duplicate points at the task it repeats). */
+export const dispatchedTaskIds = steps => (steps ?? []).filter(step => step.kind === "tool" && step.name === "dispatch_task")
+	.map(step => step.result?.taskId ?? step.result?.duplicateOf).filter(Boolean);
+
+/** What the task view shares between the headless board (TaskBoard.jsx) and the rows in the chat (TaskInline.jsx). */
+function createTaskViewStore() {
+	let state = { board: emptyBoard(), activity: null, client: null, undo: null, open: null };
+	const listeners = new Set();
+	return {
+		get: () => state,
+		set: patch => { state = { ...state, ...patch }; for (const listener of listeners) listener(); },
+		subscribe: listener => { listeners.add(listener); return () => listeners.delete(listener); },
+	};
+}
+// One agent panel per page, so one view.
+export const taskView = createTaskViewStore();
+
+/** "$0.12" for a task's cost, or "" when nothing is known yet. */
+export const costLabel = usage => (Number.isFinite(usage?.cost) && usage.cost > 0 ? `$${usage.cost.toFixed(2)}` : "");
+
+/** The compile a task waits for: how many of its compiles wait and how many run. */
+export function compileState(activity, taskId) {
+	const mine = list => (list ?? []).filter(meta => meta?.taskId === taskId).length;
+	return { waiting: mine(activity?.waiting), running: mine(activity?.running) };
+}
+
+/** The open scopes the editor's bus reports: taskId -> keys (task.begun / task.scope / task.finished|cancelled). */
+export function reduceScopes(scopes, event) {
+	if (event?.type === "task.begun" || event?.type === "task.scope") return { ...scopes, [event.taskId]: event.scope ?? [] };
+	if (event?.type === "task.finished" || event?.type === "task.cancelled") { const { [event.taskId]: _gone, ...rest } = scopes; return rest; }
+	return scopes;
+}
+
+/**
+ * The sidecar side of the board. All requests are same-origin with the Studio session's owner cookie.
+ * fetchImpl(url, init) -> Response; url(path) -> the sidecar URL.
+ */
+export function createTaskBoardClient({ fetchImpl = globalThis.fetch?.bind(globalThis), url = sidecarUrl } = {}) {
+	const json = async (path, init) => {
+		const response = await fetchImpl(url(path), { credentials: "same-origin", headers: { accept: "application/json", "content-type": "application/json" }, ...init });
+		const body = await response.json().catch(() => ({}));
+		if (!response.ok) throw Object.assign(new Error(body?.error?.message ?? `${response.status}`), { status: response.status, code: body?.error?.code });
+		return body;
+	};
+	/** Streams an SSE route to onEvent until it ends or signal aborts. */
+	async function stream(path, onEvent, signal) {
+		const response = await fetchImpl(url(path), { credentials: "same-origin", headers: { accept: "text/event-stream" }, signal });
+		if (!response.ok || !response.body) throw Object.assign(new Error(`${response.status}`), { status: response.status });
+		const reader = response.body.getReader(), decoder = new TextDecoder();
+		let buffer = "";
+		try {
+			while (true) {
+				const { value, done } = await reader.read();
+				if (done) break;
+				const parsed = parseSseChunk(buffer + decoder.decode(value, { stream: true }));
+				buffer = parsed.tail;
+				for (const event of parsed.events) onEvent(event);
+			}
+		} finally { reader.releaseLock(); }
+	}
+	const id = value => encodeURIComponent(value);
+	return {
+		board: sessionId => json(`/agent/main/${id(sessionId)}/board`),
+		events: (sessionId, after, onEvent, signal) => stream(`/agent/main/${id(sessionId)}/events?after=${after}`, onEvent, signal),
+		frames: (turnId, onEvent, signal) => stream(`/agent/turn/${id(turnId)}/events?after=0`, onEvent, signal),
+		cancel: taskId => json(`/agent/task/${id(taskId)}/cancel`, { method: "POST", body: "{}" }),
+		steer: (taskId, text) => json(`/agent/task/${id(taskId)}/steer`, { method: "POST", body: JSON.stringify({ text }) }),
+	};
+}

package/tools/check-eslint.mjs

@@ -10,7 +10,8 @@ import { fileURLToPath } from "node:url";
 const root = join(dirname(fileURLToPath(import.meta.url)), "..");
 const baselinePath = join(root, "tools", "eslint-baseline.json");
 
-const run = spawnSync(join(root, "node_modules", ".bin", "eslint"), [".", "--format", "json"], {
+// Run the package's JS entry through node: the .bin shim is a .cmd on Windows, which spawnSync cannot start without a shell.
+const run = spawnSync(process.execPath, [join(root, "node_modules", "eslint", "bin", "eslint.js"), ".", "--format", "json"], {
 	cwd: root,
 	encoding: "utf8",
 	maxBuffer: 512 * 1024 * 1024,

package/tools/check-knip.mjs

@@ -11,7 +11,8 @@ const root = join(dirname(fileURLToPath(import.meta.url)), '..');
 const baselinePath = join(root, 'tools', 'knip-baseline.json');
 
 // knip exits 1 when it finds issues; only a missing/unparseable report is a failure.
-const run = spawnSync(join(root, 'node_modules', '.bin', 'knip'), ['--reporter', 'json', '--no-progress'], {
+// Run the package's JS entry through node: the .bin shim is a .cmd on Windows, which spawnSync cannot start without a shell.
+const run = spawnSync(process.execPath, [join(root, 'node_modules', 'knip', 'bin', 'knip.js'), '--reporter', 'json', '--no-progress'], {
 	cwd: root,
 	encoding: 'utf8',
 	maxBuffer: 256 * 1024 * 1024,

package/tools/dev/pages/greybox-to-video.html

@@ -107,9 +107,8 @@
         <h2>Do it in the browser</h2>
         <p>
           CozyClay is open source previs that runs in a Chromium tab. It exists for exactly this loop: block,
-          camera, export, generate. The <a href="/#try">playground on the home page</a> walks through the camera
-          part in seven moves on the same city block you see in the reels, and <code>npx cozyclay --scene city-block</code>
-          opens that set on your machine.
+          camera, export, generate. The <a href="/#try">playground on the home page</a> runs the studio in the page, and
+          <code>npx cozyclay</code> runs it on your machine.
         </p>
         <div class="cta">
           <a class="btn primary" href="/#try">Try it in your browser</a>

package/tools/dev/pages/previs-software.html

@@ -64,8 +64,8 @@
         <p>
           The honest split is time, not money. Blender can do everything on this page and will take an
           afternoon to learn just the camera. CozyClay does one thing (block, camera, cut, export) and expects
-          you to be productive in the first ten minutes; there is a <a href="/#try">seven-step tutorial on the home page</a>
-          that takes about that long.
+          you to be productive in the first ten minutes; the <a href="/#try">playground on the home page</a>
+          runs it in the page.
         </p>
       </section>
 

package/tools/dev/pages/privacy.html

@@ -86,12 +86,11 @@ cclay telemetry on</code></pre>
             <thead><tr><th>Event</th><th>Purpose</th></tr></thead>
             <tbody>
               <tr><td>install:first_launch, app:session_started, app:session_ended</td><td>Counting installs and sessions; duration and action counts are bucketed. install:first_launch may carry heard_from (x, hn, reddit, github, friend, other, site or playground), from the first-launch prompt or a copied <code>npx cozyclay --via</code> command. app:session_ended also carries per-session edit gesture counts in five groups, pose_edit_bucket, camera_edit_bucket, object_edit_bucket, shot_edit_bucket and prompt_edit_bucket, each bucketed (0, 1-3, 4-10 or gte11); never what was edited</td></tr>
-              <tr><td>feature:used</td><td>One signal per feature per session: a fixed feature name such as pose_edit (a real bone or pose change), pose_save (saving a pose to the library), fal_motion_open (opening the AI video A/B card), camera_fly or export_video</td></tr>
+              <tr><td>feature:used</td><td>One signal per feature per session: a fixed feature name such as pose_edit (a real bone or pose change), pose_save (saving a pose to the library), camera_fly or export_video</td></tr>
               <tr><td>$pageview, scene:created, scene:loaded, craft:first_action, activation:completed</td><td>Funnel and drop-off analysis</td></tr>
               <tr><td>craft:first_edit</td><td>First successful Studio authoring change per editor mount; only a fixed edit-kind label and definition version 1 (not camera navigation, playback, loading, restore, or undo/redo)</td></tr>
               <tr><td>playground:first_edit</td><td>The same versioned first-edit definition for Playground, counted separately from Studio; no prompts or scene contents</td></tr>
               <tr><td>project:saved, project:opened</td><td>Whether people keep their work (object counts and ages are bucketed; never names or paths)</td></tr>
-              <tr><td>motion:backend_state</td><td>Session capability baseline: backend (none, local_kimodo or hosted) and boolean host_configured, never a host address</td></tr>
               <tr><td>motion:generate_requested</td><td>Explicit generation intent, not prompt-block editing: initiating surface (timeline, line_edit, trail, mcp, fal_card or agent), input_mode (prompt, pose, edit, a_to_b or still) and an ephemeral random request_id</td></tr>
               <tr><td>motion:preflight_blocked</td><td>Request readiness refusal: request_id, surface and normalized reason (unconfigured, unreachable, unsupported_route, locked or missing_input). locked means the AI video route is not enabled for the account yet; missing_input means the A/B captures were incomplete</td></tr>
               <tr><td>motion:preflight_passed</td><td>Request readiness accepted, before job start: request_id, surface and backend (none, local_kimodo, hosted or fal)</td></tr>
@@ -117,10 +116,6 @@ cclay telemetry on</code></pre>
               <tr><td>device:profile</td><td>Once per session, whether the studio can run smoothly: gpu_vendor (nvidia, amd, intel, apple, qualcomm, arm, software, other or unknown), gpu_class (discrete, integrated, software or unknown), webgl (webgl2, webgl1 or none), cpu_bucket (1-4, 5-8, 9-16, gte17 or unknown), memory_bucket (lt4, 4-7, gte8 or unknown) and frame_rate_bucket (lt20, 20-40, 40-55, gte55 or unknown) from one three-second sample. The GPU renderer string and exact hardware values never leave the browser.</td></tr>
               <tr><td>survey:use_case</td><td>An optional question shown at most once after a successful export, only while telemetry is on: use_case (animation, film, game, ad_mv, personal, other or skip) and team (team, solo or skip). Closed choices only; no free text.</td></tr>
               <tr><td>hosted:composer_viewed, hosted:login_started, hosted:ticket_created, hosted:result_opened, hosted:opened_in_studio</td><td>Hosted demo funnel</td></tr>
-              <tr><td>tutorial:started</td><td>Camera tutorial attempts on surface (studio or playground), with numeric tutorial_version 1 and start_source (query, settings or landing). Restarting starts a new attempt; no tutorial attempt identifier or user text is sent.</td></tr>
-              <tr><td>tutorial:step_entered, tutorial:dismissed</td><td>Entered steps and explicit dismissal of an unfinished tutorial; surface (studio or playground), numeric tutorial_version 1 and step_kind (fly, walk, dolly, orbit, shot, rail or play). Missing completion can indicate abandonment or missing telemetry; browser close does not promise a dismissal event.</td></tr>
-              <tr><td>tutorial:step_completed</td><td>One completion per step per attempt; surface (studio or playground), numeric tutorial_version 1, step_kind (fly, walk, dolly, orbit, shot, rail or play) and elapsed_bucket (lt1s, 1-3s, 3-10s, 10-30s or gte30s) since entering that step. No raw timing, prompts, scene contents, names or paths.</td></tr>
-              <tr><td>tutorial:completed</td><td>All seven steps completed; surface (studio or playground), numeric tutorial_version 1 and elapsed_bucket (lt1s, 1-3s, 3-10s, 10-30s or gte30s) since tutorial start. Sample loading and camera playback do not count as a user edit.</td></tr>
             </tbody>
           </table>
         </div>
@@ -132,7 +127,8 @@ cclay telemetry on</code></pre>
       <section>
         <h2>The hosted demo (Google sign-in)</h2>
         <p>
-          The hosted motion demo asks you to sign in with Google so that the daily generation cap can be
+          The hosted demo is not open to the public right now. This section describes what it handled while it
+          was running. The hosted motion demo asks you to sign in with Google so that the daily generation cap can be
           enforced per account. It receives your Google account's email address and basic profile only, stores
           a session cookie signed by our server, and keeps your prompt and the generated result for up to 30
           days so the ticket link keeps working. Results are stored on Cloudflare R2 and deleted after that

package/tools/dev/pages/seedance-camera-control.html

@@ -87,8 +87,8 @@
           Any 3D tool that renders flat can make the reference. Blender works with a clay material and a
           workbench render. CozyClay, open source and in the browser, exports the flat clip directly with the
           delivery ratio and a camera timeline built in; the reel at the top of this page came out of it.
-          The <a href="/#try">home-page playground</a> walks through blocking a shot and drawing a dolly rail in
-          seven moves, and <code>npx cozyclay --scene city-block</code> opens that set locally.
+          The <a href="/#try">home-page playground</a> runs the studio in the page, and
+          <code>npx cozyclay</code> runs it locally.
         </p>
         <div class="cta">
           <a class="btn primary" href="/#try">Try it in your browser</a>

package/tools/dev-full.mjs

@@ -45,7 +45,6 @@ await new Promise((resolvePromise, reject) => {
 });
 
 const children = [];
-const removeSignalCleanup = installSignalCleanup(() => children, () => {});
 const agentHandler = createAgentHandler({ port: mainPort });
 const oauthServer = createServer((req, res) => {
 	const path = (req.url || "").split("?")[0];
@@ -62,6 +61,16 @@ const oauthPort = configuredOAuthPort ? Number(configuredOAuthPort) : 0;
 await new Promise((resolvePromise, reject) => { oauthServer.once("error", reject); oauthServer.listen({ port: oauthPort, host: "127.0.0.1" }, resolvePromise); });
 const actualOAuthPort = oauthServer.address().port;
 
+// The oauth/agent HTTP server and the agent's live hub (its own listener on
+// COZYCLAY_LIVE_PORT) keep the event loop alive, so shutdown must close both
+// (dropping open keep-alive/SSE sockets) or the process never exits.
+const closeServers = async () => {
+	const httpClosed = new Promise((resolvePromise) => oauthServer.close(() => resolvePromise()));
+	oauthServer.closeAllConnections();
+	await Promise.allSettled([httpClosed, agentHandler.close()]);
+};
+const removeSignalCleanup = installSignalCleanup(() => children, closeServers);
+
 const vite = spawnOwned(process.execPath, ["node_modules/vite/bin/vite.js", ...viteArgs], {
 	cwd: REPO,
 		env: {
@@ -77,7 +86,7 @@ const first = await Promise.race(
 );
 
 removeSignalCleanup();
-await new Promise((resolvePromise) => oauthServer.close(resolvePromise));
+await closeServers();
 await Promise.allSettled(
 	children.filter((child) => child !== first.child).map((child) => terminateOwned(child)),
 );

package/tools/eslint-baseline.json

@@ -7,16 +7,16 @@
 	"no-regex-spaces": 2,
 	"no-undef": 24,
 	"no-unsafe-finally": 2,
-	"no-unused-vars": 100,
-	"no-useless-assignment": 10,
+	"no-unused-vars": 98,
+	"no-useless-assignment": 9,
 	"no-useless-escape": 6,
 	"preserve-caught-error": 6,
-	"react-hooks/immutability": 88,
-	"react-hooks/preserve-manual-memoization": 31,
+	"react-hooks/immutability": 81,
+	"react-hooks/preserve-manual-memoization": 28,
 	"react-hooks/purity": 5,
-	"react-hooks/refs": 111,
+	"react-hooks/refs": 102,
 	"react-hooks/rules-of-hooks": 2,
-	"react-hooks/set-state-in-effect": 30,
+	"react-hooks/set-state-in-effect": 26,
 	"react-hooks/use-memo": 1,
 	"require-yield": 2
 }

package/tools/knip-baseline.json

@@ -7,14 +7,7 @@
 	"export mcp/image-file.mjs#REFERENCE_MAX_BYTES",
 	"export src/asset-pane.jsx#CHARACTER_ASSETS",
 	"export src/asset-pane.jsx#FolderGrid",
-	"export src/burn-in.js#burnInCapture",
 	"export src/camera-block.js#CAMERA_MODES",
-	"export src/camera-tutorial.jsx#CAMERA_TUTORIAL_STEPS",
-	"export src/camera-tutorial.jsx#GestureCue",
-	"export src/camera-tutorial.jsx#TUTORIAL_BEACONS",
-	"export src/camera-tutorial.jsx#TutorialBeacon",
-	"export src/camera-tutorial.jsx#WALK_KEYS",
-	"export src/camera-tutorial.jsx#default",
 	"export src/domains/motion.js#createMotionDomain",
 	"export src/domains/objects.js#createObjectsDomain",
 	"export src/grid-view.js#STAGE_BACKGROUND_LIGHT",
@@ -23,13 +16,10 @@
 	"export src/mesh-sniff.js#looksLikeObj",
 	"export src/mesh-sniff.js#readFbxVersion",
 	"export src/object-catalog.jsx#default",
-	"export src/object-path.js#MAX_PATH_HEIGHT",
 	"export src/project.js#storeProjectHandle",
 	"export src/range-pin-panel.jsx#RANGE_PIN_TRACKS",
 	"export src/scene-asset-cache.js#loadAssetTexture",
 	"export src/scene-mesh-cache.js#loadMeshScene",
-	"export src/scenes.js#CHARACTER_SCALE_MAX",
-	"export src/scenes.js#CHARACTER_SCALE_MIN",
 	"export src/scenes.js#LEGACY_FRAME_FPS",
 	"export src/scenes.js#toTimelineFrame",
 	"export src/stage-attach-frames.js#ATTACH_BONE_NAMES",
@@ -55,7 +45,6 @@
 	"export src/stage-editor-gizmos.jsx#GizmoLabel",
 	"export src/stage-editor-gizmos.jsx#prepareRailBend",
 	"export src/ui-scrub.js#SCRUB_RANGE_STEPS",
-	"export src/use-semantic-state.js#useSemanticState",
 	"export src/workflow/AgentPanel.jsx#AGENT_PANEL_RAIL_WIDTH",
 	"export src/workflow/AgentPanel.jsx#AGENT_STATES",
 	"export src/workflow/video-contract.js#falVideoContract",

package/tools/loc-baseline.json

@@ -1,34 +1,33 @@
 {
-	"bin/agent/agent-routes.mjs": 865,
-	"bin/agent/agent-runner.mjs": 496,
-	"bin/agent/providers.mjs": 409,
+	"bin/agent/agent-routes.mjs": 804,
+	"bin/agent/agent-runner.mjs": 495,
+	"bin/agent/providers.mjs": 338,
 	"bin/agent/session-store.mjs": 324,
 	"bin/agent/supervisor.mjs": 283,
 	"bin/agent/video-adapters.mjs": 334,
-	"bin/cozyclay.mjs": 440,
+	"bin/cozyclay.mjs": 438,
 	"bin/live/cli.mjs": 456,
 	"mcp/live-hub.mjs": 529,
 	"mcp/tool-handlers.mjs": 1730,
-	"mcp/verify-live-batch.mjs": 486,
+	"mcp/verify-live-batch.mjs": 485,
 	"mcp/verify-live-capture.mjs": 268,
 	"mcp/verify-live-controller.mjs": 340,
 	"mcp/verify-live-p0.mjs": 264,
 	"mcp/verify-live.mjs": 416,
-	"src/analytics.js": 1169,
-	"src/App.jsx": 4711,
-	"src/asset-pane.jsx": 648,
+	"src/analytics.js": 1038,
+	"src/App.jsx": 4476,
+	"src/asset-pane.jsx": 643,
 	"src/camera-follow.js": 505,
 	"src/camera-move.js": 289,
-	"src/camera-tutorial.jsx": 443,
-	"src/command-bus.js": 378,
-	"src/controls.jsx": 340,
+	"src/command-bus.js": 356,
+	"src/controls.jsx": 330,
 	"src/domains/cast.js": 717,
-	"src/domains/motion.js": 812,
+	"src/domains/motion.js": 806,
 	"src/domains/objects.js": 907,
-	"src/domains/scenes.js": 754,
+	"src/domains/scenes.js": 740,
 	"src/domains/shots.js": 411,
-	"src/dualview.jsx": 371,
-	"src/hierarchy-panel.jsx": 779,
+	"src/dualview.jsx": 365,
+	"src/hierarchy-panel.jsx": 777,
 	"src/live-control.js": 338,
 	"src/matte-editor.js": 486,
 	"src/matte.js": 472,
@@ -36,41 +35,41 @@
 	"src/motion/fix-collisions.js": 748,
 	"src/motion/ik.js": 1135,
 	"src/motion/range-pin.js": 277,
-	"src/motion/timeline.jsx": 2047,
-	"src/object-gizmo.jsx": 824,
+	"src/motion/timeline.jsx": 2042,
+	"src/object-gizmo.jsx": 740,
 	"src/object-path.js": 410,
 	"src/panels/ObjectTransformPanel.jsx": 545,
 	"src/panels/SculptPanel.jsx": 370,
 	"src/planview.jsx": 887,
 	"src/poses.js": 321,
 	"src/posestudio.jsx": 1240,
-	"src/project-browser.jsx": 401,
+	"src/project-browser.jsx": 371,
 	"src/project.js": 603,
-	"src/props.jsx": 417,
+	"src/props.jsx": 414,
 	"src/range-pin-panel.jsx": 305,
 	"src/scene-assets.js": 400,
 	"src/scene-mesh.js": 350,
-	"src/scene-objects.js": 1136,
-	"src/scenes.js": 387,
+	"src/scene-objects.js": 1134,
+	"src/scenes.js": 385,
 	"src/sculpt-compare.js": 357,
 	"src/sculpt-recipe.js": 363,
 	"src/sculpt-run.js": 309,
 	"src/shell/BoardSlot.jsx": 316,
 	"src/shell/BottomDock.jsx": 416,
 	"src/shell/DetailsSlot.jsx": 334,
-	"src/shell/MenuBar.jsx": 640,
-	"src/shell/PreferencesDialog.jsx": 466,
+	"src/shell/MenuBar.jsx": 632,
+	"src/shell/PreferencesDialog.jsx": 269,
 	"src/shell/ViewportToolbar.jsx": 567,
-	"src/shot-authoring.js": 348,
-	"src/stage-canvas-rigs.jsx": 352,
+	"src/shot-authoring.js": 345,
+	"src/stage-canvas-rigs.jsx": 350,
 	"src/stage-editor-gizmos.jsx": 1116,
-	"src/studio-agent-commands.js": 492,
-	"src/studio-agent-protocol.js": 486,
+	"src/studio-agent-commands.js": 487,
+	"src/studio-agent-protocol.js": 480,
 	"src/studio-app-binding.js": 346,
-	"src/ui.jsx": 393,
-	"src/workflow/agent-client.js": 1386,
-	"src/workflow/AgentPanel.jsx": 880,
+	"src/ui.jsx": 385,
+	"src/workflow/agent-client.js": 1369,
+	"src/workflow/AgentPanel.jsx": 811,
 	"src/workflow/WorkflowBuilder.jsx": 592,
 	"tools/qa/css-rule-usage.mjs": 251,
-	"tools/run-tests.mjs": 448
+	"tools/run-tests.mjs": 441
 }