takomi 2.1.35 → 2.1.37

package/assets/.agent/skills/exam-creator-skill/references/model-routing-policy.md

@@ -0,0 +1,48 @@
+# Exam Creator Model Routing Policy
+
+Use this routing policy for the exam-creation workflow unless the user overrides it.
+
+## Terminology Rule
+
+When the user says **Gemini**, interpret that as **Gemini via the agy CLI** unless the user explicitly says otherwise.
+
+## Default Routing
+
+- **Orchestrator:** parent assistant / orchestrator
+- **Drafting agent:** **Gemini via agy CLI**
+- **Marking agent:** **Gemini via agy CLI**
+- **Verification agent:** **GPT**
+
+## Why This Is The Default
+
+- Drafting and marking are the highest-volume steps.
+- Gemini is preferred there because it is cheaper and faster.
+- Verification is the quality gate, so GPT is preferred for the final correctness check.
+
+## Escalation Rule For Drafting
+
+Upgrade the **drafting agent** from Gemini via agy CLI to **GPT 5.4 High** when any of these are true:
+
+- the source notes are messy or inconsistent
+- the subject requires tighter wording judgment
+- ambiguity risk is high
+- the diagram/question structure is more delicate than usual
+- the paper is Mathematics or English and extra care is desired
+
+## Practical Modes
+
+### Default cheap/fast mode
+- Orchestrator → parent assistant
+- Drafting → Gemini via agy CLI
+- Marking → Gemini via agy CLI
+- Verification → GPT
+
+### Escalated drafting mode
+- Orchestrator → parent assistant
+- Drafting → GPT 5.4 High
+- Marking → Gemini via agy CLI
+- Verification → GPT
+
+## Guiding Principle
+
+Use **Gemini via agy CLI for drafting and marking by default**, **GPT for verification**, and only upgrade drafting to **GPT 5.4 High** when the paper is tricky enough to justify the extra cost.

package/assets/.agent/skills/exam-creator-skill/references/workflow-rulebook.md

@@ -0,0 +1,115 @@
+# OBHIS Exam Workflow Rulebook
+
+This reference captures the current house style agreed during the Mathematics paper workflow.
+
+## Scope
+
+Use this rulebook for OBHIS / Olive Blessed Crest Academy exam generation unless the user gives a newer rule.
+
+## Terminology Rule
+
+When the user says **Gemini**, interpret that as **Gemini via the agy CLI** unless the user explicitly says otherwise.
+
+## Workflow Summary
+
+1. Gather source materials.
+2. For photographed handwritten pages, run a multimodal-first extraction pass before OCR:
+   - use direct model vision on the image files
+   - batch images in small ordered groups, usually 3-5 images per model task
+   - explicitly forbid OCR/Tesseract/Python preprocessing on the first pass
+   - use OCR only as fallback when direct vision is unavailable or fails for a specific page
+3. Confirm subject-specific mark pattern.
+4. Create clean folder structure.
+5. Draft question paper.
+6. Build marking scheme only when requested.
+7. Independently verify.
+8. Incorporate user feedback.
+9. Rerender deliverables.
+
+## Folder Structure
+
+Preferred output structure:
+
+- `Questions/`
+  - `questions.md`
+  - final exam `.docx`
+  - `assets/`
+    - all SVG diagrams
+    - all PNG diagram copies used for Word export
+- `Marking Scheme/` only when requested
+  - `marking-scheme.md`
+  - `objective-validation.md`
+  - `verification-report.md`
+  - marking-scheme `.docx` if needed
+
+## Subject Rules
+
+### Mathematics and English
+
+Default pattern:
+
+- exam total = **40 marks**
+- objective count = **50**
+- objective marks = **0.5 each**
+- objective total = **25 marks**
+- theory questions = **5**
+- answer any = **3**
+- theory total = **15 marks**
+- no separate short-answer section by default
+
+### Other Subjects
+
+Current preference:
+
+- may still use open-ended and theory sections
+- still intended to fit the 40-mark exam system
+- exact split should be clarified before final generation if not explicitly stated
+
+## Layout Rules
+
+- use **Times New Roman**
+- default body size **12 pt**
+- narrow margins
+- compact layout
+- header must be 1-column and should include: school name, academic session, term/exam title, pupil name/date, examination number/time, class, arm, subject, and instructions
+- body is **1-column by default**
+- use 2-column/3-column body only when a dense objective paper genuinely needs it for fit; do not apply columns mechanically to every subject
+- headings should be bold and black, not oversized
+- objective options should appear inline or compactly, not stacked unless unavoidable
+- remove `Total Marks` line unless requested
+- try to keep each paper around **2 pages** where practical
+
+## Diagram Rules
+
+- store diagrams in `Questions/assets/`
+- simple line/geometry diagrams: prefer SVG masters plus PNG export copies
+- pictorial nursery/primary objects (mango, pot, bucket, moon, table, cup, animals, classroom objects, etc.): prefer Anti-Gravity image generation or another image-generation path instead of rough SVG-only drawings
+- Anti-Gravity can generate images; when using it, instruct whether to generate images, use SVG, or use a hybrid method, and require a report of the method used
+- do not include answer labels from the teacher’s source in the student-facing diagram, e.g. do not label the keyboard as “Keyboard” when the question asks pupils to identify it
+- keep separate source drawings as separate assets unless the question explicitly presents them as one grouped diagram; this helps preserve order and layout
+- for diagram-heavy papers, rebuild the draft directly from the original tagged images instead of relying only on extraction summaries
+- do not show worked/grouped answers in division or counting diagrams when the child is supposed to solve them
+- if pupils are asked to colour an object or flag, leave it as an outline unless the exam explicitly asks for a sample
+- labels must be readable when labels are part of the prompt rather than the answer
+- angle values must not be hidden by edges
+- move text away from lines when needed
+- rerender diagrams if the user reports visibility problems
+
+## Review Rules
+
+- objective answer validation is mandatory when a marking scheme or answer key is requested
+- marking scheme must match final numbering when requested
+- verification should independently confirm correctness
+- for handwritten sources, infer unclear text aggressively from context before marking it unclear
+- any remaining ambiguous handwriting must be captured in a user-review list with image filename/page reference, question number, and candidate interpretations
+- if a wording ambiguity is found, fix the paper and then realign the scheme when a scheme exists
+
+## Feedback Rules
+
+- user feedback overrides previous assumptions
+- update future papers to follow the corrected rule
+- if a DOCX is locked, save a versioned file such as `v2`
+
+## Notes
+
+This rulebook is intentionally opinionated because it represents Johno's workflow. Keep it flexible enough to ask follow-up questions whenever a new subject or mark pattern does not clearly fit the stored defaults.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "takomi",
-  "version": "2.1.35",
+  "version": "2.1.37",
   "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": {
@@ -50,7 +50,7 @@
     "commander": "^13.1.0",
     "figlet": "^1.8.0",
     "fs-extra": "^11.3.0",
-    "pi-subagents": "0.28.0",
+    "pi-subagents": "0.31.0",
     "picocolors": "^1.1.1",
     "prompts": "^2.4.2"
   },

package/src/cli.js

@@ -23,6 +23,7 @@ import {
   downloadDirectoryFromGitHub,
 } from './utils.js';
 import {
+  HARNESS_MAP,
   detectHarnesses,
   printHarnessStatus,
   syncToAllHarnesses,
@@ -43,7 +44,7 @@ import {
   isStoreInitialized,
 } from './store.js';
 import { runDoctor } from './doctor.js';
-import { ensurePiInstalled, ensurePiSubagentsInstalled, launchTakomiHarness, printPiInstallResult, printPiSubagentsInstallResult, updatePiCliPackage, updatePiManagedPackages, printPiManagedPackageUpdateResult } from './pi-harness.js';
+import { disableRawPiSubagentsActivation, ensurePiInstalled, ensurePiSubagentsInstalled, formatRawPiSubagentsDisableActions, formatRawPiSubagentsFindings, inspectRawPiSubagentsActivation, launchTakomiHarness, printPiInstallResult, printPiSubagentsInstallResult, updatePiCliPackage, updatePiManagedPackages, printPiManagedPackageUpdateResult } from './pi-harness.js';
 import { installPiHarnessAssets, printPiInstallSummary, syncPiHarnessAssets, validatePiHarnessInstall } from './pi-installer.js';
 import { offerPiOptionalFeatures } from './pi-optional-features.js';
 import {
@@ -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)));
@@ -423,6 +461,37 @@ async function installAllTargets(options = {}) {
   await installSkillsTarget();
 }
 
+async function offerRawPiSubagentsHardening({ interactive = process.stdin.isTTY && process.stdout.isTTY } = {}) {
+  const audit = await inspectRawPiSubagentsActivation({ cwd: process.cwd() });
+  if (!audit.findings.length) return;
+
+  console.log(pc.yellow('\n⚠ Raw Pi subagents activation detected'));
+  console.log(pc.dim(formatRawPiSubagentsFindings(audit.findings)));
+  console.log(pc.dim('\nTakomi keeps pi-subagents installed as an internal module, but raw Pi activation exposes the separate `subagent` tool next to `takomi_subagent`.'));
+
+  let shouldDisable = process.env.TAKOMI_DISABLE_RAW_PI_SUBAGENTS === '1';
+  if (interactive && process.env.TAKOMI_DISABLE_RAW_PI_SUBAGENTS !== '1') {
+    const response = await prompts({
+      type: 'confirm',
+      name: 'disable',
+      message: 'Disable raw Pi subagents activation so agents only see takomi_subagent?',
+      initial: true,
+    });
+    shouldDisable = response.disable === true;
+  }
+
+  if (!shouldDisable) {
+    console.log(pc.yellow(interactive
+      ? 'Leaving raw Pi subagents activation unchanged.'
+      : 'Non-interactive run: leaving raw Pi subagents activation unchanged. Set TAKOMI_DISABLE_RAW_PI_SUBAGENTS=1 to disable automatically.'));
+    return;
+  }
+
+  const result = await disableRawPiSubagentsActivation({ cwd: process.cwd() });
+  console.log(pc.green('✔ Disabled raw Pi subagents activation'));
+  console.log(pc.dim(formatRawPiSubagentsDisableActions(result.actions)));
+}
+
 async function installPiTarget(options = {}) {
   const { offerOptionalFeatures = true } = options;
   console.log(pc.magenta('🧭 Pi Harness Preflight\n'));
@@ -455,12 +524,14 @@ async function installPiTarget(options = {}) {
     const result = await installPiHarnessAssets(program.version());
     const validation = await validatePiHarnessInstall();
     printPiInstallSummary(result, validation);
+    await offerRawPiSubagentsHardening();
     if (offerOptionalFeatures) {
       console.log(pc.cyan('\n🧩 Optional Takomi Pi feature packs...\n'));
       await offerPiOptionalFeatures({ interactive: true });
     }
     console.log(pc.cyan('\n📦 Checking Pi-managed extension package updates...\n'));
     printPiManagedPackageUpdateResult(await updatePiManagedPackages());
+    await offerRawPiSubagentsHardening();
     console.log(pc.dim('\nNext: cd <project> && takomi\n'));
   } catch (error) {
     console.log(pc.red('\nPi harness asset install failed.'));
@@ -474,8 +545,10 @@ async function installPiOptionalFeaturesTarget() {
   printPiInstallResult(pi);
   if (!pi.ok) return;
   await offerPiOptionalFeatures({ interactive: true });
+  await offerRawPiSubagentsHardening();
   console.log(pc.cyan('\n📦 Checking Pi-managed extension package updates...\n'));
   printPiManagedPackageUpdateResult(await updatePiManagedPackages());
+  await offerRawPiSubagentsHardening();
 }
 
 async function syncPiTarget() {
@@ -484,8 +557,10 @@ async function syncPiTarget() {
     const result = await syncPiHarnessAssets(program.version());
     const validation = await validatePiHarnessInstall();
     printPiInstallSummary(result, validation);
+    await offerRawPiSubagentsHardening();
     console.log(pc.cyan('\n📦 Checking Pi-managed extension package updates...\n'));
     printPiManagedPackageUpdateResult(await updatePiManagedPackages());
+    await offerRawPiSubagentsHardening();
   } catch (error) {
     console.log(pc.red('\nPi sync failed.'));
     console.log(pc.dim(String(error?.message || error)));
@@ -622,7 +697,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 +790,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 +882,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 +898,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 +968,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 +1090,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 +1131,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 +1206,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/doctor.js

@@ -1,7 +1,7 @@
 import fs from 'fs-extra';
 import path from 'path';
 import pc from 'picocolors';
-import { inspectPiHarnessEnvironment } from './pi-harness.js';
+import { formatRawPiSubagentsFindings, inspectPiHarnessEnvironment } from './pi-harness.js';
 import { getStoreSkills, isStoreInitialized } from './store.js';
 import { PI_MANIFEST_PATH } from './pi-installer.js';
 import { SKILLS_MANIFEST_PATH, SKILLS_ROOT } from './skills-installer.js';
@@ -41,6 +41,7 @@ export async function runDoctor({ version, cwd = process.cwd() } = {}) {
       ? `${report.piSubagents.globalPackageJson}${report.piSubagents.globalVersion ? ` (${report.piSubagents.globalVersion})` : ''}`
       : 'missing'));
   console.log(status(report.piSubagents.binaryInstalled, 'pi-subagents installer binary', report.piSubagents.binaryPath || 'missing'));
+  console.log(status(report.rawPiSubagentsActivation.findings.length === 0, 'Raw Pi subagent tool hidden', report.rawPiSubagentsActivation.findings.length ? 'raw subagent activation detected' : 'yes'));
   console.log(status(report.installed.routingPolicyPresent || report.project.routingPolicyPresent, 'Routing policy', report.project.routingPolicyPresent ? report.project.targets.routingPolicy : report.installed.targets.routingPolicy));
   console.log(status(await fs.pathExists(SKILLS_ROOT), 'Installed skills root', SKILLS_ROOT));
   console.log(status(await fs.pathExists(SKILLS_MANIFEST_PATH), 'Skills install manifest', SKILLS_MANIFEST_PATH));
@@ -68,6 +69,11 @@ export async function runDoctor({ version, cwd = process.cwd() } = {}) {
     console.log(pc.white('  - Install pi-subagents: npm install -g pi-subagents'));
   }
 
+  if (report.rawPiSubagentsActivation.findings.length) {
+    console.log(pc.white('  - Disable raw Pi subagents so models only see takomi_subagent. Run takomi setup pi or set TAKOMI_DISABLE_RAW_PI_SUBAGENTS=1 takomi refresh pi.'));
+    console.log(pc.dim(formatRawPiSubagentsFindings(report.rawPiSubagentsActivation.findings).split(/\r?\n/).map((line) => `    ${line}`).join('\n')));
+  }
+
   if (!report.project.routingPolicyPresent && !report.installed.routingPolicyPresent) {
     console.log(pc.white('  - Add a routing policy at .pi/takomi/model-routing.md when ready.'));
   }

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) {