cozyclay 2.1.1 → 3.0.0

package/src/agent-progress.js

@@ -0,0 +1,79 @@
+// What the agent's motion work looks like while it runs, for the user's eyes. Every motion.compile publishes its
+// draft here, installed or not: the take it baked, its QA (total, groups, goals) and its beats (timeline). The
+// images the agent asks to see (verify_result) are published here too. The viewport plays the latest draft as a
+// ghost, the timeline lays out its beats, and the agent panel draws the QA trend, the goals and the images.
+// In-page only: nothing here is saved with the project, undone, or sent to the agent. Each character keeps its
+// last KEEP drafts; the images keep the last KEEP. A new agent turn starts clean (clearProgress).
+
+const KEEP = 12;
+const drafts = new Map(), sheets = [], listeners = new Set();
+let version = 0, counter = 0;
+
+function emit() {
+	version++;
+	for (const listener of [...listeners]) {
+		try { listener(); } catch { /* a broken view never stops the agent */ }
+	}
+}
+
+const pick = (row, keys) => Object.fromEntries(keys.filter(k => row?.[k] !== undefined).map(k => [k, row[k]]));
+
+/**
+ * publishDraft(characterId, { take, installed, specId, label, qa, timeline }) -> the stored draft:
+ * { n (1, 2, ... per character), at (ms), characterId, take, frames, installed, specId, label,
+ *   qa: { ok, total, groups: [{ kind, subject, count, first, last, worst }], goals: [{ name, kind, ok, value, need, at }] },
+ *   timeline: the compile's beats (pipeline.js timelineOf) }.
+ */
+export function publishDraft(characterId, { take, installed = false, specId = null, label = null, qa = null, timeline = [] }) {
+	const list = drafts.get(characterId) ?? [];
+	const draft = Object.freeze({
+		n: (list.at(-1)?.n ?? 0) + 1, at: Date.now(), seq: ++counter, characterId, take, frames: take?.frameCount ?? 0,
+		installed: !!installed, specId, label,
+		qa: { ok: !!qa?.ok, total: qa?.total ?? 0,
+			groups: (qa?.groups ?? []).map(g => pick(g, ["kind", "subject", "count", "first", "last", "worst"])),
+			goals: (qa?.goals ?? []).map(g => pick(g, ["name", "kind", "ok", "value", "need", "at"])) },
+		timeline: timeline ?? [],
+	});
+	drafts.set(characterId, [...list, draft].slice(-KEEP));
+	emit();
+	return draft;
+}
+
+/** The drafts of a character, oldest first (at most KEEP). */
+export const draftsOf = characterId => drafts.get(characterId) ?? [];
+
+/** The newest draft of a character, or of any character when none is named; null when there is none. */
+export function latestDraft(characterId) {
+	if (characterId !== undefined) return draftsOf(characterId).at(-1) ?? null;
+	let best = null;
+	for (const list of drafts.values()) if (list.length && (!best || list.at(-1).seq > best.seq)) best = list.at(-1);
+	return best;
+}
+
+/** publishSheet({ characterId, dataUrl, width, height, caption, frames }) -> the stored image record. */
+export function publishSheet({ characterId = null, dataUrl, width = 0, height = 0, caption = "", frames = [] }) {
+	const sheet = Object.freeze({ at: Date.now(), seq: ++counter, characterId, dataUrl, width, height, caption, frames });
+	sheets.push(sheet);
+	sheets.splice(0, Math.max(0, sheets.length - KEEP));
+	emit();
+	return sheet;
+}
+
+/** The published images, oldest first (at most KEEP). */
+export const progressSheets = () => [...sheets];
+
+/** Forget every draft and image (a new agent turn). */
+export function clearProgress() {
+	drafts.clear();
+	sheets.length = 0;
+	emit();
+}
+
+/** subscribeProgress(listener) -> unsubscribe; with progressVersion it fits React's useSyncExternalStore. */
+export function subscribeProgress(listener) {
+	listeners.add(listener);
+	return () => { listeners.delete(listener); };
+}
+
+/** A number that changes on every publish or clear. */
+export const progressVersion = () => version;

package/src/agent-turn-mark.js

@@ -0,0 +1,30 @@
+// The agent turn's controls, and its mark. One user message is one editor transaction
+// (#702, #715): every edit of the turn lands in one composed session, so the message is one
+// undo step. A script runs inside that turn, after edits the same message already made (an
+// installed take, a placed set). When the script fails, only its own edits roll back:
+// agent.turn.mark records where it starts, and agent.turn.rollback restores exactly what came
+// after the mark and leaves the turn open, so the earlier edits still land with the turn.
+import { StudioProtocolError } from './studio-agent-protocol.js';
+
+const TURN_CONTROLS = ['begin', 'mark', 'rollback', 'finish', 'cancel'];
+/** The wire schema of each agent.turn.* control: the owning turn's id, nothing else. */
+export const agentTurnControls = (object, identifier) => Object.fromEntries(TURN_CONTROLS.map(verb => [`agent.turn.${verb}`, object({ turnId: identifier })]));
+
+/**
+ * agent.turn.mark or agent.turn.rollback on the open turn. Answers the transaction its receipt
+ * describes: a mark affects nothing, a rollback names the ids the rolled-back edits touched.
+ * The bus adds each later edit's ids to `turn.mark.since`.
+ */
+export function markAgentTurn(id, turn) {
+  if (id === 'agent.turn.mark') {
+    turn.mark = { point: turn.session?.savepoint() ?? null, affectedIds: new Set(turn.affectedIds), since: new Set() };
+    return { txId: turn.txId, affectedIds: [], toasts: [] };
+  }
+  const { mark } = turn;
+  if (!mark) throw new StudioProtocolError('STALE_TARGET', 'The agent turn has no mark to roll back to.');
+  turn.mark = null;
+  // No session at the mark: everything the turn authored came after it.
+  turn.session?.rollback(mark.point ?? undefined);
+  turn.affectedIds = mark.affectedIds;
+  return { txId: turn.txId, affectedIds: [...mark.since], toasts: [] };
+}

package/src/analytics.js

@@ -905,7 +905,7 @@ function runtimeConfig() {
 function isLoopbackOrigin(origin) {
 	try {
 		const parsed = new URL(origin);
-		return parsed.protocol === "http:" && parsed.hostname === "127.0.0.1";
+		return parsed.protocol === "http:" && ["127.0.0.1", "localhost"].includes(parsed.hostname);
 	} catch {
 		return false;
 	}
@@ -1051,17 +1051,10 @@ export async function initAnalytics() {
 			void recordDeviceProfile();
 			if (resolved.distribution === "npm") {
 				track("app:session_started");
-				// This follows the session marker so the two events form one
-				// capability baseline in funnel queries.
-				void recordMotionBackendState();
 				if (resolved.firstLaunch) {
 					const heardFrom = resolved.firstLaunchHeardFrom;
 					track("install:first_launch", heardFrom ? { heard_from: heardFrom } : {});
 				}
-			} else {
-				// Hosted sessions have PostHog's native session marker rather than
-				// the npm-only custom event above.
-				void recordMotionBackendState();
 			}
 		} catch {
 			console.info("[analytics] initialization failed");
@@ -1070,17 +1063,6 @@ export async function initAnalytics() {
 	await initPromise;
 }
 
-async function recordMotionBackendState() {
-	let health = null;
-	try {
-		const response = await fetch("/ardy/health", { signal: AbortSignal.timeout(5000) });
-		if (response.ok) health = await response.json();
-	} catch {
-		// No bridge is a normal hosted/demo state.
-	}
-	track("motion:backend_state", motionBackendState(health));
-}
-
 export function track(event, props = {}) {
 	if (!initialized || !enabled || !posthog) return;
 	try {

package/src/app-context.js

@@ -98,6 +98,11 @@ export function createAppContext({
         closed = true; activeComposition = null;
         return remember(changed);
       },
+      // A savepoint inside the open composition (a script inside an agent turn): rollback(point)
+      // restores each owner to it, and an owner first touched after it to where it began. The
+      // composition stays open, so edits made before the savepoint still land with it.
+      savepoint() { check(); return new Map([...members].map(([handle, row]) => [handle, row.session.mark()])); },
+      rollback(point = new Map()) { check(); for (const [handle, row] of [...members].reverse()) row.session.rollback(point.get(handle)); },
       cancel(options) {
         if (closed) return false;
         closed = true; activeComposition = null;

package/src/app-stage.jsx

@@ -22,8 +22,6 @@ export {
 	characterModelUrl,
 	CHARACTER_MODEL_LABELS,
 	nextCharacterId,
-	DEMO_MOTION_URL,
-	DEMO_MOTION_PROMPT,
 	OBJECT_DELETE_UNDO_MS,
 	ASSET_DELETE_UNDO_MS,
 	CLAY,
@@ -64,7 +62,7 @@ export {
 
 export * from "./stage-attach-frames.js";
 
-export { Character, MotionTrails } from "./stage-characters.jsx";
+export { Character } from "./stage-characters.jsx";
 
 export {
 	ShotRig,
@@ -105,40 +103,10 @@ export {
 } from "./stage-capture.jsx";
 export {
 	TIMELINE_FPS,
-	ARDY_FPS,
-	toArdyFrame,
-	posePlacementFrame,
-	toArdyFrameEntries,
-	toArdySegments,
 	DEFAULT_DURATION_S,
 	DEFAULT_PLAYBACK_SPEED,
-	BRIDGE_RECHECK_MS,
-	ARDY_PROMPT_HORIZON_FRAMES,
 	MAX_WAYPOINTS,
-	ARDY_PROMPT_MAX,
-	ARDY_DURATION_MIN,
-	ARDY_DURATION_MAX,
-	ARDY_SEED_MAX,
-	ARDY_PRESERVE_DEFAULT,
-	DEFAULT_PROMPT_CLIPS,
-	buildPromptSchedule,
-	ikTracksInRange,
-	PRESERVE_TRACK_LIMBS,
-	PRESERVE_LIMB_ORDER,
-	preserveLimbLabel,
-	preserveTracksSummary,
-	LINE_EDIT_TRACK_OPTIONS,
-	lineTrackLabel,
-	LINE_EDIT_DEFAULT_TRACK,
-	LINE_CURVE_MARKER_STRIDE,
-	MIN_CURVE_POINTS,
-	LINE_PREVIEW_DEBOUNCE_MS,
-	LINE_CAPABILITY_RETRY_MS,
-	LINE_EDIT_REFUSALS,
-	LINE_CURVE_REFUSALS,
-	MULTIMODEL_REASONS,
-	MULTIMODEL_SAMPLE_FPS,
-} from "./ardy-bridge-contract.js";
+} from "./timeline-defaults.js";
 
 /* ------------------------------------------------------------------ 3D --- */
 

package/src/asset-pane.jsx

@@ -3,7 +3,7 @@ import { ko } from "./locale.js";
 import { CHARACTER_MODEL_IDS, PROXY_FIGURE_MODEL } from "./scenes.js";
 import { OBJECT_LIBRARY } from "./scene-objects.js";
 import { displayObjectLabel } from "./object-catalog.jsx";
-import { assetAspect, isMeshAssetId, isSupportedMeshType } from "./scene-assets.js";
+import { assetAspect, isImageAssetId, isMeshAssetId, isSupportedMeshType } from "./scene-assets.js";
 import { assetKind, formatAssetBytes } from "./asset-shelf.js";
 import { assetRecord } from "./scene-asset-cache.js";
 import ResourceStatus from "./resource-status.jsx";
@@ -99,14 +99,15 @@ function loadThumb(id) {
 			// card hides. A present record whose bytes fail below resolves null
 			// instead, and the card stays visible so it can be deleted.
 			if (!record) return undefined;
-			if (isMeshAssetId(record.id) || isSupportedMeshType(record.type)) {
+			// An HDR environment file (hdr- id) is no picture either: it gets the same generic card.
+			if (!isImageAssetId(record.id) || isSupportedMeshType(record.type)) {
 				// A GLB is not a picture. Decoding it as one would mark every
 				// model "unreadable" in Manage storage — show a generic cube
 				// instead, using the same card preview the catalogue already has.
 				return {
 					name: record.name,
 					bytesLabel: formatAssetBytes(record.bytes.byteLength),
-					kind: "mesh",
+					kind: isMeshAssetId(record.id) || isSupportedMeshType(record.type) ? "mesh" : "environment",
 					mesh: true,
 				};
 			}
@@ -167,7 +168,7 @@ function StorageAssetRow({ id, onDelete, deleting, usageCount = 0, graphSignatur
 	const usageLabel = ko(`Used by ${usageCount} scene object${usageCount === 1 ? "" : "s"}`, `${usageCount}개 씬 오브젝트에서 사용 중`);
 	const deleteLabel = ko(`Delete ${name} from storage`, `${name}을(를) 저장소에서 삭제`);
 	const confirmationId = `asset-storage-warning-${id}`;
-	const kindLabel = thumb?.kind === "mesh" ? ko("Model", "모델") : thumb?.kind === "matte" ? ko("Matte", "매트") : ko("Image", "이미지");
+	const kindLabel = thumb?.kind === "mesh" ? ko("Model", "모델") : thumb?.kind === "environment" ? ko("HDR environment", "HDR 환경") : thumb?.kind === "matte" ? ko("Matte", "매트") : ko("Image", "이미지");
 	return (
 		<li className="asset-storage-row">
 			{mesh ? (
@@ -486,7 +487,7 @@ export function FolderGrid({ folder, query, ...props }) {
 					/>
 				);
 			});
-		if (!takeVersions.length) empty = ko("No takes for this character yet. Generate Motion creates one.", "이 인물의 테이크가 아직 없어요. Generate Motion으로 만들 수 있어요.");
+		if (!takeVersions.length) empty = ko("No takes for this character yet. Ask the agent to compile one.", "이 인물의 테이크가 아직 없어요. 에이전트에게 모션 컴파일을 요청하세요.");
 	} else if (folder === "poses") {
 		tiles = poses.map((pose, index) => ({ pose, index, label: pose?.name || pose?.label || ko(`Pose ${index + 1}`, `포즈 ${index + 1}`) }))
 			.filter(({ label }) => matchesQuery(label, query))

package/src/camera-block.js

@@ -59,6 +59,26 @@ function cloneRailFollow(value) {
 	return null;
 }
 
+/**
+ * What a rail shot's head holds: up to 4 cast ids (their middle, frame by
+ * frame, at their chest or at a world height) or one world point. Null = the follow subject (every older shot).
+ * Like the crane, an aim and a lens of its own (focalMm) ride the rail and
+ * are left out of the block without one, so untouched shots stay byte-stable.
+ */
+function cloneRailAim(value) {
+	const ids = Array.isArray(value?.ids) ? value.ids.filter((id) => typeof id === "string" && id).slice(0, 4) : [];
+	if (ids.length) return Number.isFinite(value.height) ? { ids, height: value.height } : { ids };
+	const point = value?.point;
+	return point && [point.x, point.y, point.z].every(Number.isFinite) ? { point: { x: point.x, y: point.y, z: point.z } } : null;
+}
+
+/** The aim and lens fields a block with a rail carries (none without one). */
+export function railShotFields(value, cameraRail) {
+	const aim = cameraRail ? cloneRailAim(value.aim) : null;
+	const focalMm = cameraRail && Number.isFinite(value.focalMm) && value.focalMm > 0 ? value.focalMm : null;
+	return { ...(aim ? { aim } : {}), ...(focalMm ? { focalMm } : {}) };
+}
+
 /** Build a complete block from a partial or stored camera value. */
 export function createCameraBlock(input = {}) {
 	const value = input && typeof input === "object" ? input : {};
@@ -82,6 +102,7 @@ export function createCameraBlock(input = {}) {
 		railFollow: cloneRailFollow(value.railFollow),
 		craneHeight,
 		dollyTiming: timingIsFlat(dollyTiming) ? null : dollyTiming,
+		...railShotFields(value, cameraRail),
 	};
 }
 

package/src/camera-direction.js

@@ -0,0 +1,120 @@
+// Pure camera direction helpers shared by playback, export and the agent's
+// receipts: the per-frame follow/rail camera of every shot, where a rail
+// shot's head aims, and the stops a chain of camera keys makes.
+
+import { createCameraBlock } from "./camera-block.js";
+import { buildFollowTrack, buildRail, buildRailFollowTrack } from "./camera-follow.js";
+import { shortestArc } from "./camera-move.js";
+import { RAIL_SCHEDULE_LEGACY, RAIL_SCHEDULE_RANGE, resolveRailSchedule } from "./camera-rail-schedule.js";
+import { shotAtFrame } from "./cuts.js";
+import { objectTransformAt } from "./object-path.js";
+import { placementAt } from "./root-path.js";
+import { sampleAt } from "./sample-at.js";
+import { SUBJECT_HEIGHT_M, focalMmToFov } from "./shot.js";
+import { takeHips } from "./motion3/take.js";
+
+const DEG = Math.PI / 180;
+/** where a character's aim sits on its body: chest height, as a share of its stature, or above a take's hips */
+const CHEST = 0.75, HIPS_TO_CHEST = 0.35;
+
+/**
+ * The follow and rail cameras of every shot, one sample per timeline frame
+ * (null where a shot keys its camera or its rail is off). A rail shot with
+ * an aim holds that aim instead of the follow subject and runs its rail on
+ * schedule (no distance pull, no pitch offset), with its own lens when the
+ * block names one. aimAt(id, frame) answers one cast member's aim point.
+ */
+export function buildShotCameraTracks({ shots, subjectTrack, fps, yawDeg = 0, aimAt = () => null, filmback = {} }) {
+	const combined = new Array(subjectTrack.length).fill(null);
+	const initialDir = { x: Math.sin(yawDeg * DEG), z: Math.cos(yawDeg * DEG) };
+	for (const shot of shots) {
+		const camera = createCameraBlock(shot.camera);
+		if (camera.mode === "keys") continue;
+		const start = shot.startFrame, subjectSlice = subjectTrack.slice(start, Math.min(subjectTrack.length, shot.endFrame + 1));
+		const params = { ...camera.followCam, craneHeight: camera.craneHeight, dollyTiming: camera.dollyTiming, initialDir };
+		const rail = camera.mode === "rail" ? buildRail(camera.cameraRail) : null;
+		if (!rail) {
+			buildFollowTrack(subjectSlice, fps, params).forEach((sample, offset) => { combined[start + offset] = sample; });
+			continue;
+		}
+		const schedule = resolveRailSchedule({ railFollow: camera.railFollow, cameraRail: camera.cameraRail, frameCount: subjectSlice.length });
+		if (schedule.kind !== RAIL_SCHEDULE_RANGE && schedule.kind !== RAIL_SCHEDULE_LEGACY) continue;
+		const from = start + schedule.startFrame, length = schedule.endFrame - schedule.startFrame + 1;
+		const aim = camera.aim ? Array.from({ length }, (_, offset) => railAimPoint(camera.aim, from + offset, aimAt)) : null;
+		const aimed = aim?.every(Boolean) ? aim : null;
+		const track = aimed
+			? buildRailFollowTrack(aimed, fps, rail, { ...params, aimHeight: aimed.reduce((sum, point) => sum + point.y, 0) / length, distanceInfluence: 0, pitchOffsetDeg: 0 })
+			: buildRailFollowTrack(subjectSlice.slice(schedule.startFrame, schedule.endFrame + 1), fps, rail, params);
+		const fovDeg = camera.focalMm ? focalMmToFov(camera.focalMm, filmback.sensorId, filmback.aspectRatio) / DEG : null;
+		track.forEach((sample, offset) => { combined[from + offset] = fovDeg ? { ...sample, fovDeg } : sample; });
+	}
+	return combined;
+}
+
+/** A rail aim at one frame: its world point, or the middle of its cast (null when one is missing). */
+function railAimPoint(aim, frame, aimAt) {
+	if (aim.point) return aim.point;
+	const points = aim.ids.map((id) => aimAt(id, frame));
+	if (points.some((point) => !point)) return null;
+	const mean = (axis) => points.reduce((sum, point) => sum + point[axis], 0) / points.length;
+	return { x: mean("x"), y: aim.height ?? mean("y"), z: mean("z") };
+}
+
+/**
+ * One cast member's aim point at a frame: a character's chest where its take
+ * (or placement) puts it, an object's middle where its route (or placement)
+ * puts it. clipOf(character) is the take the character plays.
+ */
+export function castAimPoint(id, frame, { characters = [], objects = [], shots = [], clipOf = () => null, frameCount, fps }) {
+	const character = characters.find((entry) => entry.id === id);
+	if (character) {
+		const clip = clipOf(character), scale = character.scale ?? 1, yaw = (character.rot ?? 0) * DEG;
+		// A take v3 moves the hips in the character's placement frame (motion3/take.js), not its root.
+		if (clip?.hips) {
+			const [x, y, z] = takeHips(clip, frame);
+			return { x: character.x + (x * Math.cos(yaw) + z * Math.sin(yaw)) * scale, y: (character.y ?? 0) + (y + HIPS_TO_CHEST) * scale, z: character.z + (-x * Math.sin(yaw) + z * Math.cos(yaw)) * scale };
+		}
+		const at = placementAt(character, frame, { shotAt: (at) => shotAtFrame(shots, at),
+			takeRoot: clip ? sampleAt({ frameCount: clip.frames, motion: clip }, null, frame).subject : null });
+		return { x: at.x, y: (character.y ?? 0) + CHEST * SUBJECT_HEIGHT_M * (character.scale ?? 1), z: at.z };
+	}
+	const object = objects.find((entry) => entry.id === id);
+	if (!object) return null;
+	const at = objectTransformAt(object, frame, { frameCount, fps }) ?? object;
+	return { x: at.x, y: at.y + ((object.height ?? 0) * (object.scaleY ?? 1)) / 2, z: at.z };
+}
+
+/** The follow subject's path, where its take v3 moves its body rather than its root (a follow or
+ * aimless rail camera keeps up with the walk); any other subject keeps the path it has. */
+export function followSubjectTrack(subjectTrack, subjectId, cast) {
+	const character = cast.characters?.find((entry) => entry.id === subjectId);
+	if (!subjectTrack || !character || !cast.clipOf(character)?.hips) return subjectTrack;
+	return subjectTrack.map((point, frame) => castAimPoint(subjectId, frame, cast) ?? point);
+}
+
+/**
+ * The frames of the keys a camera halts at for no reason: an interior key the
+ * move runs on through in the same direction. Every key eases in and out, so
+ * the camera slows to a stop there; a hold, a reversal or a new direction is
+ * a stop the shot means and is not listed.
+ */
+export function cameraKeyStops(keys = []) {
+	const steps = keys.slice(1).map((key, index) => {
+		const a = keys[index].framing, b = key.framing;
+		return [b.pos.x - a.pos.x, b.pos.y - a.pos.y, b.pos.z - a.pos.z, shortestArc(a.yaw, b.yaw), b.pitch - a.pitch, (b.fovDeg - a.fovDeg) * DEG];
+	});
+	const length = (step) => Math.hypot(...step);
+	return keys.slice(1, -1).filter((_, index) => {
+		const u = steps[index], v = steps[index + 1], dot = u.reduce((sum, value, axis) => sum + value * v[axis], 0);
+		return length(u) > 0.02 && length(v) > 0.02 && dot > 0.5 * length(u) * length(v);
+	}).map((key) => key.frame);
+}
+
+/** A receipt warning for a shot whose camera keys halt a move (none when they do not). */
+export function cameraKeyWarnings(shot) {
+	const stops = cameraKeyStops(shot.cameraKeys);
+	if (!stops.length) return [];
+	const listed = `${stops.slice(0, 4).join(", ")}${stops.length > 4 ? ` +${stops.length - 4}` : ""}`;
+	return [{ code: "CAMERA_KEY_STOPS", id: shot.id, count: stops.length,
+		message: `Camera stops at keys ${listed} (keys ease in/out); use a rail (shot.setCameraRail) or 2 keys.`.slice(0, 120) }];
+}

package/src/character-kind.js

@@ -6,7 +6,7 @@ import { isProxyFigure } from "./scenes.js";
 import { isKo } from "./locale.js";
 import { StudioProtocolError } from "./studio-agent-protocol.js";
 
-export const CHARACTER_CAPABILITIES = Object.freeze(["rig", "ik", "pose", "motion", "mocap", "physics", "trails", "lineEdit"]);
+export const CHARACTER_CAPABILITIES = Object.freeze(["rig", "ik", "pose", "motion"]);
 const PROXY_BODY_RADIUS = 0.22;
 const PROXY_BODY_HEIGHT = 1.45;
 const PROXY_HEAD_RADIUS = 0.12;
@@ -36,7 +36,7 @@ export function proxyFigureBounds(character, placement = character) {
 	return { min, max };
 }
 
-/** `{ rig, ik, pose, motion, mocap, physics, trails, lineEdit }` - all false
+/** `{ rig, ik, pose, motion }` - all false
  * for a capsule figure, all true for a rigged character. */
 export function characterCapabilities(character) {
 	const rigged = !isProxyFigure(character);
@@ -48,13 +48,7 @@ const FEATURE_LABELS = {
 	rig: ["the rig", "리그"],
 	ik: ["IK", "IK"],
 	pose: ["Pose mode", "포즈 모드"],
-	motion: ["Motion generation", "모션 생성"],
-	mocap: ["Motion capture", "모션 캡처"],
-	photoPose: ["Photo pose", "사진 포즈"],
-	physics: ["Physics", "물리 보정"],
-	collision: ["Collision cleanup", "충돌 정리"],
-	trails: ["Motion trails", "궤적선"],
-	lineEdit: ["Line edit", "라인 편집"],
+	motion: ["Compiled motion", "모션 컴파일"],
 	take: ["Loading a take", "테이크 불러오기"],
 };
 

package/src/command-bus.js

@@ -3,6 +3,7 @@
 // idempotency. Synchronous UI actions stay synchronous (including user gestures).
 import { HISTORY_LIMIT } from './history.js';
 import { StudioProtocolError, StudioSchemas, validateStudioSchema, validateReceipt, validateStudioIdentity } from './studio-agent-protocol.js';
+import { agentTurnControls, markAgentTurn } from './agent-turn-mark.js';
 
 // A batching/retention adapter over the existing object history owner. The
 // native store still owns every snapshot and transition; this tracks only the
@@ -62,9 +63,7 @@ export function createCommandBus({ registry, ports }) {
   const object = properties => ({ type: 'object', properties, required: Object.keys(properties), additionalProperties: false });
   const argsSchema = { type: 'object', properties: {}, required: [], additionalProperties: true };
   const controls = {
-    'agent.turn.begin': object({ turnId: identifier }),
-    'agent.turn.finish': object({ turnId: identifier }),
-    'agent.turn.cancel': object({ turnId: identifier }),
+    ...agentTurnControls(object, identifier),
     'run.begin': object({ id: identifier, args: argsSchema }),
     'run.update': object({ txId: identifier, args: argsSchema }),
     'run.commit': object({ txId: identifier }),
@@ -94,6 +93,8 @@ export function createCommandBus({ registry, ports }) {
       }
       if (agentTurn?.txId !== args.turnId) fail('STALE_TARGET', 'The agent turn is no longer open.');
       const turn = agentTurn;
+      // A script's mark, and the rollback to it that keeps the turn open (agent-turn-mark.js).
+      if (id === 'agent.turn.mark' || id === 'agent.turn.rollback') return transactionReceipt(id, markAgentTurn(id, turn), request, before);
       // A rolled-back turn restores every owner it touched and leaves no entry.
       if (id === 'agent.turn.cancel') { agentTurn = null; turn.session?.cancel(); return transactionReceipt(id, turn, request, before); }
       try { turn.historyEntryId = turn.session?.commit().historyEntryId; }
@@ -219,7 +220,7 @@ export function createCommandBus({ registry, ports }) {
     if (entry.kind === 'mutation' && changed && !historyEntryId && !turn) fail('UNCERTAIN_APPLY', `${entry.id} changed the scene without one undoable entry.`);
     const completed = entry.kind === 'job' || entry.kind === 'document' || (entry.kind === 'mutation' && changed && (turn || after.revision > before.revision + 1));
     const ids = completed || changed ? result.affectedIds : entry.kind === 'transient' ? [before.host.sceneId] : [];
-    if (turn && changed) for (const id of ids) turn.affectedIds.add(id);
+    if (turn && changed) for (const id of ids) { turn.affectedIds.add(id); turn.mark?.since.add(id); }
     const build = level => validateReceipt({ ok: true, commandId: request.commandId, receiptId: crypto.randomUUID(), host: before.host,
       action: entry.id, summary: result.summary, status: completed ? 'completed' : entry.kind === 'transient' ? 'transient' : changed ? 'applied' : 'noop',
       authored: changed, ...(completed ? { kind: entry.kind, ...(result.output === undefined ? {} : { output: result.output }), ...(same(before.host, after.host) ? {} : { nextHost: after.host }) } : entry.kind === 'transient' ? { view: { before: before.viewRevision ?? 0, after: after.viewRevision ?? 0 } } : { mutated: changed }),
@@ -292,8 +293,9 @@ export function createCommandBus({ registry, ports }) {
         // Job controls observe/cancel an admitted identity; completion itself
         // can advance the revision while their wire request is in transit.
         // Document identity and the job's own publication fence still apply.
-        if (!['job.await', 'job.cancel', 'agent.turn.finish', 'agent.turn.cancel'].includes(id) && request.expectedRevision !== before.revision) fail('STALE_SCENE', 'Authored state changed; obtain fresh intent.');
-        if (before.busy && !turn && !transactions.has(validated.txId) && !id.startsWith('job.')) fail('TARGET_BUSY', 'Finish the current editor gesture first.');
+        // A readOnly action (declared data, e.g. motion.qa) only measures: no revision or gesture fence, the host check above still holds.
+        if (!entry?.readOnly && !['job.await', 'job.cancel', 'agent.turn.mark', 'agent.turn.rollback', 'agent.turn.finish', 'agent.turn.cancel'].includes(id) && request.expectedRevision !== before.revision) fail('STALE_SCENE', 'Authored state changed; obtain fresh intent.');
+        if (!entry?.readOnly && before.busy && !turn && !transactions.has(validated.txId) && !id.startsWith('job.')) fail('TARGET_BUSY', 'Finish the current editor gesture first.');
       }
       if (controls[id]) return mapResult(control(id, validated, request, before), remember, rejected);
       if (transactions.size) fail('TARGET_BUSY', 'Finish or cancel the open command transaction first.');

package/src/commands/cast.js

@@ -9,8 +9,7 @@ import { createCharacterEntry, CHARACTER_KIND_IDS, POSTURES, PROXY_FIGURE_MODEL,
 import { KIND_FIXED_REFUSAL } from '../character-kind.js';
 import { track } from '../analytics.js';
 import { DEFAULT_POSE } from '../poses.js';
-import { createStableItemId, updateStableItem, removeStableItem } from '../stable-items.js';
-import { movePromptClipFrames } from '../ardy/prompt-clips.js';
+import { createStableItemId } from '../stable-items.js';
 import { STUDIO_TOOL_SCHEMAS, StudioSchemas } from '../studio-agent-protocol.js';
 
 const id = StudioSchemas.TargetGuard.properties.targetId;
@@ -21,7 +20,7 @@ const record = { type: 'object', properties: {}, additionalProperties: true };
 const newCharacter = { ...record, properties: { model: { type: 'string', enum: [...CHARACTER_KIND_IDS] }, posture: { type: 'string', enum: [...POSTURES] } }, required: [] };
 const characterPatch = { ...record, properties: { posture: { type: 'string', description: `One of ${POSTURES.join(', ')}; anything else stands.` } }, required: [] };
 const mutation = (id, label, schema, exposure = 'open') => ({ id, label, description: label, kind: 'mutation', undoDomain: 'cast', input: schema, exposure });
-const blocks = elementSetSchema('character').properties.set.properties.layer.properties.promptClips;
+
 const semantic = [
 	mutation('character.set', 'Set character fields', elementSetSchema('character')),
 	mutation('character.add', 'Add character', input({ character: newCharacter })),
@@ -29,7 +28,7 @@ const semantic = [
 	mutation('character.update', 'Update character', input({ characterId: id, patch: characterPatch })),
 	studioActionDeclaration('character.move'),
 	mutation('character.setPose', 'Set character pose', input({ characterId: id, pose: { oneOf: [id, record, { type: 'null' }] }, clearMotion: { type: 'boolean' } }, ['characterId', 'pose'])),
-	mutation('character.setPromptBlocks', 'Set prompt blocks', input({ characterId: id, blocks })),
+	
 	mutation('characters.arrange', 'Arrange characters', STUDIO_TOOL_SCHEMAS.arrange_characters),
 	mutation('cast.replace', 'Replace cast', input({ characters: { type: 'array', items: record, minItems: 1 } }), 'ui-only'),
 	mutation('cast.setCustomPoses', 'Set pose library', input({ poses: { type: 'array', items: record } }), 'ui-only'),
@@ -37,9 +36,6 @@ const semantic = [
 	mutation('cast.removePose', 'Remove saved pose', input({ id }), 'ui-only'),
 	mutation('cast.showExtras', 'Show extra subjects', input({ show: { type: 'boolean' } }), 'ui-only'),
 	mutation('cast.setLayer', 'Set character layer', input({ characterId: id, layer: record }), 'ui-only'),
-	...['add', 'move', 'resize', 'change', 'remove'].map(verb => mutation(`character.${verb}PromptBlock`, `${verb} prompt block`,
-		input({ characterId: id, id, frame: { type: 'number' }, edge: { type: 'string', enum: ['start', 'end'] }, text: { type: 'string', maxLength: 2000 } },
-			verb === 'add' ? ['characterId', 'frame'] : verb === 'remove' ? ['characterId', 'id'] : verb === 'change' ? ['characterId', 'id', 'text'] : verb === 'resize' ? ['characterId', 'id', 'edge', 'frame'] : ['characterId', 'id', 'frame']), 'ui-only')),
 ];
 export const declarations = Object.freeze([...semantic, ...["character.addWaypoint", "character.moveWaypoint", "character.removeWaypoint", "character.clearWaypoints"].map(studioActionDeclaration)]);
 
@@ -56,29 +52,6 @@ export function register(registry, ports) {
 		const object = ports.state().objects.find(row => row.id === value) ?? fail('STALE_TARGET', `Object ${value} is not in this scene.`);
 		if (object.attach) fail('INVALID_ARGUMENT', 'A character cannot be grouped under an object that a character carries.');
 	};
-	function promptEdit(command, args) {
-		const before = character(args.characterId), clips = before.layer.promptClips;
-		let next;
-		if (command === 'character.addPromptBlock') {
-			const snapped = Math.max(0, Math.round(args.frame / 48) * 48);
-			const blocked = clips.some(clip => snapped < clip.endFrame && snapped + 48 > clip.startFrame);
-			const startFrame = blocked ? Math.max(snapped, ...clips.map(clip => clip.endFrame)) : snapped;
-			next = [...clips, { id: createStableItemId('prompt-clip'), startFrame, endFrame: startFrame + 48, text: '' }];
-		} else if (command === 'character.removePromptBlock') next = removeStableItem(clips, args.id, 'promptClips');
-		else if (command === 'character.changePromptBlock') next = updateStableItem(clips, args.id, clip => ({ ...clip, text: args.text }), 'promptClips');
-		else if (command === 'character.movePromptBlock') next = movePromptClipFrames(clips, args.id, args.frame, 48);
-		else {
-			next = updateStableItem(clips, args.id, clip => {
-				const snapped = Math.max(0, Math.round(args.frame / 48) * 48);
-				return args.edge === 'start' ? { ...clip, startFrame: Math.min(Math.max(snapped, clip.endFrame - 120), clip.endFrame - 48) }
-					: { ...clip, endFrame: Math.min(Math.max(clip.startFrame + 48, snapped), clip.startFrame + 120) };
-			}, 'promptClips');
-			const resized = next.find(clip => clip.id === args.id);
-			if (next.some(clip => clip.id !== args.id && resized.startFrame < clip.endFrame && resized.endFrame > clip.startFrame)) return;
-		}
-		patch(args.characterId, { layer: { ...before.layer, promptClips: next } });
-		owner().extendTimeline(next.reduce((end, clip) => Math.max(end, clip.endFrame), 24));
-	}
 	const methods = {
 		'character.add': ({ character: value }) => {
 			const row = createCharacterEntry({ ...value, id: value.id ?? createStableItemId('character') }, owner().read().length);
@@ -94,9 +67,7 @@ export function register(registry, ports) {
 		},
 		'character.move': ({ characterId, ...value }) => patch(characterId, value),
 		'character.setPose': ({ characterId, pose: value, clearMotion }) => { character(characterId); owner().applyPose(characterId, pose(value), clearMotion); },
-		'character.setPromptBlocks': ({ characterId, blocks }) => {
-			const entry = character(characterId); patch(characterId, { layer: { ...entry.layer, promptClips: blocks } });
-		},
+		
 		'cast.replace': ({ characters }) => owner().write(characters),
 		'cast.setCustomPoses': ({ poses }) => owner().writeState(before => ({ ...before, customPoses: poses })),
 		'cast.savePose': ({ pose, characterId, clearMotion }) => {
@@ -127,7 +98,7 @@ export function register(registry, ports) {
 	for (const declaration of semantic.slice(1)) registry.register({ ...declaration, available: mounted, run(args, context) {
 		if (declaration.id === 'characters.arrange') { const plan = owner().arrange(args); return { affectedIds: plan.affectedIds, summary: 'Arranged characters.', checks: plan.checks, warnings: plan.warnings }; }
 		const before = owner().read();
-		if (declaration.id.endsWith('PromptBlock')) promptEdit(declaration.id, args); else methods[declaration.id](args);
+		methods[declaration.id](args);
 		// The Assets tile and the MCP live path report themselves; this is the agent and
 		// any other non-UI bus caller adding a capsule figure.
 		if (declaration.id === 'character.add' && context?.origin && context.origin !== 'ui' && isProxyFigure(owner().read().find(row => !before.some(prior => prior.id === row.id)))) track('cast:proxy_added', { surface: 'agent' });

package/src/commands/elements/character.js

@@ -5,7 +5,7 @@ import { registerElementKind } from '../elements.js';
 const elements = STUDIO_ELEMENTS.filter(row => row.path.startsWith('character.')).map(row => {
   const { min, max, gizmo, ...element } = row;
   if (row.path === 'character.position') return { ...element, documentPath: { x: 'x', y: 'y', z: 'z' } };
-  if (row.path === 'character.promptBlocks') return { ...element, documentPath: 'layer.promptClips' };
+  
   if (row.path === 'character.pose') return { ...element, readback: item => ({ text: item?.pose?.id ?? null }) };
   return element;
 });

package/src/commands/elements/motion.js

@@ -1,14 +1,9 @@
 import { registerElementKind } from '../elements.js';
-import { wrapAngle } from '../../scene-objects.js';
 
 const elements = [
-  ...['anchorX', 'anchorZ', 'rotationDeg'].map(field => ({ path: `motion.take.${field}`, type: 'number' })),
   { path: 'motion.take.prompt', type: 'string' },
   { path: 'motion.ikKeys', type: 'array', readOnly: true },
   { path: 'motion.takeRecipe', type: 'object', readOnly: true },
   { path: 'motion.takeVersions', type: 'array', readOnly: true },
 ];
-registerElementKind('motion', { collection: true, elements, normalize: row => ({ ...row, take: row.take && { ...row.take,
-  anchorX: Math.max(-240, Math.min(240, row.take.anchorX ?? 0)), anchorZ: Math.max(-240, Math.min(240, row.take.anchorZ ?? 0)),
-  rotationDeg: wrapAngle(row.take.rotationDeg ?? 0),
-} }) });
+registerElementKind('motion', { collection: true, elements, normalize: row => ({ ...row, take: row.take && { ...row.take } }) });