aos-harness 0.7.1 → 0.8.0

package/README.md

@@ -19,6 +19,13 @@ npm i -g aos-harness
 
 ### 2. Install an adapter
 
+Install the vendor CLI you want to drive first, then install the matching AOS adapter package. The adapter is the AOS integration layer on top of the vendor CLI:
+
+- `claude` + `@aos-harness/claude-code-adapter`
+- `codex` + `@aos-harness/codex-adapter`
+- `gemini` + `@aos-harness/gemini-adapter`
+- `pi` + `@aos-harness/pi-adapter`
+
 Pick the AI CLI you'll drive agents with and install the matching adapter. You can install more than one. Versions are lockstep — pin the adapter to the same version as the CLI.
 
 ```bash
@@ -34,6 +41,12 @@ npm i -g @aos-harness/pi-adapter             # Pi (https://pi.dev)
 # Initialize a project (writes .aos/ and copies core/ into the project)
 aos init
 
+# Or scan only in CI / automation
+aos init --non-interactive
+
+# Or install missing adapter packages after config generation
+aos init --apply
+
 # Run a strategic deliberation
 aos run strategic-council --brief brief.md
 
@@ -58,7 +71,7 @@ aos validate
 | 0 | Success |
 | 1 | Uncaught runtime error |
 | 2 | Invalid input (unknown adapter, bad path, bad URL, missing adapter package) |
-| 3 | Profile tool-policy error (malformed `tools:` block, flag cannot widen profile) |
+| 3 | Validation failure that requires user action (`aos init --non-interactive --adapter ...` selected adapter not ready, or profile tool-policy widening failure) |
 
 ## What It Does
 

package/package.json

@@ -1,9 +1,11 @@
 {
   "name": "aos-harness",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Agentic Orchestration System — assemble AI agents into deliberation and execution teams",
   "license": "MIT",
-  "publishConfig": { "access": "public" },
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/aos-engineer/aos-harness.git"
@@ -36,24 +38,35 @@
     "test": "bun run src/index.ts validate"
   },
   "dependencies": {
-    "@aos-harness/adapter-shared": "0.7.1",
-    "@aos-harness/runtime": "0.7.1",
+    "@aos-harness/adapter-shared": "0.8.0",
+    "@aos-harness/runtime": "0.8.0",
+    "@clack/prompts": "^1.2.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "js-yaml": "^4.1.0"
+    "js-yaml": "^4.1.0",
+    "yaml": "^2.8.3"
   },
   "peerDependencies": {
-    "@aos-harness/claude-code-adapter": ">=0.6.0 <1.0.0",
-    "@aos-harness/codex-adapter": ">=0.6.0 <1.0.0",
-    "@aos-harness/gemini-adapter": ">=0.6.0 <1.0.0",
-    "@aos-harness/pi-adapter": ">=0.6.0 <1.0.0"
+    "@aos-harness/claude-code-adapter": ">=0.8.0 <1.0.0",
+    "@aos-harness/codex-adapter": ">=0.8.0 <1.0.0",
+    "@aos-harness/gemini-adapter": ">=0.8.0 <1.0.0",
+    "@aos-harness/pi-adapter": ">=0.8.0 <1.0.0"
   },
   "peerDependenciesMeta": {
-    "@aos-harness/claude-code-adapter": { "optional": true },
-    "@aos-harness/codex-adapter": { "optional": true },
-    "@aos-harness/gemini-adapter": { "optional": true },
-    "@aos-harness/pi-adapter": { "optional": true }
+    "@aos-harness/claude-code-adapter": {
+      "optional": true
+    },
+    "@aos-harness/codex-adapter": {
+      "optional": true
+    },
+    "@aos-harness/gemini-adapter": {
+      "optional": true
+    },
+    "@aos-harness/pi-adapter": {
+      "optional": true
+    }
   },
   "devDependencies": {
+    "@types/bun": "^1.3.12",
     "@types/js-yaml": "^4.0.9",
     "typescript": "^5.4.0"
   }

package/src/aos-config.ts

@@ -0,0 +1,151 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import yaml from "js-yaml";
+import { readAdapterConfig } from "./adapter-config";
+import { ADAPTER_ALLOWLIST, type AdapterName, isValidAdapter } from "./utils";
+import type { InitModels } from "./init-types";
+
+export interface AosConfigV2 {
+  api_version?: string;
+  adapters?: {
+    enabled?: string[];
+    default?: string;
+  };
+  package_manager?: string;
+  models?: Partial<InitModels>;
+  editor?: string;
+  platform?: {
+    enabled?: boolean;
+    url?: string;
+  };
+}
+
+export interface AosConfigV1 {
+  adapter?: string;
+  models?: Partial<InitModels>;
+  editor?: string;
+  platform?: {
+    enabled?: boolean;
+    url?: string;
+  };
+}
+
+export type AosConfig = AosConfigV1 & AosConfigV2 & Record<string, unknown>;
+
+export interface AdapterResolution {
+  adapter: AdapterName;
+  source: "flag" | "config-v2" | "config-v1" | "adapter-yaml" | "default";
+}
+
+export function readAosConfig(root: string): AosConfig | null {
+  const path = join(root, ".aos", "config.yaml");
+  if (!existsSync(path)) return null;
+  const parsed = yaml.load(readFileSync(path, "utf-8"), { schema: yaml.JSON_SCHEMA }) as AosConfig | null;
+  if (!parsed || typeof parsed !== "object") return null;
+  return parsed;
+}
+
+export function isAosConfigV2(config: AosConfig | null): boolean {
+  return !!config && config.api_version === "aos/config/v2";
+}
+
+export function parseAdapterList(value: unknown): AdapterName[] {
+  if (typeof value !== "string") return [];
+  const seen = new Set<AdapterName>();
+  for (const raw of value.split(",")) {
+    const candidate = raw.trim();
+    if (isValidAdapter(candidate)) seen.add(candidate);
+  }
+  return [...seen];
+}
+
+export function getEnabledAdaptersFromConfig(config: AosConfig | null): AdapterName[] {
+  if (!config) return [];
+  if (isAosConfigV2(config)) {
+    const enabled = Array.isArray(config.adapters?.enabled) ? config.adapters?.enabled : [];
+    return enabled.filter((value): value is AdapterName => isValidAdapter(value));
+  }
+  return typeof config.adapter === "string" && isValidAdapter(config.adapter) ? [config.adapter] : [];
+}
+
+export function getDefaultAdapterFromConfig(config: AosConfig | null): AdapterName | null {
+  if (!config) return null;
+  if (isAosConfigV2(config)) {
+    if (typeof config.adapters?.default === "string" && isValidAdapter(config.adapters.default)) {
+      return config.adapters.default;
+    }
+    const enabled = getEnabledAdaptersFromConfig(config);
+    return enabled[0] ?? null;
+  }
+  return typeof config.adapter === "string" && isValidAdapter(config.adapter) ? config.adapter : null;
+}
+
+export function resolveAdapterSelection(root: string, flagAdapter?: string | boolean): AdapterResolution {
+  if (typeof flagAdapter === "string" && isValidAdapter(flagAdapter)) {
+    return { adapter: flagAdapter, source: "flag" };
+  }
+
+  const aosConfig = readAosConfig(root);
+  if (aosConfig) {
+    const v2Default = isAosConfigV2(aosConfig) ? getDefaultAdapterFromConfig(aosConfig) : null;
+    if (v2Default) return { adapter: v2Default, source: "config-v2" };
+
+    if (typeof aosConfig.adapter === "string" && isValidAdapter(aosConfig.adapter)) {
+      return { adapter: aosConfig.adapter, source: "config-v1" };
+    }
+  }
+
+  const adapterConfig = readAdapterConfig(root);
+  if (typeof adapterConfig?.platform === "string" && isValidAdapter(adapterConfig.platform)) {
+    return { adapter: adapterConfig.platform, source: "adapter-yaml" };
+  }
+
+  return { adapter: "pi", source: "default" };
+}
+
+export function getSelectedAdaptersForInit(root: string, flagAdapter?: string | boolean): AdapterName[] {
+  const explicit = parseAdapterList(flagAdapter);
+  if (explicit.length > 0) return explicit;
+
+  const config = readAosConfig(root);
+  const fromConfig = getEnabledAdaptersFromConfig(config);
+  if (fromConfig.length > 0) return fromConfig;
+
+  const adapterConfig = readAdapterConfig(root);
+  if (typeof adapterConfig?.platform === "string" && isValidAdapter(adapterConfig.platform)) {
+    return [adapterConfig.platform];
+  }
+
+  return [];
+}
+
+export function getPlatformUrlFromConfig(root: string): string | null {
+  const config = readAosConfig(root);
+  if (!config?.platform?.enabled) return null;
+  return typeof config.platform.url === "string" ? config.platform.url : null;
+}
+
+export const DEFAULT_INIT_MODELS: InitModels = {
+  economy: "anthropic/claude-haiku-4-5",
+  standard: "anthropic/claude-sonnet-4-6",
+  premium: "anthropic/claude-opus-4-6",
+};
+
+export function getInitModels(root: string): InitModels {
+  const config = readAosConfig(root);
+  const models = config?.models ?? {};
+  return {
+    economy: typeof models.economy === "string" ? models.economy : DEFAULT_INIT_MODELS.economy,
+    standard: typeof models.standard === "string" ? models.standard : DEFAULT_INIT_MODELS.standard,
+    premium: typeof models.premium === "string" ? models.premium : DEFAULT_INIT_MODELS.premium,
+  };
+}
+
+export function getInitEditor(root: string): string {
+  const config = readAosConfig(root);
+  return typeof config?.editor === "string" ? config.editor : "code";
+}
+
+export function listKnownAdapters(): readonly AdapterName[] {
+  return ADAPTER_ALLOWLIST;
+}

package/src/bridge-server.ts

@@ -6,11 +6,28 @@ export interface BridgeHandlers {
   end: (params: { closing_message: string }) => Promise<unknown>;
 }
 
+function parseListenTarget(target: string): { host: string; port: number } | { path: string } {
+  if (!target.startsWith("tcp://")) {
+    return { path: target };
+  }
+
+  const url = new URL(target);
+  const port = Number.parseInt(url.port, 10);
+  if (!url.hostname || Number.isNaN(port)) {
+    throw new Error(`Invalid bridge listen target: ${target}`);
+  }
+
+  return { host: url.hostname, port };
+}
+
 export async function startBridgeServer(
   socketPath: string,
   handlers: BridgeHandlers,
 ): Promise<() => Promise<void>> {
-  if (existsSync(socketPath)) unlinkSync(socketPath);
+  const listenTarget = parseListenTarget(socketPath);
+  const isUnixSocket = "path" in listenTarget;
+
+  if (isUnixSocket && existsSync(listenTarget.path)) unlinkSync(listenTarget.path);
 
   const open = new Set<Socket>();
 
@@ -43,12 +60,16 @@ export async function startBridgeServer(
 
   await new Promise<void>((resolve, reject) => {
     server.once("error", reject);
-    server.listen(socketPath, () => resolve());
+    if ("path" in listenTarget) {
+      server.listen(listenTarget.path, () => resolve());
+      return;
+    }
+    server.listen(listenTarget.port, listenTarget.host, () => resolve());
   });
 
   return async () => {
     for (const s of open) s.destroy();
     await new Promise<void>((resolve) => server.close(() => resolve()));
-    if (existsSync(socketPath)) unlinkSync(socketPath);
+    if (isUnixSocket && existsSync(listenTarget.path)) unlinkSync(listenTarget.path);
   };
 }

package/src/commands/init.ts

@@ -1,12 +1,20 @@
 /**
- * aos init — Initialize AOS configuration in the current project.
+ * aos init — Initialize or reconfigure AOS in the current project.
  */
 
 import { cpSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import yaml from "js-yaml";
 import { c, type ParsedArgs } from "../colors";
-import { ADAPTER_ALLOWLIST, getHarnessRoot, getPackageCoreDir, isValidAdapter } from "../utils";
+import { getHarnessRoot, getPackageCoreDir, isValidAdapter } from "../utils";
+import { getInitEditor, getInitModels, getSelectedAdaptersForInit, parseAdapterList } from "../aos-config";
+import { scanEnvironment } from "../env-scanner";
+import { mergeConfig, generateMemoryYaml } from "../init-config-writer";
+import { applyActions } from "../init-applier";
+import type { AdapterName } from "../utils";
+import type { ScanReport, WizardResult } from "../init-types";
+import { runWizard } from "../init-wizard";
 
 function readCliVersion(): string {
   try {
@@ -19,39 +27,75 @@ function readCliVersion(): string {
 }
 
 const HELP = `
-${c.bold("aos init")} — Initialize AOS in the current project
+${c.bold("aos init")} — Initialize or reconfigure AOS in the current project
 
 ${c.bold("USAGE")}
-  aos init [--adapter <adapter>] [--force]
+  aos init [--adapter <adapter>] [--force] [--apply] [--non-interactive] [--from-yaml <path>]
 
 ${c.bold("OPTIONS")}
-  --adapter <name>    Adapter to use: pi (default), claude-code, gemini, codex
-  --force             Reinitialize even if AOS is already set up (overwrites existing core configs)
+  --adapter <name>      Adapter to enable or validate: pi, claude-code, gemini, codex
+  --force               Reinitialize config files and recopy core/ if needed
+  --apply               Install missing AOS adapter packages after config generation
+  --non-interactive     Scan-only mode. Writes .aos/scan.json and validates selected adapters if provided
+  --from-yaml <path>    Read a prebuilt WizardResult YAML/JSON file and write config from it
 
 ${c.bold("DESCRIPTION")}
-  Creates an .aos/ configuration directory in the current project with
-  a default config.yaml. This is the first step to running AOS deliberations.
-
-${c.bold("EXAMPLES")}
-  aos init
-  aos init --adapter pi
-  aos init --adapter claude-code
+  Scans vendor CLI readiness, scans AOS adapter-package readiness, writes
+  .aos/config.yaml in v2 shape, and can optionally install missing adapter
+  packages. In non-interactive mode without a selected adapter, init is pure
+  scan/report and does not write config.
 `;
 
-function generateConfig(adapter: string): string {
-  return `# AOS Harness Configuration
-# Generated by: aos init
-# Adapter: ${adapter}
+function projectNameFromCwd(cwd: string): string {
+  return cwd.split("/").pop()?.toLowerCase().replace(/[^a-z0-9-]/g, "-") ?? "default";
+}
+
+function parseWizardResultFile(path: string): WizardResult {
+  const parsed = yaml.load(readFileSync(path, "utf-8"), { schema: yaml.JSON_SCHEMA }) as Partial<WizardResult> | null;
+  if (!parsed || typeof parsed !== "object") {
+    throw new Error("Malformed --from-yaml input: expected an object");
+  }
 
-adapter: ${adapter}
+  const enabledAdapters = Array.isArray(parsed.enabledAdapters)
+    ? parsed.enabledAdapters.filter((value): value is AdapterName => typeof value === "string" && isValidAdapter(value))
+    : [];
+  const defaultAdapter = typeof parsed.defaultAdapter === "string" && isValidAdapter(parsed.defaultAdapter)
+    ? parsed.defaultAdapter
+    : null;
 
-models:
-  economy: anthropic/claude-haiku-4-5
-  standard: anthropic/claude-sonnet-4-6
-  premium: anthropic/claude-opus-4-6
+  if (enabledAdapters.length === 0 || !defaultAdapter || !enabledAdapters.includes(defaultAdapter)) {
+    throw new Error("Malformed --from-yaml input: enabledAdapters/defaultAdapter are invalid");
+  }
 
-editor: code
-`;
+  return {
+    enabledAdapters,
+    defaultAdapter,
+    memory: {
+      provider: parsed.memory?.provider === "mempalace" ? "mempalace" : "expertise",
+    },
+    models: parsed.models ?? getInitModels(process.cwd()),
+    editor: typeof parsed.editor === "string" ? parsed.editor : getInitEditor(process.cwd()),
+    actions: Array.isArray(parsed.actions) ? parsed.actions : [],
+  };
+}
+
+function writeScanReport(aosDir: string, scan: ScanReport): string {
+  mkdirSync(aosDir, { recursive: true });
+  const scanPath = join(aosDir, "scan.json");
+  writeFileSync(scanPath, JSON.stringify(scan, null, 2), "utf-8");
+  return scanPath;
+}
+
+function printAdapterInstallHints(version: string): void {
+  console.log(`${c.bold("Next step: install an adapter")}
+  Adapters augment the AI CLI you already use. Install the AOS adapter package that matches it:
+
+    Claude Code:   ${c.cyan(`npm i -g @aos-harness/claude-code-adapter@${version}`)}
+    Gemini CLI:    ${c.cyan(`npm i -g @aos-harness/gemini-adapter@${version}`)}
+    Codex CLI:     ${c.cyan(`npm i -g @aos-harness/codex-adapter@${version}`)}
+    Pi:            ${c.cyan(`npm i -g @aos-harness/pi-adapter@${version}`)}
+
+  ${c.dim("Install one (or more) that matches the vendor CLI you already have.")}`);
 }
 
 export async function initCommand(args: ParsedArgs): Promise<void> {
@@ -60,39 +104,59 @@ export async function initCommand(args: ParsedArgs): Promise<void> {
     return;
   }
 
-  const adapter = (args.flags.adapter as string) || "pi";
-
-  if (!isValidAdapter(adapter)) {
-    console.error(c.red(`Invalid adapter: "${adapter}". Valid adapters: ${ADAPTER_ALLOWLIST.join(", ")}`));
-    process.exit(1);
-  }
-
   const cwd = process.cwd();
   const aosDir = join(cwd, ".aos");
   const configPath = join(aosDir, "config.yaml");
-
+  const memoryPath = join(aosDir, "memory.yaml");
   const force = !!args.flags.force;
-
-  if (existsSync(join(cwd, "core", "agents")) && !force) {
-    console.error(c.yellow("AOS project already exists in this directory."));
-    console.log(c.dim(`  Use "aos init --force" to reinitialize (overwrites existing core configs).`));
-    process.exit(1);
+  const apply = !!args.flags.apply;
+  const isInteractive = !!(process.stdin.isTTY && process.stdout.isTTY);
+  const fromYamlPath = typeof args.flags["from-yaml"] === "string" ? args.flags["from-yaml"] : null;
+  const explicitAdapters = parseAdapterList(args.flags.adapter);
+
+  if (!isInteractive && !args.flags["non-interactive"] && !fromYamlPath) {
+    console.error('Pass --from-yaml=<path> or --non-interactive');
+    process.exit(2);
   }
 
-  if (existsSync(configPath) && !force) {
-    console.log(c.yellow("AOS is already initialized in this project."));
-    console.log(c.dim(`  Config: ${configPath}`));
-    console.log(c.dim(`  Use "aos init --force" to reinitialize.`));
+  const scan = await scanEnvironment({ cwd });
+  const scanPath = writeScanReport(aosDir, scan);
+
+  if (args.flags["non-interactive"] && !fromYamlPath) {
+    const selected = explicitAdapters.length > 0 ? explicitAdapters : getSelectedAdaptersForInit(cwd, args.flags.adapter);
+    if (selected.length === 0) {
+      console.log(`${c.green("Scan complete.")} Report: ${c.cyan(scanPath)}`);
+      return;
+    }
+
+    const notReady = selected.filter((adapter) => scan.adapters[adapter].status !== "ready");
+    if (notReady.length > 0) {
+      console.error(c.red(`Selected adapters are not ready: ${notReady.join(", ")}`));
+      for (const adapter of notReady) {
+        console.error(c.dim(`  ${adapter}: ${scan.adapters[adapter].statusHint}`));
+      }
+      process.exit(3);
+    }
+
+    console.log(`${c.green("Selected adapters are ready.")} Report: ${c.cyan(scanPath)}`);
     return;
   }
 
-  // Create .aos directory
+  let wizardResult: WizardResult;
+  if (fromYamlPath) {
+    wizardResult = parseWizardResultFile(fromYamlPath);
+  } else {
+    wizardResult = await runWizard(scan, cwd, args.flags.adapter);
+  }
+
   mkdirSync(aosDir, { recursive: true });
+  writeFileSync(configPath, mergeConfig(cwd, wizardResult, scan.packageManager), "utf-8");
 
-  // Write config
-  writeFileSync(configPath, generateConfig(adapter), "utf-8");
+  const projectName = projectNameFromCwd(cwd);
+  if (!existsSync(memoryPath) || force) {
+    writeFileSync(memoryPath, generateMemoryYaml(projectName, wizardResult.memory.provider), "utf-8");
+  }
 
-  // Copy core configs if not already present (or --force)
   const destCore = join(cwd, "core");
   if (!existsSync(destCore) || force) {
     const sourceCore = getPackageCoreDir() ?? join(getHarnessRoot(), "core");
@@ -101,82 +165,31 @@ export async function initCommand(args: ParsedArgs): Promise<void> {
       console.log(c.green("  Copied core configs (agents, profiles, domains, workflows, skills)"));
     } else {
       console.log(c.yellow("  Warning: Could not find core configs to copy."));
-      console.log(c.dim(`  You may need to manually copy the core/ directory from the AOS Harness repository.`));
     }
   }
 
-  const projectName = cwd.split("/").pop()?.toLowerCase().replace(/[^a-z0-9-]/g, "-") ?? "default";
-
-  const memoryYaml = `# AOS Memory Configuration
-# Generated by: aos init
-api_version: aos/memory/v1
-
-# Memory provider: "mempalace" (recommended) or "expertise" (built-in fallback)
-provider: expertise
-
-# MemPalace settings (used when provider: mempalace)
-# mempalace:
-#   palace_path: ~/.mempalace/palace
-#   project_wing: ${projectName}
-#   wake_layers: [L0, L1]
-#   auto_hall: true
-#   max_wake_tokens: 1200
-#   max_drawer_tokens: 500
-
-# Built-in expertise settings (used when provider: expertise)
-expertise:
-  max_lines: 200
-  scope: per-project
-
-# Orchestrator memory behavior
-orchestrator:
-  remember_prompt: session_end
-  recall_gate: true
-  max_recall_per_session: 10
-`;
-
-  const memoryPath = join(aosDir, "memory.yaml");
-  if (!existsSync(memoryPath) || force) {
-    writeFileSync(memoryPath, memoryYaml);
-    console.log(c.dim(`  Memory config: ${memoryPath}`));
-  }
-
   console.log(`
 ${c.green("AOS initialized successfully!")}
 
 ${c.bold("Configuration")}
   Directory: ${c.cyan(aosDir)}
   Config:    ${c.cyan(configPath)}
-  Adapter:   ${c.cyan(adapter)}
-
-${c.bold("Getting Started")}
-  1. Write a brief describing your strategic problem
-     ${c.dim("See core/briefs/sample-product-decision/brief.md for an example")}
-
-  2. Run a deliberation session:
-     ${c.cyan("aos run strategic-council --brief path/to/your/brief.md")}
-
-  3. Or list available profiles and agents:
-     ${c.cyan("aos list")}
-
-${c.bold("Customization")}
-  Create custom agents:   ${c.cyan("aos create agent <name>")}
-  Create custom profiles: ${c.cyan("aos create profile <name>")}
-  Create domain packs:    ${c.cyan("aos create domain <name>")}
-  Validate everything:    ${c.cyan("aos validate")}
+  Adapter:   ${c.cyan(wizardResult.defaultAdapter)}
+  Scan:      ${c.cyan(scanPath)}
 `);
 
-  // Adapter-install guidance. Starting in 0.6.0 the CLI no longer bundles
-  // adapter source — users must install the adapter(s) they want to use.
-  const v = readCliVersion();
-  console.log(`${c.bold("Next step: install an adapter")}
-  Adapters live as separate npm packages. Install the one(s) you'll use:
+  printAdapterInstallHints(readCliVersion());
 
-    Claude Code:   ${c.cyan(`npm i -g @aos-harness/claude-code-adapter@${v}`)}
-    Gemini CLI:    ${c.cyan(`npm i -g @aos-harness/gemini-adapter@${v}`)}
-    Codex CLI:     ${c.cyan(`npm i -g @aos-harness/codex-adapter@${v}`)}
-    Pi (pi.dev):   ${c.cyan(`npm i -g @aos-harness/pi-adapter@${v}`)}
-
-  ${c.dim("Pick one (or more). Then run `aos run`.")}
-`);
+  if (apply) {
+    const result = await applyActions(wizardResult.actions);
+    if (!result.ok) {
+      console.error(c.red(`Some installs failed: ${result.failures.join(", ")}`));
+      process.exit(1);
+    }
+  } else {
+    const installable = wizardResult.actions.filter((action) => action.type === "install-adapter");
+    if (installable.length > 0) {
+      console.log(c.dim(`Run "aos init --apply" to install missing adapter packages with ${scan.packageManager}.`));
+    }
+  }
 }

package/src/commands/run.ts

@@ -10,6 +10,7 @@ import type { TranscriptEntry } from "@aos-harness/runtime/types";
 import { runAdapterSession } from "../adapter-session";
 import { readAdapterConfig } from "../adapter-config";
 import { buildToolPolicy, type ToolPolicy } from "@aos-harness/adapter-shared";
+import { getPlatformUrlFromConfig, resolveAdapterSelection } from "../aos-config";
 
 function createEventBuffer(platformUrl: string, sessionId: string) {
   const buffer: TranscriptEntry[] = [];
@@ -273,8 +274,8 @@ export async function runCommand(args: ParsedArgs): Promise<void> {
     let workflowSection = "";
     if (isExecutionProfile && workflowConfig) {
       const stepSummary = workflowConfig.steps
-        .map((s: { id: string; name: string; action: string; review_gate?: boolean }) =>
-          `    ${s.id.padEnd(20)} ${s.name.padEnd(30)} ${s.action}${s.review_gate ? " [gate]" : ""}`
+        .map((s) =>
+          `    ${s.id.padEnd(20)} ${(s.name ?? s.id).padEnd(30)} ${s.action}${s.review_gate ? " [gate]" : ""}`
         )
         .join("\n");
       const gateCount = workflowConfig.gates?.length || 0;
@@ -348,20 +349,13 @@ ${c.bold(`AOS ${sessionType} Session`)}
   Output:   ${c.cyan(deliberationDir)}
 `);
 
-  // Determine adapter: --adapter flag > .aos/config.yaml > default "pi"
+  // 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;
-  const aosConfigPath = join(process.cwd(), ".aos", "config.yaml");
-  let adapter = "pi";
-  if (existsSync(aosConfigPath)) {
-    const yaml = await import("js-yaml");
-    const configText = await Bun.file(aosConfigPath).text();
-    const config = yaml.load(configText, { schema: yaml.JSON_SCHEMA }) as Record<string, unknown>;
-    adapter = (config.adapter as string) || "pi";
-    if (!platformUrl && config?.platform && (config.platform as Record<string, unknown>)?.enabled && (config.platform as Record<string, unknown>)?.url) {
-      platformUrl = (config.platform as Record<string, unknown>).url as string;
-    }
+  const { adapter } = resolveAdapterSelection(process.cwd(), args.flags["adapter"]);
+  if (!platformUrl) {
+    platformUrl = getPlatformUrlFromConfig(process.cwd());
   }
-  if (args.flags["adapter"]) adapter = args.flags["adapter"] as string;
 
   // Validate platform URL (spec D5). Fires for both --platform-url flag
   // and .aos/config.yaml platform.url after both sources are merged.