@groeponline/pi-wishcraft 1.1.0 → 1.2.0

package/src/extension/ui/deck/route-bodies.ts

@@ -0,0 +1,209 @@
+/**
+ * Center-pane bodies for Craft, Motion Gallery, and Composer.
+ * Pure: given snapshot + nav + optional composer draft, return lines.
+ */
+
+import {
+  COMPOSER_FIELDS,
+  composerPreview,
+  type ComposerDraft,
+} from "../../../motion/composer.ts";
+import { filterMotions, GALLERY_CATEGORIES, previewStrip } from "../../../motion/gallery.ts";
+import { getMotion } from "../../../motion/catalog.ts";
+import { STRUCTURAL_PRESET_NAMES } from "../../../config/types.ts";
+import {
+  appearanceDisplayName,
+  getStructuralPreset,
+} from "../../../config/structural-presets.ts";
+import { config } from "../../core/state.ts";
+import type { DeckNavState, DeckSessionSnapshot, DeckSkillRow } from "./types.ts";
+
+export function filterSkillRows(skills: readonly DeckSkillRow[], query: string): DeckSkillRow[] {
+  const q = query.trim().toLowerCase();
+  if (!q) return [...skills];
+  return skills.filter((skill) =>
+    `${skill.name} ${skill.category} ${skill.description}`.toLowerCase().includes(q),
+  );
+}
+
+export function appearanceLines(
+  snapshot: DeckSessionSnapshot,
+  state: DeckNavState,
+): string[] {
+  const selected = STRUCTURAL_PRESET_NAMES[state.selectedAppearance];
+  const selectedDef = selected ? getStructuralPreset(selected) : null;
+  const lines = [
+    `Active: ${appearanceDisplayName(snapshot.appearanceBase)}`,
+    `Layout ${config.preset} · motion ${snapshot.motionLevel}`,
+    selectedDef ? selectedDef.description : "Enter applies the structural base to Signal.",
+  ];
+  const cursor = state.selectedAppearance;
+  for (let i = 0; i < STRUCTURAL_PRESET_NAMES.length; i++) {
+    const name = STRUCTURAL_PRESET_NAMES[i]!;
+    const preset = getStructuralPreset(name);
+    const marker = i === cursor ? "→" : " ";
+    const star = name === snapshot.appearanceBase ? "*" : " ";
+    lines.push(`${marker}${star} ${preset.displayName.padEnd(14)} ${name}`);
+  }
+  return lines;
+}
+
+export function motionGalleryLines(
+  snapshot: DeckSessionSnapshot,
+  state: DeckNavState,
+  width: number,
+  composer: ComposerDraft | null,
+  tick = Date.now(),
+): string[] {
+  if (state.composerOpen && composer) {
+    return composerLines(composer, state, width, tick);
+  }
+  const query = state.route === "motion" ? state.searchQuery : "";
+  const motions = filterMotions(query);
+  const cursor = Math.min(state.selectedMotion, Math.max(0, motions.length - 1));
+  const selected = motions[cursor];
+  const counts = GALLERY_CATEGORIES.map((category) => {
+    const n = motions.filter((entry) => entry.category === category).length;
+    return n > 0 ? `${category} ${n}` : "";
+  }).filter(Boolean);
+  const frameTick = Math.floor(tick / (selected ? (selected.generator?.intervalMs ?? 100) : 100));
+  const lines = [
+    `${motions.length} motions · ${counts.join(" · ")}`,
+    `assign ${state.assignEvent} · live ${snapshot.signalMotion}`,
+    selected
+      ? previewStrip(selected, frameTick, Math.min(28, width - 2))
+      : "No motions match",
+    "↑↓ select · t event · e composer · enter apply",
+  ];
+  const window = 8;
+  const start = Math.max(0, cursor - 3);
+  const end = Math.min(motions.length, start + window);
+  for (let i = start; i < end; i++) {
+    const def = motions[i]!;
+    const marker = i === cursor ? "→" : " ";
+    lines.push(`${marker} ${def.category.padEnd(10)} ${def.name}`);
+  }
+  if (selected) {
+    lines.push("");
+    lines.push(selected.description);
+  }
+  return lines;
+}
+
+function composerLines(
+  draft: ComposerDraft,
+  state: DeckNavState,
+  width: number,
+  tick = Date.now(),
+): string[] {
+  const frameTick = Math.floor(tick / draft.intervalMs);
+  const field = COMPOSER_FIELDS[state.composerField] ?? "intervalMs";
+  const lines = [
+    `COMPOSER · ${draft.name}`,
+    composerPreview(draft, frameTick, Math.min(28, width - 2)),
+    `Assign to ${draft.assignEvent}`,
+    "←→ nudge · ↑↓ field · enter apply · esc back",
+  ];
+  for (const name of COMPOSER_FIELDS) {
+    const marker = name === field ? "→" : " ";
+    const value =
+      name === "geometry"
+        ? draft.geometry
+        : name === "intervalMs"
+          ? `${draft.intervalMs}ms`
+          : name === "trail"
+            ? String(draft.trail)
+            : name === "direction"
+              ? draft.direction
+              : name === "ease"
+                ? draft.ease
+                : draft.assignEvent;
+    lines.push(`${marker} ${name}: ${value}`);
+  }
+  return lines;
+}
+
+export function skillsWorkbenchLines(
+  snapshot: DeckSessionSnapshot,
+  state: DeckNavState,
+  width: number,
+): string[] {
+  const query = state.route === "skills" ? state.searchQuery : "";
+  const rows = filterSkillRows(snapshot.skills, query);
+  const cursor = Math.min(state.selectedSkill, Math.max(0, rows.length - 1));
+  const selected = rows[cursor];
+  if (state.skillCreate) {
+    return [
+      "NEW SKILL",
+      `Name: ${state.skillCreateName}_`,
+      "Writes ~/.pi/agent/skills/<name>/SKILL.md from the standard template.",
+      "type a name · enter create · esc cancel",
+    ];
+  }
+  const lines = [
+    `WORKBENCH · ${snapshot.skillsTotal} skills · ${snapshot.skillsWarnings} warnings`,
+    "↑↓ select · enter insert · n new skill",
+  ];
+  if (rows.length === 0) {
+    lines.push(query ? "No skills match this search" : "No skills loaded");
+    return lines;
+  }
+  const start = Math.max(0, cursor - 4);
+  const end = Math.min(rows.length, start + 8);
+  for (let i = start; i < end; i++) {
+    const skill = rows[i]!;
+    const marker = i === cursor ? "→" : " ";
+    const mark = skill.status === "ok" ? "✓" : skill.status === "fail" ? "✗" : "!";
+    const spark = "#".repeat(Math.min(6, skill.usage)) + "·".repeat(Math.max(0, 6 - Math.min(6, skill.usage)));
+    lines.push(`${marker}${mark} ${skill.name} · ${skill.category} ${spark}`);
+  }
+  if (selected) {
+    lines.push("");
+    lines.push(`${selected.name} [${selected.status}]`);
+    lines.push(selected.description || "No description");
+  }
+  return lines;
+}
+
+export function ideasLines(snapshot: DeckSessionSnapshot, state: DeckNavState): string[] {
+  const lines = [
+    `${snapshot.ideaCount} ideas · ${snapshot.queueCount} queued`,
+    "Capture with # or /ideas",
+  ];
+  if (snapshot.ideas.length === 0) {
+    lines.push("No captured ideas");
+    return lines;
+  }
+  const cursor = Math.min(state.selectedIdea, snapshot.ideas.length - 1);
+  snapshot.ideas.forEach((idea, i) => {
+    const marker = i === cursor ? "→" : " ";
+    lines.push(`${marker}[${idea.reviewStatus}] ${idea.text}`);
+  });
+  return lines;
+}
+
+export function guardrailLines(snapshot: DeckSessionSnapshot): string[] {
+  const lines = [
+    `Policy: ${snapshot.policyEnabled ? "ENABLED" : "OFF"} (${snapshot.policyRuleCount} rules)`,
+    snapshot.policySummary,
+  ];
+  if (snapshot.guardrailRules.length === 0) {
+    lines.push("No declarative rules in wishcraft.policy");
+    return lines;
+  }
+  for (const rule of snapshot.guardrailRules) {
+    lines.push(`${rule.action} ${rule.tool} · ${rule.reason}`);
+  }
+  return lines;
+}
+
+export function selectedGalleryMotion(state: DeckNavState) {
+  const motions = filterMotions(state.route === "motion" ? state.searchQuery : "");
+  return motions[Math.min(state.selectedMotion, Math.max(0, motions.length - 1))] ?? getMotion("ember-relay");
+}
+
+export function filteredSkillCount(snapshot: DeckSessionSnapshot, state: DeckNavState): number {
+  if (state.route !== "skills") return snapshot.skills.length;
+  return filterSkillRows(snapshot.skills, state.searchQuery).length;
+}
+

package/src/extension/ui/deck/routes.ts

@@ -0,0 +1,37 @@
+import type { DeckRoute, DeckRouteDef } from "./types.ts";
+import { DECK_ROUTES } from "./types.ts";
+
+export const DECK_ROUTE_DEFS: readonly DeckRouteDef[] = [
+  { id: "home", label: "Home", jumpKey: "h", description: "Session overview and next intent" },
+  { id: "signal", label: "Signal", jumpKey: "s", description: "Lane layout and live activity" },
+  { id: "skills", label: "Skills", jumpKey: "k", description: "Catalog and health diagnostics" },
+  { id: "ideas", label: "Ideas", jumpKey: "i", description: "Captured intents and queue" },
+  { id: "guardrails", label: "Guardrails", jumpKey: "r", description: "Policy rules and enforcement" },
+  { id: "shell", label: "Shell", jumpKey: "l", description: "Terminal and bash mode" },
+  { id: "usage", label: "Usage", jumpKey: "u", description: "Context and token metrics" },
+  { id: "appearance", label: "Appearance", jumpKey: "a", description: "Presets, palette, and chrome" },
+  { id: "motion", label: "Motion", jumpKey: "m", description: "Animation gallery and sensitivity" },
+  { id: "shortcuts", label: "Shortcuts", jumpKey: "c", description: "Keyboard navigation reference" },
+  { id: "diagnostics", label: "Diagnostics", jumpKey: "d", description: "Environment and capability checks" },
+];
+
+export function isDeckRoute(value: string): value is DeckRoute {
+  return (DECK_ROUTES as readonly string[]).includes(value);
+}
+
+export function parseDeckRouteArg(args: string | undefined): DeckRoute {
+  const token = args?.trim().toLowerCase().split(/\s+/)[0] ?? "";
+  if (!token || token === "home" || token === "deck") return "home";
+  if (token === "settings" || token === "config") return "appearance";
+  if (isDeckRoute(token)) return token;
+  return "home";
+}
+
+export function deckRouteByJump(key: string): DeckRoute | null {
+  const match = DECK_ROUTE_DEFS.find((route) => route.jumpKey === key);
+  return match?.id ?? null;
+}
+
+export function deckRouteIndex(route: DeckRoute): number {
+  return DECK_ROUTE_DEFS.findIndex((entry) => entry.id === route);
+}

package/src/extension/ui/deck/session-snapshot.ts

@@ -0,0 +1,104 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { effectiveAppearanceMix, resolveAppearanceMix } from "../../../config/appearance.ts";
+import { config } from "../../core/state.ts";
+import type { RuntimeState } from "../../core/types.ts";
+import { buildSegmentContext } from "../../core/segment-context.ts";
+import { getQueueContext } from "../../queue/queue-context.ts";
+import { loadSkillCatalog } from "../../skills/skill-registry.ts";
+import { collectSkillDoctorInputs, diagnoseSkills } from "../../skills/skill-doctor.ts";
+import { parsePolicySettings } from "../../hooks/policy-config.ts";
+import { readSettings } from "../../settings/settings-io.ts";
+import { describePolicy } from "../../../motion/accessibility.ts";
+import type { DeckSessionSnapshot } from "./types.ts";
+
+export function buildDeckSessionSnapshot(rt: RuntimeState, ctx: any): DeckSessionSnapshot {
+  const theme = { fg: (_color: string, text: string) => text } as Theme;
+  let segmentCtx;
+  try {
+    segmentCtx = buildSegmentContext(rt, ctx, theme);
+  } catch {
+    segmentCtx = null;
+  }
+
+  const queue = rt.queueStore.summarize(
+    getQueueContext(ctx),
+    rt.powerlineCompacting,
+  );
+  const cwd = ctx.cwd ?? process.cwd();
+  const skills = loadSkillCatalog(cwd);
+  const doctorInputs = collectSkillDoctorInputs(cwd);
+  const doctor = diagnoseSkills(
+    doctorInputs.entries,
+    doctorInputs.usage,
+    doctorInputs.contents,
+  );
+  const warnings = doctor.filter((row) => row.status !== "ok").length;
+  const settings = readSettings(cwd);
+  const policy = parsePolicySettings(settings.wishcraft);
+  const appearance = resolveAppearanceMix(
+    effectiveAppearanceMix(config.appearance, config.preset),
+  );
+
+  const model = segmentCtx?.model;
+  const modelLabel = model?.name ?? model?.id ?? "no model";
+  const branch = segmentCtx?.git.branch;
+  const branchLabel = branch ?? "no branch";
+
+  const recentActivity: string[] = [];
+  if (rt.signal.activity && rt.signal.activity !== "ready") {
+    recentActivity.push(rt.signal.activity);
+  }
+  if (queue.leadingText) {
+    recentActivity.push(queue.leadingText);
+  }
+  if (rt.lastUserPrompt) {
+    recentActivity.push(rt.lastUserPrompt.slice(0, 48));
+  }
+
+  return {
+    modelLabel,
+    branchLabel,
+    contextPercent: Math.round(segmentCtx?.contextPercent ?? 0),
+    contextTokens: segmentCtx?.contextTokens ?? 0,
+    contextWindow: segmentCtx?.contextWindow ?? 0,
+    signalActivity: rt.signal.activity,
+    signalMotion: rt.signal.motionId,
+    queueCount: queue.queueCount,
+    ideaCount: queue.ideaCount,
+    skillsTotal: skills.length,
+    skillsWarnings: warnings,
+    policyEnabled: policy.enabled,
+    policyRuleCount: policy.rules.length,
+    shellName: rt.shellSession?.state.shellName ?? null,
+    bashModeActive: rt.bashModeActive,
+    appearanceBase: appearance.base,
+    recentActivity: recentActivity.slice(0, 5),
+    nextIntent: queue.leadingText,
+    motionLevel: config.motionLevel,
+    policySummary: describePolicy(rt.motionPolicy),
+    skills: skills.slice(0, 24).map((skill) => {
+      const row = doctor.find((entry) => entry.skill === skill.name);
+      const usage = doctorInputs.usage.get(skill.name);
+      return {
+        name: skill.name,
+        category: skill.category,
+        status: row?.status ?? (skill.warning ? "warn" : "ok"),
+        description: skill.description.slice(0, 72),
+        usage: usage?.count ?? 0,
+      };
+    }),
+    ideas: rt.queueStore
+      .list()
+      .filter((item) => item.intent === "idea")
+      .slice(0, 12)
+      .map((item) => ({
+        text: item.text.slice(0, 64),
+        reviewStatus: item.reviewStatus ?? "idea",
+      })),
+    guardrailRules: policy.rules.slice(0, 8).map((rule) => ({
+      action: rule.action,
+      tool: rule.tool,
+      reason: rule.action === "deny" ? rule.reason : rule.context.slice(0, 48),
+    })),
+  };
+}

package/src/extension/ui/deck/types.ts

@@ -0,0 +1,92 @@
+/**
+ * src/extension/ui/deck/types.ts
+ * ---------------------------------------------------------------------------
+ * Types for the Wishcraft Deck control surface.
+ * ---------------------------------------------------------------------------
+ */
+
+export const DECK_ROUTES = [
+  "home",
+  "signal",
+  "skills",
+  "ideas",
+  "guardrails",
+  "shell",
+  "usage",
+  "appearance",
+  "motion",
+  "shortcuts",
+  "diagnostics",
+] as const;
+
+export type DeckRoute = (typeof DECK_ROUTES)[number];
+
+export interface DeckRouteDef {
+  id: DeckRoute;
+  label: string;
+  jumpKey: string;
+  description: string;
+}
+
+export interface DeckSessionSnapshot {
+  modelLabel: string;
+  branchLabel: string;
+  contextPercent: number;
+  contextTokens: number;
+  contextWindow: number;
+  signalActivity: string;
+  signalMotion: string;
+  queueCount: number;
+  ideaCount: number;
+  skillsTotal: number;
+  skillsWarnings: number;
+  policyEnabled: boolean;
+  policyRuleCount: number;
+  shellName: string | null;
+  bashModeActive: boolean;
+  appearanceBase: string;
+  recentActivity: string[];
+  nextIntent: string | null;
+  motionLevel: string;
+  policySummary: string;
+  skills: DeckSkillRow[];
+  ideas: DeckIdeaRow[];
+  guardrailRules: DeckGuardrailRow[];
+}
+
+export interface DeckSkillRow {
+  name: string;
+  category: string;
+  status: string;
+  description: string;
+  usage: number;
+}
+
+export interface DeckIdeaRow {
+  text: string;
+  reviewStatus: string;
+}
+
+export interface DeckGuardrailRow {
+  action: string;
+  tool: string;
+  reason: string;
+}
+
+export interface DeckNavState {
+  route: DeckRoute;
+  selectedNav: number;
+  searchOpen: boolean;
+  searchQuery: string;
+  pendingJump: string | null;
+  /** Cursor into STRUCTURAL_PRESET_NAMES on the Appearance route. */
+  selectedAppearance: number;
+  selectedMotion: number;
+  selectedSkill: number;
+  selectedIdea: number;
+  composerOpen: boolean;
+  composerField: number;
+  assignEvent: import("../../../motion/types.ts").MotionEvent;
+  skillCreate: boolean;
+  skillCreateName: string;
+}

package/src/extension/ui/powerline-menu-view.ts

@@ -56,26 +56,30 @@ async function activatePowerlineMenuAction(
   }
 }
 
-/** Main powerline menu: three top-level overlays, Status drills down. */
+import { openWishcraftDeck } from "./deck/index.ts";
+
+/** Main powerline / Wishcraft Deck menu: opens the Deck on Alt+P */
 export async function showPowerlineMainMenu(
   rt: RuntimeState,
   ctx: any,
 ): Promise<void> {
   rt.currentCtx = ctx;
-  while (true) {
-    const top = await pickPowerlineMenuNode(
-      ctx,
-      "Powerline",
-      assertPowerlineMenuBounds(),
-    );
-    if (!top) return;
-    if (top.children?.length) {
-      const child = await pickPowerlineMenuNode(ctx, top.label, top.children);
-      if (!child) continue;
-      await activatePowerlineMenuAction(rt, ctx, child.id);
-      continue;
-    }
-    await activatePowerlineMenuAction(rt, ctx, top.id);
+  await openWishcraftDeck(rt, ctx, "home");
+}
+
+/** Classic Navigate / Configure / Status overlays (`/signal menu`). */
+export async function showPowerlineClassicMenu(
+  rt: RuntimeState,
+  ctx: any,
+): Promise<void> {
+  rt.currentCtx = ctx;
+  const nodes = assertPowerlineMenuBounds();
+  const picked = await pickPowerlineMenuNode(ctx, "Signal", nodes);
+  if (!picked) return;
+  if (picked.children?.length) {
+    const child = await pickPowerlineMenuNode(ctx, picked.label, picked.children);
+    if (child) await activatePowerlineMenuAction(rt, ctx, child.id);
     return;
   }
+  await activatePowerlineMenuAction(rt, ctx, picked.id);
 }

package/src/extension/ui/signal-layout.ts

@@ -0,0 +1,77 @@
+/**
+ * src/extension/ui/signal-layout.ts
+ * ---------------------------------------------------------------------------
+ * 3-Lane Motion-Aware Signal Powerline Renderer.
+ * Left: Model / Git · Center: Live Activity & Tools · Right: Context / Queue
+ * ---------------------------------------------------------------------------
+ */
+
+import { visibleWidth } from "@earendil-works/pi-tui";
+import type { PresetDef, SegmentContext } from "../../config/types.ts";
+import { renderSegmentWithWidth } from "./layout.ts";
+import { getSeparator } from "../../theme/separators.ts";
+import { ansi, colorEnabled, getFgAnsiCode } from "../../theme/colors.ts";
+
+export interface SignalRenderResult {
+  content: string;
+  leftLaneContent: string;
+  centerLaneContent: string;
+  rightLaneContent: string;
+}
+
+/**
+ * Computes the 3-lane Signal powerline with active motion sweeps.
+ */
+export function computeSignal3LaneLayout(
+  ctx: SegmentContext,
+  presetDef: PresetDef,
+  availableWidth: number,
+  motionGlyph: string = "✦",
+): SignalRenderResult {
+  const separatorStyle = presetDef.separator ?? "powerline-thin";
+  const sepDef = getSeparator(separatorStyle);
+  const sep = sepDef.left;
+  const sepAnsi = getFgAnsiCode("sep");
+  const reset = colorEnabled() ? ansi.reset : "";
+
+  // 1. Left Lane: Identity (model, git, path)
+  const leftIds: any[] = presetDef.leftSegments ?? ["model", "path", "git"];
+  const leftParts: string[] = [];
+  for (const id of leftIds) {
+    const { content, visible } = renderSegmentWithWidth(id, ctx);
+    if (visible && content) leftParts.push(content);
+  }
+
+  // 2. Center Lane: Live Activity & Motion Conduit
+  const centerIds: any[] = ["thinking", "shell_mode", "subagents"];
+  const centerParts: string[] = [];
+  for (const id of centerIds) {
+    const { content, visible } = renderSegmentWithWidth(id, ctx);
+    if (visible && content) centerParts.push(content);
+  }
+
+  // 3. Right Lane: Metrics & Context (context_pct, queue, cost, tps)
+  const rightIds: any[] = presetDef.rightSegments ?? ["cost", "context_pct", "queue"];
+  const rightParts: string[] = [];
+  for (const id of rightIds) {
+    const { content, visible } = renderSegmentWithWidth(id, ctx);
+    if (visible && content) rightParts.push(content);
+  }
+
+  const leftText = leftParts.join(` ${sepAnsi}${sep}${reset} `);
+  const rightText = rightParts.join(` ${sepAnsi}${sep}${reset} `);
+
+  // Dynamic conduit sweep pulse in center lane
+  const centerText = centerParts.length > 0
+    ? `━━━╾${motionGlyph}╼━━━ ${centerParts.join(" ")}`
+    : `━━━╾${motionGlyph}╼━━━`;
+
+  const fullLine = ` ${leftText} ${sepAnsi}${sep}${reset} ${centerText} ${sepAnsi}${sep}${reset} ${rightText} `;
+
+  return {
+    content: fullLine,
+    leftLaneContent: leftText,
+    centerLaneContent: centerText,
+    rightLaneContent: rightText,
+  };
+}

package/src/extension/ui/status-line-renderers.ts

@@ -3,13 +3,14 @@ import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
 
 import type { SegmentContext } from "../../config/types.ts";
 import { getPreset } from "../../config/presets.ts";
+import { effectiveAppearanceMix, resolveAppearanceMix } from "../../config/appearance.ts";
 import {
   collectHiddenExtensionStatusKeys,
   getNotificationExtensionStatuses,
 } from "../../config/powerline-config.ts";
 import { ansi, colorEnabled, getFgAnsiCode } from "../../theme/colors.ts";
+import { hasNerdFonts } from "../../theme/icons.ts";
 
-import { computeResponsiveLayout } from "./layout.ts";
 import { getQueueContext } from "../queue/queue-context.ts";
 import { buildSegmentContext } from "../core/segment-context.ts";
 import {
@@ -19,6 +20,8 @@ import {
 } from "../core/constants.ts";
 import { config } from "../core/state.ts";
 import type { RuntimeState } from "../core/types.ts";
+import { prefersAsciiGlyphs } from "../../motion/index.ts";
+import { renderSignal } from "../../signal/render.ts";
 
 /**
  * Get cached responsive layout or compute fresh one.
@@ -71,7 +74,22 @@ export function getResponsiveLayout(
   }
 
   rt.lastLayoutWidth = width;
-  rt.lastLayoutResult = computeResponsiveLayout(segmentCtx, presetDef, width);
+  const appearance = resolveAppearanceMix(
+    effectiveAppearanceMix(config.appearance, config.preset),
+  );
+  rt.lastLayoutResult = renderSignal(
+    segmentCtx,
+    presetDef,
+    rt.signal,
+    width,
+    {
+      separatorStyle: config.separator ?? presetDef.separator,
+      signal: appearance.signal,
+      ascii: prefersAsciiGlyphs(rt.motionPolicy, hasNerdFonts()),
+      layout: config.layout,
+      disabledSegments: config.disabledSegments,
+    },
+  );
   rt.lastLayoutTimestamp = now;
   rt.layoutDirty = false;
   rt.forceNextLayoutRecompute = false;

package/src/motion/accessibility.ts

@@ -0,0 +1,59 @@
+/**
+ * First-class accessibility policy. Environment flags plus an optional
+ * persisted motion level become a MotionPolicy the scheduler already understands.
+ */
+
+import { detectEnvironment, motionLevelFromEnv } from "../theme/detect.ts";
+import { DEFAULT_MOTION_POLICY, type MotionLevel, type MotionPolicy } from "./types.ts";
+
+export type { MotionLevel, MotionPolicy };
+import { effectiveLevel, targetFps } from "./policy.ts";
+
+export const MOTION_LEVELS: readonly MotionLevel[] = [
+  "full",
+  "reduced",
+  "functional",
+  "off",
+];
+
+export function isMotionLevel(value: unknown): value is MotionLevel {
+  return typeof value === "string" && (MOTION_LEVELS as readonly string[]).includes(value);
+}
+
+/**
+ * Build a policy from the host environment, then overlay a saved level.
+ * Screen-reader mode always forces off. An explicit WISHCRAFT_MOTION env
+ * wins over the saved level.
+ */
+export function policyFromEnvironment(
+  env: NodeJS.ProcessEnv = process.env,
+  persistedLevel?: MotionLevel,
+): MotionPolicy {
+  const detected = detectEnvironment(env);
+  const fromEnv = motionLevelFromEnv(env);
+  let level: MotionLevel = fromEnv ?? persistedLevel ?? "full";
+  if (detected.screenReader) level = "off";
+  return {
+    level,
+    toggles: { ...DEFAULT_MOTION_POLICY.toggles },
+    noColor: detected.noColor,
+    lowColor: detected.lowColor || detected.dumb,
+    screenReader: detected.screenReader,
+    reducedMotion: detected.reducedMotion,
+  };
+}
+
+/** Idle FPS for the current policy with no consumers must be 0. */
+export function idleFps(policy: MotionPolicy): number {
+  return targetFps(policy, [], []);
+}
+
+export function describePolicy(policy: MotionPolicy): string {
+  const level = effectiveLevel(policy);
+  const bits = [`motion ${level}`];
+  if (policy.noColor) bits.push("NO_COLOR");
+  if (policy.lowColor) bits.push("low-color");
+  if (policy.screenReader) bits.push("screen-reader");
+  if (policy.reducedMotion) bits.push("reduced-motion host");
+  return bits.join(" · ");
+}