@a-t-h-i/bot-lobby 0.6.4 → 0.6.6

package/src/workflow/workflow.ts

@@ -49,6 +49,7 @@ import { assessReconnaissance, completionBlockers, decideReviewLoop, recordDecis
 import { detectSharedFiles, summarizeOutcomes } from "../master/synthesis.ts";
 import { tail, truncate } from "../text.ts";
 import { isAutoMode } from "../state/auto.ts";
+import { briefRejection } from "./brief.ts";
 import { assertNoPendingApprovals, pendingApprovals, requestApproval, resolveApproval } from "./approvals.ts";
 import { pingApproval } from "../pi/notify.ts";
 import { describeRun, runLogEntry } from "../pi/run-summary.ts";
@@ -59,6 +60,7 @@ import type { EffortRouter } from "../classifier/effort.ts";
 import { answerClarify } from "../classifier/triage.ts";
 import { appendMetrics, metricFromRun } from "../state/metrics.ts";
 import { markCommentsAddressed, pendingComments, readPlanComments } from "../state/comments.ts";
+import { fastNext, onFastTrack, parseRoster, qaRequired, qaStillDue, qaTookPart, rosterWords, trackSummary } from "./track.ts";
 
 export const ORCHESTRATE_ACTIONS = [
   "clarify",
@@ -76,6 +78,7 @@ export const ORCHESTRATE_ACTIONS = [
   "resume",
   "decide",
   "budget",
+  "track",
   "status",
   "cancel",
 ] as const;
@@ -112,6 +115,10 @@ export interface OrchestrateParams {
   note?: string;
   reason?: string;
   text?: string;
+  /** track: the path the task takes. */
+  track?: "fast" | "full";
+  /** track: who takes part (designer, backend, qa, researcher). */
+  roster?: string[];
 }
 
 export interface WorkflowDeps {
@@ -204,6 +211,7 @@ export function describeTask(task: Task): string {
     `${task.id} — state: ${task.state}${task.paused ? " (paused)" : ""}`,
     `Title: ${task.title}`,
     `Request: ${truncate(taskRequest(task), 200)}`,
+    task.track ? trackSummary(task.track) : "",
     task.domains.length > 0 ? `Domains: ${task.domains.join(", ")}` : "",
     `Review iterations: ${Object.entries(task.reviewIterations).map(([d, n]) => `${d}=${n}`).join(", ")}`,
     pendingApprovals(task).length > 0
@@ -512,10 +520,12 @@ function handlePlan(task: Task, params: OrchestrateParams, deps: WorkflowDeps):
   requireState(task, ["planning", ...AMEND_PLAN_STATES]);
   const plan = params.plan?.trim();
   if (!plan) throw new Error("plan requires the plan text");
-  const missing = validatePlan(plan);
+  // The fast track keeps a short plan: the full plan's required areas are the full workflow's.
+  const missing = onFastTrack(task) ? [] : validatePlan(plan);
   if (missing.length > 0) throw new Error(`plan is missing: ${missing.join(", ")}`);
   const amending = AMEND_PLAN_STATES.includes(task.state);
   task.plan = plan;
+  if (task.track?.autoPlan) delete task.track.autoPlan;
   writeFileEnsured(join(taskDirFor(deps.root, deps.configDir, task.id), "plan.md"), plan);
   const addressed = addressComments(task, deps);
   if (amending) {
@@ -570,7 +580,9 @@ function recordAdvisoryPushbacks(task: Task, entries: Array<{ pushback?: Pushbac
   }
 }
 
-function workerReport(outcome: WorkerOutcome, approvals: Approval[], pushback?: Approval): string {
+const FULL_NEXT = "Next: inspect the diff, then run action=qa once this domain's work is complete.";
+
+function workerReport(outcome: WorkerOutcome, approvals: Approval[], pushback?: Approval, next = FULL_NEXT): string {
   const { result, run, issues } = outcome;
   const objection = result.pushback;
   return [
@@ -593,7 +605,7 @@ function workerReport(outcome: WorkerOutcome, approvals: Approval[], pushback?:
     pushback && objection
       ? `Pushback recorded (${pushback.id}): ${truncate(objection.reason, 240)}. Resolve with action=resolve_approval before re-delegating ${result.domain}.`
       : "",
-    "Next: inspect the diff, then run action=qa once this domain's work is complete.",
+    next,
   ]
     .filter((line) => line.length > 0)
     .join("\n");
@@ -835,17 +847,46 @@ function absorbWorkerOutcome(task: Task, deps: WorkflowDeps, outcome: WorkerOutc
   const pushback = recordPushback(task, outcome);
   task.blockers = [...task.blockers.filter((blocker) => blocker.domain !== domain), ...outcome.result.blockers];
   updateScratchpad(deps, task, outcome);
-  const spent = timeReport(outcome);
-  return spent ? `${workerReport(outcome, approvals, pushback)}\n${spent}` : workerReport(outcome, approvals, pushback);
+  const grown = qaJoinsGrownFastTask(task, outcome);
+  const report = workerReport(outcome, approvals, pushback, onFastTrack(task) ? fastNext(task) : FULL_NEXT);
+  return [report, grown, timeReport(outcome)].filter(Boolean).join("\n");
 }
 
+/**
+ * A fast task whose worker asks for a new dependency or an architecture
+ * change is not the small change it read as: QA joins, so it is checked
+ * before it completes. Returns the line for the oracle, or "".
+ */
+function qaJoinsGrownFastTask(task: Task, outcome: WorkerOutcome): string {
+  const track = task.track;
+  if (!track || track.path !== "fast" || track.roster.includes("qa")) return "";
+  const asks = [...outcome.result.dependencyNeeds, ...outcome.result.architectureChanges];
+  if (asks.length === 0) return "";
+  track.roster = parseRoster([...track.roster, "qa"]);
+  track.reasons = [...track.reasons, `tests: ${AGENT_LABELS[outcome.result.domain]} asked for a dependency or an architecture change`];
+  recordDecision(task, `QA joined the fast track: ${AGENT_LABELS[outcome.result.domain]} asked for ${truncate(asks.join("; "), 200)}.`);
+  return "QA now takes part: a fast-track change that needs a new dependency or an architecture change is checked before it completes.";
+}
+
+/** States a fast task starts its work from: before anything is planned, and never while the user decides on a proposal. */
+const FAST_START_STATES: readonly TaskState[] = ["created", "clarifying", "scouting", "synthesizing"];
+
 async function handleImplement(task: Task, params: OrchestrateParams, deps: WorkflowDeps): Promise<string> {
-  requireState(task, ["planning", "implementing", "reviewing"]);
+  const starting = onFastTrack(task) && FAST_START_STATES.includes(task.state);
+  if (!starting && FAST_START_STATES.includes(task.state)) {
+    throw new Error(`action not allowed in state "${task.state}": on the full workflow the user approves a proposal first (a small, clear change can take the fast track: action=track track=fast)`);
+  }
+  if (!starting) requireState(task, ["planning", "implementing", "reviewing"]);
   const assignments = parseAssignments(params);
+  const short = !deps.config.workflow.briefCheck ? [] : assignments.map((entry) => briefRejection(task.id, entry.domain, entry.instruction)).filter(Boolean);
+  if (short.length > 0) throw new Error(short.join("\n"));
   for (const { domain } of assignments) assertNoPendingApprovals(task, domain);
   for (const { domain } of assignments) if (!task.domains.includes(domain)) task.domains.push(domain);
   // Under a time budget every step is given its share before any starts; a spent budget starts none.
   const times = workerTimes(task, deps, assignments);
+  if (task.track && onFastTrack(task)) task.track.roster = parseRoster([...task.track.roster, ...assignments.map((entry) => entry.domain)]);
+  if (starting) startFast(task);
+  if (task.track?.autoPlan) addFastSteps(task, deps, assignments);
   if (task.state !== "implementing") transition(task, "implementing");
   await takeBaseline(task, deps);
   let report: string;
@@ -863,6 +904,61 @@ async function handleImplement(task: Task, params: OrchestrateParams, deps: Work
   return note ? `${report}\n\n${note}` : report;
 }
 
+/**
+ * The fast track's start: the request is small and clear, so it goes from
+ * shaping straight to planning without a proposal round (the engine walks the
+ * same states, so every transition stays legal), and the engine keeps a short
+ * plan whose steps are the delegations themselves.
+ */
+function startFast(task: Task): void {
+  const walk: Partial<Record<TaskState, TaskState[]>> = {
+    created: ["clarifying", "awaiting_approval", "planning"],
+    clarifying: ["awaiting_approval", "planning"],
+    scouting: ["synthesizing", "awaiting_approval", "planning"],
+    synthesizing: ["awaiting_approval", "planning"],
+  };
+  for (const state of walk[task.state] ?? []) transition(task, state);
+  const track = task.track!;
+  if (!task.plan) {
+    task.plan = [
+      "## Objective",
+      oneLine(taskRequest(task), 600),
+      "",
+      "## Track",
+      `Fast track (${track.size}): ${rosterWords(track.roster)}. No scouts, proposal round or plan review; ${qaRequired(task) ? "QA takes part before completion (its tests as the last step, or the QA gate)" : "no QA gate, as nothing here needs tests"}.`,
+      "",
+      "## Steps",
+    ].join("\n");
+    track.autoPlan = true;
+  }
+  recordDecision(task, `Fast track: started without a proposal round (${track.size}; ${rosterWords(track.roster)}).`);
+}
+
+/** `Step 3: …`, `Steps 2-4 — …` at the start of a delegation. */
+const STEP_PREFIX = /^\s*(?:\*\*)?steps?\s*#?\s*(\d+)(?:\s*(?:-|\u2013|\u2014|to|and|&)\s*#?\s*(\d+))?(?:\*\*)?\s*[:.)\u2013\u2014-]?\s*/i;
+
+/**
+ * The fast track's plan grows with its delegations: a delegation that does
+ * not name a step already in the plan adds one, so the lobby's checklist
+ * follows the work without a plan document.
+ */
+function addFastSteps(task: Task, deps: WorkflowDeps, assignments: readonly Assignment[]): void {
+  const plan = task.plan ?? "";
+  const lines = plan.split("\n");
+  const heading = lines.findIndex((line) => /^##\s+steps\s*$/i.test(line));
+  let count = heading < 0 ? 0 : lines.slice(heading + 1).filter((line) => /^\d+\.\s/.test(line)).length;
+  const added: string[] = [];
+  for (const { domain, instruction } of assignments) {
+    const named = STEP_PREFIX.exec(instruction);
+    if (named && Number(named[2] ?? named[1]) <= count) continue;
+    count += 1;
+    added.push(`${count}. ${AGENT_LABELS[domain]}: ${oneLine(instruction.replace(STEP_PREFIX, ""), 160) || "its part of the request"}`);
+  }
+  if (added.length === 0) return;
+  task.plan = `${plan.trimEnd()}\n${added.join("\n")}`;
+  writeFileEnsured(join(taskDirFor(deps.root, deps.configDir, task.id), "plan.md"), task.plan);
+}
+
 /**
  * Several domains at once. The workers share one file desk: each claims a file
  * before editing it, queues for a busy one, and hands it over with a note; a
@@ -1159,9 +1255,10 @@ function handleCompact(task: Task, params: OrchestrateParams, deps: WorkflowDeps
 
 /** §63: record history, drop scratchpads, then mark the task completed. */
 async function handleComplete(task: Task, params: OrchestrateParams, deps: WorkflowDeps): Promise<string> {
-  requireState(task, ["reviewing", "blocked"]);
-  // Without a QA pass only the user can let the task finish: they are asked, never overruled.
-  if (task.qaVerdict !== "pass" && !task.qaWaiver) await offerAcceptance(task, deps);
+  // The fast track completes straight from its work; the full workflow from review.
+  requireState(task, onFastTrack(task) ? ["implementing", "reviewing", "blocked"] : ["reviewing", "blocked"]);
+  // Without QA's part (where the track asks for it) only the user can let the task finish: they are asked, never overruled.
+  if (qaRequired(task) && !qaTookPart(task) && !task.qaWaiver) await offerAcceptance(task, deps);
   if (task.state === "blocked") throw new Error("cannot complete: the task is blocked, and the user did not accept its work as it is");
   const blockers = completionBlockers(task, pendingApprovals(task).length);
   if (blockers.length > 0) throw new Error(`cannot complete: ${blockers.join("; ")}`);
@@ -1170,6 +1267,7 @@ async function handleComplete(task: Task, params: OrchestrateParams, deps: Workf
   recordCompletion(deps, task, summary);
   removeTaskScratchpads(deps.root, deps.configDir, task.id);
   task.blockers = [];
+  if (task.state === "implementing") transition(task, "reviewing");
   transition(task, "completed");
   const oversized = overThreshold(readDataRoots(deps.root, deps.configDir), deps.config.knowledge.compactionThreshold);
   const advice =
@@ -1227,6 +1325,48 @@ function handleResume(task: Task, params: OrchestrateParams): string {
   return "Task resumed. Continue with action=implement.";
 }
 
+/**
+ * `action=track`: with neither `track` nor `roster`, the task's track; with
+ * them, the oracle corrects the engine's read of the request. The fast track
+ * is taken only before the work is planned, never against the user's --full
+ * or the settings; once work is under way a track only gets stricter (the
+ * full workflow, more members, QA never dropped).
+ */
+function handleTrack(task: Task, params: OrchestrateParams, deps: WorkflowDeps): string {
+  const current = task.track;
+  if (!params.track && !params.roster) return current ? trackSummary(current) : "This task began before tracks: it takes the full workflow.";
+  const reason = oneLine(params.reason?.trim() || params.text?.trim() || "", 240);
+  if (!reason) throw new Error("track requires reason: why the task takes that path, or needs those members");
+  const path = params.track ?? current?.path ?? "full";
+  const shaping = FAST_START_STATES.includes(task.state);
+  if (path === "fast" && current?.path !== "fast") {
+    if (!deps.config.workflow.fastTrack) throw new Error("the fast track is off in settings (workflow.fastTrack): this task takes the full workflow");
+    if (current?.userChoice === "full") throw new Error("the user asked for the full workflow on this task (--full)");
+    if (!shaping) throw new Error(`a task takes the fast track before its work is planned; this one is ${task.state}`);
+  }
+  const asked = params.roster ? parseRoster(params.roster) : [...(current?.roster ?? [])];
+  // The full workflow always ends with the QA gate.
+  const roster = path === "full" ? parseRoster([...asked, "qa"]) : asked;
+  if (!shaping && current?.roster.includes("qa") && !roster.includes("qa")) throw new Error("QA stays on the roster once the work is under way");
+  const grew = current?.path === "fast" && path === "full";
+  task.track = {
+    path,
+    size: current?.size ?? "small",
+    roster,
+    reasons: [`oracle: ${reason}`, ...(current?.reasons ?? [])].slice(0, 8),
+    source: "oracle",
+    ...(current?.userChoice ? { userChoice: current.userChoice } : {}),
+    ...(current?.autoPlan ? { autoPlan: true } : {}),
+    at: new Date().toISOString(),
+  };
+  recordDecision(task, `Track: ${path === "fast" ? "fast track" : "full workflow"}; ${rosterWords(roster)} — ${reason}`);
+  if (path === "fast") {
+    return `Fast track: ${rosterWords(roster)}. Delegate straight away with action=implement (open each task with "Step N:"); no scouts, proposal or plan. ${qaRequired(task) ? "QA takes part before completion: its tests as the last step, or action=qa." : "No QA gate: nothing here needs tests."} Then action=complete.`;
+  }
+  if (!shaping) return `Full workflow from here: ${rosterWords(roster)}. The QA gate runs before the task completes${grew ? "; tell the user in one line why the task grew" : ""}.`;
+  return `Full workflow: ${rosterWords(roster)}. Scout what the request touches, then propose a short bullet list for approval.`;
+}
+
 function handleDecide(task: Task, params: OrchestrateParams): string {
   const text = params.text?.trim();
   if (!text) throw new Error("decide requires text");
@@ -1254,7 +1394,7 @@ type WorkerTime = AgentTime & { id: string };
 /** The task's budget and where it stands, when it has one. */
 function budgetFor(task: Task, deps: WorkflowDeps): { budget: TaskBudget; state: BudgetState } | undefined {
   const budget = readBudget(deps.root, deps.configDir, task.id);
-  return budget ? { budget, state: budgetState(task.id, budget, task.qaVerdict === "pass") } : undefined;
+  return budget ? { budget, state: budgetState(task.id, budget, !qaStillDue(task)) } : undefined;
 }
 
 /** No new work starts once the budget is spent: the oracle asks the user for more, or wraps up. */
@@ -1501,6 +1641,7 @@ const HANDLERS: Record<OrchestrateAction, (task: Task, params: OrchestrateParams
   resume: handleResume,
   decide: handleDecide,
   budget: handleBudget,
+  track: handleTrack,
   status: (task) => describeTask(task),
   cancel: handleCancel,
 };

package/src/pi/expressions.ts

@@ -1,169 +0,0 @@
-/**
- * Caller-driven expression schedule for the zen sprites.
- *
- * Pure and deterministic: `now` and the random source are always injected, so
- * the art, layout and metrics stay free of `Date.now`/`Math.random`. Each slot
- * and the oracle keeps its own state, holds its rest frame between events and,
- * after a random 20-30 s gap, plays a short blink or a longer emote.
- */
-
-/** Resting gap before the next expression, milliseconds. */
-export const BLINK_MIN_MS = 20_000;
-export const BLINK_MAX_MS = 30_000;
-/** How long one blink and one emote are held. */
-export const BLINK_MS = 500;
-export const EMOTE_MS = 2000;
-/** Fast clock while an expression plays, short enough that a blink is never skipped. */
-export const FAST_TICK_MS = 120;
-
-/** Art frame indexes: 0 rests, 1 blinks, `2 ..` are emotes. */
-export const REST_FRAME = 0;
-export const BLINK_FRAME = 1;
-export const EMOTE_FRAME = 2;
-/**
- * Emote frame range: `EMOTE_FRAME .. EMOTE_FRAME + EMOTE_FRAMES - 1`; an emote
- * steps through them: the open face, a blink, then its action (see kaomoji.ts).
- */
-export const EMOTE_FRAMES = 4;
-/** Each emote frame is held this long, so an emote steps through its frames. */
-export const EMOTE_STEP_MS = Math.floor(EMOTE_MS / EMOTE_FRAMES);
-
-const BLINK_CHANCE = 0.65;
-/** Working agents emote as often as they blink. */
-export const WORKING_BLINK_CHANCE = 0.5;
-/** Upper bound (exclusive) of an expression's variant. */
-const VARIANT_SPAN = 2 ** 30;
-
-export interface ExpressionState {
-  /** Earliest `now` the next expression may start. */
-  nextAt: number;
-  /** When the playing expression ends; not after `now` while resting. */
-  until: number;
-  /** When the current expression started; drives emote frame stepping. */
-  startedAt: number;
-  /** Frame index for the art: 0 rest, 1 blink, 2+ emote. */
-  frame: number;
-  /** Drawn once per expression; picks which face an emote shows (see kaomoji.ts). */
-  variant: number;
-}
-
-/** A random draw clamped to `[0, 1]`, so a non-finite source value can never leak. */
-function unit(rng: () => number): number {
-  const value = rng();
-  return Number.isFinite(value) ? Math.min(1, Math.max(0, value)) : 0;
-}
-
-/** Resting window between expressions, milliseconds. */
-export interface ExpressionGap {
-  min: number;
-  max: number;
-}
-
-/** Idle agent slots rest 20-30 s between expressions. */
-export const SLOT_GAP: ExpressionGap = { min: BLINK_MIN_MS, max: BLINK_MAX_MS };
-/** Working agents are livelier: 8-15 s between expressions. */
-export const WORKING_GAP: ExpressionGap = { min: 8_000, max: 15_000 };
-/** The oracle is the scene's centrepiece: it blinks and emotes every 6-12 s. */
-export const ORACLE_GAP: ExpressionGap = { min: 6_000, max: 12_000 };
-
-/** Random resting gap before the next expression, inside `gap` (the slot window by default). */
-export function nextGap(rng: () => number, gap: ExpressionGap = SLOT_GAP): number {
-  return gap.min + Math.round(unit(rng) * (gap.max - gap.min));
-}
-
-/** Whether the next expression blinks (~65% by default) or emotes. */
-export function pickEvent(rng: () => number, blinkChance = BLINK_CHANCE): "blink" | "emote" {
-  return unit(rng) < blinkChance ? "blink" : "emote";
-}
-
-function drawVariant(rng: () => number): number {
-  return Math.floor(unit(rng) * (VARIANT_SPAN - 1));
-}
-
-/** A freshly rested expression that fires for the first time after one random gap. */
-export function createExpression(now: number, rng: () => number, gap: ExpressionGap = SLOT_GAP): ExpressionState {
-  const start = Number.isFinite(now) ? now : 0;
-  return { nextAt: start + nextGap(rng, gap), until: start, startedAt: start, frame: REST_FRAME, variant: 0 };
-}
-
-/** True while `now` is inside a playing blink or emote. */
-export function isPlaying(state: ExpressionState, now: number): boolean {
-  return Number.isFinite(now) && now < state.until;
-}
-
-/** True when any state is mid-expression; the caller uses it to retime its clock. */
-export function anyPlaying(states: readonly ExpressionState[], now: number): boolean {
-  return states.some((state) => isPlaying(state, now));
-}
-
-/**
- * Advance one sprite to `now`: start a blink or emote once the gap has elapsed,
- * drop back to the rest frame when it ends, and change nothing in between.
- */
-export function advanceExpression(
-  state: ExpressionState,
-  now: number,
-  rng: () => number,
-  gap: ExpressionGap = SLOT_GAP,
-  blinkChance = BLINK_CHANCE,
-): ExpressionState {
-  if (!Number.isFinite(now)) return state;
-  if (now < state.until) return state.frame >= EMOTE_FRAME ? steppedEmote(state, now) : state;
-  if (now < state.nextAt) return state.frame === REST_FRAME ? state : { ...state, frame: REST_FRAME };
-  return play(now, rng, gap, blinkChance);
-}
-
-function play(now: number, rng: () => number, gap: ExpressionGap, blinkChance: number): ExpressionState {
-  const blink = pickEvent(rng, blinkChance) === "blink";
-  return blink ? startBlink(now, rng, gap) : triggerEmote(now, rng, gap);
-}
-
-function startBlink(now: number, rng: () => number, gap: ExpressionGap): ExpressionState {
-  const until = now + BLINK_MS;
-  return { nextAt: until + nextGap(rng, gap), until, startedAt: now, frame: BLINK_FRAME, variant: drawVariant(rng) };
-}
-
-/**
- * Start an emote right now, whatever the sprite was doing: the reaction when a
- * slot's situation changes (it starts, finishes, fails, stalls, waits or
- * receives a file). The next scheduled expression follows one gap later.
- */
-export function triggerEmote(now: number, rng: () => number, gap: ExpressionGap = SLOT_GAP): ExpressionState {
-  const start = Number.isFinite(now) ? now : 0;
-  const until = start + EMOTE_MS;
-  return { nextAt: until + nextGap(rng, gap), until, startedAt: start, frame: EMOTE_FRAME, variant: drawVariant(rng) };
-}
-
-/** One sub-step of a playing expression; the oracle's blink and glance step through these. */
-export const PHASE_MS = FAST_TICK_MS;
-
-/** Sub-steps elapsed in the playing expression, 0 while resting or on a bad clock. */
-export function expressionPhase(state: ExpressionState, now: number): number {
-  if (!isPlaying(state, now)) return 0;
-  const elapsed = now - state.startedAt;
-  return Number.isFinite(elapsed) && elapsed > 0 ? Math.floor(elapsed / PHASE_MS) : 0;
-}
-
-/** How long the oracle lip-syncs after it says something new, and one mouth shape's hold. */
-export const TALK_MS = 1800;
-export const TALK_STEP_MS = FAST_TICK_MS;
-
-/** Mouth-shape index while the oracle is still talking about what it said at `since`, else undefined. */
-export function talkFrame(since: number | undefined, now: number): number | undefined {
-  if (since === undefined || !Number.isFinite(since) || !Number.isFinite(now)) return undefined;
-  const elapsed = now - since;
-  return elapsed >= 0 && elapsed < TALK_MS ? Math.floor(elapsed / TALK_STEP_MS) : undefined;
-}
-
-/** Emote frame for `now`: one step per EMOTE_STEP_MS, clamped to the last frame. */
-function emoteFrameAt(startedAt: number, now: number): number {
-  const elapsed = now - startedAt;
-  const step = Number.isFinite(elapsed) && elapsed > 0 ? Math.floor(elapsed / EMOTE_STEP_MS) : 0;
-  return EMOTE_FRAME + Math.min(EMOTE_FRAMES - 1, Math.max(0, step));
-}
-
-/** Advance an in-flight emote's frame, keeping the same object when it has not changed. */
-function steppedEmote(state: ExpressionState, now: number): ExpressionState {
-  const frame = emoteFrameAt(state.startedAt, now);
-  return frame === state.frame ? state : { ...state, frame };
-}