takomi 2.1.35 → 2.1.37

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 };
 }
 
@@ -102,6 +119,100 @@ function getGlobalNodeModulesRoot(home = HOME) {
   return path.join(home, '.npm-global', 'lib', 'node_modules');
 }
 
+async function readJsonIfExists(filePath) {
+  try {
+    if (await fs.pathExists(filePath)) return await fs.readJson(filePath);
+  } catch {}
+  return null;
+}
+
+async function writeJsonWithBackup(filePath, value, backupLabel = 'takomi-backup') {
+  await fs.ensureDir(path.dirname(filePath));
+  if (await fs.pathExists(filePath)) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+    await fs.copy(filePath, `${filePath}.${backupLabel}-${stamp}`);
+  }
+  await fs.writeJson(filePath, value, { spaces: 2 });
+}
+
+function removeRawPiSubagentsPackageEntries(settings) {
+  if (!settings || typeof settings !== 'object' || Array.isArray(settings)) return { changed: false, settings };
+  if (!Array.isArray(settings.packages)) return { changed: false, settings };
+  const before = settings.packages.length;
+  const nextPackages = settings.packages.filter((entry) => entry !== 'npm:pi-subagents' && entry !== 'pi-subagents');
+  if (nextPackages.length === before) return { changed: false, settings };
+  return { changed: true, settings: { ...settings, packages: nextPackages } };
+}
+
+export async function inspectRawPiSubagentsActivation({ cwd = process.cwd(), home = HOME } = {}) {
+  const user = getPiGlobalTargets(home);
+  const project = getProjectPiTargets(cwd);
+  const legacyExtension = path.join(user.extensions, 'subagent');
+  const findings = [];
+
+  for (const [scope, filePath] of [['user', user.settings], ['project', project.settings]]) {
+    const settings = await readJsonIfExists(filePath);
+    const packages = Array.isArray(settings?.packages) ? settings.packages : [];
+    if (packages.includes('npm:pi-subagents') || packages.includes('pi-subagents')) {
+      findings.push({ type: 'settings-package', scope, path: filePath });
+    }
+  }
+
+  if (await fs.pathExists(path.join(legacyExtension, 'index.ts')) || await fs.pathExists(path.join(legacyExtension, 'index.js'))) {
+    findings.push({ type: 'legacy-extension', scope: 'user', path: legacyExtension });
+  }
+
+  return { findings };
+}
+
+export async function disableRawPiSubagentsActivation({ cwd = process.cwd(), home = HOME } = {}) {
+  const user = getPiGlobalTargets(home);
+  const project = getProjectPiTargets(cwd);
+  const actions = [];
+
+  for (const [scope, filePath] of [['user', user.settings], ['project', project.settings]]) {
+    const settings = await readJsonIfExists(filePath);
+    const result = removeRawPiSubagentsPackageEntries(settings);
+    if (result.changed) {
+      await writeJsonWithBackup(filePath, result.settings, 'takomi-disable-raw-pi-subagents');
+      actions.push({ type: 'settings-package-removed', scope, path: filePath });
+    }
+  }
+
+  const legacyExtension = path.join(user.extensions, 'subagent');
+  if (await fs.pathExists(path.join(legacyExtension, 'index.ts')) || await fs.pathExists(path.join(legacyExtension, 'index.js'))) {
+    const disabledRoot = path.join(user.root, 'disabled-extensions');
+    await fs.ensureDir(disabledRoot);
+    let dest = path.join(disabledRoot, 'subagent');
+    if (await fs.pathExists(dest)) {
+      const stamp = new Date().toISOString().replace(/[:.]/g, '-');
+      dest = path.join(disabledRoot, `subagent-${stamp}`);
+    }
+    await fs.move(legacyExtension, dest, { overwrite: false });
+    actions.push({ type: 'legacy-extension-moved', scope: 'user', path: legacyExtension, disabledPath: dest });
+  }
+
+  return { actions };
+}
+
+export function formatRawPiSubagentsFindings(findings = []) {
+  if (!findings.length) return 'No raw pi-subagents activation found.';
+  return findings.map((finding) => {
+    if (finding.type === 'settings-package') return `- ${finding.scope} settings package entry: ${finding.path}`;
+    if (finding.type === 'legacy-extension') return `- legacy raw subagent extension: ${finding.path}`;
+    return `- ${finding.path || JSON.stringify(finding)}`;
+  }).join('\n');
+}
+
+export function formatRawPiSubagentsDisableActions(actions = []) {
+  if (!actions.length) return 'No raw pi-subagents activation changes were needed.';
+  return actions.map((action) => {
+    if (action.type === 'settings-package-removed') return `- removed raw pi-subagents package from ${action.scope} settings: ${action.path}`;
+    if (action.type === 'legacy-extension-moved') return `- moved raw subagent extension out of Pi extensions: ${action.path} -> ${action.disabledPath}`;
+    return `- ${action.path || JSON.stringify(action)}`;
+  }).join('\n');
+}
+
 export async function inspectPiSubagentsDependency(home = HOME) {
   const pkg = await getPackageJson();
   const declaredVersion = pkg?.dependencies?.['pi-subagents'] || null;
@@ -140,12 +251,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 +497,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`
@@ -425,6 +541,7 @@ export async function inspectPiHarnessEnvironment(cwd = process.cwd()) {
   const bundled = await inspectBundledPiAssets();
   const installed = await inspectInstalledTakomiPiHarness();
   const piSubagents = await inspectPiSubagentsDependency();
+  const rawPiSubagentsActivation = await inspectRawPiSubagentsActivation({ cwd });
   const project = getProjectPiTargets(cwd);
 
   return {
@@ -432,6 +549,7 @@ export async function inspectPiHarnessEnvironment(cwd = process.cwd()) {
     bundled,
     installed,
     piSubagents,
+    rawPiSubagentsActivation,
     project: {
       targets: project,
       settingsPresent: await fs.pathExists(project.settings),
@@ -458,14 +576,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 +599,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;
 }