takomi 2.1.35 → 2.1.36

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

@@ -92,6 +92,73 @@ let activeSubagentLabel: string | undefined;
 let activeSubagentAgent: string | undefined;
 let activeSubagentTask: string | undefined;
 let activeSubagentStatus: string | undefined;
+let delayedPiVersionCheckStarted = false;
+
+const PI_LATEST_VERSION_URL = "https://pi.dev/api/latest-version";
+
+function parseVersionParts(version: string): number[] | undefined {
+  const core = version.trim().replace(/^v/, "").split("-")[0];
+  if (!/^\d+(?:\.\d+)*$/.test(core)) return undefined;
+  return core.split(".").map((part) => Number.parseInt(part, 10) || 0);
+}
+
+function isNewerVersion(candidate: string, current: string): boolean {
+  const left = parseVersionParts(candidate);
+  const right = parseVersionParts(current);
+  if (!left || !right) return candidate.trim() !== current.trim();
+  for (let i = 0; i < Math.max(left.length, right.length); i += 1) {
+    const a = left[i] ?? 0;
+    const b = right[i] ?? 0;
+    if (a > b) return true;
+    if (a < b) return false;
+  }
+  return false;
+}
+
+async function readCurrentPiVersion(): Promise<string | undefined> {
+  const candidates = [
+    path.resolve(path.dirname(process.argv[1] ?? ""), "..", "package.json"),
+    path.resolve(path.dirname(process.argv[1] ?? ""), "package.json"),
+  ];
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(await readFile(candidate, "utf8")) as { name?: string; version?: string };
+      if (parsed.name === "@earendil-works/pi-coding-agent" && typeof parsed.version === "string") return parsed.version;
+    } catch { }
+  }
+  return undefined;
+}
+
+function scheduleDelayedPiVersionCheck(ctx: ExtensionContext): void {
+  if (delayedPiVersionCheckStarted) return;
+  if (process.env.TAKOMI_DELAYED_PI_VERSION_CHECK !== "1") return;
+  if (process.env.TAKOMI_SKIP_DELAYED_PI_VERSION_CHECK === "1" || process.env.PI_OFFLINE === "1") return;
+  delayedPiVersionCheckStarted = true;
+
+  const delayMs = Math.max(0, Number(process.env.TAKOMI_PI_VERSION_CHECK_DELAY_MS || 3000) || 3000);
+  const timeoutMs = Math.max(500, Number(process.env.TAKOMI_PI_VERSION_CHECK_TIMEOUT_MS || 2500) || 2500);
+  setTimeout(() => {
+    void (async () => {
+      try {
+        const currentVersion = await readCurrentPiVersion();
+        if (!currentVersion) return;
+        const response = await fetch(PI_LATEST_VERSION_URL, {
+          headers: { accept: "application/json", "user-agent": `takomi-delayed-pi-version-check/${currentVersion}` },
+          signal: AbortSignal.timeout(timeoutMs),
+        });
+        if (!response.ok) return;
+        const data = await response.json() as { version?: unknown; note?: unknown };
+        if (typeof data.version !== "string" || !isNewerVersion(data.version, currentVersion)) return;
+        if (ctx.hasUI) {
+          const note = typeof data.note === "string" && data.note.trim() ? ` ${data.note.trim()}` : "";
+          ctx.ui.notify(`Pi ${data.version} is available (installed: ${currentVersion}). Run: takomi refresh pi.${note}`, "info");
+        }
+      } catch {
+        // Best-effort only. Delayed version checks must never affect startup or usage.
+      }
+    })();
+  }, delayMs).unref?.();
+}
 
 const ThinkingSchema = Type.Union([
   Type.Literal("off"),
@@ -821,7 +888,6 @@ export default function takomiRuntime(pi: ExtensionAPI) {
       case "review":
         state.autoOrch = false;
         state.planMode = true;
-        state.launchMode = "manual";
         state.role = "review";
         state.stage = undefined;
         state.workflow = undefined;
@@ -1365,6 +1431,7 @@ ${stateJson}`
 
   pi.on("session_start", async (_event, ctx) => {
     runtimeCtx = ctx;
+    scheduleDelayedPiVersionCheck(ctx);
     activeProfile = await loadTakomiProfile(ctx.cwd);
     activeSubagentLabel = undefined;
     activeSubagentAgent = undefined;

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

@@ -81,9 +81,9 @@ export function renderRuntimeStatus(theme: Theme, state: RuntimeHudState): strin
   const sourceLabel = source === "manual" ? theme.fg("warning", "manual") : theme.fg("success", source);
   const role = state.stage && state.role !== state.stage ? theme.fg("dim", state.role) : "";
   const plan = state.planMode ? theme.fg("warning", "plan") : theme.fg("dim", "direct");
-  const gate = state.launchMode === "manual" ? theme.fg("warning", "review-gate") : "";
+  const gate = state.launchMode === "manual" ? theme.fg("warning", "review-gate") : theme.fg("success", "auto-gate");
   const subagents = state.subagentsEnabled === false ? theme.fg("error", "subagents:off") : "";
-  return [theme.fg("accent", "Takomi"), sourceLabel, stageBadge, role, gate || plan, subagents].filter(Boolean).join(" ");
+  return [theme.fg("accent", "Takomi"), sourceLabel, stageBadge, role, gate, plan, subagents].filter(Boolean).join(" ");
 }
 
 export function renderRuntimeWidget(theme: Theme, state: RuntimeHudState): string[] {
@@ -95,7 +95,7 @@ export function renderRuntimeWidget(theme: Theme, state: RuntimeHudState): strin
     sourceLabel,
     badge(theme, primary, stageTone(state.stage)),
     state.stage && state.role !== state.stage ? theme.fg("dim", `role:${state.role}`) : "",
-    state.launchMode === "manual" ? theme.fg("warning", "review-gate") : "",
+    state.launchMode === "manual" ? theme.fg("warning", "review-gate") : theme.fg("success", "auto-gate"),
     state.planMode ? theme.fg("warning", "plan") : theme.fg("dim", "direct"),
     state.subagentsEnabled === false ? theme.fg("error", "subagents:off") : theme.fg("dim", "subagents:on"),
     state.workflow ? theme.fg("dim", `wf:${state.workflow}`) : "",

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

@@ -1,6 +1,7 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { renderTakomiSubagentCall, renderTakomiSubagentResult } from "./native-render";
+import { loadPiSubagentsInternals } from "./pi-subagents-internal";
 import { executeTakomiSubagentTool } from "./tool-runner";
 
 const ChecklistItemSchema = Type.Object({
@@ -74,6 +75,11 @@ function registerSubagentTool(pi: ExtensionAPI): void {
   });
 }
 
-export default function takomiSubagents(pi: ExtensionAPI) {
+export default async function takomiSubagents(pi: ExtensionAPI) {
+  // Preload the native pi-subagents renderer before tool registration. Rendering
+  // callbacks are synchronous, so if we only lazy-load internals during execution
+  // a completed takomi_subagent result can fall back to Takomi's plain text
+  // renderer and lose the native compact/expanded details shown by `subagent`.
+  await loadPiSubagentsInternals();
   registerSubagentTool(pi);
 }

package/.pi/extensions/takomi-subagents/native-render.ts

@@ -38,12 +38,16 @@ function resultText(result: ToolResult): string {
       : JSON.stringify((result as any)?.details ?? {}, null, 2);
 }
 
-function summarizeCollapsedResult(text: string, status: string, theme: Theme): string {
+function extractPolicyNames(text: string): string[] {
   const policyMatch = text.match(/Required policies:\n((?:- .+\n?)+)/);
-  const policies = policyMatch?.[1]
+  return policyMatch?.[1]
     ?.split("\n")
     .map((line) => line.replace(/^[-\s]+/, "").trim())
     .filter(Boolean) ?? [];
+}
+
+function summarizeCollapsedResult(text: string, status: string, theme: Theme): string {
+  const policies = extractPolicyNames(text);
   const lineCount = text ? text.split(/\r?\n/).length : 0;
   const label = policies.length > 0
     ? `policy context loaded: ${policies.join(", ")}`
@@ -53,22 +57,89 @@ function summarizeCollapsedResult(text: string, status: string, theme: Theme): s
   return `${theme.fg(color, `${icon} takomi_subagent ${status}`)}${theme.fg("dim", ` · ${label} (ctrl+o to expand)`)}`;
 }
 
+function isPolicyGateBlock(text: string): boolean {
+  return /^Blocked\s+takomi_subagent:\s+required policy context had not been loaded yet\./m.test(text)
+    && /\nRequired policies:\n/.test(text)
+    && /\nLoaded policy context:\n/.test(text);
+}
+
+function renderPolicyGateBlock(text: string, expanded: boolean | undefined, theme: Theme): string {
+  const policies = extractPolicyNames(text);
+  const lineCount = text ? text.split(/\r?\n/).length : 0;
+  const policyLabel = policies.length ? policies.join(", ") : "required policy";
+  if (!expanded) {
+    return [
+      theme.fg("warning", "⚠ takomi_subagent blocked"),
+      theme.fg("dim", `Required policy context loaded for this session: ${policyLabel}.`),
+      theme.fg("dim", `Retry the original tool call. ${lineCount} policy lines hidden (ctrl+o to expand).`),
+    ].join("\n");
+  }
+  return [
+    theme.fg("warning", "⚠ takomi_subagent blocked"),
+    theme.fg("dim", "Policy context was loaded and passed back to the model; retry the original call."),
+    theme.fg("dim", "Press ctrl+o again to collapse."),
+    "",
+    text,
+  ].join("\n");
+}
+
 function recentOutputLines(value: unknown): string[] {
   if (Array.isArray(value)) return value.map(String).filter(Boolean).slice(-3);
   if (typeof value === "string") return value.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(-3);
   return [];
 }
 
+function normalizeLiveStatus(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  if (value === "complete") return "completed";
+  if (value === "in-progress") return "running";
+  if (value === "timed-out") return "failed";
+  return value;
+}
+
+function rawLiveStatus(row: any): string {
+  const explicit = normalizeLiveStatus(
+    typeof row?.progress?.status === "string" ? row.progress.status
+      : typeof row?.status === "string" ? row.status
+        : undefined,
+  );
+  if (explicit) return explicit;
+
+  const exitCode = typeof row?.exitCode === "number" ? row.exitCode
+    : typeof row?.code === "number" ? row.code
+      : undefined;
+  if (exitCode === 0) return "completed";
+  if (exitCode === undefined || exitCode === null || exitCode === -1) return "running";
+  return "failed";
+}
+
+function isLiveTerminalStatus(status: string): boolean {
+  return ["completed", "failed", "blocked", "detached", "paused"].includes(status);
+}
+
+function displayLiveStatus(status: string, allRowsTerminal: boolean): string {
+  // Native pi-subagents can emit one last partial update after the child process
+  // reaches exitCode 0 but before the takomi_subagent tool result has actually
+  // settled. In that window the tool card is still partial/running, so showing a
+  // child as "completed" is misleading. Call it finalizing until Pi renders the
+  // real final result.
+  if (allRowsTerminal && status === "completed") return "finalizing";
+  return status;
+}
+
 function livePartialText(result: ToolResult, theme: Theme): string {
   const details = (result as any)?.details ?? {};
   const results = Array.isArray(details.results) ? details.results : [];
   const progress = Array.isArray(details.progress) ? details.progress : [];
+  const rows = results.length ? results : progress;
+  const rawStatuses = rows.map(rawLiveStatus);
+  const allRowsTerminal = rows.length > 0 && rawStatuses.every(isLiveTerminalStatus);
+  const titleStatus = allRowsTerminal ? "finalizing" : "running";
   const lines = [
-    theme.fg("toolTitle", theme.bold("takomi_subagent running")),
+    theme.fg("toolTitle", theme.bold(`takomi_subagent ${titleStatus}`)),
     theme.fg("dim", "Live detail is bounded while streaming so manual scroll/ctrl+o does not jump on every token."),
   ];
 
-  const rows = results.length ? results : progress;
   if (!rows.length) {
     const text = resultText(result).split(/\r?\n/).find((line) => line.trim())?.trim();
     lines.push(theme.fg("dim", text || "Waiting for subagent progress…"));
@@ -76,7 +147,7 @@ function livePartialText(result: ToolResult, theme: Theme): string {
   }
 
   rows.slice(0, 6).forEach((row: any, index: number) => {
-    const status = row.status ?? (row.exitCode === 0 ? "completed" : row.exitCode === -1 ? "running" : row.exitCode === undefined ? "running" : "failed");
+    const status = displayLiveStatus(rawStatuses[index] ?? rawLiveStatus(row), allRowsTerminal);
     const agent = row.agent ?? `task ${index + 1}`;
     const task = String(row.task ?? "").replace(/\s+/g, " ").trim();
     const currentTool = row.currentTool ?? row.progress?.currentTool;
@@ -93,9 +164,13 @@ function livePartialText(result: ToolResult, theme: Theme): string {
 }
 
 export function renderTakomiSubagentResult(result: ToolResult, options: { expanded?: boolean; isPartial?: boolean }, theme: Theme, context: any): any {
-  const status = (result as any)?.isError ? "failed" : options.isPartial ? "running" : "completed";
+  const status = ((result as any)?.isError || context?.isError) ? "failed" : options.isPartial ? "running" : "completed";
   const text = resultText(result);
 
+  if (isPolicyGateBlock(text)) {
+    return new Text(renderPolicyGateBlock(text, options.expanded, theme), 0, 0);
+  }
+
   if (options.isPartial) {
     if (options.expanded) return new Text(livePartialText(result, theme), 0, 0);
     return new Text(summarizeCollapsedResult(text, status, theme), 0, 0);

package/.pi/extensions/takomi-subagents/tool-runner.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { TakomiThinkingLevel } from "../../../src/pi-takomi-core";
+import type { TakomiLaunchMode, TakomiThinkingLevel } from "../../../src/pi-takomi-core";
 import { loadTakomiProfile } from "../takomi-runtime/profile";
 import { applyTakomiRoutingDefaults, loadTakomiModelRoutingSnapshot } from "../takomi-runtime/model-routing-defaults";
 import { resolveAgentName } from "./agent-aliases";
@@ -192,6 +192,17 @@ function withNativeHardStop(result: any, hardStop: { reason: string; message: st
     },
   };
 }
+
+function readRuntimeLaunchMode(ctx: ExtensionContext): TakomiLaunchMode | undefined {
+  const entries = ctx.sessionManager.getEntries();
+  for (let i = entries.length - 1; i >= 0; i -= 1) {
+    const entry = entries[i] as { type?: string; customType?: string; data?: { launchMode?: unknown } };
+    if (entry.type !== "custom" || entry.customType !== "takomi-runtime-state") continue;
+    if (entry.data?.launchMode === "manual" || entry.data?.launchMode === "auto") return entry.data.launchMode;
+  }
+  return undefined;
+}
+
 function resolveMode(params: TakomiSubagentToolParams): "single" | "parallel" | "chain" | undefined {
   const hasChain = Boolean(params.chain?.length);
   const hasParallel = Boolean(params.tasks?.length);
@@ -234,6 +245,7 @@ export async function executeTakomiSubagentTool(
     return textResult(message, { results: [], agentScope: params.agentScope ?? "both" }, true);
   }
   const profile = await loadTakomiProfile(rootCwd);
+  const runtimeLaunchMode = readRuntimeLaunchMode(ctx);
   const agentScope = params.agentScope ?? "both";
   const agents = discoverTakomiAgents(rootCwd, agentScope);
   const byName = new Map<string, TakomiAgentConfig>(agents.map((agent) => [agent.name, agent]));
@@ -290,7 +302,7 @@ export async function executeTakomiSubagentTool(
   }
   const plan = createTakomiDelegationPlan({
     source: "takomi-tool",
-    launchMode: profile.launchMode ?? "auto",
+    launchMode: runtimeLaunchMode ?? profile.launchMode ?? "auto",
     profile,
     tasks: tasks.map((task, index) => ({
       id: task.conversationId ?? `direct-${index + 1}`,

package/README.md

@@ -63,7 +63,7 @@ Takomi now ships a Pi-native `takomi-context-manager` extension. It reduces prom
 
 ### Option A: Global Install (Best for Multi-IDE Users) ⭐
 
-Install once. Use everywhere. Your skills follow you across every AI harness(Antigravity, KiloCode, Windsurf, Cursor, Gemini CLI):
+Install once. Use everywhere. Your skills follow you across detected AI harnesses (Antigravity, Claude Code, Codex, Cursor, Kilo Code, Pi/shared Agent Skills, Windsurf):
 
 ```bash
 # Using pnpm
@@ -184,17 +184,21 @@ npx -y skills add https://github.com/JStaRFilms/VibeCode-Protocol-Suite --skill
 
 **One install. Every IDE. Zero friction.**
 
-Takomi v2.0 introduces the **Global Skills Router** — install skills once, and they appear in every AI harness you use. No symlinks. No admin privileges. Works on Mac & Windows.
+Takomi v2.0 introduces the **Global Skills Router** — install skills once into `~/.takomi/`, and Takomi syncs them into each harness' current global skills directory. You can choose symlink/junction mode for one canonical copy, auto fallback, or plain copy mode. Works on Mac & Windows.
+
+Note: `SKILL.md` is portable, but `~/.agents/skills` is **not** a universal global skills directory. Pi does load `~/.agents/skills`, and Takomi keeps that as the Pi/shared Agent Skills target. Other harnesses use their own global paths. See `docs/skills-harness-targets.md` for the current checked path table.
 
 ### Supported Harnesses
 
 | Harness | Global Skills Path | Global Workflows Path |
 |---|---|---|
-| **Antigravity** | `~/.gemini/antigravity/skills/` | `~/.gemini/antigravity/global_workflows/` |
-| **KiloCode** | `~/.kilocode/skills/` | `~/.kilocode/workflows/` |
+| **Antigravity** | `~/.gemini/config/skills/` | `~/.gemini/config/global_workflows/` |
+| **Claude Code** | `~/.claude/skills/` | _(skills only)_ |
+| **Codex** | `~/.codex/skills/` | _(skills only)_ |
+| **Cursor** | `~/.cursor/skills/` | _(skills only)_ |
+| **Kilo Code** | `~/.kilocode/skills/` | `~/.kilocode/workflows/` |
+| **Pi / shared Agent Skills** | `~/.agents/skills/` | _(skills only)_ |
 | **Windsurf** | `~/.codeium/windsurf/skills/` | `~/.codeium/windsurf/global_workflows/` |
-| **Global agents-compatible CLIs** _(e.g., Codex, Gemini CLI)_ | `~/.agents/skills/` | _(skills only)_ |
-| **Cursor** | `~/.cursor/skills/` | _(uses rules)_ |
 
 ### CLI Commands
 
@@ -505,7 +509,7 @@ Externally sourced skills and optional Pi packages retain credit to their upstre
 - **Context7**: From [upstash/context7](https://github.com/upstash/context7) — fresh library documentation fetcher.
 - **Audit Website**: From [squirrelscan/skills](https://github.com/squirrelscan/skills) — professional website auditor.
 - **Convex Skills**: From [waynesutton/convexskills](https://github.com/waynesutton/convexskills) — complete Convex development suite including **Functions**, **Schema Validation**, **Realtime**, **Agents**, **File Storage**, **Migrations**, **HTTP Actions**, **Cron Jobs**, **Component Authoring**, **Best Practices**, **Security Audit**, **Security Check**, **Avoid Feature Creep**, and **Optimize Agent Context**.
-- **Gemini CLI**: Custom VibeCode skill for large-context processing with Gemini 3 Pro.
+- **Anti-Gravity**: Custom skill for running Google's current Anti-Gravity CLI workflow for large-context review and analysis.
 - **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.

package/package.json

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

package/src/cli.js

@@ -23,6 +23,7 @@ import {
   downloadDirectoryFromGitHub,
 } from './utils.js';
 import {
+  HARNESS_MAP,
   detectHarnesses,
   printHarnessStatus,
   syncToAllHarnesses,
@@ -393,6 +394,43 @@ async function promptSkillsInstallSelection() {
   return { mode: response.mode, selectedSkills };
 }
 
+function normalizeHarnessSyncMode(value) {
+  return ['copy', 'symlink', 'auto'].includes(value) ? value : 'copy';
+}
+
+async function promptHarnessSyncMode(initial = 'auto') {
+  const normalizedInitial = normalizeHarnessSyncMode(initial);
+  const choices = [
+    { title: 'Auto (try symlink, copy if blocked)', value: 'auto', description: 'Best fallback when Windows permissions or filesystems block symlinks.' },
+    { title: 'Symlink / Junction (single source of truth)', value: 'symlink', description: 'Each managed skill/workflow points back to ~/.takomi; edits update one canonical copy.' },
+    { title: 'Copy (independent files)', value: 'copy', description: 'Most compatible; changes do not flow back to ~/.takomi.' },
+  ];
+  const response = await prompts({
+    type: 'select',
+    name: 'syncMode',
+    message: 'How should Takomi sync store resources into harness folders?',
+    choices,
+    initial: Math.max(0, choices.findIndex((choice) => choice.value === normalizedInitial)),
+  });
+  if (!response.syncMode) return null;
+  return normalizeHarnessSyncMode(response.syncMode);
+}
+
+function collectSyncFailures(syncSummary) {
+  return Object.entries(syncSummary || {})
+    .filter(([, result]) => result?.ok === false)
+    .map(([id, result]) => ({ id, errors: result.errors?.length ? result.errors : ['unknown sync error'] }));
+}
+
+function printSyncFailures(failures) {
+  if (!failures.length) return;
+  console.log(pc.yellow('\nSome harnesses did not fully sync:'));
+  for (const failure of failures) {
+    console.log(pc.dim(`  - ${failure.id}: ${failure.errors.join('; ')}`));
+  }
+  process.exitCode = 1;
+}
+
 async function installSkillsTarget() {
   console.log(pc.magenta('🧰 Takomi Skills Install\n'));
   try {
@@ -411,7 +449,7 @@ async function installSkillsTarget() {
     const result = await installBundledSkills(program.version(), selection);
     const validation = await validateSkillsInstall(selection.selectedSkills);
     printSkillsInstallSummary(result, validation);
-    console.log(pc.dim('\nGlobal skills are ready for Pi or other supported harnesses.\n'));
+    console.log(pc.dim('\nShared skills target is ready. For per-harness global paths, run "takomi setup" or "takomi sync".\n'));
   } catch (error) {
     console.log(pc.red('\nSkills install failed.'));
     console.log(pc.dim(String(error?.message || error)));
@@ -622,7 +660,7 @@ async function install(target) {
 
   if (detected.length === 0) {
     console.log(pc.yellow('  No AI harnesses detected on this machine.'));
-    console.log(pc.dim('  We support: Antigravity, KiloCode, Windsurf, Codex, Cursor, Gemini CLI'));
+    console.log(pc.dim(`  We support: ${Object.values(HARNESS_MAP).map(h => h.name).join(', ')}`));
     console.log(pc.dim('  Run "takomi init" instead for per-project setup.\n'));
     return;
   }
@@ -715,6 +753,11 @@ async function install(target) {
 
   if (!contentResponse.content) return;
 
+  const syncMode = await promptHarnessSyncMode(
+    (hasExistingStoreSkills || hasExistingStoreWorkflows) ? existingStoreManifest.syncMode : 'auto'
+  );
+  if (!syncMode) return;
+
   try {
     // 4. Initialize global store
     console.log(pc.cyan(`\n📦 Creating global store (${STORE_PATH})...\n`));
@@ -802,11 +845,15 @@ async function install(target) {
     const syncSummary = await syncToAllHarnesses(selectedHarnesses, STORE_PATH, {
       useOwnership: true,
       owned: manifest.harnessOwned,
+      linkMode: syncMode,
     });
 
     // 7. Update manifest
+    const syncFailures = collectSyncFailures(syncSummary);
+    const successfulHarnesses = selectedHarnesses.filter(h => !syncFailures.some(failure => failure.id === h.id));
     manifest = await getManifest();
-    manifest.linkedHarnesses = selectedHarnesses.map(h => h.id);
+    manifest.linkedHarnesses = successfulHarnesses.map(h => h.id);
+    manifest.syncMode = syncMode;
     manifest.installed.skills = await getStoreSkills();
     manifest.installed.workflows = await getStoreWorkflows();
     manifest.harnessOwned = manifest.harnessOwned || {};
@@ -814,11 +861,13 @@ async function install(target) {
       manifest.harnessOwned[harness.id] = syncSummary[harness.id]?.owned || manifest.harnessOwned[harness.id] || {};
     }
     await writeManifest(manifest);
+    printSyncFailures(syncFailures);
 
     // 8. Summary
-    console.log(pc.magenta('\n✨ Your command center is live. ✨'));
+    console.log(pc.magenta(syncFailures.length ? '\n⚠ Your command center is partially synced. ⚠' : '\n✨ Your command center is live. ✨'));
     console.log(pc.white(`\n  Store:     ${STORE_PATH}`));
-    console.log(pc.white(`  Connected: ${selectedHarnesses.map(h => h.name).join(', ')}`));
+    console.log(pc.white(`  Sync mode: ${syncMode}`));
+    console.log(pc.white(`  Connected: ${successfulHarnesses.map(h => h.name).join(', ') || 'none'}`));
     console.log(pc.dim(`\n  Add skills:    takomi add <github-url>`));
     console.log(pc.dim(`  Sync updates:  takomi sync\n`));
 
@@ -882,23 +931,33 @@ async function sync(target) {
 
   const selectedHarnesses = detected.filter(h => response.harnesses.includes(h.id));
 
-  console.log(pc.cyan('\n📡 Syncing from global store...\n'));
+  const envSyncMode = process.env.TAKOMI_HARNESS_SYNC_MODE;
+  const syncMode = normalizeHarnessSyncMode(envSyncMode || manifest.syncMode || 'copy');
+  console.log(pc.cyan(`\n📡 Syncing from global store (${syncMode})...\n`));
   const syncSummary = await syncToAllHarnesses(selectedHarnesses, STORE_PATH, {
     useOwnership: true,
     owned: manifest.harnessOwned,
+    linkMode: syncMode,
   });
 
   // Update manifest with current harnesses
-  manifest.linkedHarnesses = [...new Set([...manifest.linkedHarnesses, ...response.harnesses])];
+  const syncFailures = collectSyncFailures(syncSummary);
+  const successfulHarnessIds = response.harnesses.filter(id => !syncFailures.some(failure => failure.id === id));
+  manifest.linkedHarnesses = [...new Set([...manifest.linkedHarnesses, ...successfulHarnessIds])];
+  if (!envSyncMode) manifest.syncMode = syncMode;
   manifest.harnessOwned = manifest.harnessOwned || {};
   for (const harness of selectedHarnesses) {
     manifest.harnessOwned[harness.id] = syncSummary[harness.id]?.owned || manifest.harnessOwned[harness.id] || {};
   }
   await writeManifest(manifest);
+  printSyncFailures(syncFailures);
 
   const skills = await getStoreSkills();
   const workflows = await getStoreWorkflows();
-  console.log(pc.magenta(`\n✨ ${skills.length} skills and ${workflows.length} workflows synced to ${selectedHarnesses.length} IDE(s). Ready to build.\n`));
+  const syncedCount = successfulHarnessIds.length;
+  console.log(pc.magenta(syncFailures.length
+    ? `\n⚠ ${skills.length} skills and ${workflows.length} workflows partially synced to ${syncedCount}/${selectedHarnesses.length} IDE(s).\n`
+    : `\n✨ ${skills.length} skills and ${workflows.length} workflows synced to ${syncedCount} IDE(s). Ready to build.\n`));
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -994,8 +1053,21 @@ async function add(url) {
     if (syncResponse.doSync) {
       const detected = detectHarnesses();
       const linked = detected.filter(h => manifest.linkedHarnesses.includes(h.id));
-      await syncToAllHarnesses(linked, STORE_PATH);
-      console.log(pc.magenta(`\n✨ Live on ${linked.length} IDE(s). You're armed and ready.\n`));
+      const syncSummary = await syncToAllHarnesses(linked, STORE_PATH, {
+        useOwnership: true,
+        owned: manifest.harnessOwned,
+        linkMode: normalizeHarnessSyncMode(process.env.TAKOMI_HARNESS_SYNC_MODE || manifest.syncMode || 'copy'),
+      });
+      const syncFailures = collectSyncFailures(syncSummary);
+      manifest.harnessOwned = manifest.harnessOwned || {};
+      for (const harness of linked) {
+        manifest.harnessOwned[harness.id] = syncSummary[harness.id]?.owned || manifest.harnessOwned[harness.id] || {};
+      }
+      await writeManifest(manifest);
+      printSyncFailures(syncFailures);
+      console.log(pc.magenta(syncFailures.length
+        ? `\n⚠ Live on ${linked.length - syncFailures.length}/${linked.length} IDE(s); some harnesses need attention.\n`
+        : `\n✨ Live on ${linked.length} IDE(s). You're armed and ready.\n`));
     }
   } else {
     console.log(pc.dim('\n  Run "takomi sync" when you want to push these to your IDEs.\n'));
@@ -1022,6 +1094,7 @@ async function harnesses() {
     console.log(pc.white(`  Location:  ${STORE_PATH}`));
     console.log(pc.white(`  Skills:    ${skills.length} ready to deploy`));
     console.log(pc.white(`  Workflows: ${workflows.length} available`));
+    console.log(pc.white(`  Sync mode: ${manifest.syncMode || 'copy'}`));
     console.log(pc.white(`  Connected: ${manifest.linkedHarnesses.join(', ') || 'none'}`));
     console.log(pc.dim(`  Updated:   ${manifest.updatedAt}\n`));
   } else {
@@ -1096,8 +1169,19 @@ async function updateProjectResources() {
       const detected = detectHarnesses();
       const linked = detected.filter(h => manifest.linkedHarnesses.includes(h.id));
       if (linked.length > 0) {
-        console.log(pc.cyan('\n📡 Auto-syncing to linked harnesses...\n'));
-        await syncToAllHarnesses(linked, STORE_PATH);
+        const syncMode = normalizeHarnessSyncMode(process.env.TAKOMI_HARNESS_SYNC_MODE || manifest.syncMode || 'copy');
+        console.log(pc.cyan(`\n📡 Auto-syncing to linked harnesses (${syncMode})...\n`));
+        const syncSummary = await syncToAllHarnesses(linked, STORE_PATH, {
+          useOwnership: true,
+          owned: manifest.harnessOwned,
+          linkMode: syncMode,
+        });
+        const syncFailures = collectSyncFailures(syncSummary);
+        manifest.harnessOwned = manifest.harnessOwned || {};
+        for (const harness of linked) {
+          manifest.harnessOwned[harness.id] = syncSummary[harness.id]?.owned || manifest.harnessOwned[harness.id] || {};
+        }
+        printSyncFailures(syncFailures);
       }
     }
 

package/src/harness.js

@@ -2,7 +2,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
 import pc from 'picocolors';
-import { hashPath, normalizeOwnedMap, copyOwnedTree } from './owned-tree.js';
+import { hashPath, normalizeOwnedMap, materializeOwnedTree } from './owned-tree.js';
 
 // ─── Cross-Platform Home Directory ───────────────────────────────────────────
 const HOME = os.homedir();
@@ -34,13 +34,26 @@ function getAppData() {
 export const HARNESS_MAP = {
   antigravity: {
     name: 'Antigravity',
-    rootPath: path.join(HOME, '.gemini', 'antigravity'),
+    rootPath: path.join(HOME, '.gemini', 'config'),
     detect() {
       return fs.existsSync(this.rootPath);
     },
     targets: {
-      skills: path.join(HOME, '.gemini', 'antigravity', 'skills'),
-      workflows: path.join(HOME, '.gemini', 'antigravity', 'global_workflows'),
+      skills: path.join(HOME, '.gemini', 'config', 'skills'),
+      workflows: path.join(HOME, '.gemini', 'config', 'global_workflows'),
+      yamls: null,
+    },
+  },
+
+  claude_code: {
+    name: 'Claude Code',
+    rootPath: path.join(HOME, '.claude'),
+    detect() {
+      return fs.existsSync(this.rootPath);
+    },
+    targets: {
+      skills: path.join(HOME, '.claude', 'skills'),
+      workflows: null,
       yamls: null,
     },
   },
@@ -78,7 +91,20 @@ export const HARNESS_MAP = {
     name: 'Codex',
     rootPath: path.join(HOME, '.codex'),
     detect() {
-      return fs.existsSync(this.rootPath);
+      return fs.existsSync(this.rootPath) || fs.existsSync('/etc/codex');
+    },
+    targets: {
+      skills: path.join(HOME, '.codex', 'skills'),
+      workflows: null,
+      yamls: null,
+    },
+  },
+
+  pi: {
+    name: 'Pi / shared Agent Skills',
+    rootPath: path.join(HOME, '.pi'),
+    detect() {
+      return fs.existsSync(this.rootPath) || fs.existsSync(path.join(HOME, '.agents'));
     },
     targets: {
       skills: path.join(HOME, '.agents', 'skills'),
@@ -100,19 +126,7 @@ export const HARNESS_MAP = {
     },
   },
 
-  gemini_cli: {
-    name: 'Gemini CLI',
-    rootPath: path.join(HOME, '.gemini'),
-    detect() {
-      // Only match bare Gemini CLI — not Antigravity (which also lives under .gemini)
-      return fs.existsSync(this.rootPath) && !fs.existsSync(path.join(HOME, '.gemini', 'antigravity'));
-    },
-    targets: {
-      skills: path.join(HOME, '.agents', 'skills'),
-      workflows: null,
-      yamls: null,
-    },
-  },
+
 };
 
 // ─── Detection ───────────────────────────────────────────────────────────────
@@ -163,17 +177,14 @@ export function printHarnessStatus(detected) {
 
 /**
  * Syncs a source directory to a harness target path.
- * Uses hard copy (fs.copy) — no symlinks.
+ * Supports copy, symlink/junction, or auto-fallback materialization.
+ * When ownership is supplied, it also prunes previous Takomi-owned items
+ * that are no longer in the source while preserving manual or modified files.
  *
  * @param {string} sourcePath  - Source directory (e.g., ~/.takomi/skills/)
- * @param {string} targetPath  - Destination directory (e.g., ~/.gemini/antigravity/skills/)
+ * @param {string} targetPath  - Destination directory (e.g., ~/.gemini/config/skills/)
  * @param {string} label       - Human-readable label for logging
- * @returns {Promise<number>}  - Number of items copied
- */
-/**
- * Syncs a directory to a target path. When ownership is supplied, it also
- * prunes previous Takomi-owned items that are no longer in the source while
- * preserving manual or modified files.
+ * @returns {Promise<number|object>}  - Number of items materialized, or details
  */
 export async function syncDirectory(sourcePath, targetPath, label = '', options = {}) {
   if (!targetPath) return options.returnDetails ? { copied: 0, pruned: 0, preservedManual: [], preservedModified: [], owned: {} } : 0;
@@ -187,7 +198,10 @@ export async function syncDirectory(sourcePath, targetPath, label = '', options
     const nextOwned = {};
     const preservedManual = [];
     const preservedModified = [];
+    const symlinkFallbacks = [];
+    const linkMode = options.linkMode || process.env.TAKOMI_HARNESS_SYNC_MODE || 'copy';
     let copied = 0;
+    let linked = 0;
     let pruned = 0;
 
     if (options.prune && Object.keys(previousOwned).length > 0) {
@@ -225,29 +239,35 @@ export async function syncDirectory(sourcePath, targetPath, label = '', options
         await fs.remove(dest);
       }
 
-      await copyOwnedTree(src, dest);
+      const materialized = await materializeOwnedTree(src, dest, { linkMode });
       nextOwned[item] = {
         hash: await hashPath(dest),
         targetPath: dest,
+        sourcePath: path.resolve(src),
+        syncMethod: materialized.method,
         syncedAt: new Date().toISOString(),
       };
-      copied++;
+      if (materialized.method === 'symlink') linked++;
+      else copied++;
+      if (materialized.fallbackError) symlinkFallbacks.push(`${item}: ${materialized.fallbackError}`);
     }
 
     if (label) {
       const suffix = pruned ? `, removed ${pruned}` : '';
-      console.log(pc.green(`  ✔ ${label} (${copied} items${suffix})`));
+      const methodSummary = linked ? `${linked} linked, ${copied} copied` : `${copied} copied`;
+      console.log(pc.green(`  ✔ ${label} (${methodSummary}${suffix})`));
       if (preservedManual.length) console.log(pc.yellow(`    Preserved manual items: ${preservedManual.join(', ')}`));
       if (preservedModified.length) console.log(pc.yellow(`    Preserved modified Takomi-owned items: ${preservedModified.join(', ')}`));
+      if (symlinkFallbacks.length) console.log(pc.yellow(`    Symlink fallback copies: ${symlinkFallbacks.join('; ')}`));
     }
 
-    const details = { copied, pruned, preservedManual, preservedModified, owned: Object.fromEntries(Object.entries(nextOwned).sort(([a], [b]) => a.localeCompare(b))) };
-    return options.returnDetails ? details : copied;
+    const details = { copied: copied + linked, linked, copyCount: copied, pruned, preservedManual, preservedModified, symlinkFallbacks, owned: Object.fromEntries(Object.entries(nextOwned).sort(([a], [b]) => a.localeCompare(b))) };
+    return options.returnDetails ? details : copied + linked;
   } catch (error) {
     if (label) {
       console.log(pc.red(`  ✗ ${label}: ${error.message}`));
     }
-    return options.returnDetails ? { copied: 0, pruned: 0, preservedManual: [], preservedModified: [], owned: normalizeOwnedMap(options.owned), ok: false, error: error.message } : 0;
+    return options.returnDetails ? { copied: 0, linked: 0, copyCount: 0, pruned: 0, preservedManual: [], preservedModified: [], symlinkFallbacks: [], owned: normalizeOwnedMap(options.owned), ok: false, error: error.message } : 0;
   }
 }
 
@@ -309,6 +329,7 @@ export async function syncToHarness(harness, storePath, options = {}) {
         preserveManual: useOwnership,
         prune: useOwnership,
         returnDetails: useOwnership,
+        linkMode: options.linkMode,
       },
     );
     if (useOwnership) {
@@ -335,6 +356,7 @@ export async function syncToHarness(harness, storePath, options = {}) {
         preserveManual: useOwnership,
         prune: useOwnership,
         returnDetails: useOwnership,
+        linkMode: options.linkMode,
       },
     );
     if (useOwnership) {

package/src/owned-tree.js

@@ -84,3 +84,31 @@ export async function copyOwnedTree(src, dest, options = {}) {
     },
   });
 }
+
+export async function linkOwnedTree(src, dest) {
+  const resolvedSrc = path.resolve(src);
+  const stat = await fs.lstat(resolvedSrc);
+  const type = stat.isDirectory()
+    ? (process.platform === 'win32' ? 'junction' : 'dir')
+    : 'file';
+  await fs.ensureDir(path.dirname(dest));
+  await fs.symlink(resolvedSrc, dest, type);
+}
+
+export async function materializeOwnedTree(src, dest, options = {}) {
+  const linkMode = options.linkMode || 'copy';
+  if (linkMode === 'symlink' || linkMode === 'auto') {
+    try {
+      await linkOwnedTree(src, dest);
+      return { method: 'symlink' };
+    } catch (error) {
+      if (linkMode === 'symlink') throw error;
+      await fs.remove(dest).catch(() => {});
+      await copyOwnedTree(src, dest, options.copyOptions || {});
+      return { method: 'copy', fallbackError: error.message };
+    }
+  }
+
+  await copyOwnedTree(src, dest, options.copyOptions || {});
+  return { method: 'copy' };
+}

package/src/pi-harness.js

@@ -15,6 +15,28 @@ function getPathEntries() {
 }
 
 function commandExists(command) {
+  const pathEntries = getPathEntries();
+
+  // Avoid shelling out on the hot launch path. On Windows, `where pi` is often
+  // ~100ms by itself; a direct PATH scan is much cheaper and good enough for
+  // npm/cmd shims. Keep `where`/`which` as a fallback for edge cases.
+  const manualCandidates = process.platform === 'win32'
+    ? (() => {
+        const hasExtension = /\.(cmd|exe|bat|com)$/i.test(command);
+        const extensions = hasExtension
+          ? ['']
+          : (process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD')
+              .split(';')
+              .filter(Boolean)
+              .sort((a, b) => (a.toLowerCase() === '.cmd' ? -1 : b.toLowerCase() === '.cmd' ? 1 : 0));
+        return pathEntries.flatMap((entry) => extensions.map((extension) => path.join(entry, `${command}${extension.toLowerCase()}`)));
+      })()
+    : pathEntries.map((entry) => path.join(entry, command));
+
+  for (const candidate of manualCandidates) {
+    if (fs.existsSync(candidate)) return { found: true, path: candidate };
+  }
+
   const probe = process.platform === 'win32'
     ? spawnSync('where', [command], { stdio: 'pipe', encoding: 'utf8' })
     : spawnSync('which', [command], { stdio: 'pipe', encoding: 'utf8' });
@@ -27,11 +49,6 @@ function commandExists(command) {
     return { found: true, path: preferred || matches[0] || null };
   }
 
-  for (const entry of getPathEntries()) {
-    const candidate = path.join(entry, process.platform === 'win32' ? `${command}.cmd` : command);
-    if (fs.existsSync(candidate)) return { found: true, path: candidate };
-  }
-
   return { found: false, path: null };
 }
 
@@ -140,12 +157,17 @@ export async function inspectPiSubagentsDependency(home = HOME) {
   };
 }
 
-export async function detectPiCommand() {
+export async function detectPiCommand(options = {}) {
+  const { includeVersion = true } = options;
   const binary = commandExists('pi');
   if (!binary.found) {
     return { installed: false, path: null, version: null };
   }
 
+  if (!includeVersion) {
+    return { installed: true, path: binary.path, version: null };
+  }
+
   const versionProbe = process.platform === 'win32'
     ? spawnSync('powershell', ['-NoProfile', '-Command', `& '${(binary.path || 'pi').replace(/'/g, "''")}' --version`], { stdio: 'pipe', encoding: 'utf8' })
     : spawnSync(binary.path || 'pi', ['--version'], { stdio: 'pipe', encoding: 'utf8' });
@@ -381,7 +403,7 @@ export async function updatePiManagedPackages({ timeoutMs } = {}) {
     return { ok: true, changed: false, report: 'Skipped Pi extension package update because TAKOMI_SKIP_PI_PACKAGE_UPDATE=1.' };
   }
 
-  const pi = await detectPiCommand();
+  const pi = await detectPiCommand({ includeVersion: false });
   if (!pi.installed) return { ok: false, changed: false, report: 'Pi is not installed.' };
 
   // Only reconcile Pi-managed extension/package entries here. Plain `pi update`
@@ -458,14 +480,22 @@ function printFirstRunGuidance(reason) {
 }
 
 export async function launchTakomiHarness(cwd = process.cwd()) {
-  const report = await inspectPiHarnessEnvironment(cwd);
-
-  if (!report.pi.installed) {
+  // Keep the common `takomi` path lean. A full environment inspection shells out
+  // to `pi --version`, which costs multiple seconds on Windows before Pi even
+  // starts. For launch we only need to know the command exists and the required
+  // global Takomi extensions are present; `takomi doctor` still performs the
+  // complete diagnostic check.
+  const [pi, installed] = await Promise.all([
+    detectPiCommand({ includeVersion: false }),
+    inspectInstalledTakomiPiHarness(),
+  ]);
+
+  if (!pi.installed) {
     printFirstRunGuidance('Pi is not installed yet.');
     return 1;
   }
 
-  if (!report.installed.runtimeInstalled || !report.installed.subagentsInstalled) {
+  if (!installed.runtimeInstalled || !installed.subagentsInstalled) {
     printFirstRunGuidance('Takomi Pi harness is not fully installed yet.');
     return 1;
   }
@@ -473,22 +503,21 @@ export async function launchTakomiHarness(cwd = process.cwd()) {
   const env = {
     ...process.env,
     TAKOMI_HARNESS: '1',
+    // Avoid Pi's blocking startup version check on this wrapped launch path.
+    // Takomi runtime schedules its own UI-safe delayed check after session_start.
+    PI_SKIP_VERSION_CHECK: process.env.PI_SKIP_VERSION_CHECK ?? '1',
+    TAKOMI_DELAYED_PI_VERSION_CHECK: process.env.TAKOMI_DELAYED_PI_VERSION_CHECK ?? '1',
   };
 
   return await new Promise((resolve) => {
-    const child = process.platform === 'win32'
-      ? spawn('cmd.exe', ['/d', '/s', '/c', 'pi'], {
-          cwd,
-          stdio: 'inherit',
-          env,
-          shell: false,
-        })
-      : spawn(report.pi.path || 'pi', [], {
-          cwd,
-          stdio: 'inherit',
-          env,
-          shell: false,
-        });
+    const resolved = resolveCommandForSpawn(pi.path || 'pi', []);
+    const child = spawn(resolved.command, resolved.args, {
+      cwd,
+      stdio: 'inherit',
+      env,
+      shell: false,
+      windowsHide: false,
+    });
 
     child.on('close', (code) => resolve(code ?? 0));
     child.on('error', () => resolve(1));

package/src/store.js

@@ -17,6 +17,7 @@ function createDefaultManifest() {
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
         linkedHarnesses: [],
+        syncMode: 'copy',
         installed: {
             skills: [],
             workflows: [],
@@ -38,6 +39,7 @@ function normalizeManifest(manifest) {
         workflows: normalizeOwnedMap(manifest?.bundledOwned?.workflows),
     };
     normalized.harnessOwned = manifest?.harnessOwned || {};
+    normalized.syncMode = manifest?.syncMode || 'copy';
     return normalized;
 }