@aiwg/cli 2026.9.5 → 2026.9.7

package/dist/src/mcp/helpers.mjs

@@ -6,6 +6,7 @@
  */
 
 import { spawn } from 'node:child_process';
+import { StringDecoder } from 'node:string_decoder';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 
@@ -72,7 +73,7 @@ export async function resolveProjectAiwgDir(projectDir) {
  */
 export async function findProjectRoot(startDir = process.cwd()) {
   let currentDir = startDir;
-  while (currentDir !== path.dirname(currentDir)) {
+  while (true) {
     const aiwgPath = path.join(currentDir, '.aiwg');
     const pointerPath = path.join(currentDir, PROJECT_AIWG_LOCATION_FILE);
     try {
@@ -87,7 +88,10 @@ export async function findProjectRoot(startDir = process.cwd()) {
     } catch {
       // continue up
     }
-    currentDir = path.dirname(currentDir);
+    // Inspect the root candidate too, then stop instead of revisiting it.
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
   }
   throw new Error('No .aiwg directory or .aiwg-location pointer found. Run from an AIWG project or `aiwg new` first.');
 }
@@ -167,33 +171,56 @@ export function runAiwgCli(args, { cwd, env, timeoutMs = 120_000, input } = {})
     });
     let stdout = '';
     let stderr = '';
-    let timedOut = false;
+    const stdoutDecoder = new StringDecoder('utf8');
+    const stderrDecoder = new StringDecoder('utf8');
+    let settled = false;
+    let killTimer;
+    const rejectAndTerminate = (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      // Settlement must not depend on a cooperative close event. Give the
+      // owned child one second to exit gracefully, then escalate cleanup.
+      reject(err);
+      killTimer = setTimeout(() => {
+        try { proc.kill('SIGKILL'); } catch { /* child may already have exited */ }
+      }, 1000);
+      killTimer.unref?.();
+      // Install cleanup first: kill() can synchronously trigger close in an adapter.
+      try { proc.kill('SIGTERM'); } catch { /* retain the original failure */ }
+    };
     const timer = setTimeout(() => {
-      timedOut = true;
-      proc.kill('SIGTERM');
+      rejectAndTerminate(new Error(`aiwg ${args[0] || ''} timed out after ${timeoutMs}ms`));
     }, timeoutMs);
 
-    proc.stdout.on('data', (chunk) => { stdout += chunk; });
-    proc.stderr.on('data', (chunk) => { stderr += chunk; });
+    proc.stdout.on('data', (chunk) => { stdout += stdoutDecoder.write(chunk); });
+    proc.stderr.on('data', (chunk) => { stderr += stderrDecoder.write(chunk); });
 
     proc.on('close', (code) => {
       clearTimeout(timer);
-      if (timedOut) {
-        reject(new Error(`aiwg ${args[0] || ''} timed out after ${timeoutMs}ms`));
-        return;
-      }
+      clearTimeout(killTimer);
+      if (settled) return;
+      settled = true;
+      stdout += stdoutDecoder.end();
+      stderr += stderrDecoder.end();
       resolve({ stdout, stderr, code: code ?? -1 });
     });
     proc.on('error', (err) => {
       clearTimeout(timer);
+      // A late error must not cancel cleanup of a failed, still-live child.
+      if (settled) return;
+      settled = true;
       reject(err);
     });
 
-    if (input !== undefined) {
-      proc.stdin.write(input);
-      proc.stdin.end();
-    } else {
-      proc.stdin.end();
+    // Pipe errors are emitted on stdin, not on the ChildProcess. Register
+    // before writing so synchronous adapter events and late EPIPE are handled.
+    proc.stdin.on('error', rejectAndTerminate);
+    try {
+      if (input !== undefined) proc.stdin.write(input);
+      if (!settled) proc.stdin.end();
+    } catch (err) {
+      rejectAndTerminate(err);
     }
   });
 }
@@ -244,13 +271,20 @@ export async function loadCommandAllowList() {
     }
   }
   if (!text) {
-    // Last-resort fallback: spawn `aiwg help` and parse — slower but always works
+    // Installed packages need not contain TypeScript sources. Ask the CLI for
+    // its versioned canonical registry; human help is incomplete and contains examples.
     try {
-      const { stdout } = await runAiwgCli(['help'], { timeoutMs: 30_000 });
-      _commandIds = new Set(
-        Array.from(stdout.matchAll(/^\s{4}([a-z][a-z0-9-]+)\s/gm))
-          .map(m => m[1])
-      );
+      const { stdout, code } = await runAiwgCli(['help', '--json'], { timeoutMs: 30_000 });
+      if (code !== 0) throw new Error('Command registry subprocess failed');
+      const registry = JSON.parse(stdout);
+      const ids = registry?.commandIds;
+      if (registry?.schema !== 'aiwg.command-registry.v1'
+        || !Array.isArray(ids) || ids.length === 0
+        || ids.some(id => typeof id !== 'string' || !/^[a-z][a-z0-9-]*$/.test(id))
+        || new Set(ids).size !== ids.length) {
+        throw new Error('Invalid command registry response');
+      }
+      _commandIds = new Set(ids);
       return _commandIds;
     } catch (e) {
       _commandIds = new Set();

package/dist/src/mcp/registry.js

@@ -1,4 +1,5 @@
 import { manageOmpMcp } from './omp-config.mjs';
+import { replaceServer } from './toml-editor.mjs';
 import { resolveOmpPaths } from '../providers/omp-paths.mjs';
 /**
  * MCP Server Registry
@@ -246,18 +247,30 @@ function buildServerConfig(server, provider) {
 /**
  * Build a TOML section for a server (Codex/OpenAI provider).
  */
+function tomlString(value) {
+    if (typeof value !== 'string' || [...value].some(char => {
+        const point = char.codePointAt(0);
+        return point >= 0xd800 && point <= 0xdfff;
+    }))
+        throw new Error('TOML values must be strings containing valid Unicode scalar values');
+    // JSON escapes align with TOML basic strings except DEL must also be escaped.
+    return JSON.stringify(value).replace(/\u007f/g, '\\u007f');
+}
+function tomlKey(value) {
+    return typeof value === 'string' && /^[A-Za-z0-9_-]+$/.test(value) ? value : tomlString(value);
+}
 function buildServerToml(server) {
     const lines = [];
-    lines.push(`[mcp_servers.${server.name}]`);
+    lines.push(`[mcp_servers.${tomlKey(server.name)}]`);
     if (server.type === 'stdio') {
-        lines.push(`command = "${server.command}"`);
+        lines.push(`command = ${tomlString(server.command)}`);
         if (server.args && server.args.length > 0) {
-            const argsStr = server.args.map(a => `"${a}"`).join(', ');
+            const argsStr = server.args.map(a => tomlString(a)).join(', ');
             lines.push(`args = [${argsStr}]`);
         }
     }
     else {
-        lines.push(`url = "${server.url}"`);
+        lines.push(`url = ${tomlString(server.url)}`);
     }
     lines.push(`startup_timeout_sec = 10.0`);
     lines.push(`tool_timeout_sec = 60.0`);
@@ -344,12 +357,21 @@ async function injectJson(registry, servers, configPath, provider, dryRun, resul
         existing = JSON.parse(content);
     }
     catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`Refusing to overwrite malformed MCP config ${configPath}: invalid JSON`);
+        }
         if ((provider === 'antigravity' || provider === 'agy') && error?.code !== 'ENOENT') {
             throw new Error(`Refusing to overwrite malformed MCP config ${configPath}: ${error.message}`);
         }
+        if (error?.code !== 'ENOENT')
+            throw error;
     }
     // Determine the MCP servers key for this provider
     const mcpKey = provider === 'opencode' ? 'mcp' : 'mcpServers';
+    const isObject = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+    if (!isObject(existing) || (Object.hasOwn(existing, mcpKey) && !isObject(existing[mcpKey]))) {
+        throw new Error('MCP configuration must contain an object root and an object server map');
+    }
     const existingServers = existing[mcpKey] || {};
     // Build new server entries
     const newServers = { ...existingServers };
@@ -382,26 +404,17 @@ async function injectToml(registry, servers, configPath, provider, dryRun, resul
     try {
         existing = await readFile(configPath, 'utf-8');
     }
-    catch {
-        // File doesn't exist
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
     }
-    const sectionsToAdd = [];
     for (const server of servers) {
-        const sectionHeader = `[mcp_servers.${server.name}]`;
-        if (existing.includes(sectionHeader)) {
-            // Replace the existing section
-            const sectionRegex = new RegExp(`\\[mcp_servers\\.${escapeRegex(server.name)}\\][\\s\\S]*?(?=\\n\\[|$)`);
-            existing = existing.replace(sectionRegex, buildServerToml(server));
+        const edited = replaceServer(existing, server.name, buildServerToml(server));
+        existing = edited.text;
+        if (edited.alreadyPresent)
             result.alreadyPresent.push(server.name);
-        }
-        else {
-            sectionsToAdd.push(buildServerToml(server));
-        }
         result.serversInjected.push(server.name);
     }
-    if (sectionsToAdd.length > 0) {
-        existing = existing.trimEnd() + '\n\n' + sectionsToAdd.join('\n\n') + '\n';
-    }
     if (!dryRun) {
         await mkdir(resolve(configPath, '..'), { recursive: true });
         await writeFile(configPath, existing, 'utf-8');
@@ -411,9 +424,6 @@ async function injectToml(registry, servers, configPath, provider, dryRun, resul
     }
     return result;
 }
-function escapeRegex(str) {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 /** All supported provider names for injection */
 export const SUPPORTED_PROVIDERS = [
     'antigravity',

package/dist/src/mcp/registry.mjs

@@ -1,4 +1,5 @@
 import { manageOmpMcp } from './omp-config.mjs';
+import { replaceServer } from './toml-editor.mjs';
 import { resolveOmpPaths } from '../providers/omp-paths.mjs';
 /**
  * MCP Server Registry (Runtime ESM)
@@ -269,18 +270,31 @@ function buildServerConfig(server, provider) {
   }
 }
 
+function tomlString(value) {
+  if (typeof value !== 'string' || [...value].some(char => {
+    const point = char.codePointAt(0);
+    return point >= 0xd800 && point <= 0xdfff;
+  })) throw new Error('TOML values must be strings containing valid Unicode scalar values');
+  // JSON escapes align with TOML basic strings except DEL must also be escaped.
+  return JSON.stringify(value).replace(/\u007f/g, '\\u007f');
+}
+
+function tomlKey(value) {
+  return typeof value === 'string' && /^[A-Za-z0-9_-]+$/.test(value) ? value : tomlString(value);
+}
+
 function buildServerToml(server) {
   const lines = [];
-  lines.push(`[mcp_servers.${server.name}]`);
+  lines.push(`[mcp_servers.${tomlKey(server.name)}]`);
 
   if (server.type === 'stdio') {
-    lines.push(`command = "${server.command}"`);
+    lines.push(`command = ${tomlString(server.command)}`);
     if (server.args && server.args.length > 0) {
-      const argsStr = server.args.map(a => `"${a}"`).join(', ');
+      const argsStr = server.args.map(a => tomlString(a)).join(', ');
       lines.push(`args = [${argsStr}]`);
     }
   } else {
-    lines.push(`url = "${server.url}"`);
+    lines.push(`url = ${tomlString(server.url)}`);
   }
 
   lines.push(`startup_timeout_sec = 10.0`);
@@ -344,12 +358,20 @@ async function injectJson(registry, servers, configPath, provider, dryRun, resul
     const content = await readFile(configPath, 'utf-8');
     existing = JSON.parse(content);
   } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new Error(`Refusing to overwrite malformed MCP config ${configPath}: invalid JSON`);
+    }
     if (normalizeRuntimeProviderId(provider) === 'antigravity' && error?.code !== 'ENOENT') {
       throw new Error(`Refusing to overwrite malformed MCP config ${configPath}: ${error.message}`);
     }
+    if (error?.code !== 'ENOENT') throw error;
   }
 
   const mcpKey = getMcpInjectionDefinition(provider)?.serversKey || 'mcpServers';
+  const isObject = value => value !== null && typeof value === 'object' && !Array.isArray(value);
+  if (!isObject(existing) || (Object.hasOwn(existing, mcpKey) && !isObject(existing[mcpKey]))) {
+    throw new Error('MCP configuration must contain an object root and an object server map');
+  }
   const existingServers = existing[mcpKey] || {};
   const newServers = { ...existingServers };
 
@@ -381,30 +403,17 @@ async function injectToml(registry, servers, configPath, provider, dryRun, resul
   let existing = '';
   try {
     existing = await readFile(configPath, 'utf-8');
-  } catch {
-    // File doesn't exist
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
   }
 
-  const sectionsToAdd = [];
-
   for (const server of servers) {
-    const sectionHeader = `[mcp_servers.${server.name}]`;
-    if (existing.includes(sectionHeader)) {
-      const sectionRegex = new RegExp(
-        `\\[mcp_servers\\.${escapeRegex(server.name)}\\][\\s\\S]*?(?=\\n\\[|$)`,
-      );
-      existing = existing.replace(sectionRegex, buildServerToml(server));
-      result.alreadyPresent.push(server.name);
-    } else {
-      sectionsToAdd.push(buildServerToml(server));
-    }
+    const edited = replaceServer(existing, server.name, buildServerToml(server));
+    existing = edited.text;
+    if (edited.alreadyPresent) result.alreadyPresent.push(server.name);
     result.serversInjected.push(server.name);
   }
 
-  if (sectionsToAdd.length > 0) {
-    existing = existing.trimEnd() + '\n\n' + sectionsToAdd.join('\n\n') + '\n';
-  }
-
   if (!dryRun) {
     await mkdir(resolve(configPath, '..'), { recursive: true });
     await writeFile(configPath, existing, 'utf-8');
@@ -417,8 +426,4 @@ async function injectToml(registry, servers, configPath, provider, dryRun, resul
   return result;
 }
 
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
 export const SUPPORTED_PROVIDERS = listMcpInjectProviderIds();

package/dist/src/mcp/toml-editor.mjs

@@ -0,0 +1,117 @@
+// Pure source-range editing; provider filesystem access belongs to the caller.
+import { parseTOML } from 'toml-eslint-parser';
+
+const keys = node => node.key.keys.map(key => key.type === 'TOMLBare' ? key.name : key.value);
+const starts = (path, prefix) => prefix.every((key, index) => path[index] === key);
+function parse(text) {
+  try { return parseTOML(text, { tomlVersion: '1.0.0' }); }
+  catch { throw new Error('Invalid TOML configuration; no changes made'); }
+}
+
+export function replaceServer(text, name, section) {
+  const ast = parse(text);
+  const target = ['mcp_servers', name];
+  const replacement = parse(section).body[0].body;
+  if (replacement.length !== 1 || replacement[0].type !== 'TOMLTable' ||
+      replacement[0].resolvedKey.length !== 2 || !starts(replacement[0].resolvedKey, target)) {
+    throw new Error('Invalid replacement server definition');
+  }
+  const inline = '{ ' + replacement[0].body.map(node => section.slice(...node.range)).join(', ') + ' }';
+  const encodedName = section.slice(...replacement[0].key.keys[1].range);
+  const edits = [];
+  let present = false;
+  let placed = false;
+  const edit = (range, value = '') => edits.push({ start: range[0], end: range[1], value });
+
+  function inspectValue(node, path) {
+    if (path[0] === 'mcp_servers') {
+      if (path.length <= 2 && node.type !== 'TOMLInlineTable') {
+        throw new Error('MCP configuration and server entries must be TOML tables');
+      }
+      if (starts(path, target)) present = true;
+    }
+    if (node.type === 'TOMLInlineTable') {
+      for (const entry of node.body) inspectValue(entry.value, [...path, ...keys(entry)]);
+    }
+  }
+  for (const node of ast.body[0].body) {
+    if (node.type === 'TOMLTable') {
+      const path = node.resolvedKey;
+      if (path[0] === 'mcp_servers' &&
+          (typeof path[1] === 'number' || typeof path[2] === 'number')) {
+        throw new Error('MCP configuration and server entries must not be TOML arrays of tables');
+      }
+      if (starts(path, target)) present = true;
+      for (const entry of node.body) inspectValue(entry.value, [...path, ...keys(entry)]);
+    } else inspectValue(node.value, keys(node));
+  }
+
+  const selectedTables = ast.body[0].body.filter(node => node.type === 'TOMLTable' && starts(node.resolvedKey, target));
+  if (selectedTables.length === 1 && text.slice(...selectedTables[0].range) === section) {
+    return { text, alreadyPresent: true };
+  }
+  if (selectedTables.length === 1 && selectedTables[0].resolvedKey.length === 2) {
+    const [start, end] = selectedTables[0].range;
+    if (!ast.comments.some(comment => comment.range[0] >= start && comment.range[0] < end)) {
+      const output = text.slice(0, start) + section + text.slice(end);
+      parse(output);
+      return { text: output, alreadyPresent: true };
+    }
+  }
+
+  function editInlineMap(node) {
+    const entries = node.body;
+    const selected = entries.map((entry, index) => keys(entry)[0] === name ? index : -1).filter(index => index >= 0);
+    if (selected.length === 0) {
+      edit([node.range[1] - 1, node.range[1] - 1], `${entries.length ? ', ' : ''}${encodedName} = ${inline}`);
+    } else {
+      const first = selected[0];
+      if (keys(entries[first]).length === 1) edit(entries[first].value.range, inline);
+      else edit(entries[first].range, `${encodedName} = ${inline}`);
+      // Keep the first selected entry as the replacement anchor. Remove each
+      // subsequent contiguous run together with one separator, never a neighbor.
+      for (let cursor = 1; cursor < selected.length;) {
+        const start = selected[cursor];
+        let end = start;
+        while (cursor + 1 < selected.length && selected[cursor + 1] === end + 1) {
+          cursor++;
+          end++;
+        }
+        if (end + 1 < entries.length) edit([entries[start].range[0], entries[end + 1].range[0]]);
+        else edit([entries[start - 1].range[1], entries[end].range[1]]);
+        cursor++;
+      }
+    }
+    placed = true;
+  }
+  function planEntry(entry, base) {
+    const path = [...base, ...keys(entry)];
+    if (path.length === 1 && path[0] === 'mcp_servers') {
+      editInlineMap(entry.value);
+    } else if (starts(path, target)) {
+      if (path.length === 2) {
+        edit(entry.value.range, inline);
+        placed = true;
+      } else edit(entry.range);
+    }
+  }
+  for (const node of ast.body[0].body) {
+    if (node.type !== 'TOMLTable') { planEntry(node, []); continue; }
+    if (starts(node.resolvedKey, target)) {
+      const closing = ast.tokens.filter(token => token.range[0] >= node.key.range[1] && token.value === ']');
+      const last = closing[node.kind === 'array' ? 1 : 0];
+      if (!last) throw new Error('Invalid TOML table range');
+      edit([node.range[0], last.range[1]]);
+      for (const entry of node.body) edit(entry.range);
+    } else for (const entry of node.body) planEntry(entry, node.resolvedKey);
+  }
+  edits.sort((a, b) => a.start - b.start || a.end - b.end);
+  for (let index = 1; index < edits.length; index++) {
+    if (edits[index].start < edits[index - 1].end) throw new Error('Overlapping TOML edit ranges');
+  }
+  let output = text;
+  for (const change of edits.reverse()) output = output.slice(0, change.start) + change.value + output.slice(change.end);
+  if (!placed) output += `${output.endsWith('\n') ? '' : '\n'}\n${section}\n`;
+  parse(output);
+  return { text: output, alreadyPresent: present };
+}

package/dist/src/mcp/tools/orchestration.mjs

@@ -235,13 +235,13 @@ export function registerMissionToolset(server) {
       session_id: z.string().describe('Existing Mission Control session id from mc-start / mc-list'),
       objective: z.string().describe('Mission objective'),
       completion: z.string().describe('Measurable completion criterion'),
-      max_iterations: z.number().int().positive().optional().describe('Ralph iteration cap'),
-      max_total_tokens: z.number().int().positive().optional().describe('Hard cumulative token ceiling'),
-      max_output_tokens: z.number().int().positive().optional().describe('Hard cumulative output-token ceiling'),
-      max_tool_calls: z.number().int().positive().optional().describe('Hard cumulative tool-call ceiling'),
-      max_total_cost: z.number().positive().optional().describe('Hard cumulative provider-reported spend ceiling'),
-      max_wall_clock_minutes: z.number().positive().optional().describe('Hard cumulative runtime ceiling'),
-      exploration_quota: z.number().int().positive().optional().describe('Require structural variant after this many flat cycles (off unless declared; no default K)'),
+      max_iterations: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Ralph iteration cap'),
+      max_total_tokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative token ceiling'),
+      max_output_tokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative output-token ceiling'),
+      max_tool_calls: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative tool-call ceiling'),
+      max_total_cost: z.number().positive().finite().optional().describe('Hard cumulative provider-reported spend ceiling'),
+      max_wall_clock_minutes: z.number().positive().finite().optional().describe('Hard cumulative runtime ceiling'),
+      exploration_quota: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Require structural variant after this many flat cycles (off unless declared; no default K)'),
       budget_stop_policy: z.enum(['completion-wins', 'budget-wins']).optional().describe('Stop semantics when the completing iteration crosses a ceiling (default: completion-wins)'),
       project_dir: z.string().optional().describe('Project directory for CLI dispatch'),
       confirmed: z.boolean().default(false).describe('Required for durable/long-running mission dispatch'),

package/dist/src/mcp/tools/subsystems.mjs

@@ -413,13 +413,13 @@ function registerMcToolset(server) {
       session_id: z.string().describe('Session id'),
       objective: z.string().describe('Mission objective'),
       completion: z.string().optional().describe('Completion criteria'),
-      max_iterations: z.number().int().positive().optional().describe('Ralph iteration cap'),
-      max_total_tokens: z.number().int().positive().optional().describe('Hard cumulative token ceiling'),
-      max_output_tokens: z.number().int().positive().optional().describe('Hard cumulative output-token ceiling'),
-      max_tool_calls: z.number().int().positive().optional().describe('Hard cumulative tool-call ceiling'),
-      max_total_cost: z.number().positive().optional().describe('Hard cumulative provider-reported spend ceiling'),
-      max_wall_clock_minutes: z.number().positive().optional().describe('Hard cumulative runtime ceiling'),
-      exploration_quota: z.number().int().positive().optional().describe('Require structural variant after this many flat cycles (off unless declared; no default K)'),
+      max_iterations: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Ralph iteration cap'),
+      max_total_tokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative token ceiling'),
+      max_output_tokens: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative output-token ceiling'),
+      max_tool_calls: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Hard cumulative tool-call ceiling'),
+      max_total_cost: z.number().positive().finite().optional().describe('Hard cumulative provider-reported spend ceiling'),
+      max_wall_clock_minutes: z.number().positive().finite().optional().describe('Hard cumulative runtime ceiling'),
+      exploration_quota: z.number().int().positive().max(Number.MAX_SAFE_INTEGER).optional().describe('Require structural variant after this many flat cycles (off unless declared; no default K)'),
       budget_stop_policy: z.enum(['completion-wins', 'budget-wins']).optional().describe('Stop semantics when the completing iteration crosses a ceiling (default: completion-wins)'),
     },
     buildArgs: ({

package/dist/src/memory/context-pack.js

@@ -265,6 +265,7 @@ export function buildContextPack(task, candidates, options = {}) {
     };
 }
 export function buildWorkspaceContextPack(projectRoot, task, options = {}) {
+    const started = performance.now();
     if (!task.trim())
         throw new Error('context task must be nonblank');
     const root = realpathSync(projectRoot);
@@ -277,6 +278,9 @@ export function buildWorkspaceContextPack(projectRoot, task, options = {}) {
             return indexed.length > 0 ? indexed : wikiCandidates(root, taskTerms, maxFiles);
         })(),
     ];
-    return buildContextPack(task, candidates, { ...options, maxFiles });
+    const pack = buildContextPack(task, candidates, { ...options, maxFiles });
+    // Workspace callers need retrieval plus assembly latency, not assembly alone.
+    pack.metrics.elapsedMs = Number((performance.now() - started).toFixed(3));
+    return pack;
 }
 //# sourceMappingURL=context-pack.js.map

package/dist/src/plugin/skill-command-translator.js

@@ -11,8 +11,63 @@
  * @implements .aiwg/architecture/adr-skills-canonical-extension-type.md
  * @issue #550
  */
+import { createHash } from 'node:crypto';
 import fs from 'fs/promises';
 import path from 'path';
+/**
+ * Ownership signal for generated command files (#2507).
+ *
+ * Command wrappers were written as bare files: no `aiwg:managed` marker and no
+ * `.aiwg-manifest.json` entry. AIWG could neither count them as deployed nor
+ * recognise them as its own, so a later run reported the wrappers it had just
+ * written as unmanaged artifacts the operator should delete. They now carry the
+ * same signals as any other deployed artifact, tagged `skill-command` so the
+ * flat-command prune leaves them to the skills prune that governs their source.
+ */
+const MANAGED_SIDECAR = '.aiwg-manifest.json';
+const MANAGED_MARKER_PATTERN = /^(?:<!--\s*aiwg:managed\s|#\s*aiwg:managed\s)/m;
+function addManagedMarker(content, version, source) {
+    if (MANAGED_MARKER_PATTERN.test(content))
+        return content;
+    if (content.startsWith('---\n')) {
+        return content.replace(/^---\n/, `---\n# aiwg:managed v${version} ${source}\n`);
+    }
+    return `<!-- aiwg:managed v${version} ${source} -->\n${content}`;
+}
+/**
+ * Merge generated command entries into a directory's managed sidecar.
+ *
+ * Best-effort: a translation that cannot record ownership still produced a
+ * usable command file, so a sidecar failure must not fail the deploy.
+ */
+async function recordManagedCommands(targetDir, entries, version, source) {
+    if (entries.length === 0)
+        return;
+    const sidecarPath = path.join(targetDir, MANAGED_SIDECAR);
+    let sidecar = { managed: {} };
+    try {
+        const parsed = JSON.parse(await fs.readFile(sidecarPath, 'utf-8'));
+        if (parsed && typeof parsed === 'object' && parsed.managed)
+            sidecar = parsed;
+    }
+    catch {
+        // No sidecar yet, or unreadable — start a fresh managed map.
+    }
+    for (const entry of entries) {
+        sidecar.managed[entry.filename] = {
+            hash: `sha256:${createHash('sha256').update(entry.content).digest('hex')}`,
+            source,
+            version,
+            kind: 'skill-command',
+        };
+    }
+    try {
+        await fs.writeFile(sidecarPath, `${JSON.stringify(sidecar, null, 2)}\n`, 'utf-8');
+    }
+    catch {
+        // Non-fatal — the command files themselves are already written.
+    }
+}
 // ============================================
 // Provider Configuration
 // ============================================
@@ -280,6 +335,9 @@ export async function translateSkillsToCommands(skillsDir, options) {
         errors: [],
         totalProcessed: 0,
     };
+    // Ownership records for the commands this call writes (#2507).
+    const managedEntries = [];
+    const promptEntries = [];
     // Check if this provider needs commands. nameFilter overrides the
     // provider gating: when an operator passes an explicit filter (e.g. Claude
     // flow→command emission per PUW-015 #1116), they're opting in to selective
@@ -328,7 +386,7 @@ export async function translateSkillsToCommands(skillsDir, options) {
                 continue;
             }
             // Generate command content
-            const commandContent = generateCommandContent(skillName, frontmatter, body, options.provider);
+            const commandContent = addManagedMarker(generateCommandContent(skillName, frontmatter, body, options.provider), options.deployVersion ?? 'unknown', 'bundled');
             const commandFilename = `${skillName}.md`;
             const translated = {
                 sourcePath: skillMdPath,
@@ -353,7 +411,9 @@ export async function translateSkillsToCommands(skillsDir, options) {
                     const promptPath = path.join(promptsDir, `${skillName}.prompt.md`);
                     await fs.mkdir(promptsDir, { recursive: true });
                     await fs.writeFile(promptPath, commandContent, 'utf-8');
+                    promptEntries.push({ filename: `${skillName}.prompt.md`, content: commandContent });
                 }
+                managedEntries.push({ filename: commandFilename, content: commandContent });
             }
             result.translated.push(translated);
             if (options.verbose) {
@@ -373,6 +433,15 @@ export async function translateSkillsToCommands(skillsDir, options) {
             }
         }
     }
+    if (!options.dryRun) {
+        const version = options.deployVersion ?? 'unknown';
+        await recordManagedCommands(options.targetDir, managedEntries, version, 'bundled');
+        if (promptEntries.length > 0) {
+            const projectRoot = options.projectPath
+                ?? path.dirname(path.dirname(options.targetDir));
+            await recordManagedCommands(path.join(projectRoot, '.github', 'prompts'), promptEntries, version, 'bundled');
+        }
+    }
     return result;
 }
 /**