@aiwg/cli 2026.10.1 → 2026.10.4

package/dist/src/smiths/toolsmith/runtime-discovery.mjs

@@ -7,9 +7,10 @@
  * @architecture @.aiwg/architecture/toolsmith-implementation-spec.md
  */
 
-import { execSync } from 'child_process';
-import { readFile, writeFile, mkdir, access } from 'fs/promises';
+import { boundedExecFileSync, boundedExecSync } from '../../process/bounded-child-process.mjs';
+import { readFile, writeFile, mkdir, access, stat } from 'fs/promises';
 import { existsSync, constants } from 'fs';
+import { createHash } from 'node:crypto';
 import { resolve, join, dirname } from 'path';
 import { platform, arch, homedir, tmpdir, cpus, totalmem, freemem } from 'os';
 import { fileURLToPath } from 'url';
@@ -22,26 +23,59 @@ const __dirname = dirname(__filename);
  * RuntimeDiscovery - Discovers and catalogs installed system tools
  */
 export class RuntimeDiscovery {
-  constructor(basePath = null) {
-    this.basePath = basePath || projectAiwgPath(process.cwd(), 'smiths', 'toolsmith');
+  constructor(basePath = null, { cwd = process.cwd(), quiet = false } = {}) {
+    this.cwd = cwd;
+    this.quiet = quiet;
+    this.basePath = basePath || projectAiwgPath(this.cwd, 'smiths', 'toolsmith');
     this.knownTools = this.#loadKnownTools();
   }
 
   /**
-   * Perform full discovery scan
+   * Refresh discovery, skipping version probes when inputs are unchanged.
    * @returns {Promise<Object>} RuntimeCatalog
    */
-  async discover() {
-    console.log('Starting runtime discovery...');
+  async discover({ force = false } = {}) {
+    if (!this.quiet) console.log('Starting runtime discovery...');
+
+    const loaded = await this.#loadCatalog().catch(error => {
+      if (error instanceof SyntaxError) return null;
+      throw error;
+    });
+    const previous = Array.isArray(loaded?.tools) ? loaded : null;
+    const paths = new Map();
+    const inputs = [];
+    for (const name of this.#safeTools()) {
+      const toolPath = await this.#findToolPath(name);
+      paths.set(name, toolPath);
+      const metadata = toolPath ? await stat(toolPath).catch(() => null) : null;
+      inputs.push([name, toolPath, metadata && [metadata.mtimeMs, metadata.ctimeMs, metadata.size, metadata.mode]]);
+    }
+    const inputFingerprint = createHash('sha256').update(JSON.stringify([
+      1, this.knownTools, inputs, platform(), arch(), homedir(), this.cwd,
+      process.env.PATH, process.env.PATHEXT, process.env.SHELL, process.env.ComSpec,
+    ])).digest('hex');
+    if (!force && previous?.inputFingerprint === inputFingerprint
+      && existsSync(join(this.basePath, 'runtime-info.md'))) {
+      if (!this.quiet) console.log(`Discovery skipped: unchanged (${previous.tools.length} tools)`);
+      return previous;
+    }
 
     const environment = await this.getEnvironment();
     const resources = await this.getResources();
-    const tools = await this.#discoverTools();
+    const tools = await this.#discoverTools(paths);
+    const previousIds = new Set((previous?.tools || []).map(tool => tool.id));
+    const currentIds = new Set(tools.available.map(tool => tool.id));
+    const delta = {
+      added: [...currentIds].filter(id => !previousIds.has(id)),
+      removed: [...previousIds].filter(id => !currentIds.has(id)),
+    };
 
     const catalog = {
       $schema: 'https://aiwg.io/schemas/toolsmith/runtime-catalog-v1.json',
       version: '1.0',
       generated: new Date().toISOString(),
+      inputFingerprint,
+      delta,
       environment,
       resources,
       tools: tools.available,
@@ -52,7 +86,11 @@ export class RuntimeDiscovery {
     await this.#writeCatalog(catalog);
     await this.#writeRuntimeInfo(catalog);
 
-    console.log(`Discovery complete: ${catalog.tools.length} tools found`);
+    if (!this.quiet) console.log(`Discovery complete: ${catalog.tools.length} tools found`);
+    if (!this.quiet) console.log(`Tool delta: +${delta.added.length} added, -${delta.removed.length} removed`);
+    if (delta.removed.length) {
+      if (!this.quiet) console.warn(`Previously cataloged tools no longer available: ${delta.removed.join(', ')}`);
+    }
     return catalog;
   }
 
@@ -140,13 +178,13 @@ export class RuntimeDiscovery {
           }
         }
       } else if (os === 'darwin') {
-        const version = execSync('sw_vers -productVersion', { encoding: 'utf-8' }).trim();
+        const version = boundedExecFileSync('sw_vers', ['-productVersion'], 'quick', { encoding: 'utf-8' }).trim();
         osVersion = `macOS ${version}`;
       } else if (os === 'win32') {
-        osVersion = execSync('ver', { encoding: 'utf-8' }).trim();
+        osVersion = boundedExecSync('ver', 'quick', { encoding: 'utf-8' }).trim();
       }
     } catch (error) {
-      console.warn('Could not detect OS version:', error.message);
+      if (!this.quiet) console.warn('Could not detect OS version:', error.message);
     }
 
     return {
@@ -155,7 +193,7 @@ export class RuntimeDiscovery {
       arch: arch(),
       shell: process.env.SHELL || process.env.ComSpec || '/bin/sh',
       homeDir: homedir(),
-      workingDir: process.cwd()
+      workingDir: this.cwd
     };
   }
 
@@ -172,7 +210,7 @@ export class RuntimeDiscovery {
       // Disk space
       if (platform() === 'win32') {
         // Windows: use wmic
-        const output = execSync('wmic logicaldisk get size,freespace', { encoding: 'utf-8' });
+        const output = boundedExecFileSync('wmic', ['logicaldisk', 'get', 'size,freespace'], 'quick', { encoding: 'utf-8' });
         const lines = output.trim().split('\n').slice(1);
         let totalFree = 0;
         for (const line of lines) {
@@ -184,7 +222,7 @@ export class RuntimeDiscovery {
         diskFreeGb = Math.round((totalFree / (1024 ** 3)) * 10) / 10;
       } else {
         // Unix: use df
-        const output = execSync('df -k .', { encoding: 'utf-8' });
+        const output = boundedExecFileSync('df', ['-k', '.'], 'quick', { encoding: 'utf-8', cwd: this.cwd });
         const lines = output.trim().split('\n');
         if (lines.length > 1) {
           const parts = lines[1].trim().split(/\s+/);
@@ -199,7 +237,7 @@ export class RuntimeDiscovery {
       memoryTotalGb = Math.round((totalMem / (1024 ** 3)) * 10) / 10;
       memoryAvailableGb = Math.round((freeMem / (1024 ** 3)) * 10) / 10;
     } catch (error) {
-      console.warn('Could not get resource info:', error.message);
+      if (!this.quiet) console.warn('Could not get resource info:', error.message);
     }
 
     return {
@@ -298,9 +336,9 @@ export class RuntimeDiscovery {
    * @see https://git.integrolabs.net/roctinam/aiwg/issues/820
    * @private
    */
-  async #discoverTools() {
+  #safeTools() {
     // Curated list: knownTools database + common dev tools safe to probe
-    const safeToProbe = new Set([
+    return new Set([
       // From knownTools database
       ...Object.keys(this.knownTools),
       // Aliases from knownTools
@@ -328,12 +366,13 @@ export class RuntimeDiscovery {
       'yq', 'fx', 'miller',
       'htop', 'ncdu', 'dust', 'procs', 'tokei',
     ]);
+  }
 
+  async #discoverTools(paths) {
     const available = [];
     const unavailable = [];
 
-    for (const name of safeToProbe) {
-      const toolPath = await this.#findToolPath(name);
+    for (const [name, toolPath] of paths) {
       if (!toolPath) {
         // Not installed — skip silently (not an error)
         continue;
@@ -359,19 +398,38 @@ export class RuntimeDiscovery {
   }
 
   /**
-   * Find tool path using which/where
+   * Search PATH first, then common user installation directories on Unix.
    * @private
    */
   async #findToolPath(toolName) {
     try {
       const cmd = platform() === 'win32' ? 'where' : 'which';
-      const path = execSync(`${cmd} ${toolName}`, { encoding: 'utf-8' })
+      const path = boundedExecFileSync(cmd, [toolName], 'quick', { encoding: 'utf-8' })
         .trim()
         .split('\n')[0];
       return path;
     } catch {
-      return null;
+      // Scheduled jobs often omit user installation directories from PATH.
+    }
+    if (platform() !== 'win32' && !toolName.includes('/') && !toolName.includes('\\')) {
+      const home = homedir();
+      const directories = new Set([
+        join(process.env.CARGO_HOME || join(home, '.cargo'), 'bin'),
+        join(home, '.local', 'bin'), join(home, 'bin'),
+        join(home, '.npm-global', 'bin'), join(home, 'go', 'bin'),
+        join(home, '.bun', 'bin'), join(home, '.deno', 'bin'),
+      ]);
+      for (const directory of directories) {
+        const candidate = join(directory, toolName);
+        try {
+          await access(candidate, constants.X_OK);
+          if ((await stat(candidate)).isFile()) return candidate;
+        } catch {
+          // Continue to the next user directory.
+        }
+      }
     }
+    return null;
   }
 
   /**
@@ -393,15 +451,11 @@ export class RuntimeDiscovery {
     // Bare `version` (positional) is intentionally excluded: it caused
     // BPF tools to attach tracepoints, input-leapc to connect to
     // hostname "version", and cs2cs to open a file named "version".
-    const versionCommands = [
-      `${toolPath} --version`,
-      `${toolPath} -v`,
-      `${toolPath} -V`
-    ];
+    const versionArgs = ['--version', '-v', '-V'];
 
-    for (const cmd of versionCommands) {
+    for (const arg of versionArgs) {
       try {
-        const output = execSync(cmd, {
+        const output = boundedExecFileSync(toolPath, [arg], 'quick', {
           encoding: 'utf-8',
           timeout: 3000,
           killSignal: 'SIGKILL',
@@ -503,7 +557,7 @@ export class RuntimeDiscovery {
     if (platform() === 'win32') return undefined;
 
     try {
-      const manPath = execSync(`man -w ${toolName}`, {
+      const manPath = boundedExecFileSync('man', ['-w', toolName], 'quick', {
         encoding: 'utf-8',
         stdio: ['ignore', 'pipe', 'ignore']
       }).trim();

package/dist/src/storage/backends/fs.js

@@ -9,14 +9,17 @@
  * @issue #934
  * @issue #956
  */
-import { existsSync } from 'fs';
-import { appendFile, mkdir, readFile, readdir, rm, stat, writeFile } from 'fs/promises';
-import { dirname, join, relative, resolve, sep } from 'path';
+import { resolve, sep } from 'path';
+import { pinContainedRoot, readContainedFile, writeContainedFile, appendContainedFile, deleteContainedFile, listContainedFiles } from '../../utils/contained-filesystem.mjs';
 export class FilesystemAdapter {
     /** Absolute path where this subsystem's content lives. */
     root;
+    store;
     constructor(root) {
         this.root = resolve(root);
+        this.store = pinContainedRoot(this.root, undefined, {
+            createMissing: true, protectLocationPointer: false, rejectLinkedWrites: true,
+        });
     }
     /**
      * Path traversal guard. Rejects `..`, leading `/`, leading `~`, and
@@ -46,89 +49,28 @@ export class FilesystemAdapter {
         return abs;
     }
     async read(path) {
-        const abs = this.resolveSafe(path);
-        if (!existsSync(abs))
-            return null;
-        return readFile(abs, 'utf-8');
+        this.resolveSafe(path);
+        return readContainedFile(await this.store, path);
     }
     async write(path, content, _meta) {
-        const abs = this.resolveSafe(path);
-        await mkdir(dirname(abs), { recursive: true });
-        await writeFile(abs, content, 'utf-8');
+        this.resolveSafe(path);
+        await writeContainedFile(await this.store, path, content);
     }
-    /**
-     * Atomic append. Uses fs.appendFile, which opens with O_APPEND so the
-     * kernel guarantees atomicity for writes ≤ PIPE_BUF (4096 bytes on
-     * Linux). Concurrent appenders interleave at line granularity rather
-     * than racing read-then-write. See #976.
-     */
+    /** Append through a verified O_APPEND handle, without read/replace races. */
     async append(path, content) {
-        const abs = this.resolveSafe(path);
-        await mkdir(dirname(abs), { recursive: true });
-        await appendFile(abs, content, 'utf-8');
+        this.resolveSafe(path);
+        await appendContainedFile(await this.store, path, content);
     }
     async list(prefix) {
-        // Empty prefix = list everything under root. A non-empty prefix
-        // restricts to entries whose subsystem-relative path starts with it
-        // (after path-normalizing the prefix itself).
-        if (typeof prefix !== 'string') {
+        if (typeof prefix !== 'string')
             throw new Error('storage(fs): list prefix must be a string');
-        }
-        if (prefix.length > 0) {
-            // resolveSafe also validates the prefix shape
+        if (prefix)
             this.resolveSafe(prefix);
-        }
-        if (!existsSync(this.root))
-            return [];
-        const out = [];
-        await walkInto(this.root, this.root, prefix, out);
-        return out;
+        return listContainedFiles(await this.store, prefix);
     }
     async delete(path) {
-        const abs = this.resolveSafe(path);
-        if (!existsSync(abs))
-            return;
-        await rm(abs, { force: true });
-    }
-}
-async function walkInto(root, dir, prefix, out) {
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    for (const e of entries) {
-        const full = join(dir, e.name);
-        const rel = relative(root, full).split(sep).join('/');
-        if (e.isDirectory()) {
-            // Descend if the dir could contain matches
-            if (prefix === '' || rel.startsWith(prefix) || prefix.startsWith(rel + '/')) {
-                await walkInto(root, full, prefix, out);
-            }
-            continue;
-        }
-        if (!e.isFile())
-            continue;
-        if (prefix !== '' && !rel.startsWith(prefix))
-            continue;
-        let size;
-        let modifiedAt;
-        try {
-            const s = await stat(full);
-            size = s.size;
-            modifiedAt = s.mtime;
-        }
-        catch {
-            // ignore stat failures
-        }
-        const entry = { path: rel };
-        if (size !== undefined)
-            entry.size = size;
-        if (modifiedAt !== undefined)
-            entry.modifiedAt = modifiedAt;
-        out.push(entry);
+        this.resolveSafe(path);
+        await deleteContainedFile(await this.store, path);
     }
 }
 //# sourceMappingURL=fs.js.map

package/dist/src/storage/backends/logseq.js

@@ -146,7 +146,7 @@ export class LogseqAdapter {
         }
         // Defensive: refuse to write `id::` block IDs ourselves. Logseq
         // auto-assigns them; if the caller smuggled one in, strip it.
-        body = body.replace(/^\s*id::\s*[^\n]+\n/gm, '');
+        body = stripBlockIds(body);
         await writeFile(abs, body, 'utf-8');
     }
     async list(prefix) {
@@ -221,6 +221,34 @@ function expandHome(p) {
     }
     return p;
 }
+function stripBlockIds(content) {
+    const chunks = [];
+    let start = 0;
+    while (start < content.length) {
+        let property = start;
+        while (property < content.length && /\s/u.test(content[property]))
+            property++;
+        if (content.startsWith('id::', property)) {
+            // Only the property's own line belongs to the block ID.
+            let end = property + 4;
+            while (end < content.length && !/[\n\r\u2028\u2029]/u.test(content[end]))
+                end++;
+            if (content[end] === '\r' && content[end + 1] === '\n')
+                end++;
+            start = end < content.length ? end + 1 : content.length;
+            continue;
+        }
+        // Keep the original line and any preceding blank lines verbatim.
+        let end = property;
+        while (end < content.length && !/[\n\r\u2028\u2029]/u.test(content[end]))
+            end++;
+        if (end < content.length)
+            end++;
+        chunks.push(content.slice(start, end));
+        start = end;
+    }
+    return chunks.join('');
+}
 /**
  * If `content` starts with a `---` YAML block, parse the block and
  * return the parsed fields plus the body without the YAML. Otherwise
@@ -230,18 +258,51 @@ function expandHome(p) {
  * Anything more complex falls back to dropping the value as a string.
  */
 function extractYamlFrontmatter(content) {
-    const match = /^---\s*\r?\n([\s\S]*?)\r?\n---\s*\r?\n?([\s\S]*)$/.exec(content);
-    if (!match)
+    if (!content.startsWith('---'))
+        return null;
+    let openingEnd = 3;
+    let firstNewline = -1;
+    let lastNewline = -1;
+    while (openingEnd < content.length && /\s/u.test(content[openingEnd])) {
+        if (content[openingEnd] === '\n') {
+            if (firstNewline < 0)
+                firstNewline = openingEnd;
+            lastNewline = openingEnd;
+        }
+        openingEnd++;
+    }
+    if (firstNewline < 0)
         return null;
-    const [, yamlBody, body] = match;
+    let yamlStart = lastNewline + 1;
+    let closing = content.indexOf('\n---', yamlStart);
+    if (closing < 0) {
+        closing = content.indexOf('\n---', firstNewline + 1);
+        if (closing < 0)
+            return null;
+        yamlStart = firstNewline + 1;
+        for (let index = yamlStart; index < closing; index++) {
+            if (content[index] === '\n')
+                yamlStart = index + 1;
+        }
+    }
+    const yamlBody = content.slice(yamlStart, content[closing - 1] === '\r' ? closing - 1 : closing);
+    let bodyStart = closing + 4;
+    while (bodyStart < content.length && /\s/u.test(content[bodyStart]))
+        bodyStart++;
+    const body = content.slice(bodyStart);
     const fields = {};
     for (const line of yamlBody.split(/\r?\n/)) {
         if (line.trim().length === 0 || line.trim().startsWith('#'))
             continue;
-        const m = /^([A-Za-z_][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line);
-        if (!m)
+        const separator = line.indexOf(':');
+        if (separator < 0)
+            continue;
+        const k = line.slice(0, separator).trimEnd();
+        if (!/^[A-Za-z_][A-Za-z0-9_-]*$/.test(k))
+            continue;
+        const rawV = line.slice(separator + 1).trimStart();
+        if (/[\r\u2028\u2029]/u.test(rawV))
             continue;
-        const [, k, rawV] = m;
         fields[k] = parseYamlScalar(rawV.trim());
     }
     return { fields, body };

package/dist/src/storage/backends/obsidian.js

@@ -96,6 +96,7 @@ export class ObsidianAdapter {
             execSync('obsidian --version', {
                 stdio: ['ignore', 'pipe', 'pipe'],
                 timeout: 2000,
+                killSignal: 'SIGKILL',
             });
         }
         catch {

package/dist/src/storage/fortemi-qualification-receipt.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { link, mkdir, unlink, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
-import { execFileSync } from "node:child_process";
+import { boundedExecFileSync } from "../process/bounded-child-process.mjs";
 export const FORTEMI_QUALIFICATION_RECEIPT = "aiwg.fortemi-live-qualification-receipt/v1";
 const DIGEST = /^sha256:[0-9a-f]{64}$/;
 const COMMIT = /^[0-9a-f]{40}$/;
@@ -23,7 +23,7 @@ function hasCompleteOperationInventory(operations) {
         names.every((name) => REQUIRED_OPERATIONS.has(name)));
 }
 export function resolveFortemiQualificationSource(env = process.env, cwd = process.cwd()) {
-    const git = (...args) => execFileSync("git", args, {
+    const git = (...args) => boundedExecFileSync("git", args, 'quick', {
         cwd,
         encoding: "utf8",
         stdio: ["ignore", "pipe", "ignore"],