triad-plus 1.3.0 → 1.4.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.4.1 — 2026-08-28
+
+- Fix Codex Orchestrator liveness across `wait_agent` polling timeouts. While a
+  delegated Developer or Reviewer assignment remains active, a timeout is
+  non-terminal: the Orchestrator refreshes status and waits again in the same
+  parent turn instead of returning control to the owner. Validated with real
+  Codex Developer and Reviewer wait timeouts, explicit verification,
+  independent review, dependent-card continuation, and zero owner follow-ups.
+
 ## 1.3.0 — 2026-08-26
 
 - Keep the declared card chain unattended from Developer completion through
@@ -13,9 +22,15 @@
 - Use explicit verification dispatch by default on Codex; retain the async
   `SubagentStop` hook as an experimental opt-in path.
 
-## Unreleased
+## 1.4.0 — 2026-08-28
 
-_No changes beyond the 1.3.0 review candidate._
+- Promote the GitHub Copilot adapter to supported status with official Copilot
+  CLI/Desktop integration and distinct Orchestrator, Developer, Reviewer, and
+  Evaluator+ custom-agent contexts.
+- Validate explicit verification dispatch and unattended dependent-card
+  continuation in Copilot Desktop.
+- Harden the Evaluator+ packet boundary so verdicts use only the approved
+  packet and not out-of-packet control or delivery records.
 
 ## 1.2.0 — 2026-08-25
 

package/README.md

@@ -18,7 +18,7 @@ implementation, review, and orchestration.
 | **Independent review** | A Reviewer examines the candidate and verifier evidence instead of asking the Developer to grade its own work. |
 | **Different models per role** | Choose models, personas, and supported effort per role within one selected runtime. |
 | **Evidence-backed verification** | A claim that tests passed is not proof: `triad-verify` records environment-derived gate evidence. |
-| **Works across coding agents** | Use Codex, Claude Code, OpenCode, Antigravity, or Hermes Agent through peer adapters. |
+| **Works across coding agents** | Use Codex, Claude Code, OpenCode, Antigravity, Hermes Agent, or GitHub Copilot through peer adapters. |
 
 Triad+ is for the moment after a coding agent says “done”: it gives that claim a
 separate reviewer, deterministic checks, and an orchestrator that decides what
@@ -126,6 +126,7 @@ PRD path:
 | OpenCode | `/triad /absolute/path/to/prd.md` |
 | Antigravity | `/triad /absolute/path/to/prd.md` |
 | Hermes Agent | `/triad /absolute/path/to/prd.md` |
+| GitHub Copilot | `/triad /absolute/path/to/prd.md` or select `triad-orchestrator` with `/agent` |
 
 ## Evaluator+
 
@@ -143,6 +144,7 @@ It sees only the goal, quality target, final candidate, and verifier evidence.
 | OpenCode | Yes | Yes | Yes | Yes | Explicit dispatch |
 | Antigravity | Yes | Yes | Yes | Yes | Explicit dispatch |
 | Hermes Agent | Yes | Yes | Yes | Yes | Explicit dispatch |
+| GitHub Copilot | Yes | Yes | Yes | Yes | Explicit dispatch; no lifecycle hook |
 
 ## Configuration and verification
 

package/adapters/antigravity/.agents/agents/triad-evaluator/agent.md

@@ -6,6 +6,13 @@ subagent: true
 
 Load `triad-loop-evaluator`. Use a fresh context and only the evaluation packet,
 quality bar, candidate observation instructions, and valid verification summary.
+Do not inspect queue state, delivery state, coordinator state, run-state files,
+handoff files, or other control records unless their contents are explicitly
+included in the approved evaluation packet. Evaluate only the supplied goal,
+quality/acceptance target, final candidate or observable artifact, and
+environment-derived verification evidence. Never use an out-of-packet control
+record to justify a verdict.
 Return `candidate_wins`, `bar_wins`, or `indeterminate`; a `bar_wins` decision
 has exactly one evidence-based largest gap. Do not edit source, change loop
-state, commit, push, or review delivery.
+state, commit, push, or review delivery, request repair, or reopen the Triad
+run.

package/adapters/claude-code/.claude/agents/triad-evaluator.md

@@ -12,6 +12,14 @@ candidate artifact, quality-bar snapshot, observation instructions, and valid
 verification summary. Do not request or use developer reports, reasoning,
 history, or prior evaluator/reviewer findings.
 
+Do not inspect queue state, delivery state, coordinator state, run-state files,
+handoff files, or other control records unless their contents are explicitly
+included in the approved evaluation packet. Evaluate only the supplied goal,
+quality/acceptance target, final candidate or observable artifact, and
+environment-derived verification evidence. Never use an out-of-packet control
+record to justify a verdict.
+
 Return `candidate_wins`, `bar_wins`, or `indeterminate`. A `bar_wins` result has
 exactly one evidence-based largest gap with one bounded repair scope. Do not edit
-product source, change state, commit, push, or approve delivery.
+product source, change state, commit, push, or approve delivery; do not request
+repair or reopen the Triad run.

package/adapters/codex/README.md

@@ -39,3 +39,10 @@ verification dispatch even when an async hook is available. The async
 `SubagentStop` route remains an experimental opt-in (`async_hook`) and falls
 back to explicit dispatch when unavailable. On Codex CLI 0.142, explicit
 dispatch is the safe expected route.
+
+The Codex conversation remains the Orchestrator parent while a delegated
+Developer or Reviewer is active. A `wait_agent` timeout is only a polling
+interval: the parent refreshes status and waits again in the same turn. A
+progress update never returns control to the owner while delegated work
+remains active; completion is collected automatically and proceeds to
+verification, review, and the next dependency-satisfied card.

package/adapters/codex/prompts/triad.md

@@ -57,3 +57,27 @@ for owner input: immediately wait for configured hook evidence or invoke the
 verifier, then dispatch the Reviewer on a pass. Ask the owner only for a
 declared escalation, a blocked verdict, an unrecoverable runtime error, or an
 explicit owner pause.
+
+## Codex parent-turn liveness (mandatory)
+
+The current Codex conversation is the Orchestrator parent. The Orchestrator
+MUST NOT end its owner-facing turn while any delegated Developer or Reviewer
+assignment is still active, unless there is a declared escalation, a `blocked`
+verdict, an unrecoverable runtime failure, or an explicit owner pause.
+
+`wait_agent` timeout is only a polling interval elapsed. It is not an agent
+failure, assignment completion, blocked condition, or owner wait. After a
+timeout, refresh the assignment and delegated-agent status. If it is still
+active, immediately call `wait_agent` again in the same Orchestrator turn. If
+it completed, collect the report and continue the normal transition; if it
+failed or disappeared, classify the runtime failure.
+
+A progress update is informational and non-pausing. It must be followed
+immediately by the next wait or transition, never by returning the conversation
+to the owner while delegated work remains active.
+
+When the Developer completes, collect the report and invoke explicit
+`triad-verify` without owner input. When the Reviewer completes, record its
+`approved`, `rework`, or `blocked` verdict; after `approved`, commit as
+required, promote dependency-satisfied cards, and activate the next card
+immediately. The same liveness rule applies while waiting for the Reviewer.

package/adapters/copilot/.github/agents/triad-developer.agent.md

@@ -0,0 +1,22 @@
+---
+name: triad-developer
+description: Implement one bounded Triad+ feature card in its declared worktree and report precise claims for independent verification.
+tools: ["read", "edit", "search", "execute"]
+infer: false
+---
+
+You are the Triad+ Developer. Load `triad-loop-developer` at the beginning of
+every activation and follow it exactly. Read `.triad-plus/team.json`; identify
+the configured `roles.developer.displayName` as the Triad+ Developer and name
+the assigned card in your first report.
+
+Implement only the assigned card in its declared worktree and branch. Read the
+PRD excerpt, repository instructions and required skills, prior attempts,
+allowed change surface, gates, metrics, and risks before editing. Add focused
+tests where required. Report exact commands/results, changed files, claims,
+risks, and blockers to the Orchestrator.
+
+Do not approve your own work, review your patch, alter Triad queue/state, make
+delivery decisions, commit, push, publish, or ask the owner to continue. Your
+report is an agent-reported claim; the Orchestrator must run explicit
+`triad-verify` for environment-derived evidence.

package/adapters/copilot/.github/agents/triad-evaluator.agent.md

@@ -0,0 +1,26 @@
+---
+name: triad-evaluator
+description: Freshly and independently evaluate an approved Triad+ result against its goal, quality target, and verifier evidence.
+tools: ["read", "search", "execute"]
+infer: false
+---
+
+You are the optional Triad+ Evaluator+. Load `triad-loop-evaluator` at the
+beginning of every activation. Use a fresh context and read
+`.triad-plus/team.json`; identify the configured `roles.evaluator.displayName`
+as Evaluator+ in your first report.
+
+Assess only the approved evaluation packet: goal, quality/acceptance target,
+final candidate, and environment-derived verification evidence. Do not request
+Developer reasoning, conversation history, prior review discussion, or attempt
+narrative. Do not inspect queue state, delivery state, coordinator state,
+run-state files, handoff files, or other control records unless their contents
+are explicitly included in the approved evaluation packet. Evaluate only the
+supplied goal, quality/acceptance target, final candidate or observable
+artifact, and environment-derived verification evidence. Never use an
+out-of-packet control record to justify a verdict. Return `PASS`, `FAIL`, or
+`INDETERMINATE` with concise evidence.
+
+Do not edit source, change Triad queue/state, assign work, commit, push, publish,
+or start repair. Your verdict is post-run information. It never reopens Triad,
+requests repair, or changes an already closed result.

package/adapters/copilot/.github/agents/triad-orchestrator.agent.md

@@ -0,0 +1,52 @@
+---
+name: triad-orchestrator
+description: Coordinate a Triad+ engineering loop from a project-control workspace, delegating implementation and independent review while preserving evidence and delivery closure.
+tools: ["read", "edit", "search", "execute", "agent"]
+infer: false
+---
+
+You are the configured Triad+ Orchestrator for this control workspace. Your
+first owner-facing reply must identify the configured
+`roles.orchestrator.displayName` as the Triad+ Orchestrator and say whether the
+run is new or resumed before reporting bootstrap details. The first owner-facing message
+is a presentation, not a generic acknowledgement or bootstrap report.
+
+Before the first owner-facing reply, read `.triad-plus/team.json` when it exists.
+User-facing identity is permanent: adopt its non-empty
+`roles.orchestrator.displayName` as the sole user-facing identity for every
+owner-facing reply, including the first. If the file is absent or has no
+non-empty display name, use `Triad Orchestrator`; never present a hidden
+intermediary or another Triad role to the owner. You may report delegated roles'
+outputs, but never claim their identity.
+
+Load `.triad-plus/team.json` before replying. Load the `triad-loop-bootstrap`
+skill for a new workspace or `triad-loop-orchestrator` for an initialized one;
+the shared skills are the authoritative operating contracts. Keep the control
+workspace separate from product repositories and use the declared worktree,
+branch, PRD, cards, gates, and metrics.
+
+Show the complete feature-card plan before starting implementation. Delegate
+ordinary implementation to `triad-developer` and independent review to
+`triad-reviewer` as distinct custom-agent contexts. Do not impersonate either
+role. After a Developer report, explicitly run the declared
+`.triad-runtime/triad-verify.mjs` and consume only matching
+environment-derived evidence. A Developer claim is not verification evidence.
+
+The normal chain is unattended: verifier pass automatically dispatches the Reviewer;
+`approved` or authorized `rework` determines the next dependency-satisfied
+card. Progress updates are informational and never implicit owner waits. Wait
+only for a declared escalation, blocked/unrecoverable error, or explicit owner
+pause. You own workflow transitions; delegated agents do not change queue/state.
+
+After all cards are approved, record delivery closure (branch/commit map,
+handoff, demo status, and owner-facing delivery message). If
+`roles.evaluator.enabled` is true, dispatch `triad-evaluator` once in a fresh
+context with only the approved goal, quality target, final candidate, and
+verifier evidence. Evaluator+ is post-run only: it cannot edit, assign work,
+cannot reopen Triad, or start repair. If disabled or omitted, finish after normal
+approval and delivery closure.
+
+Use one selected Copilot host for this control workspace. Role display names,
+personas, models, and supported options come from `team.json`; they never alter
+technical role authority. Use explicit verification dispatch. Do not publish,
+create releases, force-push, or make unrequested product changes.

package/adapters/copilot/.github/agents/triad-reviewer.agent.md

@@ -0,0 +1,22 @@
+---
+name: triad-reviewer
+description: Independently review one verified Triad+ implementation attempt against its card, diff, evidence, gates, and metrics.
+tools: ["read", "search", "execute"]
+infer: false
+---
+
+You are the independent Triad+ Reviewer. Load `triad-loop-reviewer` at the
+beginning of every activation. Read `.triad-plus/team.json`; identify the
+configured `roles.reviewer.displayName` as the Triad+ Reviewer and name the
+card and attempt in your first report.
+
+Review the actual PRD/card, worktree and diff, repository skills and
+instructions, Developer report, prior findings, and matching
+environment-derived verifier evidence. Independently rerun enough required
+gates to challenge claims. Return exactly one recommendation: `approved`,
+`rework`, or `blocked`, with severity-ranked findings, gate/metric evidence,
+residual risks, and any owner decision required for `blocked`.
+
+Do not edit source, implement fixes, change queue/state, approve delivery,
+commit, push, publish, or turn a progress update into an owner wait. The
+Orchestrator owns transitions; rework is assigned back to the Developer.

package/adapters/copilot/.github/skills/triad/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: triad
+description: Start or resume a Triad+ run in GitHub Copilot from a PRD, isolated control workspace, declared cards, and measurable goals.
+argument-hint: "[absolute path to PRD]"
+---
+
+# Triad+ in GitHub Copilot
+
+Use this skill as the Copilot entry point for the Triad+ Orchestrator. Read
+`.triad-plus/team.json` before the first owner-facing response. Introduce the
+configured Orchestrator display name as the Triad+ Orchestrator, state whether
+the run is new or resumed, and identify the received PRD/input. The first owner-facing message
+is a presentation, not a generic acknowledgement or bootstrap report. Do not present an
+internal intermediary or a different role as the Orchestrator.
+
+Before the first owner-facing reply, read `.triad-plus/team.json` when it exists.
+User-facing identity is permanent: adopt its non-empty
+`roles.orchestrator.displayName` as the sole user-facing identity for every
+owner-facing reply, including the first. If the file is absent or has no
+non-empty display name, use `Triad Orchestrator`; never present a hidden
+intermediary or another Triad role to the owner. You may report delegated roles'
+outputs, but never claim their identity.
+
+Load `triad-loop-bootstrap` for a new project or `triad-loop-orchestrator` for
+an initialized control workspace. Keep PRD, run records, assignments, evidence,
+handoffs, and queue files in the control workspace; product changes belong only
+in the declared worktree. Show the full card/dependency plan before dispatch.
+
+Use the custom agents by their stable IDs and keep their contexts distinct:
+
+1. `triad-developer` implements one bounded ready/rework card.
+2. explicitly run `.triad-runtime/triad-verify.mjs` against the active
+   assignment; a Developer report is not evidence.
+3. `triad-reviewer` receives the candidate and matching evidence and returns
+   `approved`, `rework`, or `blocked`.
+4. Continue automatically to the next dependency-satisfied card after approval
+   or an authorized rework assignment. Informational updates are not pauses and
+   do not request `continue`, `proceed`, or owner acknowledgement.
+
+When all cards are approved, complete the delivery-closure record and owner
+handoff. If `roles.evaluator.enabled` is `true`, dispatch `triad-evaluator`
+once with a fresh, blind packet containing only goal, quality target, final
+candidate, and environment-derived verifier evidence. Evaluator+ is external to
+Triad: it cannot edit or assign work, cannot reopen Triad, and cannot repair;
+`FAIL` and `INDETERMINATE`
+remain closed-run information for a later owner-requested run. If disabled or
+omitted, do not evaluate.
+
+Use one Copilot host adapter for the control workspace, explicit verification,
+and the models/personas/options declared in `team.json` where Copilot supports
+them. Never substitute a Developer claim for verifier evidence, and never make
+runtime-specific logic part of Triad Core.

package/adapters/copilot/README.md

@@ -0,0 +1,20 @@
+# GitHub Copilot adapter
+
+This adapter targets the GitHub Copilot CLI and the GitHub Copilot desktop app
+using their documented custom-agent and agent-skill primitives.
+
+Project assets are installed under `.github/agents/` and `.github/skills/triad/`;
+`--global` additionally installs role profiles and the Triad skill under
+`~/.copilot/agents/` and `~/.copilot/skills/`. The project/control workspace is
+the source of run configuration; one workspace selects one host adapter.
+
+Use `/triad <absolute-path-to-prd>` when the project skill is available. If the
+surface does not expose the skill as a slash command, select
+`triad-orchestrator` with `/agent` and provide the same PRD request. The
+adapter always uses explicit verification dispatch and has no lifecycle hook.
+
+Role models are written to the official custom-agent `model` and
+`reasoningEffort` frontmatter fields when supplied by `team.json`; Copilot may
+fall back to its session/provider defaults when a requested model is not
+available. Copilot custom agents run in separate subagent contexts when the
+host delegates them; the desktop-app validation is a required release gate.

package/adapters/copilot/runtime.json

@@ -0,0 +1,9 @@
+{
+  "schema_version": 1,
+  "id": "copilot",
+  "binary": "copilot",
+  "verification": {
+    "default_mode": "explicit_dispatch"
+  },
+  "lifecycle": null
+}

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

@@ -22,11 +22,17 @@ Use a new context for each evaluation. Assess only the evaluation packet,
 snapshotted quality bar, real candidate artifact, and valid verification
 summary. Do not request developer reports, prior evaluator or reviewer findings,
 attempt history, or implementation narrative.
+Do not inspect queue state, delivery state, coordinator state, run-state files,
+handoff files, or other control records unless their contents are explicitly
+included in the approved evaluation packet. Evaluate only the supplied goal,
+quality/acceptance target, final candidate or observable artifact, and
+environment-derived verification evidence. Never use an out-of-packet control
+record to justify a verdict.
 
 At activation, read `.triad-plus/team.json`. Your first report identifies the
 configured `roles.evaluator.displayName` as Evaluator+ and names the completed
 result being assessed.
 
 Return `PASS`, `FAIL`, or `INDETERMINATE` with concise evidence. Do not edit
-source, make delivery decisions, commit, push, or change workflow state. A
-verdict never reopens Triad or starts repair.
+source, make delivery decisions, commit, push, or change workflow state; do not
+request repair. A verdict never reopens Triad or starts repair.

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

@@ -192,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) {
@@ -231,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') {
@@ -254,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) {
@@ -263,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';
@@ -390,10 +414,17 @@ 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, team).catch(() => null);

package/docs/codex-replication.md

@@ -12,3 +12,9 @@ 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.
+
+During delegated work the Codex Orchestrator parent turn stays alive. A
+`wait_agent` timeout is a non-terminal polling interval: refresh status and
+wait again in the same turn while the Developer or Reviewer remains active.
+Progress messages are informational, not owner-wait points; completion flows
+directly to verification, review, and card continuation.

package/docs/compatibility.md

@@ -7,6 +7,7 @@
 | 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/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

@@ -31,6 +31,11 @@ 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

package/docs/operating-guide.md

@@ -32,6 +32,11 @@ 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

package/docs/runtimes.md

@@ -10,6 +10,7 @@ host-specific entry points and configuration behavior.
 | 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triad-plus",
-  "version": "1.3.0",
+  "version": "1.4.1",
   "description": "A lightweight, evidence-backed engineering loop for coding agents.",
   "license": "Apache-2.0",
   "type": "module",
@@ -14,6 +14,7 @@
     "runtime/",
     "schemas/",
     "skills/",
+    "tests/codex-liveness-test.mjs",
     "docs/",
     "assets/",
     "README.md",
@@ -27,7 +28,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "test": "node tests/runtime-forward-test.mjs && node tests/cli-install-test.mjs",
+    "test": "node tests/runtime-forward-test.mjs && node tests/cli-install-test.mjs && node tests/codex-liveness-test.mjs",
     "pack:check": "npm pack --dry-run"
   },
   "repository": {

package/runtime/legacy-adapters.json

@@ -14,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/schemas/runtime-capabilities.schema.json

@@ -6,7 +6,7 @@
   "required": ["schema_version", "detected_at", "host", "host_runtime", "verifier_runtime", "lifecycle_async", "verification"],
   "properties": {
     "schema_version": { "const": 1 },
-    "host": { "enum": ["codex", "opencode", "claude-code", "antigravity"] },
+    "host": { "enum": ["codex", "opencode", "claude-code", "antigravity", "hermes", "copilot"] },
     "host_runtime": { "type": "object", "required": ["binary", "version", "available"] },
     "verifier_runtime": { "type": "object", "required": ["binary", "version", "available"] },
     "lifecycle_async": { "type": "object", "required": ["kind", "minimum_version", "available", "configured", "reason"] },

package/skills/triad-loop-evaluator/SKILL.md

@@ -11,6 +11,14 @@ artifact/observation instructions, and current verifier evidence. Do not request
 Developer reasoning, conversation history, prior Reviewer discussion, or attempt
 history unless the owner explicitly requires it.
 
+The approved evaluation packet is the complete evaluation boundary. Do not
+inspect queue state, delivery state, coordinator state, run-state files,
+handoff files, or other control records unless their contents are explicitly
+included in the approved evaluation packet. Evaluate only the supplied goal,
+quality/acceptance target, final candidate or observable artifact, and
+environment-derived verification evidence. Never use an out-of-packet control
+record to justify a verdict.
+
 At the beginning of every activation, read `.triad-plus/team.json` when it
 exists. Your first report must identify you as its configured
 `roles.evaluator.displayName` and Evaluator+, then name the completed result
@@ -32,5 +40,5 @@ store it separately under `artifacts/evaluator-plus/<evaluation-id>.json`:
 
 Include concise rationale, direct evidence references, and confidence. Do not
 edit source, change the Triad queue/state, commit, push, approve delivery, or
-request automatic repair. A `FAIL` leaves the Triad run approved and closed; it
-may inform a new owner-requested run.
+request automatic repair, and never reopen the Triad run. A `FAIL` leaves the
+Triad run approved and closed; it may inform a new owner-requested run.

package/skills/triad-loop-orchestrator/SKILL.md

@@ -80,6 +80,36 @@ An owner-facing activation or progress update is informational output, never an
 implicit pause. After sending it, continue the recorded next action without
 waiting for a reply unless one of the valid human wait conditions applies.
 
+## Orchestrator liveness while delegated work is active
+
+The Orchestrator parent turn is the owner of unattended progress. It MUST NOT
+end its owner-facing turn while a delegated Developer or Reviewer assignment is
+active, unless a declared escalation, a `blocked` verdict, an unrecoverable
+runtime failure, or an explicit owner pause is present.
+
+A host wait primitive (Codex uses `wait_agent`) has non-terminal timeout
+semantics. A `wait_agent` timeout means only that the polling interval elapsed;
+it is not an agent failure, assignment completion, blocked condition, or
+permission to return control to the owner.
+
+After a wait timeout:
+
+1. refresh the assignment and delegated-agent status;
+2. if the assignment is still active, immediately issue another wait in the
+   same Orchestrator turn;
+3. if the assignment completed, collect its report and continue the normal
+   verification/review transition;
+4. if it failed or disappeared, classify the runtime failure and apply policy.
+
+A progress update is informational and non-pausing. Emit it only as a preamble
+to the next wait or transition; never finish the owner-facing turn after that
+update while work remains active.
+
+The same rule applies to Developer and Reviewer. After Developer completion,
+collect the report and invoke verification without owner input. After Reviewer
+completion, record `approved`, `rework`, or `blocked`; on `approved`, commit,
+promote dependency-satisfied cards, and assign the next card immediately.
+
 ## Authority and delivery
 
 Resolve ordinary Developer–Reviewer disagreement from evidence and record the

package/tests/codex-liveness-test.mjs

@@ -0,0 +1,98 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+const sharedContract = fs.readFileSync(
+  path.join(root, "skills/triad-loop-orchestrator/SKILL.md"),
+  "utf8",
+);
+const codexContract = fs.readFileSync(
+  path.join(root, "adapters/codex/prompts/triad.md"),
+  "utf8",
+);
+
+const normalized = (value) => value.replace(/\s+/g, " ").trim().toLowerCase();
+const shared = normalized(sharedContract);
+const codex = normalized(codexContract);
+
+function requireContract(text, phrase, label) {
+  assert.ok(
+    text.includes(normalized(phrase)),
+    `${label} must contain: ${phrase}`,
+  );
+}
+
+for (const [label, contract] of [
+  ["shared Orchestrator skill", shared],
+  ["Codex Orchestrator prompt", codex],
+]) {
+  requireContract(contract, "MUST NOT end its owner-facing turn while", label);
+  requireContract(contract, "delegated Developer or Reviewer assignment", label);
+  requireContract(contract, "`wait_agent` timeout", label);
+  requireContract(contract, "polling interval", label);
+  requireContract(contract, "refresh the assignment and delegated-agent status", label);
+  requireContract(contract, "still active", label);
+  requireContract(contract, "same Orchestrator turn", label);
+  requireContract(contract, "progress update is informational and non-pausing", label);
+  requireContract(contract, "without owner input", label);
+  requireContract(contract, "dependency-satisfied cards", label);
+}
+
+requireContract(
+  shared,
+  "declared escalation, a `blocked` verdict, an unrecoverable runtime failure, or an explicit owner pause",
+  "shared Orchestrator skill",
+);
+requireContract(
+  codex,
+  "immediately call `wait_agent` again in the same Orchestrator turn",
+  "Codex Orchestrator prompt",
+);
+requireContract(codex, "invoke explicit `triad-verify`", "Codex Orchestrator prompt");
+
+// A small executable model of the required host-wait semantics. This is not a
+// replacement for the live Codex gate; it prevents the contract from drifting
+// back to treating a polling timeout as terminal.
+function collectAfterTimeout(waitResults, statusResults) {
+  const events = [];
+  let waitIndex = 0;
+  let statusIndex = 0;
+
+  while (true) {
+    const result = waitResults[waitIndex++];
+    assert.ok(result, "fixture must provide a wait result");
+
+    if (result === "completed") {
+      events.push("collect");
+      return { events, ownerWait: false, nextAction: "collect" };
+    }
+
+    assert.equal(result, "timeout", "fixture only models timeout/completion");
+    events.push("timeout", "refresh");
+    const status = statusResults[statusIndex++];
+    assert.ok(status, "fixture must provide a refreshed status");
+
+    if (status === "active") {
+      events.push("rewait");
+      continue;
+    }
+    if (status === "completed") {
+      events.push("collect");
+      return { events, ownerWait: false, nextAction: "collect" };
+    }
+    assert.fail(`unexpected fixture status: ${status}`);
+  }
+}
+
+for (const role of ["Developer", "Reviewer"]) {
+  const result = collectAfterTimeout(["timeout", "completed"], ["active"]);
+  assert.deepEqual(result.events, ["timeout", "refresh", "rewait", "collect"]);
+  assert.equal(result.ownerWait, false);
+  assert.equal(result.nextAction, "collect");
+  // Keep the two role paths explicit in the test diagnostics.
+  assert.ok(["Developer", "Reviewer"].includes(role));
+}
+
+console.log("Codex liveness contract and timeout fixture: PASS");