takomi 2.1.44 → 2.1.45

package/.pi/extensions/takomi-context-manager/diagnostics-tools.ts

@@ -2,9 +2,10 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { AutocompleteItem } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import type { ContextManagerState } from "./state";
-import { renderReport, type ContextReportMode } from "./diagnostics";
+import { contextReportPresentation, renderReport, type ContextReportMode } from "./diagnostics";
 import { discoverSkillsFromFilesystem, mergeSkills } from "./skill-registry";
 import { persistReportSnapshot, restoreReportFromSession } from "./session-state";
+import { renderCompactCard, renderExpandedMarkdown, renderToolCall, resultText, sanitizePresentation } from "./tool-renderers";
 
 export function registerDiagnostics(pi: ExtensionAPI, state: ContextManagerState): void {
   pi.registerTool({
@@ -29,7 +30,44 @@ export function registerDiagnostics(pi: ExtensionAPI, state: ContextManagerState
       state.report.toolCalls.contextReport += 1;
       persistReportSnapshot(pi, state, "context_report");
       const mode = (params.verbose ? "verbose" : params.mode ?? "summary") as ContextReportMode;
-      return { content: [{ type: "text", text: renderReport(state, mode) }], details: { ...state.report, mode } };
+      const text = renderReport(state, mode);
+      // Keep model-facing content exactly as requested. Expanded presentation
+      // renders that same mode-specific report rather than silently promoting
+      // summary/problems requests to verbose diagnostics.
+      const presentation = contextReportPresentation(state);
+      return { content: [{ type: "text", text }], details: { ...state.report, mode, presentation } };
+    },
+    renderCall(args, theme) {
+      return renderToolCall("context_report", args.verbose ? "verbose" : args.mode ?? "summary", theme);
+    },
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as {
+        mode?: ContextReportMode;
+        skillCount?: number;
+        loadedByTool?: string[];
+        loadedPolicies?: string[];
+        presentation?: {
+          status?: "success" | "warning" | "error" | "pending";
+          summary?: string;
+          attentionCount?: number;
+        };
+      } | undefined;
+      const presentation = details?.presentation;
+      const text = resultText(result);
+      const status = presentation?.status ?? "pending";
+      const summary = presentation?.summary ?? "Informational";
+      const attentionCount = presentation?.attentionCount ?? 0;
+      const metadata = `${details?.skillCount ?? 0} skills · ${details?.loadedPolicies?.length ?? 0} policies loaded · ${attentionCount} attention items`;
+      if (!expanded) {
+        return renderCompactCard({ status, title: "Context health", summary, metadata }, theme);
+      }
+      return renderExpandedMarkdown({
+        status,
+        title: "Context report",
+        summary,
+        metadata: [metadata, `Requested mode: ${details?.mode ?? "summary"}`],
+        markdown: text,
+      }, theme);
     },
   });
 
@@ -55,7 +93,7 @@ export function registerDiagnostics(pi: ExtensionAPI, state: ContextManagerState
       persistReportSnapshot(pi, state, "context-report-command");
       const requested = args.trim();
       const mode: ContextReportMode = requested === "verbose" || requested === "problems" || requested === "summary" ? requested : "summary";
-      ctx.ui.notify(renderReport(state, mode), "info");
+      ctx.ui.notify(sanitizePresentation(renderReport(state, mode)), "info");
     },
   });
 }

package/.pi/extensions/takomi-context-manager/diagnostics.ts

@@ -139,6 +139,32 @@ function overallStatus(issues: ReportIssue[]): { label: string; next: string; wa
   return { label: "⚠ Attention Required", next: actionable[0].fix, warningCount: actionable.length };
 }
 
+export type ContextReportPresentation = {
+  status: "success" | "warning" | "error" | "pending";
+  summary: string;
+  attentionCount: number;
+};
+
+/** Structured execution metadata shared by context_report renderers. */
+export function contextReportPresentation(state: ContextManagerState): ContextReportPresentation {
+  syncReportLedger(state);
+  const issues = collectIssues(state);
+  const overall = overallStatus(issues);
+  const actionable = issues.filter((issue) => issue.severity !== "info");
+  const status = issues.length === 0
+    ? "success"
+    : actionable.some((issue) => issue.severity === "failed" || issue.severity === "blocked")
+      ? "error"
+      : actionable.length > 0
+        ? "warning"
+        : "pending";
+  return {
+    status,
+    summary: overall.label.replace(/^[^\w]+\s*/, ""),
+    attentionCount: overall.warningCount,
+  };
+}
+
 function promptRewriteState(state: ContextManagerState): string {
   const rewrite = state.report.promptRewrite;
   if (!rewrite.attempted) return "Not run yet";

package/.pi/extensions/takomi-context-manager/index.ts

@@ -1,7 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { loadConfig, DEFAULT_CONFIG } from "./config";
 import { createState } from "./state";
-import { collectSkillsFromOptions, collectSkillsFromXml, discoverSkillsFromFilesystem, mergeSkills } from "./skill-registry";
+import { collectSkillsFromOptions, collectSkillsFromXml, discoverSkillsFromFilesystem, enrichSkillsWithInstallerTaxonomy, mergeSkills } from "./skill-registry";
 import { discoverPolicies } from "./policy-registry";
 import { findCandidates } from "./context-router";
 import { rewritePrompt } from "./prompt-rewriter";
@@ -48,10 +48,11 @@ export default function takomiContextManager(pi: ExtensionAPI) {
     const optionSkills = collectSkillsFromOptions(event.systemPromptOptions);
     const xmlSkills = collectSkillsFromXml(event.systemPrompt);
     const suppliedSkills = [...optionSkills, ...xmlSkills];
+    const enrichedSuppliedSkills = await enrichSkillsWithInstallerTaxonomy(suppliedSkills);
     const filesystemSkills = suppliedSkills.length === 0
       ? await discoverSkillsFromFilesystem(ctx.cwd)
       : [];
-    state.skills = mergeSkills([...filesystemSkills, ...suppliedSkills]);
+    state.skills = mergeSkills([...filesystemSkills, ...enrichedSuppliedSkills]);
 
     const candidates = findCandidates(event.prompt, state.skills, config);
     const rewrite = rewritePrompt(event.systemPrompt, state.skills, candidates, config);

package/.pi/extensions/takomi-context-manager/model-policy-gate.ts

@@ -7,6 +7,7 @@ import { recordBlocked } from "./state";
 import { resolveTakomiRoutingPolicy } from "../takomi-runtime/routing-policy";
 import { approvedModelEquivalent, isTakomiModelApproved } from "../takomi-runtime/model-routing-defaults";
 import { persistReportSnapshot } from "./session-state";
+import { sanitizePresentation } from "./tool-renderers";
 
 type Settings = {
   takomi?: { modelRoutingPolicyFile?: string };
@@ -162,18 +163,40 @@ type RecoveryChoice =
   | { action: "retry"; model: string }
   | { action: "stop" };
 
+type RecoveryOptions = {
+  options: string[];
+  retryModels: Map<string, string>;
+};
+
+/**
+ * Keep policy model IDs raw for selection and mutation, while passing only
+ * presentation-safe labels to the terminal UI. Disambiguate labels that become
+ * identical after sanitization so a selected label still maps to one raw ID.
+ */
+function recoveryOptions(approved: string[]): RecoveryOptions {
+  const retryModels = new Map<string, string>();
+  const options: string[] = [];
+  for (const model of approved) {
+    const baseLabel = `Retry with ${sanitizePresentation(model)}`;
+    let label = baseLabel;
+    let duplicate = 2;
+    while (retryModels.has(label)) label = `${baseLabel} (${duplicate++})`;
+    retryModels.set(label, model);
+    options.push(label);
+  }
+  options.push("Stop and let me send a new prompt");
+  return { options, retryModels };
+}
+
 async function askForInvalidModelRecovery(ctx: { ui: { select(title: string, options: string[]): Promise<string | undefined>; notify(message: string, level?: string): void }; abort?: () => void }, requested: string, approved: string[]): Promise<RecoveryChoice> {
   if (approved.length === 0) return { action: "stop" };
-  const options = [
-    ...approved.map((model) => `Retry with ${model}`),
-    "Stop and let me send a new prompt",
-  ];
+  const recovery = recoveryOptions(approved);
   const choice = await ctx.ui.select(
-    `takomi_subagent requested a model outside your routing policy: ${requested}`,
-    options,
+    sanitizePresentation(`takomi_subagent requested a model outside your routing policy: ${requested}`),
+    recovery.options,
   );
-  if (choice?.startsWith("Retry with ")) return { action: "retry", model: choice.replace("Retry with ", "") };
-  return { action: "stop" };
+  const model = choice ? recovery.retryModels.get(choice) : undefined;
+  return model ? { action: "retry", model } : { action: "stop" };
 }
 
 export function installModelPolicyGate(pi: ExtensionAPI, state: ContextManagerState): void {
@@ -221,7 +244,8 @@ export function installModelPolicyGate(pi: ExtensionAPI, state: ContextManagerSt
         timestamp,
       })));
       persistReportSnapshot(pi, state, "model-policy-correction");
-      ctx.ui.notify(`Takomi context manager corrected subagent model routing:\n- ${corrections.map((correction) => `${correction.from} -> ${correction.to}${correction.recovery ? ` (${correction.recovery})` : ""}`).join("\n- ")}\n\nBe careful to follow /takomi routing policy next time.`, "warning");
+      const notification = `Takomi context manager corrected subagent model routing:\n- ${corrections.map((correction) => `${sanitizePresentation(correction.from)} -> ${sanitizePresentation(correction.to)}${correction.recovery ? ` (${sanitizePresentation(correction.recovery)})` : ""}`).join("\n- ")}\n\nBe careful to follow /takomi routing policy next time.`;
+      ctx.ui.notify(notification, "warning");
     }
   });
 
@@ -231,12 +255,9 @@ export function installModelPolicyGate(pi: ExtensionAPI, state: ContextManagerSt
     if (!isModelFailure(content)) return;
 
     const snapshot = await loadSnapshot(ctx.cwd);
-    const options = [
-      ...snapshot.approvedModels.map((model) => `Retry with ${model}`),
-      "Stop and let me send a new prompt",
-    ];
-    const choice = await ctx.ui.select("Takomi subagent model/provider failure. How do you want to continue?", options);
-    const retryModel = choice?.startsWith("Retry with ") ? choice.replace("Retry with ", "") : undefined;
+    const recovery = recoveryOptions(snapshot.approvedModels);
+    const choice = await ctx.ui.select("Takomi subagent model/provider failure. How do you want to continue?", recovery.options);
+    const retryModel = choice ? recovery.retryModels.get(choice) : undefined;
     const stopped = !retryModel;
     const guidance = [
       "Takomi subagent failed with a model/provider-related error.",

package/.pi/extensions/takomi-context-manager/policy-tools.ts

@@ -1,42 +1,93 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import type { ContextManagerState } from "./state";
-import { syncReportLedger } from "./state";
-import { renderPolicies, renderPolicyManifest } from "./policy-registry";
-import { persistReportSnapshot, restoreReportFromSession } from "./session-state";
-
-export function registerPolicyTools(pi: ExtensionAPI, state: ContextManagerState): void {
-  pi.registerTool({
-    name: "policy_manifest",
-    label: "Policy Manifest",
-    description: "Return descriptions for available context policy packs without loading full policy content.",
-    promptSnippet: "Show available context policy pack descriptions",
-    parameters: Type.Object({ policies: Type.Optional(Type.Array(Type.String({ description: "Policy name to inspect" }))) }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      restoreReportFromSession(state, ctx);
-      state.report.timestamp = new Date().toISOString();
-      state.report.cwd = ctx.cwd;
-      state.report.toolCalls.policyManifest += 1;
-      persistReportSnapshot(pi, state, "policy_manifest");
-      return { content: [{ type: "text", text: renderPolicyManifest(state.policies, params.policies ?? []) }], details: { requested: params.policies ?? [...state.policies.keys()] } };
-    },
-  });
-
-  pi.registerTool({
-    name: "policy_load",
-    label: "Policy Load",
-    description: "Load one or more context policy packs required before sensitive tools such as takomi_subagent.",
-    promptSnippet: "Load policy packs required before sensitive tool calls",
-    parameters: Type.Object({ policies: Type.Array(Type.String({ description: "Policy pack name to load" })) }),
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-      restoreReportFromSession(state, ctx);
-      state.report.timestamp = new Date().toISOString();
-      state.report.cwd = ctx.cwd;
-      state.report.toolCalls.policyLoad += 1;
-      const text = renderPolicies(state.policies, state.loadedPolicies, params.policies);
-      syncReportLedger(state);
-      persistReportSnapshot(pi, state, "policy_load");
-      return { content: [{ type: "text", text }], details: { requested: params.policies, loadedPolicies: [...state.loadedPolicies].sort() } };
-    },
-  });
-}
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import type { ContextManagerState } from "./state";
+import { syncReportLedger } from "./state";
+import { renderPolicies, renderPolicyManifest } from "./policy-registry";
+import { persistReportSnapshot, restoreReportFromSession } from "./session-state";
+import { renderCompactCard, renderExpandedMarkdown, renderToolCall, resultText } from "./tool-renderers";
+import { normalizeName } from "./skill-registry";
+
+function requestedPolicies(state: ContextManagerState, names: string[] | undefined): string[] {
+  return names?.length ? names : [...state.policies.values()].map((policy) => policy.name).sort((a, b) => a.localeCompare(b, "en"));
+}
+
+function missingPolicies(state: ContextManagerState, names: string[]): string[] {
+  return names.filter((name) => !state.policies.has(normalizeName(name)));
+}
+
+export function registerPolicyTools(pi: ExtensionAPI, state: ContextManagerState): void {
+  pi.registerTool({
+    name: "policy_manifest",
+    label: "Policy Manifest",
+    description: "Return descriptions for available context policy packs without loading full policy content.",
+    promptSnippet: "Show available context policy pack descriptions",
+    parameters: Type.Object({ policies: Type.Optional(Type.Array(Type.String({ description: "Policy name to inspect" }))) }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      restoreReportFromSession(state, ctx);
+      state.report.timestamp = new Date().toISOString();
+      state.report.cwd = ctx.cwd;
+      state.report.toolCalls.policyManifest += 1;
+      persistReportSnapshot(pi, state, "policy_manifest");
+      const requested = requestedPolicies(state, params.policies);
+      const missing = missingPolicies(state, requested);
+      return { content: [{ type: "text", text: renderPolicyManifest(state.policies, params.policies ?? []) }], details: { requested, found: requested.length - missing.length, missing } };
+    },
+    renderCall(args, theme) {
+      return renderToolCall("policy_manifest", args.policies?.length ? `${args.policies.length} requested` : "all policies", theme);
+    },
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as { requested?: string[]; found?: number; missing?: string[] } | undefined;
+      const requested = details?.requested ?? [];
+      const found = details?.found ?? 0;
+      const missing = details?.missing ?? [];
+      const status = missing.length ? "warning" : requested.length ? "success" : "pending";
+      const summary = missing.length ? `${found} available · ${missing.length} unavailable` : requested.length ? `${found} policies available` : "no policies discovered";
+      const metadata = missing.length ? `Missing: ${missing.join(", ")}` : `${requested.length} requested`;
+      if (!expanded) return renderCompactCard({ status, title: "Policy manifest", summary, metadata }, theme);
+      return renderExpandedMarkdown({ status, title: "Policy manifest", summary, metadata: [metadata], markdown: resultText(result) }, theme);
+    },
+  });
+
+  pi.registerTool({
+    name: "policy_load",
+    label: "Policy Load",
+    description: "Load one or more context policy packs required before sensitive tools such as takomi_subagent.",
+    promptSnippet: "Load policy packs required before sensitive tool calls",
+    parameters: Type.Object({ policies: Type.Array(Type.String({ description: "Policy pack name to load" })) }),
+    async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+      restoreReportFromSession(state, ctx);
+      state.report.timestamp = new Date().toISOString();
+      state.report.cwd = ctx.cwd;
+      state.report.toolCalls.policyLoad += 1;
+      const text = renderPolicies(state.policies, state.loadedPolicies, params.policies);
+      syncReportLedger(state);
+      persistReportSnapshot(pi, state, "policy_load");
+      const missing = missingPolicies(state, params.policies);
+      return {
+        content: [{ type: "text", text }],
+        details: {
+          requested: params.policies,
+          loadedPolicies: [...state.loadedPolicies].sort(),
+          loadedCount: params.policies.length - missing.length,
+          missing,
+        },
+      };
+    },
+    renderCall(args, theme) {
+      return renderToolCall("policy_load", `${args.policies.length} requested`, theme);
+    },
+    renderResult(result, { expanded }, theme) {
+      const details = result.details as { requested?: string[]; loadedCount?: number; missing?: string[] } | undefined;
+      const requested = details?.requested ?? [];
+      const loadedCount = details?.loadedCount ?? 0;
+      const missing = details?.missing ?? [];
+      const status = missing.length || requested.length === 0 ? "warning" : "success";
+      const summary = requested.length === 0
+        ? "no policies requested"
+        : missing.length ? `${loadedCount} loaded · ${missing.length} unavailable` : `${loadedCount} policies loaded`;
+      const metadata = missing.length ? `Missing: ${missing.join(", ")}` : `${requested.length} requested`;
+      if (!expanded) return renderCompactCard({ status, title: "Policy load", summary, metadata }, theme);
+      return renderExpandedMarkdown({ status, title: "Policy load", summary, metadata: [metadata], markdown: resultText(result) }, theme);
+    },
+  });
+}

package/.pi/extensions/takomi-context-manager/skill-categories.d.ts

@@ -0,0 +1,11 @@
+export type SkillCategory = {
+  id: string;
+  title: string;
+  color: string;
+  description: string;
+  skills: string[];
+};
+
+export const CORE_SKILLS: string[];
+export const SKILL_CATEGORIES: SkillCategory[];
+export function getSkillCategory(skillName: string): string | undefined;

package/.pi/extensions/takomi-context-manager/skill-categories.js

@@ -0,0 +1,212 @@
+export const CORE_SKILLS = [
+  'takomi',
+  'sync-docs',
+  'code-review',
+  'security-audit',
+  'optimize-agent-context',
+  'agent-recovery',
+  'avoid-feature-creep',
+  'ai-sdk',
+  'git-commit-generation',
+];
+
+export const SKILL_CATEGORIES = [
+  {
+    id: 'core',
+    title: 'Core / Recommended',
+    color: 'cyan',
+    description: 'Essential skills for efficient Takomi usage.',
+    skills: CORE_SKILLS,
+  },
+  {
+    id: 'developer',
+    title: 'Developer / Frameworks',
+    color: 'blue',
+    description: 'Framework, repo, and developer workflow helpers.',
+    skills: [
+      'ai-sdk',
+      'nextjs-standards',
+      'context7',
+      'monorepo-management',
+      'upgrading-expo',
+      'github-ops',
+      'git-worktree',
+      'git-commit-generation',
+      'pr-comment-fix',
+      'shared-resend-portfolio',
+      'jules',
+      'gemini',
+      'anti-gravity',
+    ],
+  },
+  {
+    id: 'security',
+    title: 'Security / Review',
+    color: 'red',
+    description: 'Security, audit, and review workflows.',
+    skills: [
+      'security-audit',
+      'audit-website',
+      'code-review',
+      'jstar-reviewer',
+      'convex-security-audit',
+      'convex-security-check',
+    ],
+  },
+  {
+    id: 'convex',
+    title: 'Convex',
+    color: 'green',
+    description: 'Convex framework skills and best practices.',
+    skills: [
+      'convex',
+      'convex-agents',
+      'convex-best-practices',
+      'convex-component-authoring',
+      'convex-cron-jobs',
+      'convex-file-storage',
+      'convex-functions',
+      'convex-http-actions',
+      'convex-migrations',
+      'convex-realtime',
+      'convex-schema-validator',
+      'convex-security-audit',
+      'convex-security-check',
+    ],
+  },
+  {
+    id: 'frontend',
+    title: 'Frontend / UI',
+    color: 'magenta',
+    description: 'Frontend implementation, UI/UX, components, and testing.',
+    skills: [
+      'frontend-design',
+      'web-design-guidelines',
+      'building-native-ui',
+      'ui-ux-pro-max',
+      'component-analysis',
+      '21st-dev-components',
+      'stitch',
+      'webapp-testing',
+      'figma',
+    ],
+  },
+  {
+    id: 'docs-office',
+    title: 'Docs / Office / Extraction',
+    color: 'yellow',
+    description: 'Document formats, extraction, and README support.',
+    skills: [
+      'pdf',
+      'docx',
+      'pptx',
+      'xlsx',
+      'high-fidelity-extraction',
+      'crafting-effective-readmes',
+      'exam-creator-skill',
+    ],
+  },
+  {
+    id: 'marketing',
+    title: 'Marketing / SEO / Copy',
+    color: 'green',
+    description: 'Marketing, SEO, naming, pricing, and social strategy.',
+    skills: [
+      'copywriting',
+      'marketing-ideas',
+      'pricing-strategy',
+      'programmatic-seo',
+      'seo-ready',
+      'social-content',
+      'twitter-automation',
+      'google-trends',
+      'domain-name-brainstormer',
+      'global-brand-namer',
+      'youtube-pipeline',
+    ],
+  },
+  {
+    id: 'ai-media',
+    title: 'AI Media / Content Creation',
+    color: 'magenta',
+    description: 'Optional AI media/content skills. Not installed by default.',
+    skills: [
+      'ai-avatar-video',
+      'ai-marketing-videos',
+      'ai-podcast-creation',
+      'ai-product-photography',
+      'ai-social-media-content',
+      'ai-voice-cloning',
+      'takomi-flow',
+    ],
+  },
+  {
+    id: 'creative-video',
+    title: 'Creative / Video / Art',
+    color: 'blue',
+    description: 'Creative visuals, video, animation, and art workflows.',
+    skills: [
+      'algorithmic-art',
+      'blender-mcp-scene-director',
+      'takomi-flow',
+      'remotion',
+      'remotion-real-ui-video',
+      'youtube-pipeline',
+      'ai-avatar-video',
+      'ai-marketing-videos',
+      'photo-book-builder',
+      'hyperframes',
+      'general-video',
+      'motion-graphics',
+    ],
+  },
+  {
+    id: 'hyperframes',
+    title: 'HyperFrames',
+    color: 'magenta',
+    description: 'HTML-native video creation and animation framework.',
+    skills: [
+      'hyperframes',
+      'hyperframes-core',
+      'hyperframes-keyframes',
+      'hyperframes-animation',
+      'hyperframes-creative',
+      'hyperframes-media',
+      'hyperframes-registry',
+      'hyperframes-cli',
+      'remotion-to-hyperframes',
+      'media-use',
+      'embedded-captions',
+      'faceless-explainer',
+      'general-video',
+      'motion-graphics',
+      'music-to-video',
+      'pr-to-video',
+      'product-launch-video',
+      'slideshow',
+      'talking-head-recut',
+      'website-to-video',
+    ],
+  },
+  {
+    id: 'skill-building',
+    title: 'Skill Building / Prompting / Orchestration',
+    color: 'cyan',
+    description: 'Skill authoring, prompt engineering, and optional orchestration helpers.',
+    skills: [
+      'skill-creator',
+      'prompt-engineering',
+      'subagent-driven-development',
+      'spawn-task',
+    ],
+  },
+];
+
+/**
+ * Resolve a bundled skill to its canonical installer category. Some skills are
+ * intentionally listed in multiple browsing categories; the first catalog
+ * entry is the stable primary taxonomy used by install manifests and reports.
+ */
+export function getSkillCategory(skillName) {
+  return SKILL_CATEGORIES.find((category) => category.skills.includes(skillName))?.id;
+}