takomi 2.1.34 → 2.1.36

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/pi-installer.js

@@ -1,47 +1,15 @@
 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';
+import { hashPath, copyOwnedTree } from './owned-tree.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);
@@ -69,7 +37,7 @@ 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 });
+  await copyOwnedTree(src, dest);
   return hashPath(dest);
 }
 
@@ -77,7 +45,7 @@ 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 });
+  await copyOwnedTree(src, dest);
   return hashPath(dest);
 }
 
@@ -96,6 +64,8 @@ export async function writePiInstallManifest(manifest) {
 export async function installPiHarnessAssets(version = 'unknown') {
   const srcRoot = PATHS.pi;
   const targets = getPiGlobalTargets();
+  const previousSettingsHash = await hashPath(targets.settings);
+  const previousRoutingPolicyHash = await hashPath(targets.routingPolicy);
 
   const copied = {};
 
@@ -153,7 +123,9 @@ export async function installPiHarnessAssets(version = 'unknown') {
     owned: copied,
     preserved: {
       settings: targets.settings,
+      settingsHash: previousSettingsHash,
       routingPolicy: targets.routingPolicy,
+      routingPolicyHash: previousRoutingPolicyHash,
       userStateDir: targets.takomi,
     },
   };
@@ -168,6 +140,9 @@ export async function syncPiHarnessAssets(version = 'unknown') {
 
 export async function validatePiHarnessInstall() {
   const targets = getPiGlobalTargets();
+  const manifest = await readPiInstallManifest();
+  const currentSettingsHash = await hashPath(targets.settings);
+  const currentRoutingPolicyHash = await hashPath(targets.routingPolicy);
   return {
     runtime: await fs.pathExists(path.join(targets.extensions, 'takomi-runtime')),
     subagents: await fs.pathExists(path.join(targets.extensions, 'takomi-subagents')),
@@ -180,7 +155,8 @@ export async function validatePiHarnessInstall() {
     readme: await fs.pathExists(path.join(targets.root, 'README.md')),
     core: await fs.pathExists(path.join(path.dirname(targets.root), 'src', 'pi-takomi-core')),
     piSubagentsModule: await fs.pathExists(path.join(targets.root, 'node_modules', 'pi-subagents')),
-    settingsPreserved: !await fs.pathExists(path.join(PATHS.pi, 'settings.json')) || true,
+    settingsPreserved: !manifest || manifest.preserved?.settingsHash === currentSettingsHash,
+    routingPolicyPreserved: !manifest || manifest.preserved?.routingPolicyHash === currentRoutingPolicyHash,
   };
 }
 

package/src/store.js

@@ -1,59 +1,23 @@
 import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
-import crypto from 'crypto';
 import pc from 'picocolors';
 import { PATHS } from './utils.js';
 import { CORE_SKILLS } from './skills-catalog.js';
+import { hashPath as hashDirectory, normalizeOwnedMap, copyOwnedTree } from './owned-tree.js';
 
 // ─── Global Store Path ───────────────────────────────────────────────────────
 const HOME = os.homedir();
 export const STORE_PATH = process.env.TAKOMI_STORE_PATH || process.env.TAKOMI_HOME_DIR || path.join(HOME, '.takomi');
 export const MANIFEST_PATH = path.join(STORE_PATH, 'manifest.json');
 
-function sha256(value) {
-    return crypto.createHash('sha256').update(value).digest('hex');
-}
-
-async function hashDirectory(dir) {
-    if (!await fs.pathExists(dir)) return null;
-    const rootStat = await fs.stat(dir);
-    if (rootStat.isFile()) return sha256(await fs.readFile(dir));
-    const entries = [];
-    async function walk(current, prefix = '') {
-        const names = (await fs.readdir(current)).sort();
-        for (const name of names) {
-            const full = path.join(current, name);
-            const rel = path.join(prefix, name).replace(/\\/g, '/');
-            const stat = await fs.stat(full);
-            if (stat.isDirectory()) {
-                entries.push(`dir:${rel}`);
-                await walk(full, rel);
-            } else {
-                entries.push(`file:${rel}:${sha256(await fs.readFile(full))}`);
-            }
-        }
-    }
-    await walk(dir);
-    return sha256(entries.join('\n'));
-}
-
-function normalizeOwnedMap(value) {
-    if (!value || typeof value !== 'object') return {};
-    const normalized = {};
-    for (const [name, entry] of Object.entries(value)) {
-        if (typeof entry === 'string') normalized[name] = { hash: entry };
-        else if (entry?.hash) normalized[name] = entry;
-    }
-    return normalized;
-}
-
 function createDefaultManifest() {
     return {
         version: '2.0.0',
         createdAt: new Date().toISOString(),
         updatedAt: new Date().toISOString(),
         linkedHarnesses: [],
+        syncMode: 'copy',
         installed: {
             skills: [],
             workflows: [],
@@ -75,6 +39,7 @@ function normalizeManifest(manifest) {
         workflows: normalizeOwnedMap(manifest?.bundledOwned?.workflows),
     };
     normalized.harnessOwned = manifest?.harnessOwned || {};
+    normalized.syncMode = manifest?.syncMode || 'copy';
     return normalized;
 }
 
@@ -250,7 +215,7 @@ export async function populateSkills(mode) {
                 await fs.remove(dest);
             }
 
-            await fs.copy(src, dest, { overwrite: true });
+            await copyOwnedTree(src, dest);
             nextOwned[skill] = {
                 hash: await hashDirectory(dest),
                 targetPath: dest,
@@ -327,7 +292,7 @@ export async function populateWorkflows(mode) {
                 await fs.remove(dest);
             }
 
-            await fs.copy(src, dest, { overwrite: true });
+            await copyOwnedTree(src, dest);
             nextOwned[workflow] = {
                 hash: await hashDirectory(dest),
                 targetPath: dest,

package/src/takomi-stats.js

@@ -1,4 +1,5 @@
-import { promises as fs } from 'node:fs';
+import { createReadStream, promises as fs } from 'node:fs';
+import readline from 'node:readline';
 import os from 'os';
 import path from 'path';
 
@@ -167,9 +168,16 @@ async function scanPiSessions(root, source, events, sessionRows = [], taskRows =
     const row = { key: session, session, source, file, project: projectKey(file), cwd, start: '', end: '', turns: 0, messages: 0, toolCalls: 0, subagentCalls: 0, roles: new Map(), stages: new Map(), workflows: new Map(), activeMs: 0, activityIntervals: [] };
     const rowTracker = createActivityTracker();
     const toolCalls = new Map();
-    const text = await fs.readFile(file, 'utf8').catch(() => '');
 
-    for (const line of text.split(/\r?\n/)) {
+    let lines;
+    try {
+      lines = readline.createInterface({ input: createReadStream(file, { encoding: 'utf8' }), crlfDelay: Infinity });
+    } catch {
+      continue;
+    }
+
+    try {
+      for await (const line of lines) {
       const obj = safeJson(line); if (!obj) continue;
       if (obj.timestamp) { row.start ||= obj.timestamp; row.end = obj.timestamp; }
       if (obj.type === 'session') { session = obj.id || session; cwd = obj.cwd || cwd; row.key = session; row.session = session; row.cwd = cwd; }
@@ -254,6 +262,9 @@ async function scanPiSessions(root, source, events, sessionRows = [], taskRows =
         if (currentTask) currentTask.end = ts;
       }
 
+      }
+    } catch {
+      continue;
     }
     pushTask(taskRows, currentTask);
     if (currentTaskTracker && currentTask) {

package/src/utils.js

@@ -2,10 +2,10 @@ import fs from 'fs-extra';
 import path from 'path';
 import { fileURLToPath } from 'url';
 import https from 'https';
-import { exec } from 'child_process';
+import { execFile } from 'child_process';
 import { promisify } from 'util';
 
-const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
 
 // Reduced timeout to fail fast on bad connections
 const FETCH_TIMEOUT = 10000;
@@ -17,9 +17,18 @@ const __dirname = path.dirname(__filename);
 const PACKAGE_ROOT = path.resolve(__dirname, '..');
 
 // GitHub repository configuration
-const GITHUB_REPO = 'JStaRFilms/VibeCode-Protocol-Suite';
+const GITHUB_REPO = 'J-StaR-Films-Studios/VibeCode-Protocol-Suite';
 const GITHUB_BRANCH = 'main';
-const GITHUB_RAW_URL = `https://raw.githubusercontent.com/${GITHUB_REPO}/${GITHUB_BRANCH}`;
+
+function githubRef(options = {}) {
+  const repo = options.repo || GITHUB_REPO;
+  const branch = options.branch || GITHUB_BRANCH;
+  return {
+    repo,
+    branch,
+    rawBaseUrl: `https://raw.githubusercontent.com/${repo}/${branch}`,
+  };
+}
 
 export const PATHS = {
   root: PACKAGE_ROOT,
@@ -134,9 +143,10 @@ function delay(ms) {
  * @param {number} retries - Number of retries (default: 3)
  * @returns {Promise<string>} File content
  */
-export async function fetchFromGitHub(relativePath, retries = 3) {
+export async function fetchFromGitHub(relativePath, retries = 3, options = {}) {
   // Use raw GitHub content URL to avoid API rate limits
-  const rawUrl = `${GITHUB_RAW_URL}/${relativePath}`;
+  const { rawBaseUrl } = githubRef(options);
+  const rawUrl = `${rawBaseUrl}/${relativePath}`;
 
   return new Promise((resolve, reject) => {
     const attempt = (remainingRetries) => {
@@ -146,6 +156,19 @@ export async function fetchFromGitHub(relativePath, retries = 3) {
           'User-Agent': 'takomi-cli'
         }
       }, (res) => {
+        if ([301, 302, 307, 308].includes(res.statusCode) && res.headers.location) {
+          res.resume();
+          const redirectedUrl = new URL(res.headers.location, rawUrl).toString();
+          https.get(redirectedUrl, {
+            timeout: FETCH_TIMEOUT,
+            headers: { 'User-Agent': 'takomi-cli' }
+          }, (redirectRes) => {
+            let redirectedData = '';
+            redirectRes.on('data', chunk => redirectedData += chunk);
+            redirectRes.on('end', () => redirectRes.statusCode === 200 ? resolve(redirectedData) : reject(new Error(`HTTP ${redirectRes.statusCode}`)));
+          }).on('error', reject);
+          return;
+        }
         let data = '';
         res.on('data', chunk => data += chunk);
         res.on('end', () => {
@@ -167,8 +190,8 @@ export async function fetchFromGitHub(relativePath, retries = 3) {
         } else {
           // Fallback to curl if Node https fails (e.g. proxy/network issues)
           try {
-            // Ensure we use a timeout with curl too
-            const { stdout } = await execAsync(`curl -sL --max-time ${CURL_TIMEOUT} "${rawUrl}"`);
+            // Ensure we use a timeout with curl too, without invoking a shell.
+            const { stdout } = await execFileAsync('curl', ['-sL', '--max-time', String(CURL_TIMEOUT), rawUrl]);
             if (stdout) resolve(stdout);
             else reject(err);
           } catch (curlErr) {
@@ -192,36 +215,49 @@ export async function fetchFromGitHub(relativePath, retries = 3) {
  * @param {string} relativePath - Path relative to repo root
  * @returns {Promise<Array>} Array of file objects
  */
-export async function fetchDirectoryListing(relativePath) {
-  const apiUrl = `https://api.github.com/repos/${GITHUB_REPO}/contents/${relativePath}?ref=${GITHUB_BRANCH}`;
+export async function fetchDirectoryListing(relativePath, options = {}) {
+  const { repo, branch } = githubRef(options);
+  const apiUrl = `https://api.github.com/repos/${repo}/contents/${relativePath}?ref=${branch}`;
 
   return new Promise((resolve, reject) => {
-    https.get(apiUrl, {
-      timeout: 10000,
-      headers: {
-        'User-Agent': 'takomi-cli',
-        'Accept': 'application/vnd.github.v3+json'
-      }
-    }, (res) => {
-      let data = '';
-      res.on('data', chunk => data += chunk);
-      res.on('end', () => {
-        try {
-          if (res.statusCode === 200) {
-            const items = JSON.parse(data);
-            resolve(Array.isArray(items) ? items : []);
-          } else if (res.statusCode === 404) {
-            resolve([]);
-          } else if (res.statusCode === 403) {
-            reject(new Error('GitHub API rate limit exceeded. Please try again later.'));
-          } else {
-            reject(new Error(`GitHub API error: ${res.statusCode}`));
-          }
-        } catch (e) {
-          reject(new Error('Failed to parse GitHub API response'));
+    const requestUrl = (url, redirectsRemaining = 3) => {
+      const req = https.get(url, {
+        timeout: 10000,
+        headers: {
+          'User-Agent': 'takomi-cli',
+          'Accept': 'application/vnd.github.v3+json'
         }
+      }, (res) => {
+        if ([301, 302, 307, 308].includes(res.statusCode) && res.headers.location && redirectsRemaining > 0) {
+          res.resume();
+          requestUrl(new URL(res.headers.location, url).toString(), redirectsRemaining - 1);
+          return;
+        }
+
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => {
+          try {
+            if (res.statusCode === 200) {
+              const items = JSON.parse(data);
+              resolve(Array.isArray(items) ? items : []);
+            } else if (res.statusCode === 404) {
+              resolve([]);
+            } else if (res.statusCode === 403) {
+              reject(new Error('GitHub API rate limit exceeded. Please try again later.'));
+            } else {
+              reject(new Error(`GitHub API error: ${res.statusCode}`));
+            }
+          } catch (e) {
+            reject(new Error('Failed to parse GitHub API response'));
+          }
+        });
       });
-    }).on('error', reject);
+      req.on('timeout', () => req.destroy(new Error('Request timed out')));
+      req.on('error', reject);
+    };
+
+    requestUrl(apiUrl);
   });
 }
 
@@ -231,9 +267,9 @@ export async function fetchDirectoryListing(relativePath) {
  * @param {string} destPath - Local destination path
  * @returns {Promise<boolean>} Success status
  */
-export async function downloadFromGitHub(relativePath, destPath) {
+export async function downloadFromGitHub(relativePath, destPath, options = {}) {
   try {
-    const content = await fetchFromGitHub(relativePath);
+    const content = await fetchFromGitHub(relativePath, 3, options);
     await fs.ensureDir(path.dirname(destPath));
     await fs.writeFile(destPath, content, 'utf8');
     return true;
@@ -265,11 +301,11 @@ export async function downloadFromGitHub(relativePath, destPath) {
  * @param {number} delayMs - Delay between file downloads in ms (default: 100)
  * @returns {Promise<number>} Number of files downloaded
  */
-export async function downloadDirectoryFromGitHub(relativePath, destPath, filter = null, delayMs = 250) {
+export async function downloadDirectoryFromGitHub(relativePath, destPath, filter = null, delayMs = 250, options = {}) {
   let count = 0;
 
   try {
-    const items = await fetchDirectoryListing(relativePath);
+    const items = await fetchDirectoryListing(relativePath, options);
 
     for (const item of items) {
       if (!useGitHub) break; // Allow aborting if we disabled GitHub midway
@@ -277,7 +313,7 @@ export async function downloadDirectoryFromGitHub(relativePath, destPath, filter
 
       if (item.type === 'file') {
         const fileDest = path.join(destPath, item.name);
-        const success = await downloadFromGitHub(item.path, fileDest);
+        const success = await downloadFromGitHub(item.path, fileDest, options);
         if (success) {
           count++;
           // Add small delay between file downloads to be nice to GitHub
@@ -287,12 +323,13 @@ export async function downloadDirectoryFromGitHub(relativePath, destPath, filter
         }
       } else if (item.type === 'dir') {
         const subDirDest = path.join(destPath, item.name);
-        const subCount = await downloadDirectoryFromGitHub(item.path, subDirDest, filter, delayMs);
+        const subCount = await downloadDirectoryFromGitHub(item.path, subDirDest, filter, delayMs, options);
         count += subCount;
       }
     }
   } catch (error) {
     console.error(`Error downloading directory ${relativePath}: ${error.message}`);
+    if (options.throwOnError) throw error;
   }
 
   return count;
@@ -459,7 +496,7 @@ export async function copyLegacyManual(destFolder) {
 export async function updateWorkflows(destFolder) {
   console.log('📡 Fetching latest workflows from GitHub...');
   await fs.ensureDir(destFolder);
-  await downloadDirectoryFromGitHub('.agent/workflows', destFolder);
+  return downloadDirectoryFromGitHub('assets/.agent/workflows', destFolder, null, 250, { throwOnError: true });
 }
 
 /**
@@ -468,7 +505,7 @@ export async function updateWorkflows(destFolder) {
 export async function updateSkills(destFolder) {
   console.log('📡 Fetching latest skills from GitHub...');
   await fs.ensureDir(destFolder);
-  await downloadDirectoryFromGitHub('.agent/skills', destFolder);
+  return downloadDirectoryFromGitHub('assets/.agent/skills', destFolder, null, 250, { throwOnError: true });
 }
 
 /**
@@ -477,7 +514,7 @@ export async function updateSkills(destFolder) {
 export async function updateAgentYamls(destFolder) {
   console.log('📡 Fetching latest Agent YAMLs from GitHub...');
   await fs.ensureDir(destFolder);
-  await downloadDirectoryFromGitHub('Takomi-Agents', destFolder);
+  return downloadDirectoryFromGitHub('assets/Takomi-Agents', destFolder, null, 250, { throwOnError: true });
 }
 
 /**
@@ -486,5 +523,5 @@ export async function updateAgentYamls(destFolder) {
 export async function updateLegacyManual(destFolder) {
   console.log('📡 Fetching latest Legacy Protocols from GitHub...');
   await fs.ensureDir(destFolder);
-  await downloadDirectoryFromGitHub('Legacy (Manual Method)', destFolder);
+  return downloadDirectoryFromGitHub('assets/Legacy', destFolder, null, 250, { throwOnError: true });
 }