takomi 2.1.27 → 2.1.28

package/.pi/extensions/takomi-runtime/index.ts

@@ -84,6 +84,9 @@ const STATE_ENTRY = "takomi-runtime-state";
 
 let activeProfile: TakomiProfile = DEFAULT_TAKOMI_PROFILE;
 let activeSubagentLabel: string | undefined;
+let activeSubagentAgent: string | undefined;
+let activeSubagentTask: string | undefined;
+let activeSubagentStatus: string | undefined;
 
 const ThinkingSchema = Type.Union([
   Type.Literal("off"),
@@ -665,18 +668,27 @@ export default function takomiRuntime(pi: ExtensionAPI) {
       launchMode: state.launchMode,
       planMode: state.planMode,
       activeSubagent: activeSubagentLabel,
+      activeSubagentAgent,
+      activeSubagentTask,
+      activeSubagentStatus,
     });
   }
 
   async function applySubagentRuntimeEvent(event: TakomiSubagentRuntimeEvent, ctx: ExtensionContext): Promise<void> {
     if (event.type === "start") {
       activeSubagentLabel = `${event.state.agent}: ${event.state.taskLabel}`;
+      activeSubagentAgent = event.state.agent;
+      activeSubagentTask = event.state.taskLabel;
+      activeSubagentStatus = event.state.status ?? "running";
       syncContextPanelState();
     } else if ((event.type === "update" || event.type === "complete" || event.type === "block") && event.patch) {
       const model = event.patch.model ? ` @ ${event.patch.model}` : "";
       const thinking = event.patch.thinking ? ` (${event.patch.thinking})` : "";
       const label = event.patch.summary?.split(/\r?\n/).find(Boolean);
       if (label) activeSubagentLabel = `${label}${model}${thinking}`;
+      if (event.patch.agent) activeSubagentAgent = event.patch.agent;
+      if (event.patch.taskLabel) activeSubagentTask = event.patch.taskLabel;
+      activeSubagentStatus = event.type === "complete" ? "completed" : event.type === "block" ? "blocked" : event.patch.status ?? activeSubagentStatus;
       syncContextPanelState();
     }
     switch (event.type) {
@@ -761,6 +773,9 @@ export default function takomiRuntime(pi: ExtensionAPI) {
       await updateState(ctx, () => {
         state = cloneState(DEFAULT_STATE);
         activeSubagentLabel = undefined;
+        activeSubagentAgent = undefined;
+        activeSubagentTask = undefined;
+        activeSubagentStatus = undefined;
       }, "Takomi runtime state reset");
       subagentController.reset(ctx);
       contextPanel.resetSession();
@@ -1202,6 +1217,24 @@ ${stateJson}`
     }
 
     const routingPolicy = await resolveTakomiRoutingPolicy(runtimeCwd);
+    const optionalFeatureContext = (() => {
+      try {
+        const tools = typeof (pi as { getAllTools?: () => Array<{ name?: string }> }).getAllTools === "function"
+          ? (pi as { getAllTools: () => Array<{ name?: string }> }).getAllTools()
+          : [];
+        const toolNames = new Set(tools.map((tool) => tool.name).filter(Boolean));
+        const guidance: string[] = [];
+        if (toolNames.has("ask_user_question")) {
+          guidance.push("Takomi Interview is available: when Genesis, Design, or ambiguous planning would otherwise require guessing, use ask_user_question to ask concise structured questions before proceeding.");
+        }
+        if (toolNames.has("todo")) {
+          guidance.push("Takomi Todo is available as an optional live overlay. You may use todo for short-lived execution visibility, but takomi_board remains the durable lifecycle/task source of truth.");
+        }
+        return guidance.join("\n");
+      } catch {
+        return "";
+      }
+    })();
     const modelPreflightContext = (() => {
       try {
         const available = typeof (ctx as { modelRegistry?: { getAvailable?: () => Array<{ provider?: string; id?: string; name?: string }> } }).modelRegistry?.getAvailable === "function"
@@ -1223,6 +1256,7 @@ ${stateJson}`
       routingPolicy.text
         ? `${routingPolicy.source === "bundled" ? "Bundled" : "Project"} Takomi model routing policy is active. Apply it when choosing parent/subagent models and escalation levels:\n\n${routingPolicy.text}`
         : "No Takomi routing policy file was found. Users can install one with `/takomi routing <policy>` or by saying `Update Takomi routing logic: \"\"\"...\"\"\"`.",
+      optionalFeatureContext,
       modelPreflightContext,
       `Execution mode: ${route.executionMode}. Session recommendation: ${route.sessionRecommendation}.`,
       `Takomi execution gate: ${effectiveState.launchMode === "manual" ? "review" : "auto"}. In review gate mode, show the delegation plan before launching and return to the user after each task with results, verification guidance, and the recommended next step.`,
@@ -1257,8 +1291,10 @@ ${stateJson}`
     runtimeCtx = ctx;
     activeProfile = await loadTakomiProfile(ctx.cwd);
     activeSubagentLabel = undefined;
+    activeSubagentAgent = undefined;
+    activeSubagentTask = undefined;
+    activeSubagentStatus = undefined;
     subagentController.reset(ctx);
-    contextPanel.resetSession();
     const entries = ctx.sessionManager.getEntries();
     for (let i = entries.length - 1; i >= 0; i--) {
       const entry = entries[i] as { type: string; customType?: string; data?: TakomiState };
@@ -1278,6 +1314,7 @@ ${stateJson}`
     }
 
     syncContextPanelState();
+    contextPanel.rebuildFromSession(ctx);
     await refreshUi(ctx, state);
     contextPanel.show(ctx);
     flushPendingSubagentEvents();

package/.pi/extensions/takomi-runtime/takomi-stats.js

@@ -40,6 +40,28 @@ function cost(model, input, cache, output, additiveCache = true) { const p = PRI
 function fmtTokens(n) { if (n >= 1e9) return `${(n/1e9).toFixed(2)}B`; if (n >= 1e6) return `${(n/1e6).toFixed(1)}M`; if (n >= 1e3) return `${(n/1e3).toFixed(1)}K`; return String(Math.round(n || 0)); }
 function fmtMoney(n) { return `$${(n || 0).toFixed(n > 100 ? 0 : 2)}`; }
 function ms(n) { if (!n) return '-'; const s = Math.round(n/1000); if (s < 60) return `${s}s`; const m = Math.floor(s/60); if (m < 60) return `${m}m ${s%60}s`; const h = Math.floor(m/60); return `${h}h ${m%60}m`; }
+const ACTIVE_GAP_THRESHOLD_MS = 15 * 60 * 1000;
+function timestampMs(value) {
+  if (typeof value === 'number') return Number.isFinite(value) ? value : null;
+  if (typeof value === 'string' && value) {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function addTimestamp(target, value) {
+  const parsed = timestampMs(value);
+  if (parsed !== null) target.push(parsed);
+}
+function activeDuration(timestamps, maxGapMs = ACTIVE_GAP_THRESHOLD_MS) {
+  const sorted = [...new Set((timestamps || []).filter(Number.isFinite))].sort((a, b) => a - b);
+  let total = 0;
+  for (let i = 1; i < sorted.length; i += 1) {
+    const delta = sorted[i] - sorted[i - 1];
+    if (delta > 0 && delta <= maxGapMs) total += delta;
+  }
+  return total;
+}
 function parseSince(value) {
   if (!value) return null;
   const raw = String(value).trim().toLowerCase();
@@ -88,14 +110,20 @@ async function files(root, suffix = '.jsonl') {
   await walk(root); return out;
 }
 
+function pushTask(taskRows, task) {
+  if (!task?.end || task.end === task.start) return;
+  task.activeMs = activeDuration(task.activityTimestamps || []);
+  taskRows.push(task);
+}
+
 async function scanPiSessions(root, source, events, sessionRows = [], taskRows = []) {
   for (const file of await files(root)) {
     let provider = 'unknown', model = 'unknown', session = path.basename(file, '.jsonl'), cwd = '', currentTask = null;
-    const row = { key: session, session, source, file, project: projectKey(file), cwd, start: '', end: '', turns: 0, messages: 0, toolCalls: 0, subagentCalls: 0, roles: new Map(), stages: new Map(), workflows: new Map(), activeMs: 0 };
+    const row = { key: session, session, source, file, project: projectKey(file), cwd, start: '', end: '', turns: 0, messages: 0, toolCalls: 0, subagentCalls: 0, roles: new Map(), stages: new Map(), workflows: new Map(), activeMs: 0, activityTimestamps: [] };
     const text = await fs.readFile(file, 'utf8').catch(() => '');
     for (const line of text.split(/\r?\n/)) {
       const obj = safeJson(line); if (!obj) continue;
-      if (obj.timestamp) { row.start ||= obj.timestamp; row.end = obj.timestamp; }
+      if (obj.timestamp) { row.start ||= obj.timestamp; row.end = obj.timestamp; addTimestamp(row.activityTimestamps, obj.timestamp); }
       if (obj.type === 'session') { session = obj.id || session; cwd = obj.cwd || cwd; row.key = session; row.session = session; row.cwd = cwd; }
       if (obj.type === 'model_change') { provider = obj.provider || provider; model = obj.modelId || model; }
       if (obj.type === 'custom' && obj.customType === 'takomi-runtime-state' && obj.data) {
@@ -112,12 +140,14 @@ async function scanPiSessions(root, source, events, sessionRows = [], taskRows =
         row.messages += 1;
         const ts = obj.timestamp || msg.timestamp || '';
         if (msg.role === 'user') {
-          if (currentTask?.end && currentTask.end !== currentTask.start) taskRows.push(currentTask);
+          pushTask(taskRows, currentTask);
           row.turns += 1;
           const textPart = (msg.content || []).find(p => p?.type === 'text')?.text || '';
-          currentTask = { source, file, session, project: projectKey(file), cwd, start: ts, end: ts, provider, model, turns: 1, toolCalls: 0, title: String(textPart).replace(/\s+/g, ' ').trim() };
+          currentTask = { source, file, session, project: projectKey(file), cwd, start: ts, end: ts, provider, model, turns: 1, toolCalls: 0, title: String(textPart).replace(/\s+/g, ' ').trim(), activityTimestamps: [] };
+          addTimestamp(currentTask.activityTimestamps, ts);
         } else if (currentTask && ts) {
           currentTask.end = ts;
+          addTimestamp(currentTask.activityTimestamps, ts);
         }
         for (const part of msg.content || []) {
           if (!part || part.type !== 'toolCall') continue;
@@ -135,8 +165,8 @@ async function scanPiSessions(root, source, events, sessionRows = [], taskRows =
       const u = msg && msg.usage;
       if (u) events.push({ source, file, timestamp: obj.timestamp, day: dayOf(obj.timestamp), session, provider, model, project: projectKey(file), kind: 'usage', input: +u.input||0, cache: +u.cacheRead||0, output: +u.output||0, total: +u.totalTokens||0, cost: cost(model, +u.input||0, +u.cacheRead||0, +u.output||0, true) });
     }
-    if (currentTask?.end && currentTask.end !== currentTask.start) taskRows.push(currentTask);
-    row.activeMs = taskRows.filter(t => t.file === file).reduce((sum, t) => sum + taskDuration(t), 0);
+    pushTask(taskRows, currentTask);
+    row.activeMs = activeDuration(row.activityTimestamps);
     if (row.messages || row.toolCalls || row.turns) sessionRows.push(row);
   }
 }
@@ -336,9 +366,7 @@ function sessionDuration(row) {
   return row?.activeMs || 0;
 }
 function taskDuration(row) {
-  const start = Date.parse(row?.start || '');
-  const end = Date.parse(row?.end || '');
-  return Number.isFinite(start) && Number.isFinite(end) && end >= start ? end - start : 0;
+  return row?.activeMs ?? activeDuration(row?.activityTimestamps || []);
 }
 function taskLabel(row, width = 34) {
   const label = row?.title || row?.project || row?.session || 'unknown';
@@ -379,7 +407,7 @@ function renderFocusedView(stats, opts = {}) {
     `      ${pc.cyan(ms(sessionDuration(r)))}  ${pc.dim(r.turns + ' turns')}  ${pc.dim(r.toolCalls + ' tools')}`,
     `      ${pc.dim(r.file || '')}`,
   ].join('\n'), limit);
-  if (view === 'tasks-full' || view === 'task-full') return renderFullList('Longest Tasks — Full Prompts', stats.topTasks || [], (r, i) => [
+  if (view === 'tasks-full' || view === 'task-full') return renderFullList('Longest Active Turns — Full Prompts', stats.topTasks || [], (r, i) => [
     `  ${pc.dim(String(i + 1).padStart(2, '0') + '.')} ${pc.cyan(ms(taskDuration(r)))}  ${pc.magenta(r.toolCalls + ' tools')}  ${pc.dim(dayOf(r.start))}`,
     `      ${pc.white(indentWrap(r.title || r.project || r.session || 'unknown'))}`,
     `      ${pc.dim(r.project || '')}`,
@@ -426,7 +454,7 @@ function renderFocusedView(stats, opts = {}) {
       { width: 8, align: 'right', get: r => pc.cyan(String(r.toolCalls)) },
       { width: 8, align: 'left', get: () => pc.dim('tools') },
     ]],
-    tasks: ['Longest Tasks', stats.topTasks || [], [
+    tasks: ['Longest Active Turns', stats.topTasks || [], [
       { width: 6, align: 'left', get: r => pc.dim(dayOf(r.start).slice(5)) },
       { width: 9, align: 'right', get: r => pc.cyan(ms(taskDuration(r))) },
       { width: 11, align: 'right', get: r => pc.magenta(`${r.toolCalls} tools`) },
@@ -518,9 +546,9 @@ export function renderTakomiStats(stats, opts = {}) {
   // ── Duration Cards ────────────────────────────────────────────────────
   lines.push('');
   const cards3 = [
-    statCard(longestSession ? ms(sessionDuration(longestSession)) : '-', 'Active Session', pc.cyan),
+    statCard(longestSession ? ms(sessionDuration(longestSession)) : '-', 'Top Active Session', pc.cyan),
     statCard(longestSession ? String(longestSession.turns) : '-', 'Turns in Session', pc.cyan),
-    statCard(longestTask ? ms(taskDuration(longestTask)) : '-', 'Longest Task', pc.magenta),
+    statCard(longestTask ? ms(taskDuration(longestTask)) : '-', 'Longest Active Turn', pc.magenta),
     statCard(longestTask ? String(longestTask.toolCalls) : '-', 'Tools in Task', pc.magenta),
     statCard(stats.mostSubagentsSession ? String(stats.mostSubagentsSession.subagentCalls) : '0', 'Max Subagents', pc.blue),
   ];
@@ -530,7 +558,7 @@ export function renderTakomiStats(stats, opts = {}) {
 
   // ── Info line ─────────────────────────────────────────────────────────
   lines.push('');
-  const infoText = `Peak: ${peak?.key || '-'}  ·  ${streaks.quietDays} quiet days  ·  ${stats.totals.events.toLocaleString()} events${stats.since ? `  ·  since ${stats.since}` : ''}`;
+  const infoText = `Peak: ${peak?.key || '-'}  ·  ${streaks.quietDays} quiet days  ·  ${stats.totals.events.toLocaleString()} events  ·  active gaps ≤15m${stats.since ? `  ·  since ${stats.since}` : ''}`;
   lines.push(center(pc.dim(infoText), W));
 
   lines.push('');
@@ -586,10 +614,10 @@ export function renderTakomiStats(stats, opts = {}) {
     ]));
   }
 
-  // ── Longest Tasks ──────────────────────────────────────────────────────
+  // ── Longest Active Turns ───────────────────────────────────────────────
   if (stats.topTasks?.length) {
     lines.push('');
-    lines.push(renderTable('Longest Tasks', stats.topTasks.slice(0, 5), [
+    lines.push(renderTable('Longest Active Turns', stats.topTasks.slice(0, 5), [
       { width: 6,  align: 'left',  get: r => pc.dim(dayOf(r.start).slice(5)) },
       { width: 9,  align: 'right', get: r => pc.cyan(ms(taskDuration(r))) },
       { width: 11, align: 'right', get: r => pc.magenta(`${r.toolCalls} tools`) },

package/README.md

@@ -29,6 +29,11 @@ Optional global skills:
 
 ```bash
 takomi setup skills
+# First install defaults to Core Skills.
+# Repeat installs default to Leave As Is so existing selections are not pruned accidentally.
+# Custom opens a color-coded category TUI with expandable skill rows when a TTY is available.
+# Optional Pi feature packs can also be managed later:
+takomi setup pi-features
 ```
 
 Useful management commands:
@@ -43,6 +48,8 @@ takomi setup project
 
 Legacy commands like `takomi install pi`, `takomi sync pi`, `takomi upgrade`, and `takomi init` still work, but the simpler mental model is: **setup once, refresh when stale, run `takomi` to use it.**
 
+During `takomi setup pi` or `takomi setup pi-features`, Takomi offers optional Pi feature packs with recommended/manual/select-all/skip choices. Current defaults install **Takomi Interview** (`npm:@juicesharp/rpiv-ask-user-question`) so models can ask structured clarification questions. **Takomi Todo** (`npm:@juicesharp/rpiv-todo`), **Takomi Browser QA** (`npm:pi-chrome`), and **Takomi Doc Preview** (`npm:pi-markdown-preview`) remain opt-in. `takomi refresh` runs Pi's package updater so installed optional, custom, old, and new Pi packages are reconciled together.
+
 ### Context Manager
 
 Takomi now ships a Pi-native `takomi-context-manager` extension. It reduces prompt bloat with progressive context loading:
@@ -69,7 +76,8 @@ npx takomi install
 What happens next:
 - 🔍 **Auto-detects** every AI harness on your machine
 - 📦 **Creates your command center** at `~/.takomi/`
-- 📡 **Syncs your entire toolkit** to every IDE automatically
+- 🧰 **Lets you choose Core, Present Custom, Custom, All, or Leave As Is for skills**
+- 📡 **Syncs your selected toolkit** to every IDE automatically
 - 🔄 **Keeps KiloCode in sync** across CLI and VS Code
 
 ### Option B: Per-Project Setup
@@ -118,7 +126,9 @@ Original Takomi-authored skills in this bundle include `21st-dev-components`, `t
 
 Think of skills as specialized team members you can summon on demand. From security audits to AI video generation — there's a skill for that.
 
-The published bundle currently ships **69 top-level skills**, including the original `21st-dev-components` workflow for guided 21st.dev integration. The `pr-comment-fix` skill is sourced from https://gist.github.com/GSonofNun/35c67304c35dac7d6b43308b5371f671.
+Takomi's own installer no longer installs every bundled skill by default. `takomi setup skills` uses **Core Skills** for first-time installs, **Leave As Is** for repeat installs, and ownership-safe cleanup when you explicitly deselect Takomi-managed skills. Manual/user-added skills are preserved. Custom selection opens a color-coded category browser with expandable rows on capable terminals, and falls back to simple prompts elsewhere. The global store/harness sync path uses the same ownership model so deselected Takomi-managed skills and workflows can be pruned from `~/.takomi/` and synced harness folders without touching manual or imported resources.
+
+The published bundle currently ships **72 top-level skills**, including the original `21st-dev-components` workflow for guided 21st.dev integration. The `pr-comment-fix` skill is sourced from https://gist.github.com/GSonofNun/35c67304c35dac7d6b43308b5371f671.
 
 ### Interactive Search & Install
 ```bash
@@ -130,7 +140,22 @@ npx -y skills add https://github.com/JStaRFilms/VibeCode-Protocol-Suite
 ```
 
 ### Core Essentials (Start Here)
-The non-negotiables for daily development:
+The recommended Takomi installer defaults are:
+
+```txt
+takomi
+sync-docs
+code-review
+security-audit
+optimize-agent-context
+agent-recovery
+avoid-feature-creep
+ai-sdk
+git-commit-generation
+```
+
+For the external `skills` CLI, install only the router skill if you want the smallest possible footprint:
+
 ```bash
 npx -y skills add https://github.com/JStaRFilms/VibeCode-Protocol-Suite --skill takomi
 ```
@@ -466,8 +491,9 @@ This is a living system. If you discover improvements:
 
 ## 🙏 Acknowledgements
 
-Externally sourced skills in this bundle retain credit to their upstream creators. Takomi-original skills and workflows in this repository, including `21st-dev-components`, remain authored and maintained by J StaR Films Studios.
+Externally sourced skills and optional Pi packages retain credit to their upstream creators. Takomi-original skills, workflows, and Takomi runtime/orchestration extensions in this repository, including `21st-dev-components`, remain authored and maintained by J StaR Films Studios.
 
+- **Pi Coding Agent**: Built for [Pi](https://github.com/earendil-works/pi) / `@earendil-works/pi-coding-agent` by **Mario Zechner** and Earendil Works — the MIT-licensed coding-agent runtime and extension API that powers the Pi-native Takomi harness.
 - **Anthropic Skills**: From [anthropics/skills](https://github.com/anthropics/skills) — a massive collection including **Office Suite** (PDF/DOCX/PPTX/XLSX), **Frontend Design**, **Webapp Testing**, **Algorithmic Art**, **Monorepo Management**, and **Skill Creator**.
 - **Inference.sh Skills**: From [inference.sh/skills](https://github.com/inference-sh/skills) — complete media & automation suite including **Marketing Videos**, **Voice Cloning**, **Social Content**, **Twitter Automation**, **Product Photography**, and **Prompt Engineering**.
 - **Marketing Skills**: From [coreyhaines31/marketingskills](https://github.com/coreyhaines31/marketingskills) — the complete marketer's toolkit: **Copywriting**, **Pricing Strategy**, **Social Strategy**, **Programmatic SEO**, and **Marketing Ideas**.
@@ -483,6 +509,10 @@ Externally sourced skills in this bundle retain credit to their upstream creator
 - **Google Stitch Skills**: From [google-labs-code/stitch-skills](https://github.com/google-labs-code/stitch-skills) — Design-to-code suite including **design-md**, **enhance-prompt**, **stitch-loop**, **react-components**, and **shadcn-ui**.
 - **Jules**: From [sanjay3290/ai-skills](https://github.com/sanjay3290/ai-skills) — delegate coding tasks to Google Jules AI agent.
 - **Subagent Execution**: Built on **[`pi-subagents`](https://github.com/nicobailon/pi-subagents)** by **Nico Bailon** — providing the underlying Pi extension for delegated subagent runs (result rendering, live progress, single/parallel/chain execution, session/artifact handling, and related subagent tooling), upon which Takomi adds its own lifecycle orchestration, model-routing policy, and workflow metadata.
+- **Takomi Interview / Todo Optional Packs**: Optional setup integrates **[`@juicesharp/rpiv-ask-user-question`](https://github.com/juicesharp/rpiv-mono/tree/main/packages/rpiv-ask-user-question)** and **[`@juicesharp/rpiv-todo`](https://github.com/juicesharp/rpiv-mono/tree/main/packages/rpiv-todo)** by **juicesharp** — MIT-licensed Pi extensions for structured user questions and live todo overlays.
+- **Takomi Browser QA Optional Pack**: Optional setup can install **[`pi-chrome`](https://github.com/tianrendong/pi-chrome)** by **tianrendong** — an MIT-licensed Pi extension for explicitly authorized Chrome/browser automation.
+- **Takomi Doc Preview Optional Pack**: Optional setup can install **[`pi-markdown-preview`](https://github.com/omaclaren/pi-markdown-preview)** by **omaclaren** — an MIT-licensed Pi extension for terminal/browser/PDF markdown and LaTeX previews.
+- **Context Mode Research / Optional Power User Tooling**: **[`context-mode`](https://github.com/mksglu/context-mode)** by **Mert Koseoğlu** is credited as an external context-window and session-continuity project. It is not bundled as a Takomi default; users can install/evaluate it separately under its own license.
 - **Git Commit Generation**: From the **[`kilocode`](https://github.com/Kilo-Org/kilocode)** repository by **Kilo-Org** (specifically, [git-commit-generation.md](https://github.com/Kilo-Org/kilocode/blob/main/packages/kilo-docs/pages/code-with-ai/features/git-commit-generation.md)) — enabling automated, high-quality conventional git commit messages based on staged changes.
 
 ## 📄 License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "takomi",
-  "version": "2.1.27",
+  "version": "2.1.28",
   "description": "🎯 Stop wrestling with AI. Start building with purpose. The artisan's toolkit for agent workflows, Codex skills, and original Takomi capabilities like 21st.dev integration.",
   "type": "module",
   "bin": {
@@ -22,7 +22,9 @@
     ".pi/takomi/policies"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "postinstall": "node src/postinstall.js",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "test:skills": "node scripts/test-skill-selection.js"
   },
   "repository": {
     "type": "git",