takomi 2.1.13 → 2.1.14

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

@@ -1,4 +1,5 @@
 import { readFile } from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import type { ContextManagerState } from "./state";
@@ -20,14 +21,35 @@ function asRecord(value: unknown): Record<string, unknown> {
   return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : {};
 }
 
-async function readSettings(cwd: string): Promise<Settings> {
+async function readSettingsFile(filePath: string): Promise<Settings> {
   try {
-    return JSON.parse(await readFile(path.resolve(cwd, ".pi/settings.json"), "utf8")) as Settings;
+    return JSON.parse(await readFile(filePath, "utf8")) as Settings;
   } catch {
     return {};
   }
 }
 
+function mergeSettings(globalSettings: Settings, projectSettings: Settings): Settings {
+  const globalOverrides = asRecord(globalSettings.subagents?.agentOverrides);
+  const projectOverrides = asRecord(projectSettings.subagents?.agentOverrides);
+  return {
+    ...globalSettings,
+    ...projectSettings,
+    takomi: { ...(globalSettings.takomi ?? {}), ...(projectSettings.takomi ?? {}) },
+    subagents: {
+      ...(globalSettings.subagents ?? {}),
+      ...(projectSettings.subagents ?? {}),
+      agentOverrides: { ...globalOverrides, ...projectOverrides },
+    },
+  };
+}
+
+async function readSettings(cwd: string): Promise<Settings> {
+  const globalSettings = await readSettingsFile(path.join(os.homedir(), ".pi", "agent", "settings.json"));
+  const projectSettings = await readSettingsFile(path.resolve(cwd, ".pi/settings.json"));
+  return mergeSettings(globalSettings, projectSettings);
+}
+
 function modelFamily(model: string): string {
   return model.split("/").at(-1)?.toLowerCase() ?? model.toLowerCase();
 }

package/.pi/extensions/takomi-runtime/command-text.ts

@@ -16,7 +16,7 @@ const ROOT_COMPLETIONS: TakomiCompletion[] = [
   { value: "mode", label: "mode", description: "Set direct, orchestrate, or review mode" },
   { value: "gate", label: "gate", description: "Set auto or review-gated execution" },
   { value: "subagents", label: "subagents", description: "Control subagent usage and view" },
-  { value: "routing", label: "routing", description: "Install/update Takomi model routing policy" },
+  { value: "routing", label: "routing", description: "Show or update Takomi model routing policy" },
 ];
 
 const SUBCOMMAND_COMPLETIONS: Record<string, TakomiCompletion[]> = {
@@ -37,6 +37,12 @@ const SUBCOMMAND_COMPLETIONS: Record<string, TakomiCompletion[]> = {
     { value: "collapse", label: "collapse", description: "Collapse native tool results" },
     { value: "toggle", label: "toggle", description: "Toggle native tool result expansion" },
   ],
+  routing: [
+    { value: "show", label: "show", description: "Show active routing policy source, path, and contents" },
+    { value: "global", label: "global", description: "Save following policy text globally" },
+    { value: "local", label: "local", description: "Save following policy text as a project override" },
+    { value: "where", label: "where", description: "Show where the active routing policy is loaded from" },
+  ],
 };
 
 const SUBCOMMAND_ALIASES: Record<string, string> = {
@@ -71,7 +77,9 @@ export function commandHelp(): string {
     "/takomi mode <direct|orchestrate|review>",
     "/takomi gate <auto|review>",
     "/takomi subagents <on|off|status|expand|collapse|toggle>",
-    "/takomi routing <policy text>",
+    "/takomi routing [show|where]",
+    "/takomi routing <policy text>              # updates global policy",
+    "/takomi routing local <policy text>        # project override",
     "/takomi-status",
     "/takomi-reset",
   ].join("\n");

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

@@ -7,7 +7,7 @@ import type {
 } from "../../../src/pi-takomi-core";
 import { commandHelp, completions, statusText, workflowPrompt } from "./command-text";
 import type { TakomiSubagentController } from "./subagent-types";
-import { installTakomiRoutingPolicy } from "./routing-policy";
+import { installTakomiRoutingPolicy, resolveTakomiRoutingPolicy, type RoutingPolicyInstallScope } from "./routing-policy";
 
 export type TakomiRuntimeCommandState = {
   enabled: boolean;
@@ -82,14 +82,87 @@ export function registerTakomiCommands(pi: ExtensionAPI, options: RegisterTakomi
   }
 
   async function handleRouting(ctx: ExtensionCommandContext, body?: string): Promise<void> {
-    if (!body?.trim()) {
-      ctx.ui.notify("Usage: /takomi routing <policy text>\nTip: paste the policy after the command, or say: Update Takomi routing logic: \"\"\"...\"\"\"", "warning");
+    const trimmed = body?.trim() ?? "";
+
+    const usage = [
+      "Usage:",
+      "/takomi routing show                 Print the full active policy",
+      "/takomi routing where                Show source/path only",
+      "/takomi routing <policy text>        Update the global policy",
+      "/takomi routing local <policy text>  Create/update this project's override",
+    ].join("\n");
+
+    async function showRoutingHelp(): Promise<void> {
+      const resolved = await resolveTakomiRoutingPolicy(ctx.cwd);
+      ctx.ui.notify([
+        "Takomi routing options",
+        "",
+        `Active source: ${resolved.source}`,
+        `Active path: ${resolved.policyPath ?? "not found"}`,
+        "",
+        usage,
+        "",
+        "Resolution order: project .pi/takomi/model-routing.md → global ~/.pi/takomi/model-routing.md → bundled fallback.",
+      ].join("\n"), "warning");
+    }
+
+    async function showRoutingLocation(): Promise<void> {
+      const resolved = await resolveTakomiRoutingPolicy(ctx.cwd);
+      ctx.ui.notify([
+        "Active Takomi routing policy location",
+        "",
+        `Source: ${resolved.source}`,
+        `Path: ${resolved.policyPath ?? "not found"}`,
+        "",
+        usage,
+      ].join("\n"), resolved.source === "missing" ? "warning" : "info");
+    }
+
+    async function showActivePolicy(): Promise<void> {
+      const resolved = await resolveTakomiRoutingPolicy(ctx.cwd);
+      const text = resolved.text ?? "No Takomi routing policy found.";
+      const clipped = text.length > 6000 ? `${text.slice(0, 6000)}\n\n…truncated; open the file above for the full policy.` : text;
+      ctx.ui.notify([
+        "Active Takomi routing policy",
+        "",
+        `Source: ${resolved.source}`,
+        `Path: ${resolved.policyPath ?? "not found"}`,
+        "",
+        clipped,
+        "",
+        usage,
+      ].join("\n"), resolved.source === "missing" ? "warning" : "info");
+    }
+
+    if (!trimmed) {
+      await showRoutingHelp();
       return;
     }
+    if (/^(where|path|status)$/i.test(trimmed)) {
+      await showRoutingLocation();
+      return;
+    }
+    if (/^(show|view)$/i.test(trimmed)) {
+      await showActivePolicy();
+      return;
+    }
+
+    if (/^(global|local|project|set)$/i.test(trimmed)) {
+      ctx.ui.notify(usage, "warning");
+      return;
+    }
+
+    const scopeMatch = trimmed.match(/^(global|local|project)\s+([\s\S]+)$/i);
+    const scope: RoutingPolicyInstallScope = scopeMatch?.[1]?.toLowerCase() === "local" || scopeMatch?.[1]?.toLowerCase() === "project" ? "project" : "global";
+    const policyText = scopeMatch?.[2] ?? trimmed.replace(/^set\s+/i, "");
+
     try {
-      const result = await installTakomiRoutingPolicy(ctx.cwd, body);
+      const result = await installTakomiRoutingPolicy(ctx.cwd, policyText, { scope });
       const detected = result.detectedDefaults.length ? `\n\nDetected defaults:\n- ${result.detectedDefaults.join("\n- ")}` : "\n\nNo model names were auto-detected; saved policy only.";
-      ctx.ui.notify(`Takomi routing policy updated.\n\nPolicy: ${result.policyPath}\nSettings: ${result.settingsPath}${detected}`, "info");
+      const overrideNote = scope === "global"
+        ? "\n\nThis will be used by every project unless that project has its own .pi/takomi/model-routing.md override."
+        : "\n\nThis project-local policy overrides the global policy for the current project.";
+      ctx.ui.notify(`Takomi routing policy updated (${scope}).\n\nPolicy: ${result.policyPath}\nSettings: ${result.settingsPath}${detected}${overrideNote}`, "info");
     } catch (error) {
       ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
     }

package/.pi/extensions/takomi-runtime/routing-policy.ts

@@ -1,8 +1,12 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 export const TAKOMI_ROUTING_POLICY_RELATIVE = path.join(".pi", "takomi", "model-routing.md");
+export const GLOBAL_TAKOMI_ROUTING_POLICY_PATH = path.join(os.homedir(), ".pi", "takomi", "model-routing.md");
+export const GLOBAL_PI_SETTINGS_PATH = path.join(os.homedir(), ".pi", "agent", "settings.json");
+export const PROJECT_PI_SETTINGS_RELATIVE = path.join(".pi", "settings.json");
 export const BUNDLED_TAKOMI_ROUTING_POLICY_PATH = path.resolve(
   path.dirname(fileURLToPath(import.meta.url)),
   "..",
@@ -18,7 +22,8 @@ export type RoutingPolicyInstallResult = {
   detectedDefaults: string[];
 };
 
-export type RoutingPolicySource = "project" | "bundled" | "missing";
+export type RoutingPolicyInstallScope = "global" | "project";
+export type RoutingPolicySource = "project" | "global" | "bundled" | "missing";
 
 export type ResolvedRoutingPolicy = {
   source: RoutingPolicySource;
@@ -55,6 +60,10 @@ function extractQuotedPolicy(text: string): string {
   return raw.replace(/^update\s+(?:takomi\s+)?(?:model\s+)?routing\s+(?:logic|policy|philosophy)\s*:?/i, "").trim();
 }
 
+function normalizeForSettings(filePath: string): string {
+  return filePath.replaceAll(path.sep, "/");
+}
+
 function deriveSubagentDefaults(policy: string): { overrides: JsonObject; detected: string[] } {
   const lower = policy.toLowerCase();
   const has55 = /gpt[- ]?5\.5/.test(lower);
@@ -89,16 +98,42 @@ function deriveSubagentDefaults(policy: string): { overrides: JsonObject; detect
 }
 
 export async function resolveTakomiRoutingPolicy(cwd: string): Promise<ResolvedRoutingPolicy> {
-  const settingsPath = path.join(cwd, ".pi", "settings.json");
-  const settings = await readJsonObject(settingsPath);
-  const takomi = asObject(settings.takomi);
-  const configured = typeof takomi.modelRoutingPolicyFile === "string"
-    ? takomi.modelRoutingPolicyFile
+  const projectSettingsPath = path.join(cwd, PROJECT_PI_SETTINGS_RELATIVE);
+  const projectSettings = await readJsonObject(projectSettingsPath);
+  const projectTakomi = asObject(projectSettings.takomi);
+  const configuredProject = typeof projectTakomi.modelRoutingPolicyFile === "string"
+    ? projectTakomi.modelRoutingPolicyFile
     : TAKOMI_ROUTING_POLICY_RELATIVE;
-  const configuredPath = path.isAbsolute(configured) ? configured : path.join(cwd, configured);
-  const configuredText = await readPolicyText(configuredPath);
-  if (configuredText) {
-    return { source: "project", policyPath: configuredPath, text: configuredText };
+  const configuredProjectPath = path.isAbsolute(configuredProject) ? configuredProject : path.join(cwd, configuredProject);
+  const configuredProjectText = await readPolicyText(configuredProjectPath);
+  if (configuredProjectText) {
+    return { source: "project", policyPath: configuredProjectPath, text: configuredProjectText };
+  }
+
+  const defaultProjectPath = path.join(cwd, TAKOMI_ROUTING_POLICY_RELATIVE);
+  if (path.resolve(defaultProjectPath) !== path.resolve(configuredProjectPath)) {
+    const defaultProjectText = await readPolicyText(defaultProjectPath);
+    if (defaultProjectText) {
+      return { source: "project", policyPath: defaultProjectPath, text: defaultProjectText };
+    }
+  }
+
+  const globalSettings = await readJsonObject(GLOBAL_PI_SETTINGS_PATH);
+  const globalTakomi = asObject(globalSettings.takomi);
+  const configuredGlobal = typeof globalTakomi.modelRoutingPolicyFile === "string"
+    ? globalTakomi.modelRoutingPolicyFile
+    : GLOBAL_TAKOMI_ROUTING_POLICY_PATH;
+  const configuredGlobalPath = path.isAbsolute(configuredGlobal) ? configuredGlobal : path.join(os.homedir(), configuredGlobal);
+  const configuredGlobalText = await readPolicyText(configuredGlobalPath);
+  if (configuredGlobalText) {
+    return { source: "global", policyPath: configuredGlobalPath, text: configuredGlobalText };
+  }
+
+  if (path.resolve(configuredGlobalPath) !== path.resolve(GLOBAL_TAKOMI_ROUTING_POLICY_PATH)) {
+    const globalText = await readPolicyText(GLOBAL_TAKOMI_ROUTING_POLICY_PATH);
+    if (globalText) {
+      return { source: "global", policyPath: GLOBAL_TAKOMI_ROUTING_POLICY_PATH, text: globalText };
+    }
   }
 
   const bundledText = await readPolicyText(BUNDLED_TAKOMI_ROUTING_POLICY_PATH);
@@ -113,19 +148,26 @@ export async function resolveTakomiRoutingPolicy(cwd: string): Promise<ResolvedR
   return { source: "missing" };
 }
 
-export async function installTakomiRoutingPolicy(cwd: string, input: string): Promise<RoutingPolicyInstallResult> {
+export async function installTakomiRoutingPolicy(cwd: string, input: string, options: { scope?: RoutingPolicyInstallScope } = {}): Promise<RoutingPolicyInstallResult> {
   const policy = extractQuotedPolicy(input);
   if (!policy) throw new Error("No routing policy text found. Paste the policy after /takomi routing or inside triple quotes.");
 
-  const policyPath = path.join(cwd, TAKOMI_ROUTING_POLICY_RELATIVE);
-  const settingsPath = path.join(cwd, ".pi", "settings.json");
+  const scope = options.scope ?? "global";
+  const policyPath = scope === "project"
+    ? path.join(cwd, TAKOMI_ROUTING_POLICY_RELATIVE)
+    : GLOBAL_TAKOMI_ROUTING_POLICY_PATH;
+  const settingsPath = scope === "project"
+    ? path.join(cwd, PROJECT_PI_SETTINGS_RELATIVE)
+    : GLOBAL_PI_SETTINGS_PATH;
   await mkdir(path.dirname(policyPath), { recursive: true });
   await mkdir(path.dirname(settingsPath), { recursive: true });
   await writeFile(policyPath, `# Takomi Model Routing Policy\n\n${policy}\n`, "utf8");
 
   const settings = await readJsonObject(settingsPath);
   const takomi = asObject(settings.takomi);
-  takomi.modelRoutingPolicyFile = TAKOMI_ROUTING_POLICY_RELATIVE.replaceAll(path.sep, "/");
+  takomi.modelRoutingPolicyFile = scope === "project"
+    ? normalizeForSettings(TAKOMI_ROUTING_POLICY_RELATIVE)
+    : normalizeForSettings(GLOBAL_TAKOMI_ROUTING_POLICY_PATH);
   settings.takomi = takomi;
 
   const { overrides, detected } = deriveSubagentDefaults(policy);

package/.pi/extensions/takomi-subagents/pi-subagents-internal.ts

@@ -2,8 +2,11 @@
 // pi-subagents ships TS internals rather than a stable public JS API. Import them
 // dynamically with computed specifiers so Takomi's own tsc does not type-check
 // dependency source, while Pi's runtime TS loader can still load them.
+// Do not hide import() inside Function/eval: Pi's extension VM does not provide
+// a dynamic import callback for that path and fails with
+// "A dynamic import callback was not specified."
 
-const dynamicImport = new Function("specifier", "return import(specifier)") as <T = any>(specifier: string) => Promise<T>;
+const dynamicImport = async <T = any>(specifier: string): Promise<T> => import(specifier) as Promise<T>;
 const spec = (path: string) => `pi-subagents/${path}.ts`;
 
 export async function loadPiSubagentsInternals() {

package/README.md

@@ -41,10 +41,6 @@ takomi install all
 takomi init
 ```
 
-### Subagent execution credit
-
-Takomi's Pi-native subagent execution and terminal UI build on **[`pi-subagents`](https://github.com/nicobailon/pi-subagents)** by **Nico Bailon**. That package provides the underlying Pi extension for delegated subagent runs, including the native subagent result renderer, live progress/status display, single/parallel/chain execution support, session/artifact handling, and related subagent tooling. Takomi adds its own lifecycle orchestration, model-routing policy, workflow metadata, board/checklist context, and agent conventions on top of that foundation.
-
 ### Context Manager
 
 Takomi now ships a Pi-native `takomi-context-manager` extension. It reduces prompt bloat with progressive context loading:
@@ -480,6 +476,8 @@ Externally sourced skills in this bundle retain credit to their upstream creator
 - **Gemini CLI**: Custom VibeCode skill for large-context processing with Gemini 3 Pro.
 - **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.
+- **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/assets/.agent/skills/git-commit-generation/SKILL.md

@@ -0,0 +1,195 @@
+---
+name: git-commit-generation
+description: "Automatically generate meaningful git commit messages based on staged changes."
+---
+
+# Generate Commit Messages
+
+> [!NOTE]
+> This skill is based on the **Kilo Code** Git Commit Generation feature.
+> **Attribution**: Originally from the [Kilo Code Repository](https://github.com/Kilo-Org/kilocode/blob/main/packages/kilo-docs/pages/code-with-ai/features/git-commit-generation.md).
+
+Generate descriptive commit messages automatically based on your staged git changes. Kilo Code analyzes your staged files and creates conventional commit messages that follow best practices.
+
+{% callout type="info" %}
+This feature only analyzes **staged changes**. Make sure to stage your files using `git add` or via `VS Code` interface before generating commit messages.
+{% /callout %}
+
+## How It Works
+
+The git commit message generator:
+
+- Analyzes only your **staged changes** (not unstaged or untracked files)
+- Uses AI to understand the context and purpose of your changes
+- Creates descriptive commit messages that explain what was changed and why following the [Conventional Commits](https://www.conventionalcommits.org/) (by default, customizable)
+
+## Using the Feature
+
+### Generating a Commit Message
+
+1. Stage your changes using `git add` or the VS Code git interface
+2. In the VS Code Source Control panel, look for the `Kilo Code` logo next to the commit message field)
+3. Click the logo to generate a commit message
+
+The generated message will appear in the commit message field, ready for you to review and modify if needed.
+
+{% image src="/docs/img/git-commit-generation/git-commit-1.png" alt="Generated commit message example" width="600" /%}
+
+### Conventional Commit Format
+
+By default, generated messages follow the Conventional Commits specification:
+
+```
+<type>(<scope>): <description>
+
+<body>
+```
+
+Common types include:
+
+- `feat`: New features
+- `fix`: Bug fixes
+- `docs`: Documentation changes
+- `style`: Code style changes (formatting, etc.)
+- `refactor`: Code refactoring
+- `test`: Adding or updating tests
+- `chore`: Maintenance tasks
+
+## Configuration
+
+{% tabs %}
+{% tab label="VSCode" %}
+
+The extension provides the same **SCM button** in the VS Code Source Control panel. Clicking it generates a commit message using the CLI backend's commit message generation API.
+
+Configuration is handled through the extension's settings or the shared `kilo.jsonc` config file.
+
+Customize the commit prompt from **Settings > Commit Message**. Kilo saves this prompt to the current project's config so each repository can follow its own commit conventions without changing your global settings.
+
+You can also set it directly in the project config:
+
+```json
+{
+  "commit_message": {
+    "prompt": "Write concise conventional commits with the package scope when possible."
+  }
+}
+```
+
+{% callout type="info" %}
+Git commit message generation is a **VS Code extension feature**. It is not available in the CLI/TUI.
+{% /callout %}
+
+{% /tab %}
+{% tab label="VSCode (Legacy)" %}
+
+### Customizing the Commit Template
+
+You can customize how commit messages are generated by modifying the prompt template:
+
+1. Open Settings by clicking the gear icon {% codicon name="gear" /%} → `Prompts`
+2. Find the "Commit Message Generation" section
+3. Edit the `Prompt` template to match your project's conventions
+
+{% image src="/docs/img/git-commit-generation/git-commit-2.png" alt="Commit message generation settings" width="600" /%}
+
+The default template creates conventional commit messages, but you can modify it to:
+
+- Use different commit message formats
+- Include specific information relevant to your project
+- Follow your team's commit message conventions
+- Add custom instructions for the AI
+
+### API Configuration
+
+You can configure which API profile to use for commit message generation:
+
+1. In the `Prompts` settings, scroll to "API Configuration"
+2. Select a specific profile or use the currently selected one
+
+{% callout type="tip" %}
+Consider creating a dedicated [API configuration profile](/docs/ai-providers) with a faster, more cost-effective model specifically for commit message generation.
+{% /callout %}
+
+{% /tab %}
+{% /tabs %}
+
+## Best Practices
+
+### Staging Strategy
+
+- Stage related changes together for more coherent commit messages
+- Avoid staging unrelated changes in a single commit
+- Use `git add -p` for partial file staging when needed
+
+### Message Review
+
+- Always review generated messages before committing
+- Edit messages to add context the AI might have missed
+- Ensure the message accurately describes the changes
+
+### Custom Templates
+
+- Tailor the prompt template to your project's needs
+- Include project-specific terminology or conventions
+- Add instructions for handling specific types of changes
+
+## Example Generated Messages
+
+Here are examples of messages the feature might generate:
+
+```
+feat(auth): add OAuth2 integration with Google
+
+Implement Google OAuth2 authentication flow including:
+- OAuth2 client configuration
+- User profile retrieval
+- Token refresh mechanism
+```
+
+```
+fix(api): resolve race condition in user data fetching
+
+Add proper error handling and retry logic to prevent
+concurrent requests from causing data inconsistency
+```
+
+```
+docs(readme): update installation instructions
+
+Add missing dependency requirements and clarify
+setup steps for new contributors
+```
+
+## Troubleshooting
+
+### No Staged Changes
+
+If the button doesn't appear or generation fails, ensure you have staged changes:
+
+```bash
+git add <files>
+# or stage all changes
+git add .
+```
+
+### Poor Message Quality
+
+If generated messages aren't helpful:
+
+- Review your staging strategy - don't stage unrelated changes together
+- Customize the prompt template with more specific instructions
+- Try a different AI model through API configuration
+
+### Integration Issues
+
+The feature integrates with VS Code's built-in git functionality. If you encounter issues:
+
+- Ensure your repository is properly initialized
+- Check that VS Code can access your git repository
+- Verify git is installed and accessible from VS Code
+
+## Related Features
+
+- [API Configuration Profiles](/docs/ai-providers) - Use different models for commit generation
+- [Settings Management](/docs/getting-started/settings) - Manage all your Kilo Code preferences

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "takomi",
-  "version": "2.1.13",
+  "version": "2.1.14",
   "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": {