triad-plus 1.8.0 → 1.10.0

package/adapters/opencode/.opencode/agents/triad-orchestrator.md

@@ -17,6 +17,7 @@ permission:
     triad-reviewer: allow
   skill:
     "triad-loop-*": allow
+    "triad-model-configuration": allow
 ---
 
 You are the Triad+ Engineering Loop orchestrator. Govern the workflow and the
@@ -64,6 +65,21 @@ developer-reviewer disagreements and record the rationale; escalate only a
 decision that changes product intent, criteria, metrics, gates, architecture,
 security, budget, or accepted risk.
 
+Before each delegation, create the immutable Assignment Packet and bind it to
+the assignment by running:
+
+```bash
+node .triad-runtime/triad-assignment-packet.mjs \
+  --project /absolute/path/to/control-workspace \
+  --assignment .loop/runtime/assignments/<assignment-file>.json
+```
+
+Use its returned `dispatch.cwd` as the OpenCode task workdir; it MUST equal the
+assigned product worktree. Give Developer and Reviewer the same packet plus
+explicit control/repository/branch/card/skill paths. The packet is primary;
+full PRD/ADR reads are only fallback for a missing or contradictory detail.
+Do not use the packet to bypass real skill reads or verifier hash checks.
+
 Perform hands-on development or review only when delegation is genuinely
 unavailable or cannot proceed. Record the trigger, scope, alternatives, risk,
 validation, independent-review evidence, and the restoration of normal roles.

package/adapters/opencode/.opencode/agents/triad-reviewer.md

@@ -18,14 +18,33 @@ permission:
 
 You are the independent Triad+ Engineering Loop reviewer. Load
 `triad-loop-reviewer` at the start of every assignment and follow it exactly.
-Review the actual card, PRD excerpt, diff, worktree, developer evidence,
-repository instructions, prior attempts, gates, and metrics. Independently rerun
-enough required gates to verify claims.
+The host SHOULD launch this activation with its workdir/cwd equal to the
+candidate product worktree when direct inspection is needed. Read the same
+immutable Assignment Packet used by the Developer, then the card, diff,
+developer evidence, repository instructions, prior attempts, gates, and
+metrics. Consult only a necessary PRD/ADR section when the packet is
+insufficient or contradictory; do not reconstruct the full requirement by
+default. Independently rerun enough required gates to verify claims.
 
 At activation, read `.triad-plus/team.json`. Your first report to the
 Orchestrator identifies the configured `roles.reviewer.displayName` as the
 Triad+ Reviewer and names the feature and attempt under review.
 
+Before inspecting the candidate, run this exact runtime-context proof from the
+actual Reviewer cwd:
+
+```bash
+node /absolute/path/to/control-workspace/.triad-runtime/triad-runtime-context.mjs \
+  --project /absolute/path/to/control-workspace \
+  --assignment /absolute/path/to/control-workspace/.loop/runtime/assignments/<assignment-file>.json
+```
+
+Record packet cwd, process cwd, shell `pwd`, Git top-level, and each resolved
+repository-skill path/hash. On non-zero status, `NotFound`, hash mismatch,
+mixed repository roots, or cwd inconsistency, return `blocked` / invalid
+runtime context. Do not use a same-named skill from the control workspace or
+global skills as a fallback.
+
 Return one evidence-based recommendation: `approved`, `rework`, or `blocked`.
 List severity-ranked findings before gate and metric evidence, residual risks,
 and the recommendation. A blocked recommendation must identify the exact owner
@@ -34,3 +53,6 @@ decision or external condition required.
 Do not modify code, implement routine fixes, commit, push, publish packages,
 create releases, or change workflow state. The orchestrator makes transitions;
 the developer implements rework.
+
+Use OpenCode read/grep/glob/list tools for simple reads; reserve Bash for
+builds, tests, git, scripts, and system commands.

package/adapters/opencode/.opencode/commands/triad.md

@@ -7,6 +7,11 @@ Operate a Triad+ Engineering Loop for the following owner request:
 
 $ARGUMENTS
 
+When the input is a native BMAD `epics.md` (or its `_bmad-output` directory),
+use the deterministic native intake from `triad-loop-orchestrator`. Do not ask
+the owner to create one Story file per BMAD Story or to run
+`import-bmad-story` repeatedly; keep `epics.md` read-only.
+
 If `.triad-plus/team.json` exists, load it before replying. Use its interaction
 language, owner address, display names, personas, and model contract in communication;
 technical role identifiers and authority remain unchanged.
@@ -43,3 +48,19 @@ When true, automatically dispatch `triad-evaluator` in a fresh context with only
 the approved evaluation packet. When false or omitted, finish without evaluation.
 An Evaluator+ verdict never reopens Triad, assigns Developer work, or starts
 repair; `--evaluator` and `--no-evaluator` are per-run overrides when supplied.
+
+Before delegating each card, create the immutable Assignment Packet with:
+
+```bash
+node .triad-runtime/triad-assignment-packet.mjs \
+  --project /absolute/path/to/control-workspace \
+  --assignment .loop/runtime/assignments/<assignment-file>.json
+```
+
+Dispatch the Developer with the returned `dispatch.cwd` as its OpenCode
+workdir, which MUST be the assigned product worktree. Pass the packet and card
+as the primary contract, followed by explicit control paths and mandatory skill
+paths. Dispatch the Reviewer with the same packet and candidate worktree when
+it needs direct inspection; do not reconstruct the full PRD/ADR by default.
+Use native read/grep/glob/list tools for simple reads and Bash only for
+build/test/git/script/system commands.

package/adapters/opencode/README.md

@@ -1,6 +1,6 @@
 # Triad+ Engineering Loop for OpenCode
 
-This adapter makes the repository's existing five standard Agent Skills
+This adapter makes the repository's existing six standard Agent Skills
 operational in OpenCode. It installs four specialized agents and the `/triad`
 command; it does not duplicate the method or alter `opencode.json`.
 
@@ -26,6 +26,7 @@ skills/triad-loop-orchestrator/
 skills/triad-loop-developer/
 skills/triad-loop-evaluator/
 skills/triad-loop-reviewer/
+skills/triad-model-configuration/
 .triad-runtime/
   triad-verify.mjs
   triad-runtime-capabilities.mjs
@@ -53,10 +54,26 @@ remain in a declared project workspace.
 
 ## Configure models deliberately
 
-The adapter intentionally does not set `model` in its agent files. OpenCode
-therefore uses the currently selected primary model and, by default, passes it
-to subagents. Set a `model: provider/model-id` field in each installed agent
-file when role-specific routing is wanted:
+`.triad-plus/team.json` is the source of truth for role-level model
+configuration. When a team file supplies values, Triad+ materializes the
+OpenCode-native `model` and `variant` frontmatter fields in each project agent
+definition during `init` and `upgrade --apply`:
+
+```text
+team.json model             → OpenCode model
+team.json reasoning_effort → OpenCode variant
+```
+
+Do not treat generated `.opencode/agents/*.md` files as an independent
+configuration source; a later managed upgrade regenerates them from
+`.triad-plus/team.json`. A `null` or blank value leaves the corresponding field
+absent so OpenCode uses its host/session default.
+
+The adapter only writes fields supported by this OpenCode materialization. Host
+and provider capabilities may still limit which model or reasoning levels are
+available. Inspect identifiers and variants with `opencode models` and keep
+role-specific routing explicit in the team file. OpenCode's role `variant` is
+not the same thing as the default model/session selected by the TUI:
 
 | Agent | Recommended profile |
 | --- | --- |
@@ -69,6 +86,13 @@ Use `opencode models` to inspect the provider/model identifiers available in
 the local installation. Keep the developer, evaluator, and reviewer separately
 configured when independent model routing is required.
 
+The adapter targets the installed OpenCode agent contract: `variant` is the
+host-native per-agent option, while `team.json` remains the canonical desired
+configuration. A null or blank model/effort removes the managed field and lets
+OpenCode use its host or session default. `upgrade --apply` refreshes managed
+agents and then reapplies this same binding; it does not rewrite `team.json`.
+OpenCode 1.18.x exposes this contract through the `AgentConfig.variant` field.
+
 ## Start the loop
 
 Launch OpenCode from the project-control repository, then enter:

package/adapters/opencode/install.sh

@@ -31,7 +31,7 @@ adapter_root="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
 repository_root="$(cd -- "$adapter_root/../.." && pwd)"
 
 agent_names=(triad-orchestrator triad-developer triad-evaluator triad-reviewer)
-skill_names=(triad-loop-bootstrap triad-loop-orchestrator triad-loop-developer triad-loop-evaluator triad-loop-reviewer)
+skill_names=(triad-loop-bootstrap triad-loop-orchestrator triad-loop-developer triad-loop-evaluator triad-loop-reviewer triad-model-configuration)
 command_name="triad"
 collisions=()
 

package/adapters/registry.mjs

@@ -7,7 +7,8 @@ export const sharedSkillNames = [
   'triad-loop-orchestrator',
   'triad-loop-developer',
   'triad-loop-evaluator',
-  'triad-loop-reviewer'
+  'triad-loop-reviewer',
+  'triad-model-configuration'
 ];
 
 export const roleDefinitions = [
@@ -37,6 +38,7 @@ function projectRuntimeAssets(id) {
   return [
     { source: 'runtime', destination: '.triad-runtime' },
     { source: 'schemas', destination: '.triad-runtime/schemas' },
+    { source: 'integrations/bmad', destination: '.triad-runtime/integrations/bmad' },
     { source: `adapters/${id}/runtime.json`, destination: '.triad-runtime/adapter.json', file: true }
   ];
 }
@@ -86,6 +88,13 @@ const definitions = [
     entry: '/triad',
     lifecycle: null,
     modelBinding: 'project-frontmatter',
+    // OpenCode's agent frontmatter has a first-class `variant` field.  Keep
+    // Triad's canonical `reasoning_effort` name in team.json and map it to
+    // that host-native field rather than emitting provider options such as
+    // `reasoningEffort` into the agent profile.
+    modelFields: ['model', 'variant'],
+    modelFieldSources: { model: 'model', variant: 'reasoning_effort' },
+    modelCleanupFields: ['reasoningEffort'],
     modelRoles: roleDefinitions.map((role) => role.id),
     projectAssets: [
       { source: 'adapters/opencode/.opencode/agents', destination: '.opencode/agents' },
@@ -112,6 +121,10 @@ const definitions = [
     },
     roleModelPaths(controlRoot) {
       return roleDefinitions.map((role) => join(controlRoot, '.opencode', 'agents', `triad-${role.id}.md`));
+    },
+    globalRoleModelPaths() {
+      const root = hostHome('.config', 'opencode');
+      return rolePaths(root, roleDefinitions.map((role) => `triad-${role.id}`));
     }
   },
   {
@@ -155,6 +168,10 @@ const definitions = [
     },
     roleModelPaths(controlRoot) {
       return ['developer', 'reviewer', 'evaluator'].map((role) => join(controlRoot, '.claude', 'agents', `triad-${role}.md`));
+    },
+    globalRoleModelPaths() {
+      const root = hostHome('.claude');
+      return ['developer', 'reviewer', 'evaluator'].map((role) => join(root, 'agents', `triad-${role}.md`));
     }
   },
   {
@@ -220,6 +237,7 @@ const definitions = [
     lifecycle: null,
     modelBinding: 'project-frontmatter',
     modelFields: ['model', 'reasoningEffort'],
+    modelFieldSources: { model: 'model', reasoningEffort: 'reasoning_effort' },
     modelRoles: roleDefinitions.map((role) => role.id),
     projectAssets: [
       { source: 'adapters/copilot/.github/agents', destination: '.github/agents' },
@@ -251,6 +269,10 @@ const definitions = [
     },
     roleModelPaths(controlRoot) {
       return roleDefinitions.map((role) => join(controlRoot, '.github', 'agents', `triad-${role.id}.agent.md`));
+    },
+    globalRoleModelPaths() {
+      const root = hostHome('.copilot');
+      return roleDefinitions.map((role) => join(root, 'agents', `triad-${role.id}.agent.md`));
     }
   }
 ];

package/bin/triad-plus.js

@@ -9,6 +9,17 @@ import process from 'node:process';
 import { createInterface } from 'node:readline/promises';
 import { getAdapter, listAdapters, roleDefinitions, sharedSkillNames } from '../adapters/registry.mjs';
 import { writeImportedCard } from '../integrations/bmad/story-importer.mjs';
+import {
+  hostModelField,
+  materializedHostRoleConfiguration,
+  supportsNativeReasoning,
+  validateTeamConfiguration
+} from '../runtime/lib/model-config.mjs';
+import {
+  formatDoctorLine,
+  formatDoctorSection,
+  formatSetupSummary
+} from '../runtime/lib/terminal.mjs';
 
 const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
 
@@ -19,7 +30,7 @@ function usage(exitCode = 0) {
 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>]
+  npx triad-plus doctor --host <adapter-id> --control <path> [--global] [--hook-config <path>]
   npx triad-plus upgrade --host <adapter-id> --control <path> [--global] [--apply]
   npx triad-plus import-bmad-story --source <story.md> --output <card.md> [--target-repository <id>] [--provenance <record.json>] [--required-gate <id>] [--depends-on <card-id>]
 
@@ -180,19 +191,13 @@ async function applyOverlay(controlRoot, apply, team) {
 }
 
 async function loadTeamConfig(options) {
-  if (options.team) return options.team;
+  if (options.team) return validateTeamConfiguration(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;
+  try { return validateTeamConfiguration(team); }
+  catch (error) { throw new Error(`--team-config is invalid: ${error.message}`); }
 }
 
 async function writeTeamConfig(controlRoot, team) {
@@ -201,20 +206,22 @@ async function writeTeamConfig(controlRoot, team) {
   await writeFile(target, `${JSON.stringify(team, null, 2)}\n`, 'utf8');
 }
 
-async function applyMarkdownModel(target, configuration, fields = ['model']) {
-  if (!fields.some((field) => configuration?.[field === 'reasoningEffort' ? 'reasoning_effort' : field])) return;
+async function applyMarkdownModel(target, configuration, fields = ['model'], cleanupFields = []) {
+  const managedFields = [...new Set([...fields, ...cleanupFields])];
+  if (managedFields.length === 0) 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}`);
   let frontmatter = source.slice(4, closing);
-  for (const field of fields) frontmatter = frontmatter.replace(new RegExp(`^${field}:\\s*.*\\n?`, 'm'), '');
+  for (const field of managedFields) frontmatter = frontmatter.replace(new RegExp(`^${field}:\\s*.*\\n?`, 'm'), '');
   const values = fields
-    .map((field) => ({ field, value: field === 'reasoningEffort' ? configuration.reasoning_effort : configuration[field] }))
+    .map((field) => ({ field, value: configuration?.[field] }))
     .filter(({ value }) => value !== null && value !== undefined && value !== '');
-  if (values.length === 0) return;
   const additions = values.map(({ field, value }) => `${field}: ${JSON.stringify(value)}`).join('\n');
-  await writeFile(target, `---\n${frontmatter}${additions}\n${source.slice(closing)}`, 'utf8');
+  const normalizedFrontmatter = frontmatter.replace(/\s*$/, '');
+  const next = `---\n${normalizedFrontmatter}${additions ? `\n${additions}` : ''}${source.slice(closing)}`;
+  if (next !== source) await writeFile(target, next, 'utf8');
 }
 
 async function writeRoleProfiles(paths, team) {
@@ -240,18 +247,29 @@ async function writeRoleProfiles(paths, team) {
   }
 }
 
-async function applyTeamBinding(adapter, controlRoot, team, installContext) {
+async function applyTeamBinding(adapter, controlRoot, team, installContext, scope = 'project') {
   if (!team || adapter.modelBinding === 'team-record') return;
   if (adapter.modelBinding === 'project-frontmatter') {
-    const paths = adapter.roleModelPaths(controlRoot, installContext);
+    const pathFactory = scope === 'global' ? adapter.globalRoleModelPaths : adapter.roleModelPaths;
+    if (typeof pathFactory !== 'function') return;
+    const paths = scope === 'global'
+      ? pathFactory(installContext)
+      : pathFactory(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], adapter.modelFields ?? ['model']);
+      const fields = adapter.modelFields ?? ['model'];
+      await applyMarkdownModel(
+        paths[index],
+        materializedHostRoleConfiguration(adapter, role.id, team.roles[role.id]),
+        fields,
+        adapter.modelCleanupFields ?? []
+      );
     }
     return;
   }
   if (adapter.modelBinding === 'global-profiles') {
+    if (scope !== 'global') return;
     await writeRoleProfiles(adapter.roleModelPaths(installContext), team);
     return;
   }
@@ -276,6 +294,100 @@ async function allExist(paths) {
   return true;
 }
 
+function sharedSkillRoots(adapter, root, installContext, scope) {
+  const assets = scope === 'global' ? adapter.globalAssets : adapter.projectAssets;
+  return assets
+    .filter((asset) => asset.source === 'shared-skills')
+    .map((asset) => resolveDestination(asset.destination, root, installContext));
+}
+
+async function anyExist(paths) {
+  for (const target of paths) if (await exists(target)) return true;
+  return false;
+}
+
+/** Return one status per shared skill so a partial install cannot look healthy. */
+async function sharedSkillStatuses(adapter, root, installContext, scope) {
+  const roots = sharedSkillRoots(adapter, root, installContext, scope);
+  if (roots.length === 0) return [];
+  const configuredRoots = [];
+  for (const skillRoot of roots) if (await exists(skillRoot)) configuredRoots.push(skillRoot);
+  const statuses = [];
+  for (const name of sharedSkillNames) {
+    const paths = roots.map((skillRoot) => join(skillRoot, name));
+    if (configuredRoots.length === 0) {
+      statuses.push({ name, status: 'not configured', paths });
+      continue;
+    }
+    let present = 0;
+    for (const target of paths) if (await exists(target)) present += 1;
+    statuses.push({ name, status: present === paths.length ? 'OK' : 'MISSING', paths });
+  }
+  return statuses;
+}
+
+function roleModelEntries(adapter, controlRoot, installContext, scope) {
+  let paths;
+  if (scope === 'global') {
+    if (adapter.modelBinding === 'global-profiles') paths = adapter.roleModelPaths?.(installContext) ?? [];
+    else paths = adapter.globalRoleModelPaths?.(installContext) ?? [];
+  } else {
+    if (adapter.modelBinding !== 'project-frontmatter') return [];
+    paths = adapter.roleModelPaths?.(controlRoot, installContext) ?? [];
+  }
+  const roleIds = adapter.modelRoles ?? roleDefinitions.map((role) => role.id);
+  return roleIds.map((roleId, index) => ({
+    role: roleDefinitions.find((definition) => definition.id === roleId),
+    path: paths[index]
+  })).filter((entry) => entry.role && entry.path);
+}
+
+function parseFrontmatterFields(source, fields) {
+  const result = {};
+  if (!source.startsWith('---\n')) return result;
+  const closing = source.indexOf('\n---\n', 4);
+  if (closing < 0) return result;
+  const frontmatter = source.slice(4, closing);
+  for (const field of fields) {
+    const match = frontmatter.match(new RegExp(`^${field}:\\s*(.*?)\\s*$`, 'm'));
+    if (!match) {
+      result[field] = null;
+      continue;
+    }
+    try { result[field] = JSON.parse(match[1]); }
+    catch { result[field] = match[1].replace(/^['"]|['"]$/g, ''); }
+  }
+  return result;
+}
+
+async function modelBindingEvidence(adapter, controlRoot, installContext, team, scope) {
+  const entries = roleModelEntries(adapter, controlRoot, installContext, scope);
+  if (!entries.length) return [];
+  const evidence = [];
+  for (const { role, path: target } of entries) {
+    const configuration = team?.roles?.[role.id];
+    if (!configuration) {
+      evidence.push({ role, status: 'not configured', target });
+      continue;
+    }
+    const expected = materializedHostRoleConfiguration(adapter, role.id, configuration);
+    const fields = [...new Set([...(adapter.modelFields ?? Object.keys(expected)), ...(adapter.modelCleanupFields ?? [])])];
+    if (Object.keys(expected).length === 0) {
+      evidence.push({ role, status: 'UNSUPPORTED', target, expected, observed: null });
+      continue;
+    }
+    if (!(await exists(target))) {
+      evidence.push({ role, status: 'UNKNOWN / NOT OBSERVABLE', target, expected, observed: null });
+      continue;
+    }
+    const observed = parseFrontmatterFields(await readFile(target, 'utf8'), fields);
+    const matches = fields.every((field) => (expected[field] ?? null) === (observed[field] ?? null));
+    const allDefault = Object.values(expected).every((value) => value === null || value === undefined || value === '');
+    evidence.push({ role, status: matches && allDefault ? 'HOST DEFAULT' : matches ? 'VERIFIED' : 'MATERIALIZED MISMATCH', target, expected, observed });
+  }
+  return evidence;
+}
+
 function commandVersion(binary) {
   const candidates = Array.isArray(binary) ? binary : [binary];
   for (const candidate of candidates) {
@@ -307,8 +419,9 @@ async function collectTeamConfiguration(prompt, adapter) {
     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
+    const reasoningEffort = supportsNativeReasoning(adapter, role.id)
+      ? (await prompt.question(`${role.label} reasoning effort [${adapter.modelBinding === 'global-profiles' && model ? role.defaultEffort : 'host default'}]: `)).trim()
+        || (adapter.modelBinding === 'global-profiles' && model ? role.defaultEffort : null)
       : null;
     roles[role.id] = { displayName, persona, model: model || null, reasoning_effort: reasoningEffort, enabled };
   }
@@ -330,15 +443,19 @@ async function init(options) {
     ...adapter.projectPaths(controlRoot, installContext),
     ...(team ? [teamConfigPath(controlRoot)] : []),
     ...(options.global ? adapter.globalPaths(installContext) : []),
-    ...(team && options.global && adapter.modelBinding === 'global-profiles' ? adapter.roleModelPaths(installContext) : [])
+    ...(team && options.global && adapter.modelBinding === 'global-profiles' ? adapter.roleModelPaths(installContext) : []),
+    ...(team && options.global && adapter.modelBinding === 'project-frontmatter' && adapter.globalRoleModelPaths
+      ? adapter.globalRoleModelPaths(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 applyOverlay(controlRoot, true, team);
-  if (team) await applyTeamBinding(adapter, controlRoot, team, installContext);
   if (options.global) await installAssets(adapter.globalAssets, controlRoot, installContext);
+  if (team) await applyTeamBinding(adapter, controlRoot, team, installContext, 'project');
+  if (team && options.global) await applyTeamBinding(adapter, controlRoot, team, installContext, 'global');
   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`);
@@ -349,7 +466,7 @@ async function init(options) {
 async function currentTeam(controlRoot) {
   const target = teamConfigPath(controlRoot);
   if (!(await exists(target))) return null;
-  try { return JSON.parse(await readFile(target, 'utf8')); }
+  try { return validateTeamConfiguration(JSON.parse(await readFile(target, 'utf8'))); }
   catch { throw new Error(`Cannot safely upgrade an invalid team config: ${target}`); }
 }
 
@@ -394,12 +511,15 @@ async function upgrade(options) {
   const backupRoot = join(controlRoot, '.triad-plus', 'backups', stamp);
   process.stdout.write(`Triad+ upgrade ${options.apply ? 'applying' : 'plan'} for ${adapter.label}\n`);
   await refreshAssets(adapter.projectAssets, controlRoot, installContext, join(backupRoot, 'project'), options.apply);
+  if (team && options.apply && adapter.modelBinding === 'project-frontmatter') {
+    await applyTeamBinding(adapter, controlRoot, team, installContext, 'project');
+  }
   await upgradeRunStateDelivery(controlRoot, backupRoot, options.apply);
   if (team) await applyOverlay(controlRoot, options.apply, team);
   else process.stdout.write('  Instructions skipped: .triad-plus/team.json is not configured\n');
   if (options.global) {
     await refreshAssets(adapter.globalAssets, controlRoot, installContext, join(backupRoot, 'global'), options.apply);
-    if (team) await applyTeamBinding(adapter, controlRoot, team, installContext);
+    if (team && options.apply) await applyTeamBinding(adapter, controlRoot, team, installContext, 'global');
   }
   if (!options.apply) process.stdout.write('Dry run only. Re-run with --apply to update managed assets.\n');
 }
@@ -426,13 +546,18 @@ async function doctor(options) {
   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')); }
+    try { team = validateTeamConfiguration(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 globalDetected = adapter.globalPaths ? await anyExist(adapter.globalPaths(installContext)) : false;
+    const inspectGlobal = Boolean(options.global || globalDetected);
+    const globalTargets = inspectGlobal && adapter.globalPaths ? adapter.globalPaths(installContext) : [];
+    const globalAbsent = [];
+    for (const target of globalTargets) if (!(await exists(target))) globalAbsent.push(target);
     const binary = commandVersion(adapter.binaryCandidates ?? adapter.binary);
     const node = commandVersion('node');
     const manifestPath = join(controlRoot, '.triad-runtime', 'adapter.json');
@@ -442,25 +567,71 @@ async function doctor(options) {
     const roleTargets = targets.filter((target) => /[/\\]agents[/\\]triad-/.test(target));
     const triadSkillTargets = targets.filter((target) => /[/\\]skills[/\\]triad$/.test(target));
     const capability = manifest ? capabilitySnapshot(controlRoot, manifestPath) : null;
-    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`);
-    if (roleTargets.length) process.stdout.write(`  Role agents  ${await allExist(roleTargets) ? 'OK' : 'missing'}\n`);
-    if (triadSkillTargets.length) process.stdout.write(`  Triad skill  ${await allExist(triadSkillTargets) ? 'OK' : 'missing'}\n`);
-    process.stdout.write(`  Verification ${capability?.verification?.selected_mode ?? 'unavailable'}${capability?.verification?.reason ? ` (${capability.verification.reason})` : ''}\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`);
+    process.stdout.write(`\n${formatDoctorSection(`Triad+ doctor — ${adapter.label}`)}\n`);
+    process.stdout.write(`${formatDoctorLine(adapter.label, absent.length || globalAbsent.length ? 'incomplete' : 'OK')}\n`);
+    process.stdout.write(`${formatDoctorSection('Runtime and installation')}\n`);
+    process.stdout.write(`  ${formatDoctorLine('Host runtime', binary ? `OK (${binary})` : 'not installed or version unavailable')}\n`);
+    process.stdout.write(`  ${formatDoctorLine('Verifier', node && await exists(join(controlRoot, '.triad-runtime', 'triad-verify.mjs')) ? 'OK' : 'incomplete')}\n`);
+    process.stdout.write(`  ${formatDoctorLine('Adapter', manifest ? 'OK' : 'missing or different adapter')}\n`);
+    if (roleTargets.length) process.stdout.write(`  ${formatDoctorLine('Role agents', await allExist(roleTargets) ? 'OK' : 'missing')}\n`);
+    if (triadSkillTargets.length) process.stdout.write(`  ${formatDoctorLine('Triad skill', await allExist(triadSkillTargets) ? 'OK' : 'missing')}\n`);
+    const projectSharedSkills = await sharedSkillStatuses(adapter, controlRoot, installContext, 'project');
+    if (projectSharedSkills.length) {
+      process.stdout.write(`${formatDoctorSection('Shared skills')}\n`);
+      for (const skill of projectSharedSkills) process.stdout.write(`  ${formatDoctorLine(skill.name, skill.status)}\n`);
+    }
+    if (inspectGlobal) {
+      const globalSharedSkills = await sharedSkillStatuses(adapter, controlRoot, installContext, 'global');
+      if (globalSharedSkills.length) {
+        process.stdout.write(`${formatDoctorSection('Global shared skills')}\n`);
+        for (const skill of globalSharedSkills) process.stdout.write(`  ${formatDoctorLine(skill.name, skill.status)}\n`);
+      }
+    }
+    process.stdout.write(`${formatDoctorSection('Verification and capabilities')}\n`);
+    process.stdout.write(`  ${formatDoctorLine('Verification', capability?.verification?.selected_mode ?? 'unavailable')}${capability?.verification?.reason ? ` (${capability.verification.reason})` : ''}\n`);
+    process.stdout.write(`${formatDoctorSection('Configuration')}\n`);
+    process.stdout.write(`  ${formatDoctorLine('Team config', team === 'invalid' ? 'invalid' : team ? 'OK' : 'not configured')}\n`);
+    process.stdout.write(`  ${formatDoctorLine('Evaluator+', team?.roles?.evaluator?.enabled === true ? 'configured' : 'not configured')}\n`);
+    const modelFields = adapter.modelBinding === 'global-profiles'
+      ? 'model, reasoning_effort'
+      : Array.isArray(adapter.modelFields) && adapter.modelFields.length ? adapter.modelFields.join(', ') : 'team.json record / host-managed';
+    process.stdout.write(`  ${formatDoctorLine('Model binding', `${adapter.modelBinding ?? 'unavailable'} (${modelFields})`)}\n`);
+    const modelScopes = [];
+    const validTeam = team !== 'invalid' ? team : null;
+    if (adapter.modelBinding === 'project-frontmatter') {
+      modelScopes.push(['project', await modelBindingEvidence(adapter, controlRoot, installContext, validTeam, 'project')]);
+    }
+    if (inspectGlobal && (adapter.modelBinding === 'project-frontmatter' || adapter.modelBinding === 'global-profiles')) {
+      modelScopes.push(['global', await modelBindingEvidence(adapter, controlRoot, installContext, validTeam, 'global')]);
+    }
+    if (modelScopes.some(([, entries]) => entries.length)) {
+      process.stdout.write(`${formatDoctorSection('Model configuration evidence')}\n`);
+      for (const [scope, entries] of modelScopes) {
+        for (const entry of entries) {
+          const field = hostModelField(adapter, entry.role.id, 'reasoning_effort');
+          const desired = validTeam?.roles?.[entry.role.id];
+          const desiredText = desired
+            ? `desired model=${desired.model || 'host default'}${field ? ` ${field}=${desired.reasoning_effort || 'host default'}` : ''}`
+            : 'desired unavailable';
+          const observedText = entry.observed ? ` — materialized ${JSON.stringify(entry.observed)}` : '';
+          process.stdout.write(`  ${formatDoctorLine(`${scope} ${entry.role.label}`, entry.status)} ${desiredText}${observedText}\n`);
+        }
+      }
+      if (adapter.modelBinding === 'project-frontmatter') {
+        process.stdout.write(`  ${formatDoctorLine('Host default', 'UNKNOWN / NOT OBSERVABLE')}\n`);
+        process.stdout.write(`  ${formatDoctorLine('Current session', 'UNKNOWN / NOT OBSERVABLE')}\n`);
+      }
+    }
     const overlay = await overlayPlan(controlRoot, team).catch(() => null);
-    process.stdout.write(`  Instructions ${overlay ? overlay.action === 'update' ? 'managed' : `needs ${overlay.action}` : 'invalid managed block'}\n`);
+    process.stdout.write(`  ${formatDoctorLine('Instructions', overlay ? overlay.action === 'update' ? 'managed' : `needs ${overlay.action}` : 'invalid managed block')}\n`);
     const globalAgents = join(codexHome(), 'AGENTS.md');
     if (await exists(globalAgents)) {
       const globalText = await readFile(globalAgents, 'utf8');
       const fixedIdentity = /(?:identity|name)[\s\S]{0,100}(?:always|only|must)/i.test(globalText);
-      process.stdout.write(`  Identity policy ${fixedIdentity ? 'host rule detected; review for Triad role conflicts' : 'no fixed host rule detected'}\n`);
+      process.stdout.write(`  ${formatDoctorLine('Identity policy', fixedIdentity ? 'host rule detected; review for Triad role conflicts' : 'no fixed host rule detected')}\n`);
     }
     if (options.hookConfig && adapter.lifecycle) {
-      process.stdout.write(`  Hook config  declared; run runtime capability detection for detailed status\n`);
+      process.stdout.write(`  ${formatDoctorLine('Hook config', 'declared; run runtime capability detection for detailed status')}\n`);
     }
   }
 }
@@ -480,6 +651,7 @@ async function interactiveInit() {
     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);
+    process.stdout.write(`\n${formatSetupSummary({ adapter, control, global, team })}`);
     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 });

package/docs/architecture.md

@@ -14,6 +14,14 @@ 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.
 
+At assignment time the Orchestrator may materialize a small immutable
+Assignment Packet. It is a bounded projection of the card and relevant context,
+not a second control plane or PRD. The host receives an explicit dispatch
+context whose `cwd` is the declared product worktree; control-workspace paths
+remain explicit for policy, state, and evidence. Developer and Reviewer share
+the packet, while mandatory repository skills continue to be read and checked
+from their real worktree paths.
+
 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-