takomi 2.0.6 → 2.1.0

package/src/doctor.js

@@ -0,0 +1,84 @@
+import fs from 'fs-extra';
+import pc from 'picocolors';
+import { 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';
+
+function status(ok, label, value) {
+  const icon = ok ? pc.green('✔') : pc.yellow('✗');
+  const suffix = value ? ` ${pc.dim(value)}` : '';
+  return `  ${icon} ${label}${suffix}`;
+}
+
+export async function runDoctor({ version, cwd = process.cwd() } = {}) {
+  const report = await inspectPiHarnessEnvironment(cwd);
+  const storeReady = await isStoreInitialized();
+  const storeSkills = storeReady ? await getStoreSkills() : [];
+
+  console.log(pc.magenta('🩺 Takomi Doctor\n'));
+  console.log(status(true, 'Takomi CLI', version || 'unknown'));
+  console.log(status(report.pi.installed, 'Pi command', report.pi.installed ? `${report.pi.path}${report.pi.version ? ` (${report.pi.version})` : ''}` : 'missing'));
+  console.log(status(report.bundled.packageReady, 'Bundled .pi assets', report.bundled.targets.root));
+  console.log(status(report.bundled.checks.runtime, 'Bundled takomi-runtime', report.bundled.targets.runtime));
+  console.log(status(report.bundled.checks.subagents, 'Bundled takomi-subagents', report.bundled.targets.subagents));
+  console.log(status(report.bundled.packageIncluded, 'Package includes .pi assets', report.bundled.packageIncluded ? 'yes' : 'no'));
+  console.log(status(report.installed.runtimeInstalled, 'Installed takomi-runtime', report.installed.targets.extensions));
+  console.log(status(report.installed.subagentsInstalled, 'Installed takomi-subagents', report.installed.targets.extensions));
+  console.log(status(await fs.pathExists(`${report.installed.targets.extensions}/oauth-router`), 'Installed oauth-router', `${report.installed.targets.extensions}`));
+  console.log(status(report.installed.agentsInstalled, 'Installed agents dir', report.installed.targets.agents));
+  console.log(status(report.installed.themesInstalled, 'Installed themes dir', report.installed.targets.themes));
+  console.log(status(await fs.pathExists(PI_MANIFEST_PATH), 'Pi install manifest', PI_MANIFEST_PATH));
+  console.log(status(report.piSubagents.declaredVersion !== null, 'pi-subagents dependency declared', report.piSubagents.declaredVersion || 'missing'));
+  console.log(status(report.piSubagents.localInstalled || report.piSubagents.globalInstalled, 'pi-subagents package available', report.piSubagents.localInstalled
+    ? `${report.piSubagents.localPackageJson}${report.piSubagents.localVersion ? ` (${report.piSubagents.localVersion})` : ''}`
+    : report.piSubagents.globalInstalled
+      ? `${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.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));
+  console.log(status(storeReady, 'Global Takomi store', storeReady ? `${storeSkills.length} skills` : 'missing'));
+
+  console.log(pc.cyan('\nRecommendations\n'));
+
+  if (!report.pi.installed) {
+    console.log(pc.white('  - Install Pi first: npm install -g @mariozechner/pi-coding-agent'));
+  }
+
+  if (!report.bundled.packageIncluded) {
+    console.log(pc.white('  - Package .pi assets before enabling takomi install pi in releases.'));
+  }
+
+  if (!report.installed.runtimeInstalled || !report.installed.subagentsInstalled) {
+    console.log(pc.white('  - Run takomi install pi after the package-safe Pi asset layout is finalized.'));
+  }
+
+  if (!report.piSubagents.declaredVersion) {
+    console.log(pc.white('  - Add pi-subagents to takomi package dependencies so subagent support is bundled intentionally.'));
+  }
+
+  if (!report.piSubagents.localInstalled && !report.piSubagents.globalInstalled) {
+    console.log(pc.white('  - Install pi-subagents: npm install -g pi-subagents'));
+  }
+
+  if (!report.project.routingPolicyPresent && !report.installed.routingPolicyPresent) {
+    console.log(pc.white('  - Add a routing policy at .pi/takomi/model-routing.md when ready.'));
+  }
+
+  if (!await fs.pathExists(PI_MANIFEST_PATH) && report.installed.runtimeInstalled) {
+    console.log(pc.white('  - Re-run takomi install pi to write the Pi asset manifest.'));
+  }
+
+  if (!await fs.pathExists(SKILLS_ROOT)) {
+    console.log(pc.white('  - Run takomi install skills to install the bundled Takomi skills.'));
+  }
+
+  if (!storeReady) {
+    console.log(pc.white('  - Legacy global command center is not initialized. Run takomi install for current behavior.'));
+  }
+
+  console.log('');
+  return report;
+}

package/src/harness.js

@@ -73,6 +73,19 @@ export const HARNESS_MAP = {
     },
   },
 
+  codex: {
+    name: 'Codex',
+    rootPath: path.join(HOME, '.codex'),
+    detect() {
+      return fs.existsSync(this.rootPath);
+    },
+    targets: {
+      skills: path.join(HOME, '.codex', 'skills'),
+      workflows: null,
+      yamls: null,
+    },
+  },
+
   cursor: {
     name: 'Cursor',
     rootPath: path.join(HOME, '.cursor'),

package/src/pi-harness.js

@@ -0,0 +1,351 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import { spawn, spawnSync } from 'child_process';
+import pc from 'picocolors';
+import { PATHS } from './utils.js';
+import { STORE_PATH, MANIFEST_PATH } from './store.js';
+
+const TAKOMI_PACKAGE_DIR = PATHS.root;
+
+const HOME = os.homedir();
+
+function getPathEntries() {
+  return (process.env.PATH || '').split(path.delimiter).filter(Boolean);
+}
+
+function commandExists(command) {
+  const probe = process.platform === 'win32'
+    ? spawnSync('where', [command], { stdio: 'pipe', encoding: 'utf8' })
+    : spawnSync('which', [command], { stdio: 'pipe', encoding: 'utf8' });
+
+  if (probe.status === 0) {
+    const matches = probe.stdout.split(/\r?\n/).map(v => v.trim()).filter(Boolean);
+    const preferred = process.platform === 'win32'
+      ? matches.find((entry) => /\.(cmd|exe|bat)$/i.test(entry))
+      : matches[0];
+    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 };
+}
+
+export function getPiAgentRoot(home = HOME) {
+  return path.join(home, '.pi', 'agent');
+}
+
+export function getPiGlobalTargets(home = HOME) {
+  const agentRoot = getPiAgentRoot(home);
+  return {
+    root: agentRoot,
+    extensions: path.join(agentRoot, 'extensions'),
+    prompts: path.join(agentRoot, 'prompts'),
+    agents: path.join(agentRoot, 'agents'),
+    themes: path.join(agentRoot, 'themes'),
+    settings: path.join(agentRoot, 'settings.json'),
+    takomi: path.join(agentRoot, 'takomi'),
+    routingPolicy: path.join(agentRoot, 'takomi', 'model-routing.md'),
+  };
+}
+
+export function getProjectPiTargets(cwd = process.cwd()) {
+  return {
+    root: path.join(cwd, '.pi'),
+    extensions: path.join(cwd, '.pi', 'extensions'),
+    prompts: path.join(cwd, '.pi', 'prompts'),
+    agents: path.join(cwd, '.pi', 'agents'),
+    themes: path.join(cwd, '.pi', 'themes'),
+    settings: path.join(cwd, '.pi', 'settings.json'),
+    takomiProfile: path.join(cwd, '.pi', 'takomi-profile.json'),
+    routingPolicy: path.join(cwd, '.pi', 'takomi', 'model-routing.md'),
+  };
+}
+
+export function getBundledPiAssetTargets() {
+  const root = path.join(PATHS.root, '.pi');
+  return {
+    root,
+    runtime: path.join(root, 'extensions', 'takomi-runtime'),
+    subagents: path.join(root, 'extensions', 'takomi-subagents'),
+    prompts: path.join(root, 'prompts'),
+    agents: path.join(root, 'agents'),
+    themes: path.join(root, 'themes'),
+    settings: path.join(root, 'settings.json'),
+    routingPolicy: path.join(root, 'takomi', 'model-routing.md'),
+    profile: path.join(root, 'takomi-profile.json'),
+  };
+}
+
+async function getPackageJson() {
+  try {
+    return await fs.readJson(PATHS.packageJson);
+  } catch {
+    return {};
+  }
+}
+
+async function getPackageFileEntries() {
+  const pkg = await getPackageJson();
+  return Array.isArray(pkg.files) ? pkg.files : [];
+}
+
+function getGlobalNodeModulesRoot(home = HOME) {
+  if (process.platform === 'win32') {
+    return path.join(process.env.APPDATA || path.join(home, 'AppData', 'Roaming'), 'npm', 'node_modules');
+  }
+  return path.join(home, '.npm-global', 'lib', 'node_modules');
+}
+
+export async function inspectPiSubagentsDependency(home = HOME) {
+  const pkg = await getPackageJson();
+  const declaredVersion = pkg?.dependencies?.['pi-subagents'] || null;
+  const localPackageJson = path.join(TAKOMI_PACKAGE_DIR, 'node_modules', 'pi-subagents', 'package.json');
+  const globalPackageJson = path.join(getGlobalNodeModulesRoot(home), 'pi-subagents', 'package.json');
+
+  let localVersion = null;
+  let globalVersion = null;
+
+  try {
+    if (await fs.pathExists(localPackageJson)) {
+      const localPkg = await fs.readJson(localPackageJson);
+      localVersion = localPkg.version || null;
+    }
+  } catch {}
+
+  try {
+    if (await fs.pathExists(globalPackageJson)) {
+      const globalPkg = await fs.readJson(globalPackageJson);
+      globalVersion = globalPkg.version || null;
+    }
+  } catch {}
+
+  const bin = commandExists('pi-subagents');
+
+  return {
+    declaredVersion,
+    localInstalled: Boolean(localVersion),
+    localVersion,
+    localPackageJson,
+    globalInstalled: Boolean(globalVersion),
+    globalVersion,
+    globalPackageJson,
+    binaryInstalled: bin.found,
+    binaryPath: bin.path,
+  };
+}
+
+export async function detectPiCommand() {
+  const binary = commandExists('pi');
+  if (!binary.found) {
+    return { installed: false, path: null, 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' });
+  const output = [versionProbe.stdout, versionProbe.stderr].filter(Boolean).join('\n').trim();
+  return {
+    installed: true,
+    path: binary.path,
+    version: versionProbe.status === 0 ? (output || null) : null,
+  };
+}
+
+export async function inspectBundledPiAssets() {
+  const targets = getBundledPiAssetTargets();
+  const checks = {
+    root: await fs.pathExists(targets.root),
+    runtime: await fs.pathExists(targets.runtime),
+    subagents: await fs.pathExists(targets.subagents),
+    prompts: await fs.pathExists(targets.prompts),
+    agents: await fs.pathExists(targets.agents),
+    themes: await fs.pathExists(targets.themes),
+    settings: await fs.pathExists(targets.settings),
+    routingPolicy: await fs.pathExists(targets.routingPolicy),
+    profile: await fs.pathExists(targets.profile),
+  };
+
+  const packageReady = await fs.pathExists(targets.root);
+  const packageFiles = await getPackageFileEntries();
+  const packageIncluded = packageFiles.includes('.pi') || packageFiles.some((entry) => entry.startsWith('.pi/')) || packageReady;
+
+  return {
+    targets,
+    checks,
+    packageReady,
+    packageIncluded,
+  };
+}
+
+export async function inspectInstalledTakomiPiHarness(home = HOME) {
+  const targets = getPiGlobalTargets(home);
+  const runtime = path.join(targets.extensions, 'takomi-runtime');
+  const subagents = path.join(targets.extensions, 'takomi-subagents');
+
+  return {
+    targets,
+    runtimeInstalled: await fs.pathExists(runtime),
+    subagentsInstalled: await fs.pathExists(subagents),
+    promptsInstalled: await fs.pathExists(targets.prompts),
+    agentsInstalled: await fs.pathExists(targets.agents),
+    themesInstalled: await fs.pathExists(targets.themes),
+    settingsPresent: await fs.pathExists(targets.settings),
+    routingPolicyPresent: await fs.pathExists(targets.routingPolicy),
+    manifestPresent: await fs.pathExists(MANIFEST_PATH),
+    storePresent: await fs.pathExists(STORE_PATH),
+  };
+}
+
+function runCommand(command, args) {
+  return spawnSync(command, args, { stdio: 'pipe', encoding: 'utf8', shell: process.platform === 'win32' });
+}
+
+export async function ensurePiInstalled() {
+  const before = await detectPiCommand();
+  if (before.installed) {
+    return { ok: true, changed: false, report: 'Pi already available.' };
+  }
+
+  const attempts = [
+    { command: 'npm', args: ['install', '-g', '@mariozechner/pi-coding-agent'] },
+    { command: 'npm.cmd', args: ['install', '-g', '@mariozechner/pi-coding-agent'] },
+  ];
+
+  let lastError = 'Unknown install failure.';
+  for (const attempt of attempts) {
+    const result = runCommand(attempt.command, attempt.args);
+    if (result.status === 0) {
+      const after = await detectPiCommand();
+      if (after.installed) {
+        return {
+          ok: true,
+          changed: true,
+          report: (result.stdout || result.stderr || 'Installed Pi.').trim(),
+        };
+      }
+      lastError = 'npm install reported success, but pi was still not detected.';
+      continue;
+    }
+    lastError = [result.stdout, result.stderr].filter(Boolean).join('\n').trim() || lastError;
+  }
+
+  return { ok: false, changed: false, report: lastError };
+}
+
+export function printPiInstallResult(result) {
+  if (result.ok) {
+    console.log(pc.green(`✔ ${result.changed ? 'Installed' : 'Validated'} Pi`));
+    if (result.report) console.log(pc.dim(result.report.split(/\r?\n/).slice(-4).join('\n')));
+    return;
+  }
+  console.log(pc.red('✗ Failed to install Pi'));
+  if (result.report) console.log(pc.dim(result.report.split(/\r?\n/).slice(-8).join('\n')));
+}
+
+export async function ensurePiSubagentsInstalled() {
+  const before = await inspectPiSubagentsDependency();
+  if (before.localInstalled || before.globalInstalled) {
+    return { ok: true, changed: false, report: 'pi-subagents already available.' };
+  }
+
+  const attempts = [
+    { command: 'npm', args: ['install', '-g', 'pi-subagents'] },
+    { command: 'npm.cmd', args: ['install', '-g', 'pi-subagents'] },
+  ];
+
+  let lastError = 'Unknown install failure.';
+  for (const attempt of attempts) {
+    const result = runCommand(attempt.command, attempt.args);
+    if (result.status === 0) {
+      const after = await inspectPiSubagentsDependency();
+      if (after.localInstalled || after.globalInstalled) {
+        return {
+          ok: true,
+          changed: true,
+          report: (result.stdout || result.stderr || 'Installed pi-subagents.').trim(),
+        };
+      }
+      lastError = 'npm install reported success, but pi-subagents was still not detected.';
+      continue;
+    }
+    lastError = [result.stdout, result.stderr].filter(Boolean).join('\n').trim() || lastError;
+  }
+
+  return { ok: false, changed: false, report: lastError };
+}
+
+export function printPiSubagentsInstallResult(result) {
+  if (result.ok) {
+    console.log(pc.green(`✔ ${result.changed ? 'Installed' : 'Validated'} pi-subagents`));
+    if (result.report) console.log(pc.dim(result.report.split(/\r?\n/).slice(-4).join('\n')));
+    return;
+  }
+  console.log(pc.red('✗ Failed to install pi-subagents'));
+  if (result.report) console.log(pc.dim(result.report.split(/\r?\n/).slice(-8).join('\n')));
+}
+
+export async function inspectPiHarnessEnvironment(cwd = process.cwd()) {
+  const pi = await detectPiCommand();
+  const bundled = await inspectBundledPiAssets();
+  const installed = await inspectInstalledTakomiPiHarness();
+  const piSubagents = await inspectPiSubagentsDependency();
+  const project = getProjectPiTargets(cwd);
+
+  return {
+    pi,
+    bundled,
+    installed,
+    piSubagents,
+    project: {
+      targets: project,
+      settingsPresent: await fs.pathExists(project.settings),
+      routingPolicyPresent: await fs.pathExists(project.routingPolicy),
+      profilePresent: await fs.pathExists(project.takomiProfile),
+    },
+  };
+}
+
+export async function launchTakomiHarness(cwd = process.cwd()) {
+  const report = await inspectPiHarnessEnvironment(cwd);
+
+  if (!report.pi.installed) {
+    console.log(pc.red('Pi is not installed.'));
+    console.log(pc.dim('Run: takomi install pi'));
+    return 1;
+  }
+
+  if (!report.installed.runtimeInstalled || !report.installed.subagentsInstalled) {
+    console.log(pc.red('Takomi Pi harness is not fully installed.'));
+    console.log(pc.dim('Run: takomi install pi'));
+    return 1;
+  }
+
+  const env = {
+    ...process.env,
+    TAKOMI_HARNESS: '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,
+        });
+
+    child.on('close', (code) => resolve(code ?? 0));
+    child.on('error', () => resolve(1));
+  });
+}

package/src/pi-installer.js

@@ -0,0 +1,171 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path from 'path';
+import crypto from 'crypto';
+import pc from 'picocolors';
+import { PATHS } from './utils.js';
+import { getPiGlobalTargets } from './pi-harness.js';
+
+const HOME = os.homedir();
+const TAKOMI_HOME = path.join(HOME, '.takomi');
+export const PI_MANIFEST_PATH = path.join(TAKOMI_HOME, 'pi-manifest.json');
+
+function sha256(value) {
+  return crypto.createHash('sha256').update(value).digest('hex');
+}
+
+async function hashPath(targetPath) {
+  if (!await fs.pathExists(targetPath)) return null;
+  const stat = await fs.stat(targetPath);
+  if (stat.isFile()) {
+    const buf = await fs.readFile(targetPath);
+    return sha256(buf);
+  }
+
+  const entries = [];
+  async function walk(dir, prefix = '') {
+    const names = (await fs.readdir(dir)).sort();
+    for (const name of names) {
+      const full = path.join(dir, name);
+      const rel = path.join(prefix, name).replace(/\\/g, '/');
+      const st = await fs.stat(full);
+      if (st.isDirectory()) {
+        entries.push(`dir:${rel}`);
+        await walk(full, rel);
+      } else {
+        const buf = await fs.readFile(full);
+        entries.push(`file:${rel}:${sha256(buf)}`);
+      }
+    }
+  }
+  await walk(targetPath);
+  return sha256(entries.join('\n'));
+}
+
+async function pathIsSameSymlink(dest, src) {
+  try {
+    const stat = await fs.lstat(dest);
+    if (!stat.isSymbolicLink()) return false;
+    const target = await fs.readlink(dest);
+    const resolvedTarget = path.resolve(path.dirname(dest), target);
+    return path.resolve(src) === resolvedTarget;
+  } catch {
+    return false;
+  }
+}
+
+async function prepareOwnedTarget(src, dest) {
+  if (await pathIsSameSymlink(dest, src)) return 'symlink';
+  if (!await fs.pathExists(dest)) return 'copy';
+  const stat = await fs.lstat(dest);
+  if (stat.isSymbolicLink()) {
+    await fs.remove(dest);
+    return 'copy';
+  }
+  return 'copy';
+}
+
+async function copyOwnedDirectory(src, dest) {
+  await fs.ensureDir(path.dirname(dest));
+  const mode = await prepareOwnedTarget(src, dest);
+  if (mode === 'symlink') return hashPath(src);
+  await fs.copy(src, dest, { overwrite: true });
+  return hashPath(dest);
+}
+
+async function copyOwnedFile(src, dest) {
+  await fs.ensureDir(path.dirname(dest));
+  const mode = await prepareOwnedTarget(src, dest);
+  if (mode === 'symlink') return hashPath(src);
+  await fs.copy(src, dest, { overwrite: true });
+  return hashPath(dest);
+}
+
+export async function readPiInstallManifest() {
+  try {
+    if (await fs.pathExists(PI_MANIFEST_PATH)) return await fs.readJson(PI_MANIFEST_PATH);
+  } catch {}
+  return null;
+}
+
+export async function writePiInstallManifest(manifest) {
+  await fs.ensureDir(TAKOMI_HOME);
+  await fs.writeJson(PI_MANIFEST_PATH, manifest, { spaces: 2 });
+}
+
+export async function installPiHarnessAssets(version = 'unknown') {
+  const srcRoot = PATHS.pi;
+  const targets = getPiGlobalTargets();
+
+  const copied = {};
+
+  const readmeSrc = path.join(srcRoot, 'README.md');
+  if (await fs.pathExists(readmeSrc)) {
+    copied.readme = await copyOwnedFile(readmeSrc, path.join(targets.root, 'README.md'));
+  }
+
+  const extensionNames = ['takomi-runtime', 'takomi-subagents', 'oauth-router'];
+  for (const name of extensionNames) {
+    const src = path.join(srcRoot, 'extensions', name);
+    if (await fs.pathExists(src)) {
+      copied[`extension:${name}`] = await copyOwnedDirectory(src, path.join(targets.extensions, name));
+    }
+  }
+
+  const owned = {
+    prompts: { src: path.join(srcRoot, 'prompts'), dest: targets.prompts, type: 'dir' },
+    agents: { src: path.join(srcRoot, 'agents'), dest: targets.agents, type: 'dir' },
+    themes: { src: path.join(srcRoot, 'themes'), dest: targets.themes, type: 'dir' },
+  };
+
+  for (const [key, entry] of Object.entries(owned)) {
+    if (!await fs.pathExists(entry.src)) continue;
+    copied[key] = entry.type === 'dir'
+      ? await copyOwnedDirectory(entry.src, entry.dest)
+      : await copyOwnedFile(entry.src, entry.dest);
+  }
+
+  const manifest = {
+    takomiVersion: version,
+    installedAt: new Date().toISOString(),
+    targetRoot: targets.root,
+    owned: copied,
+    preserved: {
+      settings: targets.settings,
+      routingPolicy: targets.routingPolicy,
+      userStateDir: targets.takomi,
+    },
+  };
+
+  await writePiInstallManifest(manifest);
+  return { targets, manifest };
+}
+
+export async function syncPiHarnessAssets(version = 'unknown') {
+  return installPiHarnessAssets(version);
+}
+
+export async function validatePiHarnessInstall() {
+  const targets = getPiGlobalTargets();
+  return {
+    runtime: await fs.pathExists(path.join(targets.extensions, 'takomi-runtime')),
+    subagents: await fs.pathExists(path.join(targets.extensions, 'takomi-subagents')),
+    oauthRouter: await fs.pathExists(path.join(targets.extensions, 'oauth-router')),
+    prompts: await fs.pathExists(targets.prompts),
+    agents: await fs.pathExists(targets.agents),
+    themes: await fs.pathExists(targets.themes),
+    readme: await fs.pathExists(path.join(targets.root, 'README.md')),
+    settingsPreserved: !await fs.pathExists(path.join(PATHS.pi, 'settings.json')) || true,
+  };
+}
+
+export function printPiInstallSummary(result, validation) {
+  console.log(pc.green('\n✔ Installed Takomi Pi harness assets'));
+  console.log(pc.white(`  Root:       ${result.targets.root}`));
+  console.log(pc.white(`  Manifest:   ${PI_MANIFEST_PATH}`));
+  console.log(pc.white(`  Extensions: ${validation.runtime && validation.subagents && validation.oauthRouter ? 'ok' : 'check needed'}`));
+  console.log(pc.white(`  Prompts:    ${validation.prompts ? 'ok' : 'missing'}`));
+  console.log(pc.white(`  Agents:     ${validation.agents ? 'ok' : 'missing'}`));
+  console.log(pc.white(`  Themes:     ${validation.themes ? 'ok' : 'missing'}`));
+  console.log(pc.dim('\nPreserved user-owned config: settings.json, takomi/model-routing.md, runtime session state.'));
+}

package/src/pi-takomi-core/index.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./workflows";
+export * from "./routing";
+export * from "./orchestration";