aos-harness 0.8.3 → 0.8.5

package/core/profiles/strategic-council/profile.yaml

@@ -58,7 +58,7 @@ constraints:
     max: 8
 
 error_handling:
-  agent_timeout_seconds: 120
+  agent_timeout_seconds: 3600           # Strategic deliberations can legitimately run 2-60 minutes per agent turn
   retry_policy:
     max_retries: 2
     backoff: exponential

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aos-harness",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "description": "Agentic Orchestration System — assemble AI agents into deliberation and execution teams",
   "license": "MIT",
   "publishConfig": {
@@ -38,18 +38,18 @@
     "test": "bun run src/index.ts validate"
   },
   "dependencies": {
-    "@aos-harness/adapter-shared": "0.8.3",
-    "@aos-harness/runtime": "0.8.3",
+    "@aos-harness/adapter-shared": "0.8.5",
+    "@aos-harness/runtime": "0.8.5",
     "@clack/prompts": "^1.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "js-yaml": "^4.1.0",
     "yaml": "^2.8.3"
   },
   "peerDependencies": {
-    "@aos-harness/claude-code-adapter": ">=0.8.3 <1.0.0",
-    "@aos-harness/codex-adapter": ">=0.8.3 <1.0.0",
-    "@aos-harness/gemini-adapter": ">=0.8.3 <1.0.0",
-    "@aos-harness/pi-adapter": ">=0.8.3 <1.0.0"
+    "@aos-harness/claude-code-adapter": ">=0.8.5 <1.0.0",
+    "@aos-harness/codex-adapter": ">=0.8.5 <1.0.0",
+    "@aos-harness/gemini-adapter": ">=0.8.5 <1.0.0",
+    "@aos-harness/pi-adapter": ">=0.8.5 <1.0.0"
   },
   "peerDependenciesMeta": {
     "@aos-harness/claude-code-adapter": {

package/src/adapter-session.ts

@@ -65,6 +65,37 @@ export interface AdapterSessionConfig {
    * also batched to `${platformUrl}/api/sessions/:id/events`.
    */
   platformUrl?: string;
+  agentTimeoutMs?: number;
+}
+
+function createStreamingPrinter() {
+  let printedLength = 0;
+  let printedAny = false;
+
+  return {
+    push(partial: string) {
+      if (partial.length <= printedLength) return;
+      const delta = partial.slice(printedLength);
+      printedLength = partial.length;
+      if (!delta) return;
+      printedAny = true;
+      process.stdout.write(delta);
+    },
+    flushFinal(text: string): boolean {
+      if (!printedAny) return false;
+      if (text.length > printedLength) {
+        process.stdout.write(text.slice(printedLength));
+        printedLength = text.length;
+      }
+      if (!text.endsWith("\n")) {
+        process.stdout.write("\n");
+      }
+      return true;
+    },
+    hasOutput() {
+      return printedAny;
+    },
+  };
 }
 
 const ADAPTER_MAP: Record<string, { package: string; className: string }> = {
@@ -479,16 +510,34 @@ export async function runAdapterSession(config: AdapterSessionConfig): Promise<v
           `Tool calls will stream as rounds complete. ` +
           `Bridge socket: ${sockPath}\n`,
       );
-      const response = await adapter.sendMessage(arbiterHandle, kickoff, {
-        extraArgs: mcpArgs,
-      });
+      const printer = createStreamingPrinter();
+      const startedAt = Date.now();
+      const heartbeat = setInterval(() => {
+        if (printer.hasOutput()) return;
+        const elapsedSeconds = Math.round((Date.now() - startedAt) / 1000);
+        console.error(
+          `[arbiter] waiting for ${config.platform} response... ${elapsedSeconds}s elapsed`,
+        );
+      }, 15000);
+      let response;
+      try {
+        response = await adapter.sendMessage(arbiterHandle, kickoff, {
+          extraArgs: mcpArgs,
+          onStream: (partial) => printer.push(partial),
+          timeoutMs: config.agentTimeoutMs,
+        });
+      } finally {
+        clearInterval(heartbeat);
+      }
       if ((response as any).status !== "success") {
         console.error(
           `\n[arbiter] call failed: status=${(response as any).status} ` +
             `error=${(response as any).error ?? "(none)"}`,
         );
       }
-      console.log("\n" + response.text);
+      if (!printer.flushFinal(response.text)) {
+        console.log("\n" + response.text);
+      }
     } finally {
       rl.close();
       await closeBridge();

package/src/commands/run.ts

@@ -2,7 +2,7 @@
  * aos run — Launch a deliberation or execution session.
  */
 
-import { existsSync, readdirSync, mkdirSync } from "node:fs";
+import { existsSync, readdirSync, mkdirSync, readFileSync } from "node:fs";
 import { join, resolve, basename } from "node:path";
 import { c, type ParsedArgs } from "../colors";
 import { getHarnessRoot, discoverDirs, promptSelect, getAdapterDir, ADAPTER_ALLOWLIST, isValidAdapter, validatePlatformUrl, parseAllowCodeExecutionFlag } from "../utils";
@@ -10,6 +10,7 @@ import { runAdapterSession } from "../adapter-session";
 import { buildToolPolicy, type ToolPolicy } from "@aos-harness/adapter-shared";
 import { getPlatformUrlFromConfig, getRuntimeAdapterModelConfig, resolveAdapterSelection } from "../aos-config";
 import { backfillAdapterDefaults } from "../config-migration";
+import { ADAPTER_METADATA, scanEnvironment } from "../env-scanner";
 
 const HELP = `
 ${c.bold("aos run")} — Run a deliberation or execution session
@@ -49,6 +50,63 @@ ${c.bold("EXAMPLES")}
   aos run  # interactive profile selection
 `;
 
+function readCliVersion(): string {
+  try {
+    const raw = readFileSync(join(import.meta.dir, "..", "..", "package.json"), "utf-8");
+    return (JSON.parse(raw) as { version?: string }).version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+
+function versionMismatchSeverity(cliVer: string, adapterVer?: string): "none" | "warn" {
+  if (!adapterVer) return "none";
+  const [cliMaj, cliMin] = cliVer.split(".").map(Number);
+  const [adaMaj, adaMin] = adapterVer.split(".").map(Number);
+  if (Number.isNaN(cliMaj) || Number.isNaN(adaMaj)) return "none";
+  if (cliMaj !== adaMaj) return "warn";
+  if (cliMin !== adaMin) return "warn";
+  return "none";
+}
+
+async function probeClaudeExternalApiKey(): Promise<{ ok: boolean; hint?: string }> {
+  const proc = Bun.spawn(["claude", "--print", "Reply with OK."], {
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  let timedOut = false;
+  const timeout = setTimeout(() => {
+    timedOut = true;
+    proc.kill();
+  }, 15000);
+
+  try {
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+    const combined = `${stdout}\n${stderr}`.trim();
+    if (timedOut) {
+      return { ok: true, hint: "Claude auth probe timed out; continuing without blocking launch." };
+    }
+    if (exitCode === 0) {
+      return { ok: true };
+    }
+    if (/invalid api key|fix external api key|api key/i.test(combined)) {
+      return {
+        ok: false,
+        hint: "Claude Code external API-key auth failed. Unset or refresh ANTHROPIC_API_KEY, or switch back to `claude login` auth before running AOS.",
+      };
+    }
+    return { ok: true, hint: combined ? `Claude auth probe returned: ${combined.split("\n")[0]}` : undefined };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
 export async function runCommand(args: ParsedArgs): Promise<void> {
   if (args.flags.help) {
     console.log(HELP);
@@ -224,7 +282,6 @@ export async function runCommand(args: ParsedArgs): Promise<void> {
 
   // ── Dry-run mode ─────────────────────────────────────────────
   if (args.flags["dry-run"]) {
-    const { readFileSync } = await import("node:fs");
     const briefContent = readFileSync(briefPath, "utf-8");
     const briefSections = briefContent.match(/^##\s+.+/gm) || [];
 
@@ -301,22 +358,6 @@ ${c.green("All configuration validated successfully. Ready to launch.")}
     process.exit(0);
   }
 
-  // ── Set up deliberation directory for artifact storage ──────
-  const sessionId = `${new Date().toISOString().slice(0, 10)}-${profileName}-${Date.now().toString(36)}`;
-  const deliberationDir = join(root, ".aos", "sessions", sessionId);
-  mkdirSync(deliberationDir, { recursive: true });
-
-  // ── Launch adapter ───────────────────────────────────────────
-  const sessionType = isExecutionProfile ? "Execution" : "Deliberation";
-  console.log(`
-${c.bold(`AOS ${sessionType} Session`)}
-  Profile:  ${c.cyan(profileName!)}
-  Type:     ${isExecutionProfile ? c.magenta("execution") : c.cyan("deliberation")}${isExecutionProfile && workflowConfig ? `\n  Workflow: ${c.magenta(workflowConfig.id)} (${workflowConfig.steps.length} steps)` : ""}
-  Domain:   ${c.cyan(domainName || "none")}
-  Brief:    ${c.cyan(briefPath)}
-  Output:   ${c.cyan(deliberationDir)}
-`);
-
   // Determine adapter with shared precedence so init/run agree:
   // --adapter > config v2 > config v1 > .aos/adapter.yaml > default "pi"
   let platformUrl = (args.flags["platform-url"] as string) || null;
@@ -342,12 +383,69 @@ ${c.bold(`AOS ${sessionType} Session`)}
     process.exit(2);
   }
 
+  if (adapter !== "pi") {
+    const scan = await scanEnvironment({ cwd: process.cwd() });
+    const readiness = scan.adapters[adapter];
+    const meta = ADAPTER_METADATA[adapter];
+
+    if (readiness.status !== "ready") {
+      console.error(c.red(`${meta.label} is not ready for \`aos run\`.`));
+      console.error(c.red(`  ${readiness.statusHint}`));
+      if (scan.notes.length > 0) {
+        for (const note of scan.notes.filter((entry) => entry.startsWith(`${adapter}:`))) {
+          console.error(c.dim(`  ${note}`));
+        }
+      }
+      process.exit(2);
+    }
+
+    const cliVersion = readCliVersion();
+    if (versionMismatchSeverity(cliVersion, readiness.aosAdapter.version) === "warn") {
+      const installHint = readiness.aosAdapter.store === "bun"
+        ? `bun add -g ${meta.packageName}@${cliVersion}`
+        : `npm i -g ${meta.packageName}@${cliVersion}`;
+      console.error(c.yellow(`⚠ Version mismatch before launch: aos-harness@${cliVersion} and ${meta.packageName}@${readiness.aosAdapter.version}`));
+      console.error(c.dim(`  Install matching versions: ${installHint}`));
+    }
+
+    if (readiness.statusHint.includes("ANTHROPIC_API_KEY")) {
+      console.error(c.yellow(`⚠ ${readiness.statusHint}`));
+      if (adapter === "claude-code") {
+        const authProbe = await probeClaudeExternalApiKey();
+        if (!authProbe.ok) {
+          console.error(c.red(`Claude Code auth preflight failed.`));
+          console.error(c.red(`  ${authProbe.hint}`));
+          process.exit(2);
+        }
+        if (authProbe.hint) {
+          console.error(c.dim(`  ${authProbe.hint}`));
+        }
+      }
+    }
+  }
+
   const adapterName = adapter;
   // Resolve from monorepo dev layout (CLI's own import.meta.dir) or installed
   // @aos-harness/<name>-adapter. Project-local override is intentionally absent
   // (spec D1 — workspace-trust hardening).
   const resolvedAdapterDir = getAdapterDir(adapterName);
 
+  // ── Set up deliberation directory for artifact storage ──────
+  const sessionId = `${new Date().toISOString().slice(0, 10)}-${profileName}-${Date.now().toString(36)}`;
+  const deliberationDir = join(root, ".aos", "sessions", sessionId);
+  mkdirSync(deliberationDir, { recursive: true });
+
+  // ── Launch adapter ───────────────────────────────────────────
+  const sessionType = isExecutionProfile ? "Execution" : "Deliberation";
+  console.log(`
+${c.bold(`AOS ${sessionType} Session`)}
+  Profile:  ${c.cyan(profileName!)}
+  Type:     ${isExecutionProfile ? c.magenta("execution") : c.cyan("deliberation")}${isExecutionProfile && workflowConfig ? `\n  Workflow: ${c.magenta(workflowConfig.id)} (${workflowConfig.steps.length} steps)` : ""}
+  Domain:   ${c.cyan(domainName || "none")}
+  Brief:    ${c.cyan(briefPath)}
+  Output:   ${c.cyan(deliberationDir)}
+`);
+
   if (adapter === "pi") {
     const adapterEntry = resolvedAdapterDir ? join(resolvedAdapterDir, "src", "index.ts") : null;
     if (!adapterEntry || !existsSync(adapterEntry)) {
@@ -421,6 +519,10 @@ ${c.bold(`AOS ${sessionType} Session`)}
       useVendorDefaultModel: runtimeModelConfig.useVendorDefaultModel,
       toolPolicy,
       platformUrl: platformUrl ?? undefined,
+      agentTimeoutMs:
+        typeof profile.error_handling?.agent_timeout_seconds === "number"
+          ? profile.error_handling.agent_timeout_seconds * 1000
+          : undefined,
     });
   }
 }

package/src/env-scanner.ts

@@ -210,26 +210,42 @@ function scanAdapterPackage(
   const bunPath = bunGlobalDir ? join(bunGlobalDir, meta.packageName) : null;
   const npmPath = npmGlobalDir ? join(npmGlobalDir, meta.packageName) : null;
   const projectLocalPath = join(cwd, "node_modules", meta.packageName);
+  const resolvedFrom = resolveAdapterDir(adapter) ?? undefined;
+
+  if (resolvedFrom) {
+    let store: AosAdapterReadiness["store"] = "unknown";
+    if (resolvedFrom.includes("/adapters/")) {
+      store = "workspace";
+    } else if (bunPath && resolvedFrom.startsWith(bunPath)) {
+      store = "bun";
+    } else if (npmPath && resolvedFrom.startsWith(npmPath)) {
+      store = "npm";
+    }
+
+    return {
+      installed: true,
+      version: readPackageVersion(resolvedFrom),
+      store,
+      loadable: true,
+      resolvedFrom,
+    };
+  }
 
   if (bunPath && existsSync(bunPath)) {
-    const resolvedFrom = resolveAdapterDir(adapter) ?? undefined;
     return {
       installed: true,
       version: readPackageVersion(bunPath),
       store: "bun",
-      loadable: !!resolvedFrom,
-      resolvedFrom,
+      loadable: false,
     };
   }
 
   if (npmPath && existsSync(npmPath)) {
-    const resolvedFrom = resolveAdapterDir(adapter) ?? undefined;
     return {
       installed: true,
       version: readPackageVersion(npmPath),
       store: "npm",
-      loadable: !!resolvedFrom,
-      resolvedFrom,
+      loadable: false,
     };
   }
 
@@ -242,17 +258,6 @@ function scanAdapterPackage(
     };
   }
 
-  const resolvedFrom = resolveAdapterDir(adapter) ?? undefined;
-  if (resolvedFrom) {
-    return {
-      installed: true,
-      version: readPackageVersion(resolvedFrom),
-      store: resolvedFrom.includes("/adapters/") ? "workspace" : "unknown",
-      loadable: true,
-      resolvedFrom,
-    };
-  }
-
   return {
     installed: false,
     store: "unknown",