@aiwg/cli 2026.10.0 → 2026.10.3

package/dist/src/cli/handlers/runtime-info.js

@@ -12,6 +12,7 @@ import path from 'path';
 import { AiwgError, EXIT_CODES, handlerResultFromError } from '../errors.js';
 import { getPackageRoot } from '../../channel/manager.mjs';
 import { inspectInstallation } from '../../installation/manager.mjs';
+import { isSessionProviderResolution, resolveActiveProvider } from '../provider-resolution.js';
 function isMissingRuntimeCatalogError(error) {
     return error instanceof Error && error.message.includes('No catalog found');
 }
@@ -304,21 +305,35 @@ async function handleRuntimeInfo(args, cwd = process.cwd()) {
             console.log(`  Run mode:  ${installation.identity?.runMode ?? '(unrecorded)'}`);
             console.log(`  State:     ${installation.state}`);
             // Scheduler backend detection
-            const { execSync } = await import('child_process');
+            const { boundedExecFileSync } = await import('../../process/bounded-child-process.mjs');
             let schedulerBackend = 'external trigger required (system cron/systemd/CI)';
             let chronyInstalled = false;
-            try {
-                execSync('which chronyc 2>/dev/null || which chronyd 2>/dev/null', { stdio: 'pipe' });
-                chronyInstalled = true;
-            }
-            catch {
-                // chrony not found
+            for (const tool of ['chronyc', 'chronyd']) {
+                try {
+                    boundedExecFileSync('which', [tool], 'quick', { stdio: ['pipe', 'pipe', 'ignore'] });
+                    chronyInstalled = true;
+                    break;
+                }
+                catch {
+                    // Try the next chrony binary.
+                }
             }
             // Native CronCreate is only available when running inside a Claude Code agent context.
             // The CLI itself cannot call agent tools, so we report based on platform heuristics.
             // When invoked from within an agent, the schedule skill performs live detection.
-            const isClaudeCodeContext = process.env.CLAUDE_CODE_VERSION !== undefined ||
-                process.env.ANTHROPIC_API_KEY !== undefined;
+            //
+            // Resolved through the same shared provider-resolution path `steward
+            // capabilities` uses (`resolveActiveProvider` -> the `claude` provider's
+            // `detection.env` markers in provider-definitions.ts) so the two never
+            // disagree about which provider the current session is running under
+            // (#2623, #2627). The ad-hoc `CLAUDE_CODE_VERSION`/`ANTHROPIC_API_KEY`
+            // check this replaced was stale (neither is set by current Claude Code)
+            // and `ANTHROPIC_API_KEY` was a false positive for any non-Claude
+            // session with that key set.
+            const activeProviderResolution = await resolveActiveProvider({ cwd });
+            // Only a session signal counts: a project merely configured or deployed
+            // for Claude is not a Claude Code agent context.
+            const isClaudeCodeContext = activeProviderResolution.provider === 'claude' && isSessionProviderResolution(activeProviderResolution);
             if (isClaudeCodeContext) {
                 schedulerBackend = 'native-cron (CronCreate); external trigger outside agent sessions';
             }

package/dist/src/cli/handlers/script-runner.js

@@ -30,8 +30,8 @@ export class DefaultScriptRunner {
     async run(scriptPath, args = [], options = {}) {
         const fullPath = path.join(this.frameworkRoot, scriptPath);
         return new Promise((resolve) => {
-            // When capture mode is enabled, stdout/stderr are piped back to the
-            // caller so that quiet-mode callers can suppress output. When not
+            // When capture mode is enabled, stdout/stderr are piped so that
+            // quiet-mode callers can suppress output. When not
             // capturing, stdio: 'inherit' lets subprocess output flow directly to
             // the terminal (verbose mode).
             const stdio = options.capture ? 'pipe' : 'inherit';
@@ -40,10 +40,20 @@ export class DefaultScriptRunner {
                 cwd: options.cwd || process.cwd(),
                 env: { ...process.env, ...options.env },
             });
-            let capturedStderr = '';
+            // Always drain captured pipes, even after the diagnostic cap is reached.
+            // stdout is not part of HandlerResult; discard it. Retain only the first
+            // 1 MiB of stderr for failure messages, discarding any excess.
+            child.stdout?.resume();
+            const stderrLimit = 1024 * 1024;
+            const capturedStderr = [];
+            let capturedStderrBytes = 0;
             if (options.capture && child.stderr) {
                 child.stderr.on('data', (data) => {
-                    capturedStderr += data.toString();
+                    const retained = data.subarray(0, stderrLimit - capturedStderrBytes);
+                    if (retained.length > 0) {
+                        capturedStderr.push(Buffer.from(retained));
+                        capturedStderrBytes += retained.length;
+                    }
                 });
             }
             const timeout = options.timeout;
@@ -86,10 +96,10 @@ export class DefaultScriptRunner {
                 if (killEscalationId)
                     clearTimeout(killEscalationId);
                 // On failure in capture mode, surface the captured stderr
-                if (options.capture && code !== 0 && capturedStderr) {
+                if (options.capture && code !== 0 && capturedStderrBytes > 0) {
                     resolve({
                         exitCode: code ?? 1,
-                        message: capturedStderr.trim(),
+                        message: Buffer.concat(capturedStderr).toString().trim(),
                     });
                 }
                 else {