@aiwg/cli 2026.10.4 → 2026.10.6

package/tools/agents/providers/omp.mjs

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { createHash } from 'node:crypto';
 import YAML from 'yaml';
 import { importImpl } from '../../_resolve-impl.mjs';
-import { collectFrameworkArtifacts, getAddonFiles, isKernelSkill, listMdFiles, listSkillDirs, normalizeDeploymentMode, resolveAiwgRoot } from './base.mjs';
+import { withRuleDeployment, collectFrameworkArtifacts, getAddonFiles, isKernelSkill, listMdFiles, listSkillDirs, normalizeDeploymentMode, resolveAiwgRoot } from './base.mjs';
 export const name = 'omp';
 export const aliases = ['oh-my-pi'];
 export const paths = { agents: '.omp/agents', commands: '.omp/prompts', skills: '.agents/skills', rules: '.omp/rules' };
@@ -131,7 +131,7 @@ function deployType(files, target, opts, type, transform) {
 }
 export const deployAgents = (files, target, opts = {}) => deployType(files, target, opts, 'agents', transformAgent);
 export const deployCommands = (files, target, opts = {}) => deployType(files, target, opts, 'prompts', transformCommand);
-export const deployRules = (files, target, opts = {}) => deployType(files, target, opts, 'rules', transformRule);
+export const deployRules = (files, target, opts = {}) => opts.ruleDelivery ? 0 : deployType(files, target, opts, 'rules', transformRule);
 export function deploySkills(dirs, target, opts = {}) {
   let count = 0; const seen = new Map(); const root = roots(target, opts);
   for (const dir of [...new Set(dirs)]) {
@@ -223,10 +223,20 @@ export function deployExtensionBridge(target, opts = {}) {
   return writeOwned(path.join(roots(target, opts).native, 'extensions/aiwg-bridge.ts'), fs.readFileSync(src, 'utf8'), src, opts, 'omp-extension');
 }
 export async function postDeploy(target, opts) {
-  if (opts.createAgentsMd || (!opts.commandsOnly && !opts.skillsOnly && !opts.rulesOnly)) createAgentsMd(target, opts.srcRoot, opts.dryRun);
+  if (opts.contextFiles !== false && (opts.createAgentsMd || (!opts.commandsOnly && !opts.skillsOnly && !opts.rulesOnly))) createAgentsMd(target, opts.srcRoot, opts.dryRun);
 }
 export const getFileExtension = () => '.md';
 export async function deploy(opts) {
+  return withRuleDeployment(opts, { name, paths, kernelSkillsPath }, async staged => {
+    let count = await deploySelected(staged);
+    for (const srcRoot of staged.additionalSources || []) {
+      count += await deploySelected({ ...staged, srcRoot });
+    }
+    return count;
+  });
+}
+
+async function deploySelected(opts) {
   const mode = normalizeDeploymentMode(opts.mode);
   const include = { includeAgents: true, includeCommands: opts.deployCommands || opts.commandsOnly, includeSkills: opts.deploySkills || opts.skillsOnly, includeRules: opts.deployRules || opts.rulesOnly };
   const directSource = ['agents', 'commands', 'skills', 'rules'].some(type => fs.existsSync(path.join(opts.srcRoot, type)));
@@ -251,7 +261,21 @@ export async function deploy(opts) {
   let count = 0;
   if (!opts.commandsOnly && !opts.skillsOnly && !opts.rulesOnly) count += deployAgents(selected('agents'), opts.target, opts);
   if (include.includeCommands && !opts.skillsOnly && !opts.rulesOnly) count += deployCommands(selected('commands'), opts.target, opts);
-  if (include.includeSkills && !opts.commandsOnly && !opts.rulesOnly) count += deploySkills(selected('skills'), opts.target, opts);
+  if (include.includeSkills && !opts.commandsOnly && !opts.rulesOnly) {
+    // Different frameworks may index same-named standard skills. With copying
+    // disabled they share only a stale-copy cleanup destination, not a native
+    // definition slot. Keep one cleanup pass; retain collision checks for every
+    // kernel skill and for explicitly copied standard skills.
+    const lazyNames = new Set();
+    const skills = selected('skills').filter(dir => {
+      if (opts.copyStandardSkills || isKernelSkill(dir)) return true;
+      const basename = path.basename(dir);
+      if (lazyNames.has(basename)) return false;
+      lazyNames.add(basename);
+      return true;
+    });
+    count += deploySkills(skills, opts.target, opts);
+  }
   if (include.includeRules && !opts.commandsOnly && !opts.skillsOnly) count += deployRules(selected('rules'), opts.target, opts);
   if (!opts.commandsOnly && !opts.skillsOnly && !opts.rulesOnly) count += deployExtensionBridge(opts.target, opts);
   await postDeploy(opts.target, opts); return count;

package/tools/agents/providers/opencode.mjs

@@ -23,7 +23,9 @@ const staticModelCatalog = _require('../../../agentic/code/providers/model-catal
 let fs;
 try { const gfs = _require('graceful-fs'); gfs.gracefulify(realFs); fs = realFs; } catch { fs = realFs; }
 import path from 'path';
+import { importImpl } from '../../_resolve-impl.mjs';
 import {
+  withRuleDeployment,
   ensureDir,
   listMdFiles,
   listMdFilesRecursive,
@@ -50,6 +52,7 @@ import {
   filterCommandsAgainstSkills,
   deploySoulCompanions
 } from './base.mjs';
+const { assertConfigDestination, writeConfigAtomic } = await importImpl(import.meta.url, 'mcp/config-file.mjs');
 const modelCatalog = loadRuntimeModelCatalog(staticModelCatalog);
 
 // ============================================================================
@@ -375,6 +378,7 @@ export function deploySkills(skillDirs, targetDir, opts) {
  * Deploy rules to .opencode/rule/
  */
 export function deployRules(ruleFiles, targetDir, opts) {
+  if (opts.ruleDelivery) return [];
   const destDir = path.join(targetDir, paths.rules);
   ensureDir(destDir, opts.dryRun);
   cleanupOldRuleFiles(destDir, opts);
@@ -394,9 +398,9 @@ export function deployRules(ruleFiles, targetDir, opts) {
  * Non-destructive: a malformed existing opencode.json is left untouched (warn,
  * skip) rather than overwritten.
  *
- * @returns {boolean} true if the config was changed (or would be, in dry-run)
+ * @returns {Promise<boolean>} true if the config was changed (or would be, in dry-run)
  */
-export function mergeOpenCodeInstructions(targetDir, opts = {}) {
+export async function mergeOpenCodeInstructions(targetDir, opts = {}) {
   const RULE_GLOB = `${paths.rules}*.md`; // .opencode/rule/*.md — opencode supports globs in instructions (verified in sst/opencode session/instruction.ts)
   // opencode auto-loads AGENTS.md/CLAUDE.md/CONTEXT.md but NOT AIWG.md, and the
   // generated AGENTS.md is a thin link-index that points to AIWG.md. The
@@ -407,6 +411,7 @@ export function mergeOpenCodeInstructions(targetDir, opts = {}) {
   const AIWG = 'AIWG.md';
   const wanted = [RULE_GLOB, AGENTS, AIWG];
   const configPath = path.join(targetDir, 'opencode.json');
+  await assertConfigDestination(configPath, targetDir);
 
   let config = {};
   if (fs.existsSync(configPath)) {
@@ -433,7 +438,7 @@ export function mergeOpenCodeInstructions(targetDir, opts = {}) {
 
   // Preserve operator-authored entries; append only what's missing, deduped.
   config.instructions = [...existing, ...missing];
-  fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+  await writeConfigAtomic(configPath, `${JSON.stringify(config, null, 2)}\n`, { projectRoot: targetDir });
   if (opts.verbose) {
     console.log(`Wired ${missing.length} entr${missing.length === 1 ? 'y' : 'ies'} into opencode.json instructions[]: ${missing.join(', ')}`);
   }
@@ -503,7 +508,7 @@ export async function postDeploy(targetDir, opts) {
   initializeFrameworkWorkspace(targetDir, opts.mode, opts.dryRun, opts.srcRoot);
 
   if (opts.createAgentsMd) {
-    createAgentsMd(targetDir, opts.srcRoot, opts.dryRun);
+    if (opts.contextFiles !== false) createAgentsMd(targetDir, opts.srcRoot, opts.dryRun);
   }
 
   // PUW-035 (#1136): emit SDLC primary roles as TUI modes.
@@ -527,6 +532,10 @@ export function getFileExtension(type) {
 // ============================================================================
 
 export async function deploy(opts) {
+  return withRuleDeployment(opts, { name, paths, kernelSkillsPath }, deploySelected);
+}
+
+async function deploySelected(opts) {
   const {
     srcRoot,
     target,
@@ -637,7 +646,7 @@ export async function deploy(opts) {
     // #1548: rules on disk are inert unless referenced from opencode.json
     // instructions[]. Wire them so opencode actually loads them.
     try {
-      mergeOpenCodeInstructions(target, opts);
+      await mergeOpenCodeInstructions(target, opts);
     } catch (err) {
       console.warn(`Warning: could not wire opencode.json instructions[]: ${err && err.message ? err.message : err}`);
     }

package/tools/agents/providers/openhuman.mjs

@@ -173,7 +173,7 @@ export async function postDeploy(targetDir, opts) {
     opts.createAgentsMd ||
     (!opts.commandsOnly && !opts.skillsOnly && !opts.rulesOnly)
   ) {
-    createAgentsMd(targetDir, opts.srcRoot, opts.dryRun);
+    if (opts.contextFiles !== false) createAgentsMd(targetDir, opts.srcRoot, opts.dryRun);
   }
 }
 

package/tools/agents/providers/pi.mjs

@@ -128,7 +128,7 @@ export function createAgentsMd(target, srcRoot, dryRun) {
 
 export async function postDeploy(targetDir, opts) {
   if (opts.createAgentsMd || (!opts.commandsOnly && !opts.skillsOnly && !opts.rulesOnly)) {
-    createAgentsMd(targetDir, opts.srcRoot, opts.dryRun);
+    if (opts.contextFiles !== false) createAgentsMd(targetDir, opts.srcRoot, opts.dryRun);
   }
   if (!opts.quiet && (opts.deployCommands || opts.deploySkills || opts.commandsOnly || opts.skillsOnly)) {
     console.log('Pi project resources are trust-gated; approve the project with `/trust` (restart required) or use `pi --approve` for a reviewed one-shot run.');

package/tools/agents/providers/provider-prepare-coordinator.mjs

@@ -81,6 +81,10 @@ function prepareInChild({ job, attempt, sessionRoot, poolDescriptor, workerPath,
     let outcome;
     let killTimer;
     let timedOut = false;
+    let exited = false;
+    let disconnected = false;
+    let exitCode;
+    let exitSignal;
     const finish = () => {
       if (settled) return;
       settled = true;
@@ -107,19 +111,30 @@ function prepareInChild({ job, attempt, sessionRoot, poolDescriptor, workerPath,
     timer.unref?.();
     child.once('error', error => {
       // A spawn failure has no operating-system child to reap. Every error
-      // after a pid is assigned still waits for the exit event below.
+      // after a pid is assigned still waits for exit and IPC disconnect below.
       if (!child.pid) { outcome = { error }; finish(); }
       else stop(error);
     });
-    // Settle only after the operating system reports process exit. This keeps
-    // every worker in activeChildren until it is confirmed gone, including workers
-    // that send a response and retain an unexpected live handle.
-    child.once('exit', (code, signal) => {
-      if (outcome?.value && (code !== 0 || signal)) {
-        outcome = { error: new Error(`Provider preparation worker exited ${signal || code || 'without status'} after responding for ${job.provider}`) };
+    // Exit confirms termination; disconnect confirms pending IPC messages have
+    // drained. Either event can arrive first. Keep workers active until both,
+    // including workers that respond and retain an unexpected live handle.
+    const finishAfterDisconnectAndExit = () => {
+      if (!exited || !disconnected) return;
+      if (outcome?.value && (exitCode !== 0 || exitSignal)) {
+        outcome = { error: new Error(`Provider preparation worker exited ${exitSignal || exitCode || 'without status'} after responding for ${job.provider}`) };
       }
-      if (!outcome) outcome = { error: new Error(`${timedOut ? 'Provider preparation timed out' : `Provider preparation worker exited ${code ?? 'without status'}`} for ${job.provider}${stderrBytes ? `: ${Buffer.concat(stderr).toString('utf8').trim()}` : ''}`) };
+      if (!outcome) outcome = { error: new Error(`${timedOut ? 'Provider preparation timed out' : `Provider preparation worker exited ${exitCode ?? 'without status'}`} for ${job.provider}${stderrBytes ? `: ${Buffer.concat(stderr).toString('utf8').trim()}` : ''}`) };
       finish();
+    };
+    child.once('exit', (code, signal) => {
+      exited = true;
+      exitCode = code;
+      exitSignal = signal;
+      finishAfterDisconnectAndExit();
+    });
+    child.once('disconnect', () => {
+      disconnected = true;
+      finishAfterDisconnectAndExit();
     });
     child.once('message', response => {
       try {
@@ -137,7 +152,7 @@ function prepareInChild({ job, attempt, sessionRoot, poolDescriptor, workerPath,
         if (response.type !== 'prepared') throw new Error('Invalid provider preparation worker response type');
         outcome = { value: { detached: readPlan(response, expectedPlan), scratch, attempt } };
         // Closing the IPC channel lets the single-request worker exit normally;
-        // the exit handler above confirms termination before exposing its plan.
+        // the exit/disconnect handlers confirm termination and IPC drainage.
         if (child.connected) { try { child.disconnect(); } catch {} }
       } catch (error) { stop(error); }
     });
@@ -200,6 +215,10 @@ export async function prepareProviderDeployments({
     removeSession();
   };
   const prepareOne = async (index, attempt = 0) => {
+    // Never start a worker once the session is closed: it would outlive
+    // cleanup, and anything it writes (e.g. the shared binding-index cache)
+    // would land after its owner removed it.
+    if (closed) throw new Error('Provider preparation session is closed');
     const raw = await prepareInChild({ job: jobs[index], attempt, sessionRoot, poolDescriptor, workerPath, workerEnv, activeChildren, timeoutMs });
     const plan = transaction.adopt(raw.detached, {
       scratch: raw.scratch,
@@ -212,6 +231,7 @@ export async function prepareProviderDeployments({
   try {
     await Promise.all(Array.from({ length: concurrency }, async () => {
       for (;;) {
+        if (closed) return;
         const index = next++;
         if (index >= jobs.length) return;
         prepared[index] = await prepareOne(index);