@groeponline/pi-wishcraft 1.11.0 → 1.13.0

package/AGENTS.md

@@ -115,9 +115,11 @@ scripts/github-release.sh
 
 CI workflows (`.github/workflows/`):
 - `test.yml` — Node 24, typecheck, test, circular, verify:package, npm audit
-- `release.yml` — reuses test.yml, prepares release-candidate branch
+- `release.yml` — reuses test.yml, prepares release-candidate branch, publishes on tag, attaches `npm pack` + `SHA256SUMS`
 - `promote-release-candidate.yml` — promotes verified SHA to main, tags, dispatches publish
 
+Tag `vX.Y.Z` must equal `package.json` and sit on `origin/main`. Identity: `src/product-identity.ts --version` / `/signal version`. See [`docs/release.md`](docs/release.md).
+
 Release behavior:
 - **Every main merge with `[Unreleased]` CHANGELOG notes cuts a release automatically** (verify → candidate → promote → tag → npm). Notes-less merges skip candidate creation entirely — no more empty versions.
 - Notes live under `## [Unreleased]` in CHANGELOG.md; the release commit rolls them into the new version heading.

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [1.13.0] - 2026-09-25
+
+### Added
+- `budget` segment (daily token budget): renders `budget NN%` with a fill bar when `wishcraft.tokenBudget.daily.limit` is set; wired into the `chef`, `full`, and `nerd` presets.
+- Resting animation has a real clock: while idle at full motion, the signal rail leases the scheduler's `ambient` channel and breathes from that tick. `reduced`/`off` motion still renders a stable dim marker with no scheduler consumer.
+
+## [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
@@ -31,18 +44,6 @@
 - Bash forward-mode privacy notice (issue #71): the first keystroke forwarded to a running command raises an info notice that typed input may echo into the transcript; documented in `docs/bash-mode.md`.
 - Managed PTY suite is now script-gated (issue #73): PTY-core tests skip when `script(1)` is missing instead of silently passing in degraded pipe mode, the basic run asserts a real PTY transport, and the explicit pipe-mode tests still cover the fallback.
 
-### Changed
-- Signal rail is now a compact single-line state surface. `ready` is stable and costs no animation frames; thinking, streaming, tools, and compaction use a bounded directional trail without expanding the footer to three rows.
-- Chef preset now includes session age, generated-token throughput, and cache-read information when present. The port counter names its protocol (`tcp` or `tcp+udp`) instead of displaying an ambiguous bare count.
-
-### Fixed
-- Bash paste-while-running (issue #72): a bracketed paste performed while a command runs is stripped of its markers and forwarded to the child stdin — including split delivery across input chunks — instead of silently queuing in the editor buffer behind the command.
-- PTY/transcript memory bounds (from jan `fix/runtime-pty-bounds`): a single unterminated output line is capped at a 64 KiB UTF-8 tail with a one-time notice, the partial-escape tail is bounded, and the active transcript command trims head lines/bytes within limits instead of growing unbounded.
-- Segment-options spread hygiene (CodeFactor #86–89): `normalizeSegmentOptions` assigns fields imperatively instead of spreading conditional empty objects.
-- Motion frames that contain multiple terminal columns no longer expand a rail cell and shift the footer layout while they animate.
-- Idle rail no longer samples `Date.now()` without a corresponding repaint clock, eliminating stale or apparently random idle frames.
-- TPS now reports `--` until a live two-sample rate exists, rather than falsely presenting idle telemetry as `0`; the existing `both`/`out`/`in` setting is validated and honored.
-
 ## [1.4.16] - 2026-09-05
 
 ### Fixed

package/build-stamp.json

@@ -0,0 +1 @@
+{"source_sha":"394402d958799308f24ffc284a240b878588a931"}

package/docs/commands.md

@@ -86,7 +86,7 @@ You can also set it in the agent settings file (`~/.pi/agent/settings.json` by d
 | `full` | Everything: hostname, model, path (abbreviated), full git incl commit + ↑/↓, totals, context total, elapsed + clock |
 | `nerd` | Maximum detail for Nerd Font users: qualified model, full tokens + cache, commit, totals, seconds clock |
 | `ascii` | Safe for any terminal: branch + short commit + ↑/↓, tokens, cost, context% (no Nerd glyphs) |
-| `chef` | Fork default: muted colors, slash separators, compact live state rail, session age, TPS in/out, protocol-labelled open ports, generated tokens, cache, subagent cost |
+| `chef` | Fork default: muted colors, slash separators, breathing state rail, session age, TPS in/out, protocol-labelled open ports, generated tokens, cache, budget, subagent cost |
 
 **Environment:** `POWERLINE_NERD_FONTS=1` to force Nerd Fonts, `=0` for ASCII.
 
@@ -99,7 +99,8 @@ Pi core renders the footer as static text, so live click is not possible; action
 - `/tps`: overlay of the live 1s window (same ring as the segment). `/tps <value>` sets `POWERLINE_TPS`
 - `/usage`: session / today / week overlay from `~/.pi/agent/wishcraft-usage.json`
 - `/open-ports`: list listening ports and pick one
-- `/powerline doctor`: diagnostics overlay — settings file validity, unknown presets, Nerd Font detection, git polling, bash-mode status, and queue file health
+- `/powerline doctor`: diagnostics overlay — settings file validity, unknown presets, Nerd Font detection, git polling, bash-mode status, queue file health, and `package.identity`
+- `/powerline version`: `{ version, source_sha }` from `package.json` (SHA only when release-stamped). See [release.md](./release.md).
 - `/powerline export`: export the current preset + effective layout + labels as a JSON snippet (Enter copies it to the clipboard)
 - `alt+p`: **Wishcraft Deck** — operator overlay (Home, Signal, Skills, Ideas, Guardrails, Appearance, …). `g` then a jump key (`h` home, `s` signal, `a` appearance). Escape closes. `/signal menu` still opens Navigate / Configure / Status.
 - `alt+i`: **powerline info**: full open-ports list

package/docs/index.md

@@ -11,6 +11,7 @@ This package is a Pi.dev extension, not a standalone website. The README is the
 - [Skill manager](./skill-manager.md) — browsing, inserting, `/skills doctor`, and `/skills new` templates.
 - [Working vibes](./working-vibes.md) — themed loading messages, modes, and configuration.
 - [Segments & theming](./segments.md) — segment reference, separators, thinking/path/git options, and theme overrides.
+- [Release route](./release.md) — tag == package version, GitHub Release artifacts, and identity.
 
 ## Design System & vNext Specifications
 

package/docs/release.md

@@ -0,0 +1,16 @@
+# Release route
+
+Declared version source: `package.json` `version`. Product tag `vX.Y.Z` must equal that value at the tagged commit, and the commit must be an ancestor of `origin/main`.
+
+Existing flow is unchanged: main pushes with `[Unreleased]` notes still prepare a candidate; promotion still tags protected main and dispatches publish. `scripts/npm-publish.sh` remains the npm publish target.
+
+This route adds GitHub Release evidence on top of that:
+
+1. `.github/workflows/release.yml` re-checks tag == `package.json` and ancestry on `origin/main`.
+2. It writes `build-stamp.json` / `PI_WISHCRAFT_BUILD_SHA` from the tag commit only (never a fake such as `0.0.0`).
+3. It runs `npm pack`, writes `SHA256SUMS`, and attaches those assets to the GitHub Release.
+4. Visible identity: `node --experimental-strip-types src/product-identity.ts --version` prints `{ version, source_sha }`. `/signal version` and `/signal doctor` (`package.identity`) show the same values. Missing stamp/env is `null`, never invented.
+
+`workflow_dispatch` input `tag` backfills the same checks at an existing tag (for example `v1.10.0`) and uploads artifacts. It does not publish to npm. Do not run the backfill from a contract PR.
+
+This document does not create a tag or GitHub Release.

package/docs/segments.md

@@ -6,6 +6,7 @@
 
 - `tps`: live tokens/sec over a rolling 1-second window (EMA-free, no spikes), reporting **output and input** rates separately (`⇡out ⇣in`) so you can see generation speed and incoming prompt tokens at a glance. It shows `--` until two live samples exist, rather than pretending an idle session runs at zero. Set `segmentOptions.tps.mode` to `both`, `out`, or `in`; override with `POWERLINE_TPS` when needed.
 - `open_ports`: count of unique **TCP** listening ports (`ss` → `netstat` → `/proc/net` fallback, dedupes IPv4/IPv6) rendered as `21 tcp`. Set `segmentOptions.openPorts.includeUdp: true` to include noisy UDP (mDNS/DHCP/ephemeral), rendered as `tcp+udp`.
+- `budget`: daily token-budget usage (`budget 62% ▓▓▓▓░░░░`) when `wishcraft.tokenBudget.daily.limit` is configured. Warns through the same threshold colors as the cost segment.
 
 ### Open-port process owners
 
@@ -101,7 +102,7 @@ The `minimal` and `compact` presets keep these off to stay lean; set `showCommit
 
 ## Segments
 
-`model` · `shell_mode` · `path` · `git` · `subagents` · `queue` · `token_in` · `token_out` · `token_total` · `cost` · `context_pct` · `context_total` · `time_spent` · `time` · `session` · `hostname` · `cache_read` · `cache_write` · `thinking` · `tps` · `open_ports` · `extension_statuses`
+`model` · `shell_mode` · `path` · `git` · `subagents` · `queue` · `token_in` · `token_out` · `token_total` · `cost` · `budget` · `context_pct` · `context_total` · `time_spent` · `time` · `session` · `hostname` · `cache_read` · `cache_write` · `thinking` · `tps` · `open_ports` · `extension_statuses`
 
 ## Separators
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groeponline/pi-wishcraft",
-  "version": "1.11.0",
+  "version": "1.13.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/config/presets.ts

@@ -251,6 +251,7 @@ export const PRESETS: Record<StatusLinePreset, PresetDef> = {
       "cost",
       "context_pct",
       "context_total",
+      "budget",
       "time_spent",
       "time",
       "extension_statuses",
@@ -299,6 +300,7 @@ export const PRESETS: Record<StatusLinePreset, PresetDef> = {
       "cost",
       "context_pct",
       "context_total",
+      "budget",
       "time_spent",
       "time",
       "extension_statuses",
@@ -369,6 +371,7 @@ export const PRESETS: Record<StatusLinePreset, PresetDef> = {
       "subagents",
       "cost",
       "context_pct",
+      "budget",
       "time",
     ],
     separator: "slash",

package/src/config/types.ts

@@ -213,6 +213,7 @@ export const BUILTIN_STATUS_LINE_SEGMENT_IDS = [
   "cost",
   "context_pct",
   "context_total",
+  "budget",
   "time_spent",
   "time",
   "session",

package/src/extension/commands/commands.ts

@@ -35,6 +35,7 @@ import { config, normalizePreset } from "../core/state.ts";
 import type { RuntimeState } from "../core/types.ts";
 import { getPowerlineArgumentCompletions } from "./powerline-completions.ts";
 import { settleSignal } from "../../signal/integration.ts";
+import { formatProductIdentity, readProductIdentity } from "../../product-identity.ts";
 
 export function registerCommands(pi: ExtensionAPI, rt: RuntimeState): void {
   registerCdCommand(pi, () => rt.currentCtx?.cwd ?? process.cwd());
@@ -110,6 +111,10 @@ export function registerCommands(pi: ExtensionAPI, rt: RuntimeState): void {
         await runPowerlineDoctor(rt, ctx);
         return;
       }
+      if (normalizedArgs === "version") {
+        ctx.ui.notify(formatProductIdentity(readProductIdentity()).trimEnd(), "info");
+        return;
+      }
       if (normalizedArgs === "export") {
         await runPowerlineExport(ctx);
         return;

package/src/extension/commands/powerline-completions.ts

@@ -11,6 +11,10 @@ export const POWERLINE_SUBCOMMANDS: ReadonlyArray<{
     value: "doctor",
     description: "Run environment and settings diagnostics",
   },
+  {
+    value: "version",
+    description: "Print package version and stamped source SHA",
+  },
   {
     value: "export",
     description: "Export the current status-line configuration",

package/src/extension/commands/powerline-doctor.ts

@@ -13,6 +13,7 @@ import { hasNerdFonts } from "../../theme/icons.ts";
 import { config } from "../core/state.ts";
 import type { RuntimeState } from "../core/types.ts";
 import { showSelectOverlay } from "../ui/menu-views.ts";
+import { readProductIdentity } from "../../product-identity.ts";
 
 export type DoctorStatus = "ok" | "warn" | "fail";
 
@@ -51,6 +52,15 @@ export function buildDoctorReport(
   const cwd = ctx.cwd ?? process.cwd();
   const checks: DoctorCheck[] = [];
 
+  const identity = readProductIdentity();
+  checks.push({
+    status: "ok",
+    name: "package.identity",
+    detail: identity.source_sha
+      ? `${identity.version} source_sha=${identity.source_sha}`
+      : `${identity.version} source_sha=null`,
+  });
+
   // ── Settings ─────────────────────────────────────────────────────────────
   const globalPath = getSettingsPath();
   const projectPath = getProjectSettingsPath(cwd);

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);
+}