triad-plus 1.0.0

package/adapters/registry.mjs

@@ -0,0 +1,224 @@
+import { homedir } from 'node:os';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export const sharedSkillNames = [
+  'triad-loop-bootstrap',
+  'triad-loop-orchestrator',
+  'triad-loop-developer',
+  'triad-loop-evaluator',
+  'triad-loop-reviewer'
+];
+
+export const roleDefinitions = [
+  { id: 'orchestrator', label: 'Orchestrator', defaultEffort: 'medium', core: true },
+  { id: 'developer', label: 'Developer', defaultEffort: 'max', core: true },
+  { id: 'reviewer', label: 'Reviewer', defaultEffort: 'medium', core: true },
+  { id: 'evaluator', label: 'Evaluator+', defaultEffort: 'medium', core: false }
+];
+
+const regularRoles = roleDefinitions.filter((role) => role.core);
+
+function hostHome(...parts) {
+  return join(homedir(), ...parts);
+}
+
+function hermesProfileHome() {
+  if (process.env.HERMES_HOME) return process.env.HERMES_HOME;
+  const root = hostHome('.hermes');
+  try {
+    const profile = readFileSync(join(root, 'active_profile'), 'utf8').trim();
+    if (profile) return join(root, 'profiles', profile);
+  } catch {}
+  return root;
+}
+
+function projectRuntimeAssets(id) {
+  return [
+    { source: 'runtime', destination: '.triad-runtime' },
+    { source: 'schemas', destination: '.triad-runtime/schemas' },
+    { source: `adapters/${id}/runtime.json`, destination: '.triad-runtime/adapter.json', file: true }
+  ];
+}
+
+function sharedSkills(destination) {
+  return { source: 'shared-skills', destination };
+}
+
+function rolePaths(root, names, extension = '.md') {
+  return names.map((name) => join(root, 'agents', `${name}${extension}`));
+}
+
+const definitions = [
+  {
+    id: 'codex',
+    label: 'Codex',
+    binary: 'codex',
+    entry: '/prompts:triad',
+    lifecycle: { kind: 'SubagentStop', agentType: 'triad_developer', requiresAsync: true },
+    modelBinding: 'global-profiles',
+    globalEntry: true,
+    projectAssets: [
+      sharedSkills('.agents/skills'),
+      ...projectRuntimeAssets('codex')
+    ],
+    globalAssets: [
+      { source: 'adapters/codex/prompts/triad.md', destination: ({ codexHome }) => join(codexHome, 'prompts', 'triad.md'), file: true },
+      sharedSkills(({ codexHome }) => join(codexHome, 'skills'))
+    ],
+    projectPaths(controlRoot) {
+      return [
+        ...sharedSkillNames.map((name) => join(controlRoot, '.agents', 'skills', name)),
+        join(controlRoot, '.triad-runtime')
+      ];
+    },
+    globalPaths({ codexHome }) {
+      return [join(codexHome, 'prompts', 'triad.md'), ...sharedSkillNames.map((name) => join(codexHome, 'skills', name))];
+    },
+    roleModelPaths({ codexHome }) {
+      return roleDefinitions.map((role) => join(codexHome, 'agents', `triad_${role.id}.toml`));
+    }
+  },
+  {
+    id: 'opencode',
+    label: 'OpenCode',
+    binary: 'opencode',
+    entry: '/triad',
+    lifecycle: null,
+    modelBinding: 'project-frontmatter',
+    modelRoles: roleDefinitions.map((role) => role.id),
+    projectAssets: [
+      { source: 'adapters/opencode/.opencode/agents', destination: '.opencode/agents' },
+      { source: 'adapters/opencode/.opencode/commands/triad.md', destination: '.opencode/commands/triad.md', file: true },
+      sharedSkills('.opencode/skills'),
+      ...projectRuntimeAssets('opencode')
+    ],
+    globalAssets: [
+      { source: 'adapters/opencode/.opencode/agents', destination: () => hostHome('.config', 'opencode', 'agents') },
+      { source: 'adapters/opencode/.opencode/commands/triad.md', destination: () => hostHome('.config', 'opencode', 'commands', 'triad.md'), file: true },
+      sharedSkills(() => hostHome('.config', 'opencode', 'skills'))
+    ],
+    projectPaths(controlRoot) {
+      return [
+        ...rolePaths(join(controlRoot, '.opencode'), roleDefinitions.map((role) => `triad-${role.id}`)),
+        join(controlRoot, '.opencode', 'commands', 'triad.md'),
+        ...sharedSkillNames.map((name) => join(controlRoot, '.opencode', 'skills', name)),
+        join(controlRoot, '.triad-runtime')
+      ];
+    },
+    globalPaths() {
+      const root = hostHome('.config', 'opencode');
+      return [...rolePaths(root, roleDefinitions.map((role) => `triad-${role.id}`)), join(root, 'commands', 'triad.md'), ...sharedSkillNames.map((name) => join(root, 'skills', name))];
+    },
+    roleModelPaths(controlRoot) {
+      return roleDefinitions.map((role) => join(controlRoot, '.opencode', 'agents', `triad-${role.id}.md`));
+    }
+  },
+  {
+    id: 'claude-code',
+    label: 'Claude Code',
+    binary: 'claude',
+    entry: '/triad',
+    lifecycle: { kind: 'SubagentStop', agentType: 'triad-developer', requiresAsync: false },
+    modelBinding: 'project-frontmatter',
+    modelRoles: ['developer', 'reviewer', 'evaluator'],
+    projectAssets: [
+      { source: 'adapters/claude-code/.claude/agents', destination: '.claude/agents' },
+      { source: 'adapters/claude-code/.claude/commands/triad.md', destination: '.claude/commands/triad.md', file: true },
+      { source: 'integrations/claude-code/hooks.json', destination: '.claude/triad-hooks.json', file: true },
+      sharedSkills('.claude/skills'),
+      ...projectRuntimeAssets('claude-code')
+    ],
+    globalAssets: [
+      { source: 'adapters/claude-code/.claude/agents', destination: () => hostHome('.claude', 'agents') },
+      { source: 'adapters/claude-code/.claude/commands/triad.md', destination: () => hostHome('.claude', 'commands', 'triad.md'), file: true },
+      sharedSkills(() => hostHome('.claude', 'skills'))
+    ],
+    projectPaths(controlRoot) {
+      const root = join(controlRoot, '.claude');
+      return [
+        join(root, 'agents', 'triad-developer.md'),
+        join(root, 'agents', 'triad-reviewer.md'),
+        join(root, 'agents', 'triad-evaluator.md'),
+        join(root, 'commands', 'triad.md'),
+        join(root, 'triad-hooks.json'),
+        ...sharedSkillNames.map((name) => join(root, 'skills', name)),
+        join(controlRoot, '.triad-runtime')
+      ];
+    },
+    globalPaths() {
+      const root = hostHome('.claude');
+      return [
+        join(root, 'agents', 'triad-developer.md'), join(root, 'agents', 'triad-reviewer.md'), join(root, 'agents', 'triad-evaluator.md'),
+        join(root, 'commands', 'triad.md'), ...sharedSkillNames.map((name) => join(root, 'skills', name))
+      ];
+    },
+    roleModelPaths(controlRoot) {
+      return ['developer', 'reviewer', 'evaluator'].map((role) => join(controlRoot, '.claude', 'agents', `triad-${role}.md`));
+    }
+  },
+  {
+    id: 'antigravity',
+    label: 'Antigravity',
+    binary: 'agy',
+    entry: '/triad',
+    lifecycle: null,
+    modelBinding: 'team-record',
+    projectAssets: [
+      { source: 'adapters/antigravity/.agents/agents', destination: '.agents/agents' },
+      { source: 'adapters/antigravity/.agents/skills/triad', destination: '.agents/skills/triad' },
+      sharedSkills('.agents/skills'),
+      ...projectRuntimeAssets('antigravity')
+    ],
+    globalAssets: [
+      { source: 'adapters/antigravity/.agents/agents', destination: () => hostHome('.gemini', 'config', 'agents') },
+      { source: 'adapters/antigravity/.agents/skills/triad', destination: () => hostHome('.gemini', 'config', 'skills', 'triad') },
+      sharedSkills(() => hostHome('.gemini', 'config', 'skills'))
+    ],
+    projectPaths(controlRoot) {
+      const root = join(controlRoot, '.agents');
+      return [
+        ...roleDefinitions.map((role) => join(root, 'agents', `triad-${role.id}`, 'agent.md')),
+        join(root, 'skills', 'triad'), ...sharedSkillNames.map((name) => join(root, 'skills', name)), join(controlRoot, '.triad-runtime')
+      ];
+    },
+    globalPaths() {
+      const root = hostHome('.gemini', 'config');
+      return [...roleDefinitions.map((role) => join(root, 'agents', `triad-${role.id}`, 'agent.md')), join(root, 'skills', 'triad'), ...sharedSkillNames.map((name) => join(root, 'skills', name))];
+    }
+  },
+  {
+    id: 'hermes',
+    label: 'Hermes Agent',
+    binary: 'hermes',
+    binaryCandidates: ['hermes', join(homedir(), '.local', 'bin', 'hermes')],
+    entry: '/triad',
+    lifecycle: null,
+    modelBinding: 'team-record',
+    globalEntry: true,
+    projectAssets: [
+      ...projectRuntimeAssets('hermes')
+    ],
+    globalAssets: [
+      { source: 'adapters/hermes/skills/triad', destination: () => join(hermesProfileHome(), 'skills', 'triad') },
+      sharedSkills(() => join(hermesProfileHome(), 'skills'))
+    ],
+    projectPaths(controlRoot) {
+      return [join(controlRoot, '.triad-runtime')];
+    },
+    globalPaths() {
+      const root = join(hermesProfileHome(), 'skills');
+      return [join(root, 'triad'), ...sharedSkillNames.map((name) => join(root, name))];
+    }
+  }
+];
+
+export const adapterRegistry = new Map(definitions.map((adapter) => [adapter.id, adapter]));
+
+export function getAdapter(id) {
+  return adapterRegistry.get(id) ?? null;
+}
+
+export function listAdapters() {
+  return definitions;
+}

package/assets/triad-plus-engineering-loop-icon.svg

@@ -0,0 +1,16 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512" role="img" aria-labelledby="title desc">
+  <title id="title">Triad+ Engineering Loop</title>
+  <desc id="desc">Three role nodes form a directional loop around verified evidence.</desc>
+  <rect width="512" height="512" rx="112" fill="#0E172A"/>
+  <path d="M256 102A154 154 0 0 1 408 283" fill="none" stroke="#7C8CFF" stroke-width="20" stroke-linecap="round"/>
+  <path d="M256 102A154 154 0 0 1 408 283" fill="none" stroke="#35C3B1" stroke-width="20" stroke-linecap="round" transform="rotate(120 256 256)"/>
+  <path d="M256 102A154 154 0 0 1 408 283" fill="none" stroke="#F5B95E" stroke-width="20" stroke-linecap="round" transform="rotate(240 256 256)"/>
+  <path d="M406 293L401 269L419 273Z" fill="#7C8CFF"/>
+  <path d="M406 293L401 269L419 273Z" fill="#35C3B1" transform="rotate(120 256 256)"/>
+  <path d="M406 293L401 269L419 273Z" fill="#F5B95E" transform="rotate(240 256 256)"/>
+  <circle cx="357" cy="171" r="37" fill="#7C8CFF"/>
+  <circle cx="357" cy="171" r="37" fill="#35C3B1" transform="rotate(120 256 256)"/>
+  <circle cx="357" cy="171" r="37" fill="#F5B95E" transform="rotate(240 256 256)"/>
+  <circle cx="256" cy="256" r="74" fill="#16233E" stroke="#C8D2FF" stroke-width="10"/>
+  <path d="M222 256l23 24 49-55" fill="none" stroke="#FFFFFF" stroke-width="20" stroke-linecap="round" stroke-linejoin="round"/>
+</svg>

package/bin/triad-plus.js

@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+
+import { access, cp, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
+import { spawnSync } from 'node:child_process';
+import { homedir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { dirname, join, resolve } from 'node:path';
+import process from 'node:process';
+import { createInterface } from 'node:readline/promises';
+import { getAdapter, listAdapters, roleDefinitions, sharedSkillNames } from '../adapters/registry.mjs';
+
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+function usage(exitCode = 0) {
+  const stream = exitCode === 0 ? process.stdout : process.stderr;
+  stream.write(`Triad+ installer
+
+Usage:
+  npx triad-plus
+  npx triad-plus init --host <adapter-id> --control <path> [--global] [--team-config <path>] [--allow-product-repo]
+  npx triad-plus doctor --host <adapter-id> --control <path> [--hook-config <path>]
+
+Adapters: ${listAdapters().map((adapter) => adapter.id).join(', ')}
+
+The control path is a project-control workspace, not a product repository.
+Installation refuses every asset overwrite. Doctor is read-only.
+`);
+  process.exit(exitCode);
+}
+
+function parseArgs(args) {
+  const [command, ...rest] = args;
+  const options = { command, global: false, allowProductRepo: false };
+  for (let index = 0; index < rest.length; index += 1) {
+    const argument = rest[index];
+    if (argument === '--global') options.global = true;
+    else if (argument === '--allow-product-repo') options.allowProductRepo = true;
+    else if (['--host', '--control', '--team-config', '--hook-config'].includes(argument)) {
+      const value = rest[index + 1];
+      if (!value || value.startsWith('--')) throw new Error(`${argument} requires a value.`);
+      options[argument.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase())] = value;
+      index += 1;
+    } else if (argument === '--help' || argument === '-h') usage(0);
+    else throw new Error(`Unknown argument: ${argument}`);
+  }
+  return options;
+}
+
+async function exists(target) {
+  try { await access(target); return true; } catch { return false; }
+}
+
+async function requireDirectory(target) {
+  if (!(await exists(target))) return mkdir(target, { recursive: true });
+  if (!(await stat(target)).isDirectory()) throw new Error(`Control path is not a directory: ${target}`);
+}
+
+function codexHome() {
+  return process.env.CODEX_HOME || join(homedir(), '.codex');
+}
+
+function context(controlRoot) {
+  return { controlRoot, codexHome: codexHome() };
+}
+
+function resolveDestination(destination, root, installContext) {
+  const value = typeof destination === 'function' ? destination(installContext) : join(root, destination);
+  return resolve(value);
+}
+
+function sourcePath(source) {
+  return join(packageRoot, source);
+}
+
+function planForAssets(assets, root, installContext) {
+  const paths = [];
+  for (const asset of assets) {
+    const destination = resolveDestination(asset.destination, root, installContext);
+    if (asset.source === 'shared-skills') {
+      paths.push(...sharedSkillNames.map((name) => join(destination, name)));
+    } else {
+      paths.push(destination);
+    }
+  }
+  return paths;
+}
+
+async function copyAsset(asset, root, installContext) {
+  const destination = resolveDestination(asset.destination, root, installContext);
+  if (asset.source === 'shared-skills') {
+    await mkdir(destination, { recursive: true });
+    for (const name of sharedSkillNames) await cp(join(packageRoot, 'skills', name), join(destination, name), { recursive: true });
+    return;
+  }
+  await mkdir(dirname(destination), { recursive: true });
+  await cp(sourcePath(asset.source), destination, { recursive: !asset.file });
+}
+
+async function installAssets(assets, root, installContext) {
+  for (const asset of assets) await copyAsset(asset, root, installContext);
+}
+
+function teamConfigPath(controlRoot) {
+  return join(controlRoot, '.triad-plus', 'team.json');
+}
+
+async function loadTeamConfig(options) {
+  if (options.team) return options.team;
+  if (!options.teamConfig) return null;
+  let team;
+  try { team = JSON.parse(await readFile(resolve(options.teamConfig), 'utf8')); }
+  catch (error) { throw new Error(`Cannot read --team-config: ${error.message}`); }
+  if (team?.schema_version !== 1 || !team.interaction || !team.roles) throw new Error('--team-config must contain schema_version 1, interaction, and roles.');
+  for (const role of roleDefinitions) {
+    const value = team.roles[role.id];
+    if (!value || typeof value.displayName !== 'string' || ![null, undefined].includes(value.model) && typeof value.model !== 'string') {
+      throw new Error(`--team-config has an invalid ${role.id} role definition.`);
+    }
+  }
+  return team;
+}
+
+async function writeTeamConfig(controlRoot, team) {
+  const target = teamConfigPath(controlRoot);
+  await mkdir(dirname(target), { recursive: true });
+  await writeFile(target, `${JSON.stringify(team, null, 2)}\n`, 'utf8');
+}
+
+async function applyMarkdownModel(target, model) {
+  if (!model) return;
+  const source = await readFile(target, 'utf8');
+  if (!source.startsWith('---\n')) throw new Error(`Agent definition has no YAML frontmatter: ${target}`);
+  const closing = source.indexOf('\n---\n', 4);
+  if (closing === -1) throw new Error(`Agent definition has invalid YAML frontmatter: ${target}`);
+  const frontmatter = source.slice(4, closing).replace(/^model:\s*.*\n?/m, '');
+  await writeFile(target, `---\n${frontmatter}model: ${JSON.stringify(model)}${source.slice(closing)}`, 'utf8');
+}
+
+async function writeRoleProfiles(paths, team) {
+  await mkdir(dirname(paths[0]), { recursive: true });
+  for (const [index, role] of roleDefinitions.entries()) {
+    const configuration = team.roles[role.id];
+    const instructions = [
+      `Act as ${configuration.displayName}, the ${role.label} role in Triad+.`,
+      `Persona: ${configuration.persona || 'professional and role-focused'}.`,
+      'Read .triad-plus/team.json in the active project-control workspace before working.',
+      'Technical role IDs define authority; display names never change it.'
+    ].join('\n');
+    const profile = [
+      `name = ${JSON.stringify(`triad_${role.id}`)}`,
+      `description = ${JSON.stringify(`Triad+ ${role.label}: ${configuration.displayName}.`)}`,
+      ...(configuration.model ? [`model = ${JSON.stringify(configuration.model)}`] : []),
+      ...(configuration.reasoning_effort ? [`model_reasoning_effort = ${JSON.stringify(configuration.reasoning_effort)}`] : []),
+      `developer_instructions = ${JSON.stringify(instructions)}`,
+      ''
+    ].join('\n');
+    await writeFile(paths[index], profile, 'utf8');
+  }
+}
+
+async function applyTeamBinding(adapter, controlRoot, team, installContext) {
+  if (!team || adapter.modelBinding === 'team-record') return;
+  if (adapter.modelBinding === 'project-frontmatter') {
+    const paths = adapter.roleModelPaths(controlRoot, installContext);
+    const roles = (adapter.modelRoles ?? roleDefinitions.map((role) => role.id))
+      .map((roleId) => roleDefinitions.find((role) => role.id === roleId));
+    for (const [index, role] of roles.entries()) await applyMarkdownModel(paths[index], team.roles[role.id].model);
+    return;
+  }
+  if (adapter.modelBinding === 'global-profiles') {
+    await writeRoleProfiles(adapter.roleModelPaths(installContext), team);
+    return;
+  }
+  throw new Error(`Unknown model binding: ${adapter.modelBinding}`);
+}
+
+function productRepositoryAt(controlRoot) {
+  const git = spawnSync('git', ['-C', controlRoot, 'rev-parse', '--show-toplevel'], { encoding: 'utf8' });
+  if (git.status !== 0 || resolve(git.stdout.trim()) !== controlRoot) return false;
+  return ['package.json', 'pyproject.toml', 'Cargo.toml', 'pom.xml', 'go.mod', 'Gemfile']
+    .some((marker) => spawnSync('test', ['-e', join(controlRoot, marker)]).status === 0);
+}
+
+async function collisions(paths) {
+  const result = [];
+  for (const target of paths) if (await exists(target)) result.push(target);
+  return result;
+}
+
+function commandVersion(binary) {
+  const candidates = Array.isArray(binary) ? binary : [binary];
+  for (const candidate of candidates) {
+    const result = spawnSync(candidate, ['--version'], { encoding: 'utf8' });
+    if (result.status === 0) return String(result.stdout).trim().split('\n')[0];
+  }
+  return null;
+}
+
+async function collectTeamConfiguration(prompt, adapter) {
+  const language = (await prompt.question('Conversation language [English]: ')).trim() || 'English';
+  const ownerName = (await prompt.question('How should Triad+ address the project owner [Owner]: ')).trim() || 'Owner';
+  const communicationStyle = (await prompt.question('Preferred communication style [professional and concise]: ')).trim() || 'professional and concise';
+  const evaluatorEnabled = ['y', 'yes'].includes((await prompt.question('Configure optional post-run Evaluator+? [y/N]: ')).trim().toLowerCase());
+  const roles = {};
+  for (const role of roleDefinitions) {
+    const enabled = role.core || evaluatorEnabled;
+    const displayName = (await prompt.question(`${role.label} display name [${role.label}]: `)).trim() || role.label;
+    const persona = (await prompt.question(`${role.label} persona [professional and role-focused]: `)).trim() || 'professional and role-focused';
+    const model = (await prompt.question(`${role.label} model ID [host default]: `)).trim();
+    const reasoningEffort = model && adapter.modelBinding === 'global-profiles'
+      ? (await prompt.question(`${role.label} reasoning effort [${role.defaultEffort}]: `)).trim() || role.defaultEffort
+      : null;
+    roles[role.id] = { displayName, persona, model: model || null, reasoning_effort: reasoningEffort, enabled };
+  }
+  return { schema_version: 1, interaction: { language, owner_name: ownerName, communication_style: communicationStyle }, roles };
+}
+
+async function init(options) {
+  const adapter = getAdapter(options.host);
+  if (!adapter) throw new Error(`Choose --host ${listAdapters().map((item) => item.id).join(', ')}.`);
+  if (!options.control) throw new Error('Provide --control <project-control-path>.');
+  const team = await loadTeamConfig(options);
+  const controlRoot = resolve(options.control);
+  await requireDirectory(controlRoot);
+  if (!options.allowProductRepo && productRepositoryAt(controlRoot)) {
+    throw new Error('Control path appears to be a product repository. Use a separate project-control workspace, or pass --allow-product-repo after reviewing the risk.');
+  }
+  const installContext = context(controlRoot);
+  const planned = [
+    ...adapter.projectPaths(controlRoot, installContext),
+    ...(team ? [teamConfigPath(controlRoot)] : []),
+    ...(options.global ? adapter.globalPaths(installContext) : []),
+    ...(team && options.global && adapter.modelBinding === 'global-profiles' ? adapter.roleModelPaths(installContext) : [])
+  ];
+  const existing = await collisions(planned);
+  if (existing.length > 0) throw new Error(`Installation aborted; existing paths would be overwritten:\n${existing.map((target) => `  ${target}`).join('\n')}`);
+  await installAssets(adapter.projectAssets, controlRoot, installContext);
+  if (team) await writeTeamConfig(controlRoot, team);
+  if (team) await applyTeamBinding(adapter, controlRoot, team, installContext);
+  if (options.global) await installAssets(adapter.globalAssets, controlRoot, installContext);
+  process.stdout.write(`Triad+ installed for ${adapter.label} in ${controlRoot}\n`);
+  if (adapter.globalEntry) {
+    process.stdout.write(`Install user-level assets with --global to expose ${adapter.entry}.\n`);
+  }
+  process.stdout.write(`Open the control workspace and use ${adapter.entry} <PRD path>. Evaluator+ is optional and post-run only.\n`);
+}
+
+async function doctor(options) {
+  if (!options.control) throw new Error('Provide --control <project-control-path>.');
+  const controlRoot = resolve(options.control);
+  const requested = options.host ? [getAdapter(options.host)] : listAdapters();
+  if (requested.some((adapter) => !adapter)) throw new Error(`Choose --host ${listAdapters().map((item) => item.id).join(', ')}.`);
+  let team = null;
+  if (await exists(teamConfigPath(controlRoot))) {
+    try { team = JSON.parse(await readFile(teamConfigPath(controlRoot), 'utf8')); }
+    catch { team = 'invalid'; }
+  }
+  for (const adapter of requested) {
+    const installContext = context(controlRoot);
+    const absent = [];
+    for (const target of adapter.projectPaths(controlRoot, installContext)) if (!(await exists(target))) absent.push(target);
+    const binary = commandVersion(adapter.binaryCandidates ?? adapter.binary);
+    const node = commandVersion('node');
+    const manifestPath = join(controlRoot, '.triad-runtime', 'adapter.json');
+    let manifest = false;
+    try { manifest = (JSON.parse(await readFile(manifestPath, 'utf8'))?.id === adapter.id); } catch {}
+    process.stdout.write(`${adapter.label.padEnd(14)} ${absent.length ? 'not installed' : 'OK'}\n`);
+    process.stdout.write(`  Host runtime ${binary ? `OK (${binary})` : 'not installed or version unavailable'}\n`);
+    process.stdout.write(`  Verifier     ${node && await exists(join(controlRoot, '.triad-runtime', 'triad-verify.mjs')) ? 'OK' : 'incomplete'}\n`);
+    process.stdout.write(`  Adapter      ${manifest ? 'OK' : 'missing or different adapter'}\n`);
+    process.stdout.write(`  Team config  ${team === 'invalid' ? 'invalid' : team ? 'OK' : 'not configured'}\n`);
+    process.stdout.write(`  Evaluator+   ${team?.roles?.evaluator?.enabled === true ? 'configured' : 'not configured'}\n`);
+    if (options.hookConfig && adapter.lifecycle) {
+      process.stdout.write(`  Hook config  declared; run runtime capability detection for detailed status\n`);
+    }
+  }
+}
+
+async function interactiveInit() {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) throw new Error('The interactive wizard needs a terminal. Use init in a non-interactive shell.');
+  const prompt = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    process.stdout.write('\nTriad+ setup\n');
+    listAdapters().forEach((adapter, index) => process.stdout.write(`${index + 1}) ${adapter.label}\n`));
+    let adapter;
+    while (!adapter) {
+      const answer = (await prompt.question(`Choose the host [1-${listAdapters().length}]: `)).trim().toLowerCase();
+      adapter = listAdapters()[Number(answer) - 1] ?? getAdapter(answer);
+      if (!adapter) process.stdout.write('Choose a listed host.\n');
+    }
+    const control = (await prompt.question(`Project-control workspace [${join(process.cwd(), 'triad-control')}]: `)).trim() || join(process.cwd(), 'triad-control');
+    const global = ['y', 'yes'].includes((await prompt.question(`Also install user-level ${adapter.entry} assets? [y/N]: `)).trim().toLowerCase());
+    const team = await collectTeamConfiguration(prompt, adapter);
+    const confirm = (await prompt.question('Type install to continue: ')).trim().toLowerCase();
+    if (confirm !== 'install') return process.stdout.write('Cancelled. No files were changed.\n');
+    await init({ host: adapter.id, control, global, team });
+    await doctor({ host: adapter.id, control });
+  } finally { prompt.close(); }
+}
+
+try {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.command === 'init') await init(options);
+  else if (options.command === 'doctor') await doctor(options);
+  else if (!options.command) await interactiveInit();
+  else if (options.command === '--help' || options.command === '-h') usage(0);
+  else throw new Error(`Unknown command: ${options.command}`);
+} catch (error) {
+  process.stderr.write(`${error.message}\n`);
+  usage(2);
+}

package/docs/antigravity-replication.md

@@ -0,0 +1,9 @@
+# Antigravity adapter
+
+Install with `npx triad-plus init --host antigravity --control <path>`. Open the
+control workspace and run `/triad <absolute-prd-path>`. Antigravity receives
+project agent assets, shared skills, and the common verifier runtime.
+
+It uses explicit verification dispatch. The team file records requested role
+models and personas; Triad+ does not claim a host-native per-agent model setting
+where Antigravity does not expose one.

package/docs/architecture.md

@@ -0,0 +1,24 @@
+# Architecture
+
+Triad+ has three small layers:
+
+```text
+Triad Core roles       Orchestrator / Developer / Reviewer
+        │
+Runtime adapter        host detection, assets, entry point, capabilities, model binding
+        │
+Verification layer     declared gates and environment-derived evidence
+```
+
+The host agent is the Orchestrator. It owns operational context, delegation, and
+the next decision. The runtime does not schedule work or implement a general
+state machine.
+
+Adapters are registered descriptors in `adapters/registry.mjs`. They describe
+only real host differences: binary discovery, installation destinations, native
+entry point, optional hook lifecycle, and supported model binding. Runtime-
+specific behavior belongs in the adapter. Adding a runtime must not add
+runtime-specific branches to Core installer or verification logic.
+
+Evaluator+ is outside the Core: it runs after a Reviewer-approved result, receives
+a deliberately limited fresh packet, and cannot reopen the completed run.

package/docs/claude-code-replication.md

@@ -0,0 +1,9 @@
+# Claude Code adapter
+
+Install with `npx triad-plus init --host claude-code --control <path>`. Open the
+control workspace and run `/triad <absolute-prd-path>`. Claude Code uses its
+delegated Developer, Reviewer, and optional Evaluator+ definitions; the active
+main session acts as Orchestrator.
+
+A complete `SubagentStop` hook can dispatch verification. Explicit dispatch is
+always available, and the hook never owns a Triad transition.

package/docs/codex-replication.md

@@ -0,0 +1,10 @@
+# Codex adapter
+
+Install with `npx triad-plus init --host codex --control <path> --global`.
+Open the control workspace and run `/prompts:triad <absolute-prd-path>`.
+
+Codex uses role profiles for the Orchestrator, Developer, Reviewer, and optional
+Evaluator+. The command detects whether a complete, version-compatible async
+`SubagentStop` verification hook is installed. If it is not, the Orchestrator
+explicitly invokes the verifier. Hook output is evidence only; it never changes
+Triad state by itself.

package/docs/compatibility.md

@@ -0,0 +1,13 @@
+# Compatibility matrix
+
+| Runtime | Install | Orchestrator | Developer | Reviewer | Evaluator+ | Verification dispatch | Hook support |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| Codex | Yes | Yes | Yes | Yes | Yes | Explicit fallback; async hook when validated | Optional async `SubagentStop` |
+| Claude Code | Yes | Yes | Yes | Yes | Yes | Explicit fallback; hook when validated | Optional `SubagentStop` |
+| OpenCode | Yes | Yes | Yes | Yes | Yes | Explicit dispatch | No adapter hook |
+| Antigravity | Yes | Yes | Yes | Yes | Yes | Explicit dispatch | No adapter hook |
+| Hermes Agent | Yes | Yes | Yes | Yes | Yes | Explicit dispatch | No adapter hook |
+
+All adapters consume the same role IDs and project-control records. Runtime
+model/effort application is limited to the facilities each host exposes; the
+full requested contract is always retained in `.triad-plus/team.json`.

package/docs/configuration.md

@@ -0,0 +1,27 @@
+# Configuration
+
+`.triad-plus/team.json` separates stable role IDs from user-facing names and
+personas. A schema-version-1 configuration has four role records:
+
+```json
+{
+  "schema_version": 1,
+  "interaction": { "language": "English", "owner_name": "Owner", "communication_style": "concise" },
+  "roles": {
+    "orchestrator": { "displayName": "Coordinator", "persona": "calm and precise", "model": null, "reasoning_effort": null },
+    "developer": { "displayName": "Builder", "persona": "methodical", "model": null, "reasoning_effort": null },
+    "reviewer": { "displayName": "Critic", "persona": "independent", "model": null, "reasoning_effort": null },
+    "evaluator": { "displayName": "Evaluator", "persona": "fresh and evidence-led", "model": null, "reasoning_effort": null, "enabled": false }
+  }
+}
+```
+
+`orchestrator`, `developer`, and `reviewer` are the Core roles. `evaluator` is
+optional and enabled only when `roles.evaluator.enabled` is `true`. Omitting that
+field is backward-compatible and means Evaluator+ is not configured.
+
+The runtime adapter is selected per installed control workspace (`--host`). The
+team file records role-level models and effort, but an adapter writes those into
+host-native profiles only where the host supports that facility. A blank model
+means the host default. Never put tokens, API keys, or private deployment data in
+this file.

package/docs/evaluator-plus.md

@@ -0,0 +1,13 @@
+# Evaluator+
+
+Evaluator+ is optional and outside the Triad production loop. Invoke it only
+after the Reviewer has approved a feature or delivery.
+
+It receives the goal, acceptance target, final artifact, and verifier evidence.
+It should not receive developer reasoning, prior reviewer conversation, or
+attempt history unless the owner explicitly requires it. It reports `PASS`,
+`FAIL`, or `INDETERMINATE`, with concise evidence references, under
+`artifacts/evaluator-plus/`.
+
+An Evaluator+ `FAIL` does not reopen Triad, change the approved state, or start
+repair. An owner or a later Orchestrator may use it as input to a new run.