@groeponline/pi-wishcraft 1.10.0 → 1.12.0

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+## [1.12.0] - 2026-09-25
+
+### Added
+- Recovered the unmatched vNext gallery motions (ember-trail, lantern-glow, fat-band, and the rest that were not already in the catalog) and the extreme-motion rail candidates (braille wave, boids, chevrons, shimmer, seismograph, fat-band). Assign motion `fat-band` to paint the topographic streaming rail; the default sweep stays a single status row.
+- Deck skills: `w` opens the multi-step new-skill wizard (name, description, template, triggers) and writes `SKILL.md`. `n` remains the one-field create.
+- Appearance route search (`/`) filters presets, palettes, motions, and motion levels. Enter persists a structural base, a streaming motion, or a motion level.
+
+## [1.11.0] - 2026-09-20
+
+### Fixed
+- Deck navigation (reported by Joep): ↑↓ walking the route column is now sticky. Previously ↓ arriving at a list route (Skills, Appearance, Motion, Ideas) was silently consumed by the center list, so walking down the left column appeared to jump sideways into the right pane mid-walk. Focus only crosses columns on an explicit ←/tab (nav) or → (list).
+
+### Changed
+- Motion sweeps traverse on an eased ping-pong instead of a wrapping step: the head decelerates at the rail edges, turns, and glides back — no teleport from the last cell to the first. Each motion's `ease` curve (`linear` / `pulse` / `breathe`) now actually shapes traversal velocity; fractional head positions drive a truecolor trail ramp (hot head cooling to the dim track) replacing the four discrete color steps, and ember/heat heads flicker with the welcome lantern's breathe-plus-ripple curve. Gallery previews render the same eased traversal.
+
 ## [1.10.0] - 2026-09-13
 
 ### Fixed

package/docs/design/signal.md

@@ -55,6 +55,13 @@ idle / ready       0 FPS
 
 Terminal one-shots (`success`, `warning`, `error`) settle their semantic state back to `idle/ready` when the final frame completes. This prevents a completed agent run from leaving `done` painted indefinitely without keeping a background timer alive.
 
+Active sweeps traverse the rail on an eased ping-pong: the head decelerates at
+the edges, turns, and glides back instead of teleporting from the last cell to
+the first. Each motion's `ease` curve (`linear`, `pulse`, `breathe`) shapes the
+traversal, the wake cools through a truecolor ramp from the hot head to the
+dim track, and ember/heat heads flicker with the lantern's breathe-plus-ripple
+curve. ASCII terminals keep the plain directional comet.
+
 Reduced/functional/off motion policies may suppress frames entirely; status text must still communicate the state. `NO_COLOR`, screen-reader flags and ASCII fallback are first-class inputs to the same policy.
 
 ## Fault isolation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groeponline/pi-wishcraft",
-  "version": "1.10.0",
+  "version": "1.12.0",
   "description": "Operator cockpit for Pi: live powerline status, searchable skills, idea queue, sticky Bash, hooks, policy controls, and session UX.",
   "type": "module",
   "files": [

package/src/extension/skills/workbench-catalog.ts

@@ -0,0 +1,60 @@
+/**
+ * Map the skill catalog onto workbench rows (preview, health, sparkline).
+ * The usage ledger stores a count, not a histogram, so the series is that count.
+ */
+
+import {
+  collectSkillDoctorInputs,
+  diagnoseSkills,
+  type SkillDoctorRow,
+} from "./skill-doctor.ts";
+import {
+  readSkillBody,
+  type SkillEntry,
+  type SkillUsage,
+} from "./skill-registry.ts";
+import { parseSkillTriggers, type WorkbenchSkill } from "./workbench.ts";
+
+function usageSeriesOf(usage: SkillUsage | undefined): number[] {
+  if (!usage || usage.count <= 0) return [];
+  return [usage.count];
+}
+
+export function workbenchSkillFromEntry(
+  entry: SkillEntry,
+  usage: ReadonlyMap<string, SkillUsage>,
+  doctorByName?: ReadonlyMap<string, SkillDoctorRow>,
+  body = readSkillBody(entry.filePath),
+): WorkbenchSkill {
+  const used = usage.get(entry.name);
+  const row = doctorByName?.get(entry.name);
+  return {
+    name: entry.name,
+    description: entry.description,
+    category: entry.category,
+    warning: entry.warning,
+    usageCount: used?.count ?? 0,
+    usageSeries: usageSeriesOf(used),
+    health: row?.status ?? (entry.warning ? "warn" : "ok"),
+    bodyPreview: body,
+    triggers: parseSkillTriggers(entry.name, body),
+    filePath: entry.filePath,
+  };
+}
+
+export function loadWorkbenchSkills(cwd: string = process.cwd()): WorkbenchSkill[] {
+  const inputs = collectSkillDoctorInputs(cwd);
+  const rank: Record<SkillDoctorRow["status"], number> = { fail: 0, warn: 1, ok: 2 };
+  const doctorByName = new Map<string, SkillDoctorRow>();
+  for (const row of diagnoseSkills(inputs.entries, inputs.usage, inputs.contents)) {
+    const prev = doctorByName.get(row.skill);
+    if (!prev || rank[row.status] < rank[prev.status]) doctorByName.set(row.skill, row);
+  }
+  return inputs.entries.map((entry) =>
+    workbenchSkillFromEntry(entry, inputs.usage, doctorByName, inputs.contents.get(entry.filePath)),
+  );
+}
+
+export function doctorRowsBySkill(rows: readonly SkillDoctorRow[]): Map<string, SkillDoctorRow> {
+  return new Map(rows.map((row) => [row.skill, row]));
+}

package/src/extension/skills/workbench.ts

@@ -0,0 +1,337 @@
+/**
+ * Skill workbench: split-pane list + metadata + health + sparkline + preview,
+ * plus an inline new-skill wizard and workflow visualization.
+ * Recovered from the closed vNext operator draft and wired to the Deck.
+ */
+
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { getAgentPath } from "../../paths/agent-dirs.ts";
+import { invalidateSkillCache } from "./skill-registry.ts";
+import {
+  SKILL_TEMPLATE_IDS,
+  SkillNameError,
+  isSkillTemplateId,
+  renderSkillTemplate,
+  sanitizeSkillName,
+  type SkillTemplateId,
+} from "./skill-templates.ts";
+import type { SkillDoctorStatus } from "./skill-doctor.ts";
+
+export interface WorkbenchSkill {
+  name: string;
+  description: string;
+  category: string;
+  warning?: string;
+  usageCount: number;
+  usageSeries?: number[];
+  health?: SkillDoctorStatus;
+  bodyPreview?: string;
+  triggers?: string[];
+  filePath?: string;
+}
+
+export const WIZARD_STEPS = [
+  "name",
+  "description",
+  "template",
+  "triggers",
+  "confirm",
+] as const;
+
+export type WizardStep = (typeof WIZARD_STEPS)[number];
+
+export interface SkillWizardState {
+  step: WizardStep;
+  name: string;
+  description: string;
+  template: SkillTemplateId;
+  triggers: string;
+  error: string | null;
+}
+
+export type WizardInputResult =
+  | { type: "update"; wizard: SkillWizardState }
+  | { type: "close" }
+  | { type: "save"; wizard: SkillWizardState };
+
+export function createSkillWizard(): SkillWizardState {
+  return {
+    step: "name",
+    name: "",
+    description: "",
+    template: "standard",
+    triggers: "",
+    error: null,
+  };
+}
+
+export function wizardStepIndex(step: WizardStep): number {
+  return WIZARD_STEPS.indexOf(step);
+}
+
+export function applyWizardInput(state: SkillWizardState, data: string): SkillWizardState {
+  if (data === "escape" || data === "\x1b") return state;
+  if (data === "backspace" || data === "\x7f" || data === "\b") {
+    return editWizardField(state, (value) => value.slice(0, -1));
+  }
+  if (data === "tab" || data === "enter" || data === "\r" || data === "\n") {
+    return advanceWizard(state);
+  }
+  if (data.length === 1 && data >= " " && data <= "~") {
+    return editWizardField(state, (value) => value + data);
+  }
+  return state;
+}
+
+export function handleWizardKey(wizard: SkillWizardState, data: string): WizardInputResult {
+  if (data === "escape" || data === "\x1b") {
+    if (wizard.step === "name") return { type: "close" };
+    return { type: "update", wizard: retreatWizard(wizard) };
+  }
+  if ((data === "[" || data === "]") && wizard.step === "template") {
+    return {
+      type: "update",
+      wizard: cycleWizardTemplate(wizard, data === "]" ? 1 : -1),
+    };
+  }
+  if ((data === "enter" || data === "\r" || data === "\n") && wizardIsComplete(wizard)) {
+    return { type: "save", wizard };
+  }
+  return { type: "update", wizard: applyWizardInput(wizard, data) };
+}
+
+function editWizardField(
+  state: SkillWizardState,
+  edit: (value: string) => string,
+): SkillWizardState {
+  switch (state.step) {
+    case "name":
+      return { ...state, name: edit(state.name), error: null };
+    case "description":
+      return { ...state, description: edit(state.description), error: null };
+    case "triggers":
+      return { ...state, triggers: edit(state.triggers), error: null };
+    case "template": {
+      const next = edit(state.template).trim();
+      return {
+        ...state,
+        template: isSkillTemplateId(next) ? next : state.template,
+        error: null,
+      };
+    }
+    case "confirm":
+      return state;
+    default: {
+      const exhaustive: never = state.step;
+      return exhaustive;
+    }
+  }
+}
+
+export function cycleWizardTemplate(state: SkillWizardState, direction = 1): SkillWizardState {
+  const index = SKILL_TEMPLATE_IDS.indexOf(state.template);
+  const next =
+    SKILL_TEMPLATE_IDS[(index + direction + SKILL_TEMPLATE_IDS.length) % SKILL_TEMPLATE_IDS.length]!;
+  return { ...state, template: next, error: null };
+}
+
+export function advanceWizard(state: SkillWizardState): SkillWizardState {
+  if (state.step === "name") {
+    try {
+      const name = sanitizeSkillName(state.name);
+      return { ...state, name, error: null, step: "description" };
+    } catch (error) {
+      return {
+        ...state,
+        error: error instanceof Error ? error.message : "Invalid skill name",
+      };
+    }
+  }
+  if (state.step === "description") {
+    if (!state.description.trim()) {
+      return { ...state, error: "Description is required" };
+    }
+    return { ...state, step: "template", error: null };
+  }
+  if (state.step === "template") return { ...state, step: "triggers", error: null };
+  if (state.step === "triggers") return { ...state, step: "confirm", error: null };
+  return state;
+}
+
+export function retreatWizard(state: SkillWizardState): SkillWizardState {
+  const index = wizardStepIndex(state.step);
+  if (index <= 0) return state;
+  return { ...state, step: WIZARD_STEPS[index - 1]!, error: null };
+}
+
+export function wizardIsComplete(state: SkillWizardState): boolean {
+  return state.step === "confirm" && !state.error && Boolean(state.name);
+}
+
+export function parseSkillTriggers(name: string, body: string): string[] {
+  const listed: string[] = [];
+  const heading = body.match(/## Triggers\s*\n+([\s\S]*?)(?=\n## |\s*$)/i);
+  if (heading?.[1]) {
+    for (const line of heading[1].split("\n")) {
+      const item = line.replace(/^\s*[-*]\s+/, "").trim();
+      if (item) listed.push(item);
+    }
+  }
+  return listed.length > 0 ? listed : [name, `$${name}`];
+}
+
+export function composeWizardSkill(state: SkillWizardState): string {
+  const name = sanitizeSkillName(state.name);
+  const body = renderSkillTemplate(state.template, name);
+  const triggers = state.triggers
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+  const triggerBlock =
+    triggers.length > 0
+      ? `\n## Triggers\n\n${triggers.map((item) => `- ${item}`).join("\n")}\n`
+      : "";
+  if (!state.description.trim()) return `${body}${triggerBlock}`;
+  return (
+    body.replace(/description: .*/, `description: ${state.description.trim()}`) + triggerBlock
+  );
+}
+
+export function writeWizardSkill(
+  state: SkillWizardState,
+  skillsRoot: string = getAgentPath("skills"),
+): { filePath: string } {
+  const name = sanitizeSkillName(state.name);
+  const dir = join(skillsRoot, name);
+  const filePath = join(dir, "SKILL.md");
+  if (existsSync(filePath)) {
+    throw new SkillNameError(`Skill already exists: ${name}`);
+  }
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, composeWizardSkill({ ...state, name }), "utf8");
+  invalidateSkillCache();
+  return { filePath };
+}
+
+export function renderUsageSparkline(counts: number[], width = 12): string {
+  const blocks = [" ", "▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+  if (width <= 0) return "";
+  if (counts.length === 0) return "·".repeat(width);
+  const series =
+    counts.length >= width
+      ? counts.slice(counts.length - width)
+      : [...Array(width - counts.length).fill(0), ...counts];
+  const max = Math.max(1, ...series);
+  return series
+    .map((value) => {
+      const index = Math.round((value / max) * (blocks.length - 1));
+      return blocks[index] ?? " ";
+    })
+    .join("");
+}
+
+export function renderSkillWorkflow(skill: WorkbenchSkill): string[] {
+  const health = skill.health ?? (skill.warning ? "warn" : "ok");
+  const triggers = skill.triggers?.length ? skill.triggers.join(", ") : "name / $skill";
+  return [
+    `discover(${skill.category}) → health(${health}) → usage(${skill.usageCount}x) → insert`,
+    `triggers: ${triggers}`,
+  ];
+}
+
+export function renderSkillWizard(theme: Theme, width: number, state: SkillWizardState): string[] {
+  const title = theme.fg(
+    "accent",
+    `NEW SKILL WIZARD · step ${wizardStepIndex(state.step) + 1}/${WIZARD_STEPS.length}`,
+  );
+  const lines = [
+    title,
+    `Name: ${state.name || "…"}`,
+    `Description: ${state.description || "…"}`,
+    `Template: ${state.template}`,
+    `Triggers: ${state.triggers || "(none)"}`,
+    "",
+    `Editing: ${state.step}`,
+  ];
+  if (state.error) lines.push(theme.fg("warning", state.error));
+  if (state.step === "confirm") {
+    lines.push("Enter saves · esc cancels");
+    lines.push(...composeWizardSkill(state).split("\n").slice(0, 6));
+  } else {
+    lines.push("type · enter next · [ ] template · backspace edit");
+  }
+  return lines.map((line) => truncateToWidth(line, width, "…", true));
+}
+
+export function renderSkillWorkbench(
+  theme: Theme,
+  width: number,
+  skills: readonly WorkbenchSkill[],
+  selected: number,
+  wizard: SkillWizardState | null,
+): string[] {
+  if (wizard) return renderSkillWizard(theme, width, wizard);
+  if (skills.length === 0) {
+    return [
+      theme.fg("warning", "No skills installed"),
+      "Press n or ctrl+n to open the new-skill wizard",
+    ].map((line) => truncateToWidth(line, width, "…", true));
+  }
+
+  const index = Math.max(0, Math.min(selected, skills.length - 1));
+  const skill = skills[index]!;
+  const leftW = Math.max(12, Math.floor(width * 0.32));
+  const midW = Math.max(16, Math.floor(width * 0.36));
+  const rightW = Math.max(12, width - leftW - midW - 2);
+  const windowSize = 8;
+  const start = Math.max(
+    0,
+    Math.min(index - Math.floor(windowSize / 2), Math.max(0, skills.length - windowSize)),
+  );
+  const visible = skills.slice(start, start + windowSize);
+
+  const list = [
+    theme.fg(
+      "accent",
+      skills.length > windowSize ? `SKILLS ${index + 1}/${skills.length}` : "SKILLS",
+    ),
+    ...visible.map((entry, i) => {
+      const actual = start + i;
+      const marker = actual === index ? "→" : " ";
+      const warn = entry.warning ? " !" : "";
+      return `${marker} ${entry.name}${warn}`;
+    }),
+  ];
+  const meta = [
+    theme.fg("accent", "METADATA"),
+    skill.name,
+    skill.description || "(no description)",
+    `health: ${skill.health ?? (skill.warning ? "warn" : "ok")}`,
+    `usage: ${skill.usageCount}x  ${renderUsageSparkline(skill.usageSeries ?? [skill.usageCount])}`,
+    ...renderSkillWorkflow(skill),
+  ];
+  const preview = [
+    theme.fg("accent", "PREVIEW"),
+    ...(skill.bodyPreview || "(empty body)").split("\n").slice(0, 6),
+  ];
+
+  const rows = Math.max(list.length, meta.length, preview.length);
+  const lines: string[] = [];
+  for (let i = 0; i < rows; i++) {
+    const left = padPlain(list[i] ?? "", leftW);
+    const mid = padPlain(meta[i] ?? "", midW);
+    const right = padPlain(preview[i] ?? "", rightW);
+    lines.push(truncateToWidth(`${left} ${mid} ${right}`, width, "…", true));
+  }
+  lines.push(truncateToWidth("n new skill · ↑↓ select · enter insert", width, "…", true));
+  return lines;
+}
+
+function padPlain(text: string, width: number): string {
+  const plain = text.replace(/\x1b\[[0-9;]*m/g, "");
+  if (plain.length >= width) return truncateToWidth(text, width, "…", true);
+  return text + " ".repeat(width - plain.length);
+}

package/src/extension/ui/deck/appearance-search.ts

@@ -0,0 +1,227 @@
+/**
+ * Search-first appearance catalog recovered from the vNext operator draft.
+ * The Deck appearance route filters this catalog; preset, motion, and level
+ * hits persist through the existing appearance writers.
+ */
+
+import { PRESETS } from "../../../config/presets.ts";
+import { getStructuralPreset } from "../../../config/structural-presets.ts";
+import {
+  STRUCTURAL_PRESET_NAMES,
+  type AppearanceMixConfig,
+  type StructuralPresetName,
+} from "../../../config/types.ts";
+import { describeMotionLevel, isMotionLevel } from "../../../motion/accessibility.ts";
+import { MOTION_CATALOG } from "../../../motion/catalog.ts";
+import type { MotionLevel } from "../../../motion/types.ts";
+
+export const APPEARANCE_PANES = [
+  "presets",
+  "palette",
+  "signal",
+  "glyphs",
+  "motion",
+  "layout",
+  "accessibility",
+] as const;
+
+export type AppearancePane = (typeof APPEARANCE_PANES)[number];
+
+export type AppearanceHitKind =
+  | "preset"
+  | "palette"
+  | "motion"
+  | "level"
+  | "layout"
+  | "glyphs"
+  | "setting";
+
+export interface AppearanceSearchHit {
+  id: string;
+  label: string;
+  group: string;
+  keywords: string;
+  kind: AppearanceHitKind;
+  value: string;
+}
+
+const LAYOUT_PRESETS = Object.keys(PRESETS);
+const LEVELS: MotionLevel[] = ["full", "reduced", "functional", "off"];
+
+export function appearanceCatalog(): AppearanceSearchHit[] {
+  const hits: AppearanceSearchHit[] = [];
+  for (const name of STRUCTURAL_PRESET_NAMES) {
+    const preset = getStructuralPreset(name);
+    hits.push({
+      id: `base:${name}`,
+      label: `${preset.displayName} base`,
+      group: "Presets",
+      keywords: `${name} ${preset.displayName} ${preset.description} preset`,
+      kind: "preset",
+      value: name,
+    });
+    hits.push({
+      id: `palette:${name}`,
+      label: `${preset.displayName} palette`,
+      group: "Palette",
+      keywords: `${name} palette tokens colors`,
+      kind: "palette",
+      value: name,
+    });
+  }
+  for (const motion of MOTION_CATALOG) {
+    hits.push({
+      id: `motion:${motion.id}`,
+      label: motion.name,
+      group: "Motion",
+      keywords: `${motion.id} ${motion.name} ${motion.category} ${motion.description}`,
+      kind: "motion",
+      value: motion.id,
+    });
+  }
+  for (const level of LEVELS) {
+    hits.push({
+      id: `level:${level}`,
+      label: `Motion ${level}`,
+      group: "Accessibility",
+      keywords: `motion level ${level} ${describeMotionLevel(level)} accessibility`,
+      kind: "level",
+      value: level,
+    });
+  }
+  for (const name of LAYOUT_PRESETS) {
+    hits.push({
+      id: `layout:${name}`,
+      label: `Layout ${name}`,
+      group: "Layout",
+      keywords: `layout preset ${name}`,
+      kind: "layout",
+      value: name,
+    });
+  }
+  hits.push(
+    {
+      id: "glyphs:ascii",
+      label: "ASCII glyphs",
+      group: "Glyphs",
+      keywords: "glyphs ascii fallback",
+      kind: "glyphs",
+      value: "ascii",
+    },
+    {
+      id: "glyphs:nerd",
+      label: "Nerd glyphs",
+      group: "Glyphs",
+      keywords: "glyphs nerd font",
+      kind: "glyphs",
+      value: "nerd",
+    },
+    {
+      id: "setting:no-color",
+      label: "Respect NO_COLOR",
+      group: "Accessibility",
+      keywords: "no_color no color ansi",
+      kind: "setting",
+      value: "noColor",
+    },
+  );
+  return hits;
+}
+
+export function searchAppearanceConfig(query: string): AppearanceSearchHit[] {
+  const q = query.trim().toLowerCase();
+  const catalog = appearanceCatalog();
+  if (!q) return catalog;
+  return catalog.filter((hit) => {
+    const hay = `${hit.label} ${hit.group} ${hit.keywords} ${hit.value}`.toLowerCase();
+    return hay.includes(q);
+  });
+}
+
+export function applyAppearanceHit(
+  current: AppearanceMixConfig,
+  hit: AppearanceSearchHit,
+): AppearanceMixConfig {
+  switch (hit.kind) {
+    case "preset":
+      return { ...current, base: hit.value as StructuralPresetName };
+    case "palette":
+      return { ...current, palette: hit.value as StructuralPresetName };
+    case "motion":
+      return {
+        ...current,
+        motion: {
+          ...(typeof current.motion === "object" ? current.motion : {}),
+          streaming: hit.value,
+        },
+      };
+    case "glyphs":
+      return {
+        ...current,
+        glyphs: hit.value === "ascii" ? "vellum" : "hexforge",
+      };
+    case "level":
+    case "layout":
+    case "setting":
+      return current;
+    default: {
+      const exhaustive: never = hit.kind;
+      return exhaustive;
+    }
+  }
+}
+
+export function applyAppearanceSelection(
+  current: AppearanceMixConfig,
+  pane: AppearancePane,
+  value: string,
+): AppearanceMixConfig {
+  if ((pane === "presets" || pane === "palette" || pane === "signal" || pane === "glyphs") && isStructural(value)) {
+    if (pane === "presets") return { ...current, base: value };
+    if (pane === "palette") return { ...current, palette: value };
+    if (pane === "signal") return { ...current, signalLayout: value };
+    return { ...current, glyphs: value };
+  }
+  if (pane === "motion") {
+    return {
+      ...current,
+      motion: {
+        ...(typeof current.motion === "object" ? current.motion : {}),
+        streaming: value,
+      },
+    };
+  }
+  if (pane === "accessibility" && isMotionLevel(value)) return current;
+  if (pane === "layout") return current;
+  return current;
+}
+
+function isStructural(value: string): value is StructuralPresetName {
+  return (STRUCTURAL_PRESET_NAMES as readonly string[]).includes(value);
+}
+
+export function paneOptions(pane: AppearancePane): string[] {
+  switch (pane) {
+    case "presets":
+    case "palette":
+    case "signal":
+    case "glyphs":
+      return [...STRUCTURAL_PRESET_NAMES];
+    case "motion":
+      return MOTION_CATALOG.map((motion) => motion.id);
+    case "layout":
+      return [...LAYOUT_PRESETS];
+    case "accessibility":
+      return [...LEVELS];
+    default: {
+      const exhaustive: never = pane;
+      return exhaustive;
+    }
+  }
+}
+
+export function nextAppearancePane(pane: AppearancePane, direction = 1): AppearancePane {
+  const index = APPEARANCE_PANES.indexOf(pane);
+  const next = (index + direction + APPEARANCE_PANES.length) % APPEARANCE_PANES.length;
+  return APPEARANCE_PANES[next] ?? "presets";
+}