@asterxsk/kiln 0.1.0

package/agent/extensions/subagents/src/ui/transcript.ts

@@ -0,0 +1,201 @@
+/**
+ * Transcript rendering for the takeover view: turns a SubagentSnapshot's
+ * normalized transcript + live state into plain wrapped lines. Ported from
+ * v1, with the session-poking replaced by snapshot reads.
+ */
+
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import {
+  truncateToWidth,
+  visibleWidth,
+  wrapTextWithAnsi,
+} from "@earendil-works/pi-tui";
+import type { SubagentSnapshot, TranscriptItem } from "../domain.ts";
+
+const ANSI_PATTERN =
+  // eslint-disable-next-line no-control-regex
+  /[\u001B\u009B][[\]()#;?]*(?:(?:(?:[a-zA-Z\d]*(?:;[a-zA-Z\d]*)*)?\u0007)|(?:(?:\d{1,4}(?:;\d{0,4})*)?[\dA-PR-TZcf-nq-uy=><~]))/g;
+
+/**
+ * Strip raw ANSI codes, expand tabs, and drop control chars. Terminal-expanded
+ * tabs (and stray escapes) make lines wider than the width we declare to the
+ * TUI, which desyncs the renderer and smears the overlay.
+ */
+export function sanitizeText(text: string): string {
+  return text
+    .replace(ANSI_PATTERN, "")
+    .replaceAll("\t", "  ")
+    .replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, "");
+}
+
+function renderUserText(
+  theme: Theme,
+  text: string,
+  width: number,
+  out: string[],
+) {
+  const clean = sanitizeText(text).trim();
+  if (!clean) return;
+  const wrapped = wrapTextWithAnsi(clean, Math.max(10, width - 2));
+  for (let i = 0; i < wrapped.length; i++) {
+    const prefix = i === 0 ? theme.fg("accent", "> ") : "  ";
+    out.push(
+      truncateToWidth(prefix + theme.fg("userMessageText", wrapped[i]), width),
+    );
+  }
+}
+
+function renderThinking(
+  theme: Theme,
+  text: string,
+  width: number,
+  out: string[],
+) {
+  const reasoning = sanitizeText(text).trim();
+  if (!reasoning) return;
+  const prefix = theme.fg("dim", "~ ");
+  // Preserve paragraph breaks so multi-paragraph reasoning doesn't collapse
+  // into one wall of text; each paragraph gets its own `~` continuation.
+  const wrapped = wrapTextWithAnsi(reasoning, Math.max(10, width - 2));
+  for (let i = 0; i < wrapped.length; i++) {
+    const line = wrapped[i];
+    if (line.trim() === "" && i > 0) {
+      out.push("");
+      continue;
+    }
+    out.push(
+      truncateToWidth(
+        (i === 0 ? prefix : "  ") + theme.fg("muted", theme.italic(line)),
+        width,
+      ),
+    );
+  }
+}
+
+function renderAssistantItem(
+  theme: Theme,
+  item: Extract<TranscriptItem, { kind: "assistant" }>,
+  width: number,
+  out: string[],
+) {
+  // A rendered reasoning block is followed by a blank line so the thinking
+  // doesn't run into the answer/tool call that comes next.
+  let pendingGap = false;
+  for (const part of item.parts) {
+    if (part.type === "text") {
+      const text = sanitizeText(part.text).trim();
+      if (!text) continue;
+      if (pendingGap) out.push("");
+      out.push(...wrapTextWithAnsi(text, width));
+      pendingGap = false;
+    } else if (part.type === "thinking") {
+      const before = out.length;
+      renderThinking(
+        theme,
+        part.redacted ? "[redacted reasoning]" : part.text,
+        width,
+        out,
+      );
+      pendingGap = out.length > before;
+    } else if (part.type === "toolCall") {
+      if (pendingGap) out.push("");
+      const preview = part.argsPreview ? sanitizeText(part.argsPreview) : "";
+      const line =
+        theme.fg("muted", "→ ") +
+        theme.fg("toolTitle", part.name) +
+        (preview && preview !== "{}" ? theme.fg("dim", ` ${preview}`) : "");
+      out.push(truncateToWidth(line, width));
+      pendingGap = false;
+    }
+  }
+}
+
+function renderToolResultItem(
+  theme: Theme,
+  item: Extract<TranscriptItem, { kind: "toolResult" }>,
+  width: number,
+  out: string[],
+) {
+  const firstLine =
+    sanitizeText(item.outputPreview ?? "")
+      .split("\n")
+      .find((line) => line.trim()) ?? "";
+  const label = item.isError
+    ? theme.fg("error", "  error: ")
+    : theme.fg("dim", "  output: ");
+  out.push(
+    truncateToWidth(label + theme.fg("dim", firstLine || "(no output)"), width),
+  );
+}
+
+/** Render a subagent's conversation as plain lines, wrapped to `width`. */
+export function buildTranscriptLines(
+  snap: SubagentSnapshot,
+  width: number,
+  theme: Theme,
+): string[] {
+  const out: string[] = [];
+
+  for (const item of snap.transcript) {
+    const before = out.length;
+    if (item.kind === "user") {
+      renderUserText(theme, item.text, width, out);
+    } else if (item.kind === "assistant") {
+      renderAssistantItem(theme, item, width, out);
+    } else {
+      renderToolResultItem(theme, item, width, out);
+    }
+    if (out.length > before) out.push("");
+  }
+  while (out.length > 0 && out[out.length - 1] === "") out.pop();
+
+  // Live streaming assistant buffers (cleared when the finalized message lands).
+  if (snap.liveAssistant) {
+    const { thinking, text } = snap.liveAssistant;
+    const before = out.length;
+    if (out.length > 0) out.push("");
+    if (thinking.trim()) renderThinking(theme, thinking, width, out);
+    if (text.trim()) {
+      // Separate the streamed answer from the reasoning block above it.
+      if (thinking.trim()) out.push("");
+      out.push(...wrapTextWithAnsi(sanitizeText(text).trim(), width));
+    }
+    if (out.length === before + 1) out.pop();
+  }
+
+  // Live tool executions (present until the ToolEnd lands in the transcript).
+  for (const tool of snap.liveTools) {
+    if (out.length > 0) out.push("");
+    const marker = tool.done
+      ? tool.isError
+        ? theme.fg("error", "error")
+        : theme.fg("success", "done")
+      : theme.fg("warning", "running");
+    let line = `${theme.fg("toolTitle", tool.name)} · ${marker}`;
+    const preview = tool.outputPreview && sanitizeText(tool.outputPreview);
+    if (preview) line += theme.fg("dim", ` · ${preview}`);
+    out.push(truncateToWidth(line, width));
+  }
+
+  // Queued steering/follow-up messages: show them immediately so Enter
+  // visibly acknowledges the user's input instead of appearing to do nothing.
+  for (const message of snap.queued) {
+    if (out.length > 0) out.push("");
+    const prefix = theme.fg("warning", `> [queued ${message.kind}] `);
+    const wrapped = wrapTextWithAnsi(
+      sanitizeText(message.text),
+      Math.max(10, width - visibleWidth(prefix)),
+    );
+    for (let i = 0; i < wrapped.length; i++) {
+      out.push(
+        truncateToWidth(
+          (i === 0 ? prefix : " ".repeat(visibleWidth(prefix))) +
+            theme.fg("muted", wrapped[i]),
+          width,
+        ),
+      );
+    }
+  }
+
+  return out;
+}

package/agent/extensions/subagents/takeover.test.ts

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import {
+  reconcileDashboardSelection,
+  type DashboardSelection,
+} from "./src/ui/takeover.ts";
+
+test("dashboard selection follows its subagent id and falls back by row", () => {
+  const selection: DashboardSelection = { id: "sa-7", index: 6 };
+
+  reconcileDashboardSelection(selection, [
+    { id: "sa-new" },
+    ...Array.from({ length: 8 }, (_, index) => ({ id: `sa-${index + 1}` })),
+  ]);
+  assert.deepEqual(selection, { id: "sa-7", index: 7 });
+
+  reconcileDashboardSelection(selection, [
+    ...Array.from({ length: 6 }, (_, index) => ({ id: `sa-${index + 1}` })),
+    { id: "sa-8" },
+    { id: "sa-9" },
+  ]);
+  assert.deepEqual(selection, { id: "sa-9", index: 7 });
+
+  reconcileDashboardSelection(selection, [{ id: "sa-1" }, { id: "sa-2" }]);
+  assert.deepEqual(selection, { id: "sa-2", index: 1 });
+
+  reconcileDashboardSelection(selection, []);
+  assert.deepEqual(selection, { id: undefined, index: 0 });
+});

package/agent/extensions/subagents/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "plugins": [{ "name": "@effect/language-service" }]
+  },
+  "include": ["index.ts", "src/**/*.ts", "*.test.ts"]
+}

package/agent/extensions/taste/index.ts

@@ -0,0 +1,443 @@
+/**
+ * pi-taste — local "taste" learning, no npx / no network.
+ *
+ * Mirrors Command Code's Taste but entirely on-disk:
+ *  - Learns preferences from each completed request via the active local model.
+ *  - Stores them as markdown at two scopes:
+ *      Global : ~/.pi/agent/extensions/taste/taste.md   (applies to ALL projects)
+ *      Project: <cwd>/.pi/taste/taste.md                (this codebase only)
+ *  - Feeds high-confidence learnings back into the system prompt each turn.
+ *
+ * Confidence system: new learning = newConfidence (0.40); a repeat (same
+ * category + normalized text) raises confidence by repeatIncrement (0.10),
+ * capped at 0.95. Only learnings >= applyThreshold (0.60) are injected.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+import { uuidv7 } from "@earendil-works/pi-ai";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+// ---- Paths -------------------------------------------------------------
+// Global taste lives INSIDE this extension's folder (per user request).
+const EXT_DIR = path.join(os.homedir(), ".pi", "agent", "extensions", "taste");
+const GLOBAL_TASTE = path.join(EXT_DIR, "taste.md");
+const GLOBAL_SETTINGS = path.join(EXT_DIR, "settings.json");
+
+const projectTasteFile = (cwd: string) =>
+  path.join(cwd, CONFIG_DIR_NAME, "taste", "taste.md");
+const projectSettingsFile = (cwd: string) =>
+  path.join(cwd, CONFIG_DIR_NAME, "taste", "settings.json");
+
+// ---- Settings ----------------------------------------------------------
+interface Settings {
+  learning: boolean;
+  applyThreshold: number;
+  newConfidence: number;
+  repeatIncrement: number;
+  minPromptLength: number;
+  minIntervalMs: number;
+}
+
+const DEFAULTS: Settings = {
+  learning: true,
+  applyThreshold: 0.6,
+  newConfidence: 0.4,
+  repeatIncrement: 0.1,
+  minPromptLength: 20,
+  minIntervalMs: 15000,
+};
+
+function loadSettings(file: string): Settings {
+  try {
+    if (fs.existsSync(file)) {
+      return { ...DEFAULTS, ...JSON.parse(fs.readFileSync(file, "utf8")) };
+    }
+  } catch {
+    /* corrupt settings -> defaults */
+  }
+  return { ...DEFAULTS };
+}
+
+// ---- Taste data model --------------------------------------------------
+interface Item {
+  text: string;
+  confidence: number;
+}
+type Taste = Map<string, Item[]>;
+
+const normalize = (s: string) =>
+  s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+
+function parseTaste(text: string): Taste {
+  const taste: Taste = new Map();
+  let category = "Other";
+  for (const line of text.split(/\r?\n/)) {
+    const h = line.match(/^#\s+(.+?)\s*$/);
+    if (h) {
+      category = h[1].trim() || "Other";
+      if (!taste.has(category)) taste.set(category, []);
+      continue;
+    }
+    const b = line.match(
+      /^-\s+(.*?)\s*\.\s*Confidence:\s*([0-9]+(?:\.[0-9]+)?)\s*$/i,
+    );
+    if (b) {
+      const items = taste.get(category) ?? [];
+      items.push({ text: b[1].trim(), confidence: parseFloat(b[2]) });
+      taste.set(category, items);
+    }
+  }
+  return taste;
+}
+
+function serializeTaste(taste: Taste): string {
+  const lines: string[] = [];
+  for (const [category, items] of taste) {
+    if (items.length === 0) continue;
+    lines.push(`# ${category}`);
+    for (const it of [...items].sort((a, b) => b.confidence - a.confidence)) {
+      lines.push(`- ${it.text}. Confidence: ${it.confidence.toFixed(2)}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd() + "\n";
+}
+
+/** Merge one learning; returns true if the file should be rewritten. */
+function mergeLearning(
+  taste: Taste,
+  category: string,
+  preference: string,
+  s: Settings,
+): boolean {
+  const cat = category.trim() || "Other";
+  const norm = normalize(preference);
+  if (!norm) return false;
+
+  const items = taste.get(cat) ?? [];
+  const existing = items.find((i) => normalize(i.text) === norm);
+  if (existing) {
+    const before = existing.confidence;
+    existing.confidence = Math.min(
+      0.95,
+      +(existing.confidence + s.repeatIncrement).toFixed(2),
+    );
+    return existing.confidence !== before;
+  }
+  items.push({ text: preference.trim(), confidence: s.newConfidence });
+  taste.set(cat, items);
+  return true;
+}
+
+function readTaste(file: string): Taste {
+  try {
+    if (fs.existsSync(file)) return parseTaste(fs.readFileSync(file, "utf8"));
+  } catch {
+    /* unreadable -> empty */
+  }
+  return new Map();
+}
+
+function writeTaste(file: string, taste: Taste): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, serializeTaste(taste), "utf8");
+}
+
+function safeDelete(file: string): void {
+  try {
+    if (fs.existsSync(file)) fs.unlinkSync(file);
+  } catch {
+    /* ignore */
+  }
+}
+
+// ---- Apply: build the system-prompt section ----------------------------
+function tasteToLines(taste: Taste, threshold: number): string[] {
+  const out: string[] = [];
+  for (const [cat, items] of taste) {
+    const applied = items.filter((i) => i.confidence >= threshold);
+    if (applied.length === 0) continue;
+    out.push(`**${cat}**`);
+    for (const it of [...applied].sort((a, b) => b.confidence - a.confidence)) {
+      out.push(`- ${it.text}. (conf ${it.confidence.toFixed(2)})`);
+    }
+  }
+  return out;
+}
+
+function buildTasteSection(
+  gTaste: Taste,
+  pTaste: Taste,
+  gThresh: number,
+  pThresh: number,
+): string {
+  const gLines = tasteToLines(gTaste, gThresh);
+  const pLines = tasteToLines(pTaste, pThresh);
+  if (gLines.length === 0 && pLines.length === 0) return "";
+
+  const parts = [
+    "## Your learned taste (pi-taste)",
+    "",
+    "Preferences learned from your past requests. Follow them unless the current request clearly overrides.",
+    "",
+  ];
+  if (gLines.length) {
+    parts.push("### Global preferences (all projects)");
+    parts.push(...gLines, "");
+  }
+  if (pLines.length) {
+    parts.push("### This project");
+    parts.push(...pLines, "");
+  }
+  return parts.join("\n").trimEnd();
+}
+
+// ---- Learn: extract preferences via the active local model ------------
+interface RawLearning {
+  category?: string;
+  preference?: string;
+  scope?: "global" | "project";
+}
+
+const EXTRACT_PROMPT = `You are a coding-preference extractor. Given a user's coding request and the assistant's outcome, extract DURABLE preferences about how this user likes to work.
+
+Rules:
+- Extract only preferences clearly evidenced by the request or the resulting choices: tooling, libraries, language style, architecture, testing, git/commit style, documentation, or communication/format.
+- Do NOT extract task-specific facts (file names, bug locations, one-off decisions).
+- For each, set scope:
+    - "global"  if it applies to ANY software project regardless of language/stack (e.g. "prefer pnpm", "write concise commit messages").
+    - "project" if it is specific to THIS codebase (its languages, frameworks, conventions, file layout).
+- Choose a short category from: CLI, TypeScript, JavaScript, Python, Rust, Go, Architecture, Testing, Git, Documentation, Style, Tooling, Communication, Other.
+
+Return ONLY minified JSON: an array of {"category":string,"preference":string,"scope":"global"|"project"}. No markdown fences, no commentary. If nothing durable, return [].`;
+
+function parseLearnings(text: string): RawLearning[] {
+  let t = text.trim();
+  const fence = t.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fence) t = fence[1].trim();
+  try {
+    const parsed = JSON.parse(t);
+    if (!Array.isArray(parsed)) return [];
+    return parsed
+      .filter(
+        (x) =>
+          x &&
+          typeof x.preference === "string" &&
+          x.preference.trim().length > 0,
+      )
+      .map((x) => ({
+        category: typeof x.category === "string" ? x.category : "Other",
+        preference: x.preference,
+        scope: x.scope === "global" ? "global" : "project",
+      }));
+  } catch {
+    return [];
+  }
+}
+
+function lastAssistantText(ctx: ExtensionContext): string {
+  const entries = ctx.sessionManager.getEntries();
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const e = entries[i];
+    if (e.type === "message" && e.message?.role === "assistant") {
+      const c = e.message.content;
+      if (typeof c === "string") return c;
+      if (Array.isArray(c)) {
+        return c
+          .filter((p: any) => p?.type === "text")
+          .map((p: any) => p.text)
+          .join("\n");
+      }
+      return "";
+    }
+  }
+  return "";
+}
+
+async function extractLearnings(
+  ctx: ExtensionContext,
+  userPrompt: string,
+  assistantText: string,
+): Promise<RawLearning[]> {
+  if (!ctx.model) return [];
+  if (!ctx.modelRegistry.hasConfiguredAuth(ctx.model)) return [];
+
+  const context = {
+    messages: [
+      {
+        role: "user" as const,
+        content: [
+          {
+            type: "text" as const,
+            text:
+              EXTRACT_PROMPT +
+              `\n\nUSER REQUEST:\n${userPrompt}\n\nASSISTANT OUTCOME:\n${assistantText}`,
+          },
+        ],
+        timestamp: Date.now(),
+      },
+    ],
+  } as any;
+
+  const res = await ctx.modelRegistry.complete(ctx.model, context, {
+    reasoningEffort: "low",
+    cacheRetention: "none",
+    sessionId: uuidv7(),
+  });
+
+  const text = res.content
+    .filter((c: any) => c.type === "text")
+    .map((c: any) => c.text)
+    .join("");
+  return parseLearnings(text);
+}
+
+// ---- Wiring ------------------------------------------------------------
+export default function (pi: ExtensionAPI) {
+  let lastUserPrompt = "";
+  let lastLearnAt = 0;
+  let pendingLearn: Promise<void> | null = null;
+  // True only between a genuine user `input` and that turn's `agent_settled`.
+  // Synthetic re-runs (auto-compaction, retries) emit no `input`, so this
+  // stays false and we never learn preferences from a system-generated prompt.
+  let freshInput = false;
+
+  // A genuine user submission arms learning. Extension-injected messages
+  // (source "extension") are excluded so we don't learn the taste of our own
+  // meta-prompts (e.g. review-subagent instructions).
+  pi.on("input", (event) => {
+    if (event.source !== "extension") freshInput = true;
+  });
+
+  // Apply: inject learned taste before each agent run.
+  pi.on("before_agent_start", (event, ctx) => {
+    if (freshInput) lastUserPrompt = event.prompt ?? "";
+
+
+    const gSettings = loadSettings(GLOBAL_SETTINGS);
+    const pSettings = loadSettings(projectSettingsFile(ctx.cwd));
+    const gTaste = readTaste(GLOBAL_TASTE);
+    const pTaste = readTaste(projectTasteFile(ctx.cwd));
+
+    const section = buildTasteSection(
+      gTaste,
+      pTaste,
+      gSettings.applyThreshold,
+      pSettings.applyThreshold,
+    );
+    if (!section) return;
+    return { systemPrompt: event.systemPrompt + "\n\n" + section };
+  });
+
+  // Learn: after a request fully settles (no retry/compact/follow-up left).
+  pi.on("agent_settled", async (_event, ctx) => {
+    const gSettings = loadSettings(GLOBAL_SETTINGS);
+    const pSettings = loadSettings(projectSettingsFile(ctx.cwd));
+    if (!gSettings.learning && !pSettings.learning) return;
+    if (!freshInput) return; // synthetic re-run (e.g. auto-compaction) — skip
+    freshInput = false; // this genuine turn is now being consumed
+
+    const prompt = lastUserPrompt.trim();
+    if (!prompt || prompt.length < gSettings.minPromptLength) return;
+    if (prompt.startsWith("/taste")) return; // don't learn from our own command
+
+    // Rate-limit window follows whichever scope is actually learning.
+    const interval = gSettings.learning
+      ? gSettings.minIntervalMs
+      : pSettings.minIntervalMs;
+    if (Date.now() - lastLearnAt < interval) return;
+
+    const assistantText = lastAssistantText(ctx);
+    if (!assistantText) return;
+
+    const learnings = await extractLearnings(ctx, prompt, assistantText);
+    if (learnings.length === 0) return;
+
+    // Only consume the cooldown once we actually learned something.
+    lastLearnAt = Date.now();
+
+    const task = (async () => {
+      let wrote = false;
+      for (const l of learnings) {
+        const isGlobal = l.scope === "global";
+        const settings = isGlobal ? gSettings : pSettings;
+        if (!settings.learning) continue;
+        const file = isGlobal ? GLOBAL_TASTE : projectTasteFile(ctx.cwd);
+        const taste = readTaste(file);
+        if (mergeLearning(taste, l.category ?? "Other", l.preference ?? "", settings)) {
+          writeTaste(file, taste);
+          wrote = true;
+        }
+      }
+      if (wrote && ctx.hasUI) {
+        ctx.ui.notify(
+          `TASTE learned ${learnings.length} preference(s)`,
+          "info",
+        );
+      }
+    })();
+    pendingLearn = task;
+    await task;
+  });
+
+  // Flush any in-flight learning so it isn't lost on exit.
+  pi.on("session_shutdown", async () => {
+    if (pendingLearn) {
+      try {
+        await pendingLearn;
+      } catch {
+        /* ignore */
+      }
+    }
+  });
+
+  // /taste — view or reset learnings.
+  pi.registerCommand("taste", {
+    description:
+      "Show or reset learned taste. Usage: /taste [reset [global|project]]",
+    handler: async (args, ctx) => {
+      const parts = args.trim().split(/\s+/).filter(Boolean);
+      if (parts[0] === "reset") {
+        const scope = parts[1];
+        if (scope === "global") {
+          safeDelete(GLOBAL_TASTE);
+          ctx.ui.notify("Cleared global taste.", "info");
+        } else if (scope === "project") {
+          safeDelete(projectTasteFile(ctx.cwd));
+          ctx.ui.notify("Cleared project taste.", "info");
+        } else if (!scope) {
+          safeDelete(GLOBAL_TASTE);
+          safeDelete(projectTasteFile(ctx.cwd));
+          ctx.ui.notify("Cleared global + project taste.", "info");
+        } else {
+          ctx.ui.notify(
+            `Unknown scope '${scope}'. Use 'global' or 'project'.`,
+            "warning",
+          );
+        }
+        return;
+      }
+
+      const g = readTaste(GLOBAL_TASTE);
+      const p = readTaste(projectTasteFile(ctx.cwd));
+      const gSettings = loadSettings(GLOBAL_SETTINGS);
+      const pSettings = loadSettings(projectSettingsFile(ctx.cwd));
+      const count = (t: Taste) =>
+        [...t.values()].reduce((n, a) => n + a.length, 0);
+      const applied = (t: Taste, th: number) =>
+        [...t.values()].flat().filter((i) => i.confidence >= th).length;
+
+      ctx.ui.notify(
+        [
+          `TASTE — global : ${count(g)} prefs (${applied(g, gSettings.applyThreshold)} applied) → ${GLOBAL_TASTE}`,
+          `TASTE — project: ${count(p)} prefs (${applied(p, pSettings.applyThreshold)} applied) → ${projectTasteFile(ctx.cwd)}`,
+          `Run '/taste reset [global|project]' to clear.`,
+        ].join("\n"),
+        "info",
+      );
+    },
+  });
+}

package/agent/extensions/taste/install.ps1

@@ -0,0 +1,23 @@
+#!/usr/bin/env pwsh
+# Per-extension installer — Windows / PowerShell
+# Installs npm dependencies for this extension. No-op if no package.json.
+$ErrorActionPreference = "Stop"
+$extDir = $PSScriptRoot
+if (-not $extDir) { $extDir = Split-Path -Parent $MyInvocation.MyCommand.Path }
+if (-not (Test-Path "$extDir/package.json")) {
+  Write-Host "  - no package.json — skipping" -ForegroundColor DarkGray
+  exit 0
+}
+if (-not (Get-Command npm -ErrorAction SilentlyContinue)) {
+  Write-Host "  x npm not found — install Node.js 22+" -ForegroundColor Red
+  exit 1
+}
+if (Test-Path "$extDir/package-lock.json") {
+  Write-Host "  - npm ci" -ForegroundColor DarkGray
+  npm --prefix $extDir ci --no-audit --no-fund
+} else {
+  Write-Host "  - npm install" -ForegroundColor DarkGray
+  npm --prefix $extDir install --no-audit --no-fund
+}
+if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
+Write-Host "  + done" -ForegroundColor Green