triad-plus 1.2.0 → 1.4.0

package/adapters/registry.mjs

@@ -210,6 +210,48 @@ const definitions = [
       const root = join(hermesProfileHome(), 'skills');
       return [join(root, 'triad'), ...sharedSkillNames.map((name) => join(root, name))];
     }
+  },
+  {
+    id: 'copilot',
+    label: 'GitHub Copilot',
+    binary: 'copilot',
+    entry: '/triad',
+    fallbackEntry: '/agent',
+    lifecycle: null,
+    modelBinding: 'project-frontmatter',
+    modelFields: ['model', 'reasoningEffort'],
+    modelRoles: roleDefinitions.map((role) => role.id),
+    projectAssets: [
+      { source: 'adapters/copilot/.github/agents', destination: '.github/agents' },
+      { source: 'adapters/copilot/.github/skills/triad', destination: '.github/skills/triad' },
+      sharedSkills('.github/skills'),
+      ...projectRuntimeAssets('copilot')
+    ],
+    globalAssets: [
+      { source: 'adapters/copilot/.github/agents', destination: () => hostHome('.copilot', 'agents') },
+      { source: 'adapters/copilot/.github/skills/triad', destination: () => hostHome('.copilot', 'skills', 'triad') },
+      sharedSkills(() => hostHome('.copilot', 'skills'))
+    ],
+    projectPaths(controlRoot) {
+      const root = join(controlRoot, '.github');
+      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('.copilot');
+      return [
+        ...roleDefinitions.map((role) => join(root, 'agents', `triad-${role.id}.agent.md`)),
+        join(root, 'skills', 'triad'),
+        ...sharedSkillNames.map((name) => join(root, 'skills', name))
+      ];
+    },
+    roleModelPaths(controlRoot) {
+      return roleDefinitions.map((role) => join(controlRoot, '.github', 'agents', `triad-${role.id}.agent.md`));
+    }
   }
 ];
 

package/bin/triad-plus.js

@@ -132,29 +132,40 @@ function teamConfigPath(controlRoot) {
 
 const overlayStart = '<!-- triad-plus:managed-instructions:start -->';
 const overlayEnd = '<!-- triad-plus:managed-instructions:end -->';
-const instructionOverlay = `${overlayStart}
+function instructionOverlay(team) {
+  const displayName = typeof team?.roles?.orchestrator?.displayName === 'string' && team.roles.orchestrator.displayName.trim()
+    ? team.roles.orchestrator.displayName.trim()
+    : 'Triad Orchestrator';
+  return `${overlayStart}
 ## Triad+ role-run overlay
 
 When a Triad+ entry point is invoked in this control workspace, read
 \`.triad-plus/team.json\` before the first owner-facing reply. The active
-Orchestrator presents itself only as \`roles.orchestrator.displayName\`. This
-is a role-run presentation rule; it does not change technical authority,
-repository policy, safety instructions, or the host's identity outside Triad+.
+Orchestrator is \`${displayName}\` for this run. Its first owner-facing message
+is a presentation, not a bootstrap report: begin with a first-person sentence
+that explicitly names \`${displayName}\` and says it is the Triad+ Orchestrator,
+then state whether the run is new or resumed and the received input. Do this
+before reporting bootstrap, inspecting artifacts, delegating, or asking a
+question. This is a role-run presentation rule; it does not change technical
+authority, repository policy, safety instructions, or the host's identity
+outside Triad+.
 ${overlayEnd}`;
+}
 
-async function overlayPlan(controlRoot) {
+async function overlayPlan(controlRoot, team) {
   const target = join(controlRoot, 'AGENTS.md');
-  if (!(await exists(target))) return { target, action: 'create', content: `# Project instructions\n\n${instructionOverlay}\n` };
+  const overlay = instructionOverlay(team);
+  if (!(await exists(target))) return { target, action: 'create', content: `# Project instructions\n\n${overlay}\n` };
   const source = await readFile(target, 'utf8');
   const start = source.indexOf(overlayStart);
   const end = source.indexOf(overlayEnd);
-  if (start === -1 && end === -1) return { target, action: 'append', content: `${source.replace(/\s*$/, '')}\n\n${instructionOverlay}\n` };
+  if (start === -1 && end === -1) return { target, action: 'append', content: `${source.replace(/\s*$/, '')}\n\n${overlay}\n` };
   if (start < 0 || end < start) throw new Error(`Cannot safely update managed instruction block: ${target}`);
-  return { target, action: 'update', content: `${source.slice(0, start)}${instructionOverlay}${source.slice(end + overlayEnd.length)}` };
+  return { target, action: 'update', content: `${source.slice(0, start)}${overlay}${source.slice(end + overlayEnd.length)}` };
 }
 
-async function applyOverlay(controlRoot, apply) {
-  const plan = await overlayPlan(controlRoot);
+async function applyOverlay(controlRoot, apply, team) {
+  const plan = await overlayPlan(controlRoot, team);
   process.stdout.write(`  Instructions ${apply ? plan.action : `would ${plan.action}`} ${plan.target}\n`);
   if (apply) await writeFile(plan.target, plan.content, 'utf8');
 }
@@ -181,14 +192,20 @@ async function writeTeamConfig(controlRoot, team) {
   await writeFile(target, `${JSON.stringify(team, null, 2)}\n`, 'utf8');
 }
 
-async function applyMarkdownModel(target, model) {
-  if (!model) return;
+async function applyMarkdownModel(target, configuration, fields = ['model']) {
+  if (!fields.some((field) => configuration?.[field === 'reasoningEffort' ? 'reasoning_effort' : field])) 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');
+  let frontmatter = source.slice(4, closing);
+  for (const field of fields) frontmatter = frontmatter.replace(new RegExp(`^${field}:\\s*.*\\n?`, 'm'), '');
+  const values = fields
+    .map((field) => ({ field, value: field === 'reasoningEffort' ? configuration.reasoning_effort : 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');
 }
 
 async function writeRoleProfiles(paths, team) {
@@ -199,6 +216,7 @@ async function writeRoleProfiles(paths, team) {
       `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.',
+      `At the beginning of each activation, identify yourself as ${configuration.displayName}, the Triad+ ${role.label}, in your first role report.`,
       'Technical role IDs define authority; display names never change it.'
     ].join('\n');
     const profile = [
@@ -219,7 +237,9 @@ async function applyTeamBinding(adapter, controlRoot, team, installContext) {
     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);
+    for (const [index, role] of roles.entries()) {
+      await applyMarkdownModel(paths[index], team.roles[role.id], adapter.modelFields ?? ['model']);
+    }
     return;
   }
   if (adapter.modelBinding === 'global-profiles') {
@@ -242,6 +262,11 @@ async function collisions(paths) {
   return result;
 }
 
+async function allExist(paths) {
+  for (const target of paths) if (!(await exists(target))) return false;
+  return true;
+}
+
 function commandVersion(binary) {
   const candidates = Array.isArray(binary) ? binary : [binary];
   for (const candidate of candidates) {
@@ -251,6 +276,17 @@ function commandVersion(binary) {
   return null;
 }
 
+function capabilitySnapshot(controlRoot, manifestPath) {
+  if (!manifestPath) return null;
+  const detector = join(packageRoot, 'runtime', 'triad-runtime-capabilities.mjs');
+  const result = spawnSync(process.execPath, [detector, '--adapter', manifestPath], {
+    cwd: controlRoot,
+    encoding: 'utf8'
+  });
+  if (result.status !== 0) return null;
+  try { return JSON.parse(result.stdout); } catch { 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';
@@ -291,7 +327,7 @@ async function init(options) {
   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);
+  if (team) await applyOverlay(controlRoot, true, 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`);
@@ -308,6 +344,35 @@ async function currentTeam(controlRoot) {
   catch { throw new Error(`Cannot safely upgrade an invalid team config: ${target}`); }
 }
 
+const deliveryStateDefault = `
+delivery:
+  status: not_delivered
+  handoff: null
+  branches: []
+  evaluator_report: null
+  delivered_at: null
+  owner_message: null
+`;
+
+async function upgradeRunStateDelivery(controlRoot, backupRoot, apply) {
+  const target = join(controlRoot, '.loop', 'run-state.yaml');
+  if (!(await exists(target))) {
+    process.stdout.write('  Delivery state skipped: no initialized .loop/run-state.yaml\n');
+    return;
+  }
+  const source = await readFile(target, 'utf8');
+  if (/^delivery:\s*$/m.test(source)) {
+    process.stdout.write(`  Delivery state already present ${target}\n`);
+    return;
+  }
+  process.stdout.write(`  ${apply ? 'Initialize' : 'Would initialize'} delivery state ${target} (backup)\n`);
+  if (!apply) return;
+  const backup = join(backupRoot, 'project', 'run-state.yaml');
+  await mkdir(dirname(backup), { recursive: true });
+  await cp(target, backup);
+  await writeFile(target, `${source.replace(/\s*$/, '')}\n${deliveryStateDefault}`, 'utf8');
+}
+
 async function upgrade(options) {
   const adapter = getAdapter(options.host);
   if (!adapter) throw new Error(`Choose --host ${listAdapters().map((item) => item.id).join(', ')}.`);
@@ -320,7 +385,8 @@ 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) await applyOverlay(controlRoot, options.apply);
+  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);
@@ -348,13 +414,20 @@ async function doctor(options) {
     const manifestPath = join(controlRoot, '.triad-runtime', 'adapter.json');
     let manifest = false;
     try { manifest = (JSON.parse(await readFile(manifestPath, 'utf8'))?.id === adapter.id); } catch {}
+    const targets = adapter.projectPaths(controlRoot, installContext);
+    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`);
-    const overlay = await overlayPlan(controlRoot).catch(() => null);
+    const overlay = await overlayPlan(controlRoot, team).catch(() => null);
     process.stdout.write(`  Instructions ${overlay ? overlay.action === 'update' ? 'managed' : `needs ${overlay.action}` : 'invalid managed block'}\n`);
     const globalAgents = join(codexHome(), 'AGENTS.md');
     if (await exists(globalAgents)) {

package/docs/codex-replication.md

@@ -4,7 +4,11 @@ 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.
+Evaluator+. Verification uses explicit dispatch by default, even when a complete,
+version-compatible async `SubagentStop` hook is installed. This keeps the normal
+unattended path on the directly auditable verifier route.
+
+The async hook remains available as an experimental opt-in by setting
+`requested_mode=async_hook` in capability detection. Hook output is evidence
+only; it never changes Triad state by itself. If the requested experimental hook
+is unavailable, capability detection fails safe to explicit dispatch.

package/docs/compatibility.md

@@ -2,11 +2,12 @@
 
 | 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` |
+| Codex | Yes | Yes | Yes | Yes | Yes | Explicit dispatch by default; experimental async `SubagentStop` opt-in | 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 |
+| GitHub Copilot | Yes | Yes | Yes | Yes | Yes | Explicit dispatch | No adapter hook; desktop lifecycle validated |
 
 All adapters consume the same role IDs and project-control records. Runtime
 model/effort application is limited to the facilities each host exposes; the

package/docs/configuration.md

@@ -24,8 +24,9 @@ When enabled, Evaluator+ is automatically dispatched by the Orchestrator after
 Triad reaches Reviewer approval. It receives a fresh post-run packet and cannot
 change the closed Triad result. Set `enabled` to `false` to disable this default.
 
-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.
+The runtime adapter is selected once per installed control workspace (`--host`).
+All roles in that run use that adapter; Triad+ does not orchestrate roles across
+different hosts. The team file records role-level models and effort, but an
+adapter writes those into host-native profiles only where the selected 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/npx-installation.md

@@ -35,7 +35,8 @@ the control workspace `AGENTS.md`; existing instructions are preserved. Review
 `doctor` output when host-level instructions impose a fixed identity, because a
 higher-priority host policy can prevent the configured Orchestrator identity.
 
-Supported hosts: `codex`, `opencode`, `claude-code`, `antigravity`, `hermes`.
+Supported hosts: `codex`, `opencode`, `claude-code`, `antigravity`, `hermes`, and
+the `copilot` adapter.
 Use `--global` to install a host-level entry point where desired. The installer
 refuses overwrites. If the control path is recognizably a product Git repository,
 it stops unless `--allow-product-repo` is explicitly supplied after review.

package/docs/operating-guide.it.md

@@ -26,10 +26,23 @@ PRD/card e definizione dei gate. “I test passano” detto dall’agente è una
 l’output del verifier è evidence derivata dall’ambiente. Evidence fallita o
 invalida non può essere trattata come pass.
 
+Per Codex la modalità `auto` usa intenzionalmente il dispatch esplicito. Il
+percorso asincrono `SubagentStop` resta disponibile solo come opt-in
+sperimentale: gli hook producono evidence, mentre l’Orchestrator mantiene
+l’autorità sull’avanzamento del loop.
+
+L’adapter GitHub Copilot usa custom agent di progetto e la skill `triad`, con
+dispatch esplicito della verification e senza hook di lifecycle. Lo smoke della
+desktop app ha validato contesti distinti per i ruoli e la continuazione
+unattended, oltre ai controlli CLI di asset e doctor.
+
 Il Reviewer riceve card, diff, report Developer, rilievi precedenti ed evidence.
 `rework` torna al Developer con una correzione delimitata; `blocked` richiede
 all’Orchestrator di escalare la decisione. Le push normali possono essere autonome
-dopo i goal dichiarati. Avvio e stop della demo restano del proprietario.
+dopo i goal dichiarati. La consegna formale al proprietario è un gate distinto:
+registra push finale, eventuale valutazione, handoff, stato finale della run e
+prova pratica prima di dichiarare il progetto consegnato. Avvio e stop della demo
+restano del proprietario.
 
 ## Evaluator+
 
@@ -48,3 +61,8 @@ eventuali report Evaluator+ e handoff in un workspace di controllo separato. Non
 inserire token o segreti. Gli hook sono un’ottimizzazione, non autorità: il
 dispatch esplicito della verification resta sempre disponibile. Vedi la
 [matrice di compatibilità](compatibility.md).
+
+Per ogni demo configurata, registra nel progetto e nell’handoff comando, URL
+locale, modalità di accesso remoto e URL remoto. `localhost` è solo locale: non
+va indicato a chi prova da remoto. Avvia il servizio soltanto su richiesta del
+proprietario e verifica l’URL remoto dichiarato prima di comunicarlo.

package/docs/operating-guide.md

@@ -27,10 +27,23 @@ hash. A developer saying tests pass is a claim; verifier output is
 environment-derived evidence. Failed or invalid evidence cannot be treated as a
 pass.
 
+Codex is intentionally an exception to automatic hook selection: its `auto`
+mode uses explicit dispatch. The async `SubagentStop` route remains an
+experimental opt-in; this does not change the rule that hooks produce evidence
+and the Orchestrator governs progress.
+
+The GitHub Copilot adapter uses project custom agents and the `triad` skill,
+with explicit verification dispatch and no lifecycle hook. Its desktop-app
+smoke has validated distinct role contexts and unattended continuation in
+addition to the CLI asset and doctor checks.
+
 The Reviewer sees the card, diff, Developer report, previous findings, and
 verifier evidence. `rework` returns a bounded finding to Developer; `blocked`
 asks the Orchestrator to escalate the stated decision. Normal pushes may happen
-autonomously once declared goals pass. Demo start and stop remain owner-controlled.
+autonomously once declared goals pass. A final owner delivery is a separate
+closure gate: it records the final push, optional evaluation, handoff, final run
+record, and practical test before the project is called delivered. Demo start and
+stop remain owner-controlled.
 
 ## Evaluator+
 
@@ -48,3 +61,8 @@ immutable PRD, cards, assignments, evidence, review reports, optional Evaluator+
 reports, and handoff in a separate project-control workspace. Never place tokens
 or secrets there. Hooks are an optimization, not authority; explicit verification
 is always the fallback. See the [compatibility matrix](compatibility.md).
+
+For a configured demo service, record its command, local URL, remote-access mode,
+and remote URL in the project and handoff. `localhost` is local-only; do not give
+it to a remote tester as a reachable endpoint. Start the service only on the
+owner's request and validate any declared remote URL before presenting it.

package/docs/runtimes.md

@@ -5,11 +5,12 @@ host-specific entry points and configuration behavior.
 
 | Runtime | Prerequisite | Entry point | Verification | Hook limitation |
 | --- | --- | --- | --- | --- |
-| Codex | Codex CLI | `/prompts:triad` | Explicit dispatch; async hook when validated | Hook is optional and requires trusted configuration. |
+| Codex | Codex CLI | `/prompts:triad` | Explicit dispatch by default; experimental async hook opt-in | Hook is optional, requires trusted configuration, and is not selected by `auto`. |
 | Claude Code | Claude Code CLI | `/triad` | Explicit dispatch; hook when validated | Hook is optional and requires trusted configuration. |
 | OpenCode | OpenCode | `/triad` | Explicit dispatch | No Triad lifecycle hook. |
 | Antigravity | Antigravity | `/triad` | Explicit dispatch | No Triad lifecycle hook. |
 | Hermes Agent | Hermes Agent | `/triad` | Explicit dispatch | No Triad lifecycle hook. |
+| GitHub Copilot | GitHub Copilot CLI and desktop app | `/triad` when the project skill is exposed, otherwise `/agent` → `triad-orchestrator` | Explicit dispatch | No adapter hook; desktop app supports the complete validated lifecycle. |
 
 Install with `npx triad-plus init --host <runtime> --control <path>`; use
 `--global` when you want host-level command assets. `doctor` reports the runtime
@@ -23,6 +24,28 @@ See the concise host guides for [Codex](codex-replication.md),
 [Claude Code](claude-code-replication.md), [OpenCode](opencode-replication.md),
 and [Antigravity](antigravity-replication.md).
 
+## GitHub Copilot
+
+The Copilot adapter uses the documented custom-agent and agent-skill primitives.
+Install it with:
+
+```bash
+npx triad-plus init --host copilot --control /absolute/path/to/triad-control --global
+npx triad-plus doctor --host copilot --control /absolute/path/to/triad-control
+```
+
+Project agents are generated under `.github/agents/` and the Triad skill under
+`.github/skills/triad/`; `--global` also installs the corresponding assets under
+`~/.copilot/`. Open the control workspace in the Copilot desktop app. Use
+`/triad <absolute-prd-path>` when the skill is available as a command; otherwise
+select `triad-orchestrator` through `/agent` and provide the same request.
+Verification is explicit by default and no Copilot lifecycle hook is required.
+
+The desktop app has been validated with distinct Orchestrator, Developer, and
+Reviewer contexts through a complete unattended Triad run. The adapter uses
+explicit verification and has no lifecycle hook; the CLI and asset paths are
+validated independently as well.
+
 ## OpenCode
 
 Use the interactive OpenCode TUI for complete multi-step Triad runs. OpenCode

package/docs/verification.md

@@ -1,5 +1,18 @@
 # Verification and evidence
 
+## Repository skill bindings
+
+When a target repository declares a skill router, the Orchestrator binds the
+router, routed task skills, and completion skill to the Developer assignment as
+worktree-relative paths and SHA-256 values. `triad-verify` checks that every
+declared skill exists inside the declared worktree and still matches its bound
+hash, then records the result in environment-derived verification evidence.
+
+This proves the exact repository skill policy available to the attempt; it does
+not claim to observe an LLM's private reasoning. Developer, Reviewer, and
+Evaluator+ must separately report their use of the same bound skills, so a
+missing or inconsistent attestation is visible to the Orchestrator.
+
 An agent-reported claim is not the same as verification evidence. A Developer can
 report the commands it ran; `triad-verify` independently observes declared
 required `control-plane` gates and writes atomic evidence.
@@ -15,3 +28,15 @@ it does not itself approve, rework, or transition a run.
 
 Evidence files and logs are diagnostics. Users normally need only the
 Orchestrator's summary and the Reviewer verdict.
+
+## Codex dispatch modes
+
+Codex uses `explicit_dispatch` by default, including when a compatible async
+`SubagentStop` hook is installed. This is the directly auditable path used for
+normal unattended progress. The async hook remains supported as an experimental
+opt-in with `requested_mode=async_hook`; it is selected only when the requested
+hook is valid and available. If that requested hook is unavailable, capability
+detection fails safe to `explicit_dispatch` and records the reason.
+
+Hooks may produce evidence; the Orchestrator governs progress. The hook never
+dispatches a Reviewer, selects a card, reopens a run, or performs repair.

package/integrations/codex/README.md

@@ -1,9 +1,11 @@
 # Triad Codex hook adapter
 
-This adapter is for Codex CLI 0.148.0 or newer. It dispatches the Node
-verification runner when a subagent whose type is exactly `triad_developer`
-stops. It is deliberately an asynchronous command hook: it writes immutable
-evidence and has no authority to approve, reject, or transition a feature card.
+This adapter is for Codex CLI 0.148.0 or newer. Its normal verification route is
+explicit dispatch by the Orchestrator. It also provides an experimental,
+opt-in asynchronous command hook that can dispatch the Node verification runner
+when a subagent whose type is exactly `triad_developer` stops. The hook writes
+immutable evidence and has no authority to approve, reject, or transition a
+feature card.
 
 ## Install only after verifying the local Codex schema
 
@@ -44,18 +46,24 @@ The JSON payload needs an `agent_id` matching an active assignment under
 assignment and emits only structured evidence. The orchestrator still validates
 the evidence against the active candidate before changing state.
 
-## Let Triad choose the route
+## Default and experimental routes
 
-Do not select this route by memory. Keep
-`project.control_plane.dispatch_mode: auto` and run:
+Keep `project.control_plane.dispatch_mode: auto` for the normal Codex path and
+run:
 
 ```bash
 node /absolute/path/to/triad-plus-engineering-loop/runtime/triad-runtime-capabilities.mjs \
   --hook-config /absolute/path/to/installed-triad-hooks.json
 ```
 
-Store the JSON output at `.loop/runtime/capabilities.json`. A CLI below 0.148,
-an uninstalled hook, or a configuration with placeholders selects
-`explicit_dispatch`; a supported, configured hook selects `async_hook`. The
-orchestrator follows that snapshot and re-detects only before a new assignment or
-on resume after runtime configuration changes.
+Store the JSON output at `.loop/runtime/capabilities.json`. For Codex, `auto`
+always selects `explicit_dispatch`, including when the async hook is detected as
+available. This is the default because the live Codex collaboration path did
+not reliably emit `SubagentStop` during the validation runs.
+
+To deliberately test the experimental route, pass
+`--requested-mode async_hook`. A compatible Codex version and a valid trusted
+hook configuration select `async_hook`; an unavailable or invalid hook falls
+back to `explicit_dispatch` with a diagnostic reason. The Orchestrator follows
+the snapshot and re-detects only before a new assignment or on resume after
+runtime configuration changes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triad-plus",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "A lightweight, evidence-backed engineering loop for coding agents.",
   "license": "Apache-2.0",
   "type": "module",

package/runtime/legacy-adapters.json

@@ -3,6 +3,7 @@
     "schema_version": 1,
     "id": "codex",
     "binary": "codex",
+    "verification": { "default_mode": "explicit_dispatch", "experimental_modes": ["async_hook"] },
     "lifecycle": { "kind": "SubagentStop", "agent_type": "triad_developer", "requires_async": true, "minimum_version": "0.148.0" }
   },
   "opencode": { "schema_version": 1, "id": "opencode", "binary": "opencode", "lifecycle": null },
@@ -13,5 +14,12 @@
     "lifecycle": { "kind": "SubagentStop", "agent_type": "triad-developer", "requires_async": false }
   },
   "antigravity": { "schema_version": 1, "id": "antigravity", "binary": "agy", "lifecycle": null },
-  "hermes": { "schema_version": 1, "id": "hermes", "binary": "hermes", "lifecycle": null }
+  "hermes": { "schema_version": 1, "id": "hermes", "binary": "hermes", "lifecycle": null },
+  "copilot": {
+    "schema_version": 1,
+    "id": "copilot",
+    "binary": "copilot",
+    "verification": { "default_mode": "explicit_dispatch" },
+    "lifecycle": null
+  }
 }

package/runtime/triad-runtime-capabilities.mjs

@@ -104,12 +104,40 @@ const hookAvailable = lifecycleAvailable && hook.configured;
 const explicitAvailable = Boolean(hostVersion && nodeVersion);
 let selectedMode = "unavailable";
 let reason = "verification_runtime_unavailable";
-if (hookAvailable && (requestedMode === "auto" || requestedMode === "async_hook" || requestedMode === "hook_dispatch")) {
+const defaultMode = adapter.verification?.default_mode ?? null;
+const experimentalModes = new Set(adapter.verification?.experimental_modes ?? []);
+const experimentalHookRequested = requestedMode === "async_hook" && experimentalModes.has("async_hook");
+
+// An adapter may declare a safer automatic mode. This keeps runtime policy in
+// adapter metadata instead of adding host-specific branches to the Core.
+if (requestedMode === "auto" && defaultMode) {
+  if (defaultMode === "explicit_dispatch" && explicitAvailable) {
+    selectedMode = "explicit_dispatch";
+    reason = `${adapter.id}_default_explicit_dispatch`;
+  } else if (defaultMode === "async_hook" && hookAvailable) {
+    selectedMode = "async_hook";
+    reason = `${adapter.id}_default_async_hook`;
+  } else if (defaultMode === "hook_dispatch" && hookAvailable) {
+    selectedMode = "hook_dispatch";
+    reason = `${adapter.id}_default_hook_dispatch`;
+  } else if (explicitAvailable) {
+    selectedMode = "explicit_dispatch";
+    reason = `${adapter.id}_default_${defaultMode}_unavailable_using_explicit_dispatch`;
+  }
+} else if (experimentalHookRequested && hookAvailable) {
+  selectedMode = "async_hook";
+  reason = "experimental_async_hook_requested";
+} else if (experimentalHookRequested && explicitAvailable) {
+  selectedMode = "explicit_dispatch";
+  reason = "requested_async_hook_unavailable_using_explicit_dispatch";
+} else if (hookAvailable && (requestedMode === "auto" || requestedMode === "async_hook" || requestedMode === "hook_dispatch") && (!lifecycle?.requires_async || requestedMode === "async_hook")) {
   selectedMode = lifecycle.requires_async ? "async_hook" : "hook_dispatch";
   reason = lifecycle.requires_async ? "validated_async_hook_available" : "validated_hook_dispatch_available";
 } else if (explicitAvailable) {
   selectedMode = "explicit_dispatch";
-  reason = ["async_hook", "hook_dispatch"].includes(requestedMode)
+  reason = requestedMode === "explicit_dispatch"
+    ? "explicit_dispatch_requested"
+    : ["async_hook", "hook_dispatch"].includes(requestedMode)
     ? "requested_hook_unavailable_using_explicit_dispatch"
     : "explicit_dispatch_available";
 }

package/runtime/triad-verify.mjs

@@ -27,6 +27,26 @@ async function sha256File(value) {
   return sha256(await readFile(value));
 }
 
+async function validateRepositorySkills(required, worktree) {
+  if (required === undefined) return { declared: false, skills: [] };
+  if (!Array.isArray(required) || required.length === 0) throw new Error("repository skill binding must declare at least one skill");
+  const root = await realpath(worktree);
+  const skills = [];
+  for (const item of required) {
+    if (!item || typeof item.path !== "string" || typeof item.sha256 !== "string") {
+      throw new Error("repository skill binding entries require path and sha256");
+    }
+    const candidate = path.resolve(root, item.path);
+    if (!candidate.startsWith(`${root}${path.sep}`)) throw new Error("repository skill path escapes worktree");
+    try { await access(candidate); }
+    catch { throw new Error(`repository skill missing: ${item.path}`); }
+    const actual = await sha256File(candidate);
+    if (actual !== item.sha256) throw new Error(`repository skill hash mismatch: ${item.path}`);
+    skills.push({ path: item.path, sha256: actual });
+  }
+  return { declared: true, skills };
+}
+
 function triggerFrom(payload) {
   return {
     event: payload.event ?? payload.hook_event_name ?? "manual",
@@ -100,6 +120,7 @@ async function main() {
     await access(cardPath);
     if ((await sha256File(prdPath)) !== assignment.expected_prd_sha256) throw new Error("PRD baseline hash mismatch");
     if ((await sha256File(cardPath)) !== assignment.expected_card_sha256) throw new Error("feature card hash mismatch");
+    const repositorySkills = await validateRepositorySkills(assignment.required_repository_skills, worktree);
     const before = await calculateCandidateFingerprint(worktree);
     const branch = await worktreeBranch(worktree);
     if (assignment.expected_branch && assignment.expected_branch !== branch) throw new Error("worktree branch does not match assignment");
@@ -128,6 +149,7 @@ async function main() {
         candidate_fingerprint: before.value,
         branch,
       },
+      repository_skills: repositorySkills,
       gates,
       required_gates_passed: requiredGatesPassed,
       status: candidateChanged ? "invalidated" : requiredGatesPassed ? "pass" : "fail",