triad-plus 1.0.0 → 1.1.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.1.1 — 2026-08-25
+
+- Ensure every supported host adopts the configured Orchestrator display name
+  for owner-facing communication.
+- Keep the public install-test fixture neutral.
+
+## 1.1.0 — 2026-08-24
+
+- Automatically dispatch configured Evaluator+ after Triad approval, without
+  allowing it to reopen or repair the closed run.
+- Add a five-minute OpenCode tutorial and refresh README onboarding.
+- Remove operational service artifacts from the public tree.
+- Change future releases to Apache-2.0.
+
 ## 1.0.0 — 2026-08-24
 
 - Public Triad+ engineering loop with Orchestrator, Developer, and Reviewer.

package/CONTRIBUTING.md

@@ -42,3 +42,9 @@ binding. Do not add `if <runtime>` behavior to Core installer or verifier code.
 Explain the user-facing outcome, provide test output, and call out runtime
 limitations. Maintainers may ask for a clean package smoke when install assets
 change.
+
+## Operational artifacts
+
+Keep working reports, smoke transcripts, handoffs, and release checklists in
+`.triad-internal/` (which Git ignores) or outside the repository. The tracked
+tree is reserved for product code and user/contributor documentation.

package/LICENSE

@@ -1,21 +1,201 @@
-MIT License
-
-Copyright (c) 2026 Giovanni Delbono
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Giovanni Del Bono
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,36 +1,113 @@
 # Triad+
 
-Triad+ is a lightweight engineering loop for coding agents with three explicit roles.
+<p align="center">
+  <img src="assets/triad-plus-engineering-loop-icon.svg" alt="Triad+ logo" width="220">
+</p>
+
+## Stop letting the same AI write the code and approve its own work.
+
+Triad+ gives coding agents a lightweight engineering loop with separate
+implementation, review, and orchestration.
 
 > **Developer proposes. Reviewer challenges. Orchestrator governs.**
 
-It is not a workflow engine or autonomous development platform. The coding-agent host stays in control; Triad+ provides role contracts, independent review, and verification evidence.
+## Why Triad+?
 
-```text
-                Orchestrator
-                /           \
-          Developer  ←→  Reviewer
+| | What changes |
+| --- | --- |
+| **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 a runtime, model, persona, and supported effort for each role. |
+| **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. |
+
+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
+happens next.
 
-Triad approved → optional fresh Evaluator+
+## How it works
+
+```text
+                   Orchestrator
+                   /           \
+            Developer  ←→  Reviewer
+                   ↓
+             triad-verify evidence
+
+Reviewer approved
+       ↓
+Evaluator+ (only when configured; fresh and post-run)
 ```
 
-## Why Triad?
+The normal path is `Developer → verification → Reviewer → approved | rework |
+blocked`. The Orchestrator governs the loop. When configured, Evaluator+ runs
+automatically after approval with a fresh packet; a `FAIL` is information for a
+future user-initiated run, never an automatic repair.
 
-A single agent can implement, self-check, and declare success in one conversation. Triad separates those responsibilities: the Developer changes the candidate, the Reviewer looks for defects, and the Orchestrator decides rework, approval, or escalation. `triad-verify` supplies environment-derived gate evidence, distinct from an agent claim.
+## Try Triad+ in 5 minutes with OpenCode
 
-## Supported coding agents
+OpenCode is the canonical tutorial because it is open source and makes the
+separate Triad roles easy to inspect.
 
-| Runtime | Orchestrator | Developer | Reviewer | Evaluator+ | Verification dispatch |
-| --- | --- | --- | --- | --- | --- |
-| Codex | Yes | Yes | Yes | Yes | Explicit fallback; async hook when validated |
-| Claude Code | Yes | Yes | Yes | Yes | Explicit fallback; hook when validated |
-| OpenCode | Yes | Yes | Yes | Yes | Explicit dispatch |
-| Antigravity | Yes | Yes | Yes | Yes | Explicit dispatch |
-| Hermes Agent | Yes | Yes | Yes | Yes | Explicit dispatch |
+1. Install OpenCode and configure a provider/model, following the
+   [OpenCode documentation](https://opencode.ai/docs).
+2. Create a small product folder and deterministic test command:
+
+   ```bash
+   mkdir triad-celsius && cd triad-celsius
+   npm init -y
+   npm pkg set type=module
+   npm pkg set scripts.test='node --test'
+   ```
+3. Create a separate control workspace and install the OpenCode adapter:
+
+   ```bash
+   npx triad-plus init --host opencode --control "$PWD/triad-control"
+   npx triad-plus doctor --host opencode --control "$PWD/triad-control"
+   ```
+
+   The setup asks for the Orchestrator, Developer, Reviewer, and optional
+   Evaluator+ names, personas, and models. Choose `yes` for Evaluator+ if you
+   want it automatically after approval.
+4. Save this tiny PRD as `celsius-prd.md` beside the product project:
+
+   ```md
+   # Goal
+   Create a `celsiusToFahrenheit` utility.
 
-Hooks are optional optimizations; they write evidence and never make a Triad state decision. See [runtime details](docs/runtimes.md).
+   ## Acceptance criteria
+   - Export `celsiusToFahrenheit(value)`.
+   - `celsiusToFahrenheit(0)` returns `32`.
+   - `celsiusToFahrenheit(100)` returns `212`.
+   - Add automated tests.
 
-## Quick start
+   ## Verification
+   npm test
+   ```
+5. Open `triad-control` **interactively** in the OpenCode TUI and run:
+
+   ```text
+   /triad /absolute/path/to/celsius-prd.md
+   ```
+
+Expected experience:
+
+```text
+Orchestrator
+      ↓
+Developer implements
+      ↓
+triad-verify produces evidence
+      ↓
+Reviewer inspects
+      ├─ approved → optional automatic Evaluator+
+      └─ rework → Developer
+```
+
+The Orchestrator first shows the feature cards, then delegates the bounded work.
+If a tutorial step is unclear, see the [OpenCode guide](docs/runtimes.md#opencode)
+and [troubleshooting](docs/troubleshooting.md).
+
+## Quick start for every runtime
 
 Requirements: Node.js 20+ and one supported coding-agent host.
 
@@ -39,7 +116,8 @@ npx triad-plus init --host codex --control /absolute/path/to/triad-control --glo
 npx triad-plus doctor --host codex --control /absolute/path/to/triad-control
 ```
 
-`init` creates a separate control workspace and refuses overwrites. Open it in the selected host, then start Triad with an absolute PRD path:
+Open the control workspace in the selected host and start Triad with an absolute
+PRD path:
 
 | Host | Entry point |
 | --- | --- |
@@ -49,32 +127,46 @@ npx triad-plus doctor --host codex --control /absolute/path/to/triad-control
 | Antigravity | `/triad /absolute/path/to/prd.md` |
 | Hermes Agent | `/triad /absolute/path/to/prd.md` |
 
-The Orchestrator presents feature cards before implementation. Follow [Getting started](docs/getting-started.md) for the complete copy-paste walkthrough.
-
-## Configure agents
+## Evaluator+
 
-The wizard or reviewed `team.json` configures display name/persona, model, and supported effort/options for each role. Use neutral names. The selected adapter/runtime is project-level; per-role model binding is applied only where the host supports it. [Configuration](docs/configuration.md) explains the exact contract.
+Evaluator+ is not a fourth member of Triad and is never a repair controller.
+Configure it once in `team.json` (`roles.evaluator.enabled: true`) or in the
+installer. The Orchestrator automatically dispatches it after Triad approval.
+It sees only the goal, quality target, final candidate, and verifier evidence.
 
-## Optional Evaluator+
+## Supported coding agents
 
-Evaluator+ is not a fourth member of Triad. After Reviewer approval, invoke the native command with `--evaluator` where supported:
+| Runtime | Orchestrator | Developer | Reviewer | Evaluator+ | Verification dispatch |
+| --- | --- | --- | --- | --- | --- |
+| Codex | Yes | Yes | Yes | Yes | Explicit fallback; validated async hook when available |
+| Claude Code | Yes | Yes | Yes | Yes | Explicit fallback; validated hook when available |
+| OpenCode | Yes | Yes | Yes | Yes | Explicit dispatch |
+| Antigravity | Yes | Yes | Yes | Yes | Explicit dispatch |
+| Hermes Agent | Yes | Yes | Yes | Yes | Explicit dispatch |
 
-```text
-/triad --evaluator
-```
+## Configuration and verification
 
-It evaluates the completed result freshly and independently. A `FAIL` does not reopen Triad or start repair. See [Evaluator+](docs/evaluator-plus.md).
+The installer writes `.triad-plus/team.json`, which separates stable role IDs
+from user-facing names, personas, models, and supported effort/options. Roles
+can use different models and, where the adapter supports it, different hosts.
+Read [configuration](docs/configuration.md) and [runtime details](docs/runtimes.md).
 
-## Architecture and limits
+`triad-verify` validates assignment/candidate binding, runs declared
+control-plane gates, detects mutation, and writes evidence. It supports the
+loop; it never replaces the Orchestrator. See [verification](docs/verification.md).
 
-Triad+ consists of role skills, adapters, and a verifier. Core has no runtime-specific behavior; adapters own installation, entry-point, lifecycle, and model-binding differences. The verifier validates binding, runs declared control-plane gates, detects mutation, and writes atomic evidence. It does not govern the conversation or replace the Orchestrator.
+## Scope and limitations
 
-Triad+ does not provide a daemon, scheduler, dashboard, shared memory, automatic model routing, multi-reviewer voting, or evaluator-driven repair. Read [architecture](docs/architecture.md), [verification](docs/verification.md), and [troubleshooting](docs/troubleshooting.md).
+Triad+ is deliberately not a workflow engine, daemon, scheduler, dashboard,
+shared-memory system, automatic model router, multi-reviewer system, or
+evaluator-driven repair loop. See [architecture](docs/architecture.md).
 
 ## Contributing
 
-Start with [CONTRIBUTING.md](CONTRIBUTING.md), run `npm test`, and keep runtime-specific behavior inside an adapter.
+Start with [CONTRIBUTING.md](CONTRIBUTING.md). Keep runtime-specific behavior in
+an adapter and preserve the small Core.
 
 ## License
 
-[MIT](LICENSE).
+[Apache-2.0](LICENSE). Triad+ is permissively licensed for personal and
+commercial use.

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

@@ -8,8 +8,16 @@ and `triad-loop-orchestrator` for an initialized one. Read
 `.triad-plus/team.json` if present and verify exposed role models against its
 contract before starting. If the host cannot expose a model identity, say so and
 ask the owner to confirm it; never invent a match. Keep the project-control workspace separate
-from product repositories; delegate normal development, fresh Gauntlet
-evaluation, and independent review to the corresponding Triad agents.
+from product repositories; delegate normal development and independent review to
+the corresponding Triad agents.
+
+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.
 
 Detect the runtime with `.triad-runtime/triad-runtime-capabilities.mjs --host
 antigravity`. Use explicit verification dispatch unless the recorded capability
@@ -17,3 +25,9 @@ snapshot proves a supported asynchronous route. Govern ordinary disagreements
 from evidence and record the decision. Do not implement or review routinely,
 and do not start demos, create pull requests, publish packages, releases, or
 force-push without owner authorization.
+
+After final Triad approval, read `roles.evaluator.enabled` from `team.json`.
+When true, automatically invoke a fresh `triad-evaluator` with only the approved
+goal, quality target, final candidate, and verifier evidence. When false or
+omitted, finish without evaluation. Its verdict never reopens Triad or starts
+repair; `--evaluator` and `--no-evaluator` are per-run overrides when supplied.

package/adapters/antigravity/.agents/skills/triad/SKILL.md

@@ -10,6 +10,14 @@ request. Read `.triad-plus/team.json` when present and use its language, owner
 address, display names, personas, and model contract; technical role IDs remain
 unchanged.
 
+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.
+
 Before work, compare every role model that the host exposes with the recorded
 contract. If Antigravity does not expose a model identity, say that it cannot be
 verified and ask the owner to select or confirm it; never claim a model match
@@ -23,8 +31,10 @@ its selected verification route. Use explicit verifier dispatch unless a future
 Antigravity lifecycle adapter is actually detected and validated.
 
 Delegate normal implementation to `triad-developer` and independent review to
-`triad-reviewer`. Invoke `triad-evaluator` only after Triad approval when the
-owner requests Evaluator+; its independent report never reopens Triad. Continue
+`triad-reviewer`. After Triad approval, automatically invoke fresh
+`triad-evaluator` when `roles.evaluator.enabled` is true in `team.json`; false or
+omitted means no evaluation. Its independent report never reopens Triad or starts
+repair; `--evaluator` and `--no-evaluator` are per-run overrides when supplied. Continue
 through declared cards and normal pushes after all gates pass. Escalate only the
 decision types defined by the Triad+ skills. Do not start or stop a demo without
 an owner instruction.

package/adapters/claude-code/.claude/commands/triad.md

@@ -18,9 +18,19 @@ language, owner address, display names, personas, and model contract in communic
 technical role identifiers and authority remain unchanged. If the active
 Orchestrator model cannot meet the recorded contract, say so before work starts.
 
+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.
+
 Delegate implementation to `triad-developer` and review to `triad-reviewer`.
-Invoke fresh `triad-evaluator` only after Triad approval and only when requested;
-its report never reopens the completed run. Continue
+After Triad approval, automatically invoke fresh `triad-evaluator` when
+`.triad-plus/team.json` has `roles.evaluator.enabled: true`; false or omitted
+means no evaluation. Its report never reopens the completed run; `--evaluator`
+and `--no-evaluator` are per-run overrides when supplied. Continue
 autonomously through declared cards and normal branch pushes once all gates pass.
 Escalate only the decision types defined by the Triad skills. Do not start or
 stop a demo without an owner instruction.

package/adapters/codex/prompts/triad.md

@@ -18,8 +18,18 @@ language, owner address, display names, personas, and model contract in communic
 technical role identifiers and authority remain unchanged. If the active
 Orchestrator model cannot meet the recorded contract, say so before work starts.
 
+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.
+
 Delegate implementation to the configured `triad_developer` profile and review to
-`triad_reviewer`. Once Triad is approved, invoke the optional fresh `triad_evaluator`
-only when requested; its report never reopens the completed run. Continue autonomously through declared cards and normal branch
+`triad_reviewer`. Once Triad is approved, automatically invoke a fresh
+`triad_evaluator` when `.triad-plus/team.json` has `roles.evaluator.enabled: true`.
+When false or omitted, do not invoke it. Its report never reopens the completed run;
+`--evaluator` and `--no-evaluator` are per-run overrides when supplied. Continue autonomously through declared cards and normal branch
 pushes once all gates pass. Escalate only the decision types defined by the
 Triad skills. Do not start or stop a demo without an owner instruction.

package/adapters/hermes/README.md

@@ -21,11 +21,7 @@ adapter uses those host primitives for separately invoked Developer and Reviewer
 roles when the configured model/provider is available. It uses explicit
 verification dispatch; no Hermes lifecycle hook is assumed.
 
-Evaluator+ is opt-in and post-run only:
-
-```text
-/triad --evaluator
-```
-
-It receives the approved goal, acceptance target, final artifact, and verifier
-evidence, then writes an independent report without reopening Triad.
+Evaluator+ is opt-in and post-run only. Set `roles.evaluator.enabled` to `true`
+in `team.json` and the Orchestrator dispatches it automatically after Triad
+approval. It receives the approved goal, acceptance target, final artifact, and
+verifier evidence, then writes an independent report without reopening Triad.

package/adapters/hermes/skills/triad/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: triad
-description: Start or resume a Triad run in Hermes Agent from a PRD source, declared repositories, and measurable goals. Use when the owner invokes /triad or asks Hermes to coordinate a Triad project; use --evaluator only after an approved Triad run for an independent post-run Evaluator+ report.
+description: Start or resume a Triad run in Hermes Agent from a PRD source, declared repositories, and measurable goals. Evaluator+ runs automatically after approval when enabled in team configuration.
 ---
 
 # Triad in Hermes
@@ -11,6 +11,14 @@ Operate the current Hermes session as the Triad Orchestrator. Load
 when present; its role IDs, names, personas, and model/provider contract are
 configuration, not workflow authority.
 
+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.
+
 For a normal run, govern only Orchestrator, Developer, and Reviewer. Delegate
 ordinary implementation with `hermes chat -q --in <worktree> --no-restore-cwd`
 using `--skills triad-loop-developer`; obtain a separate Reviewer result with
@@ -27,10 +35,12 @@ After the Developer finishes, explicitly run
 Triad lifecycle hook in this adapter. A verifier pass is environment-derived
 evidence; a Developer statement is not.
 
-When invoked with `--evaluator`, do not reopen a Triad run. Load
-`triad-loop-evaluator` in a fresh Hermes one-shot session with only the approved
-goal, acceptance target, final artifact, and verification evidence. Store its
+After final Triad approval, read `roles.evaluator.enabled` from `team.json`.
+When true, automatically load `triad-loop-evaluator` in a fresh Hermes one-shot
+session with only the approved goal, acceptance target, final artifact, and
+verification evidence; false or omitted finishes without evaluation. `--evaluator`
+and `--no-evaluator` are per-run overrides when supplied. Store its
 post-run report at the absolute `<control-workspace>/artifacts/evaluator-plus/`
 path supplied by the Orchestrator; never infer it relative to a product worktree.
 `FAIL` or `INDETERMINATE` is information for a new
-owner-requested run, never an automatic repair.
+owner-requested run, never an automatic repair and never reopens Triad.

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

@@ -21,13 +21,21 @@ permission:
 
 You are the Triad+ Engineering Loop orchestrator. Govern the workflow and the
 project-control records; delegate ordinary development to `triad-developer`,
-fresh Gauntlet evaluation to `triad-evaluator`, and independent review to
-`triad-reviewer`. Do not replace any role merely for convenience.
+independent review to `triad-reviewer`, and Evaluator+ only after approval. Do
+not replace any role merely for convenience.
 
 If `.triad-plus/team.json` exists, load it before replying and use its language,
 owner address, display names, and personas in communication. Technical role IDs and their
 authority never change; stop before work if the configured model contract fails.
 
+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.
+
 Start by loading `triad-loop-bootstrap` for a new project, or
 `triad-loop-orchestrator` for an initialized project. Follow the loaded skill
 exactly. Keep the project-control workspace separate from product repositories,
@@ -58,3 +66,10 @@ pass, make normal pushes of declared project branches. Do not force-push, open
 or update pull requests, publish packages, create releases, or start a demo
 without the owner's explicit instruction. A requested demo must remain running
 until the owner explicitly ends it.
+
+After final Triad approval, read `roles.evaluator.enabled` from `team.json`.
+When true, automatically dispatch `triad-evaluator` in a fresh context with only
+the approved goal, quality target, final candidate, and verifier evidence. When
+false or omitted, finish without evaluation. A verdict never reopens Triad,
+assigns Developer work, or starts repair; `--evaluator` and `--no-evaluator` are
+per-run overrides when supplied.

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

@@ -11,6 +11,14 @@ 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.
 
+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.
+
 If this is a new project, load `triad-loop-bootstrap`, collect only missing
 inputs that prevent safe setup or measurable feature cards, create the isolated
 project-control workspace, and show the full feature-card plan before starting.
@@ -22,3 +30,9 @@ Delegate implementation and review through the configured Triad subagents.
 Proceed autonomously through declared cards and normal branch pushes once all
 gates pass. Escalate only the decision types defined by the skills. Do not start
 or stop a demo unless the owner explicitly asks.
+
+After final Triad approval, read `roles.evaluator.enabled` from the team file.
+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.

package/bin/triad-plus.js

@@ -242,7 +242,7 @@ async function init(options) {
   if (adapter.globalEntry) {
     process.stdout.write(`Install user-level assets with --global to expose ${adapter.entry}.\n`);
   }
-  process.stdout.write(`Open the control workspace and use ${adapter.entry} <PRD path>. Evaluator+ is optional and post-run only.\n`);
+  process.stdout.write(`Open the control workspace and use ${adapter.entry} <PRD path>. Configured Evaluator+ runs automatically post-approval.\n`);
 }
 
 async function doctor(options) {

package/docs/configuration.md

@@ -20,6 +20,10 @@ personas. A schema-version-1 configuration has four role records:
 optional and enabled only when `roles.evaluator.enabled` is `true`. Omitting that
 field is backward-compatible and means Evaluator+ is not configured.
 
+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

package/docs/evaluator-plus.md

@@ -1,7 +1,8 @@
 # Evaluator+
 
-Evaluator+ is optional and outside the Triad production loop. Invoke it only
-after the Reviewer has approved a feature or delivery.
+Evaluator+ is optional and outside the Triad production loop. Configure
+`roles.evaluator.enabled: true` and the Orchestrator automatically invokes it
+only after the Reviewer has approved a feature or delivery.
 
 It receives the goal, acceptance target, final artifact, and verifier evidence.
 It should not receive developer reasoning, prior reviewer conversation, or

package/docs/getting-started.md

@@ -9,7 +9,8 @@ npx triad-plus doctor --host codex --control "$PWD/triad-control"
 ```
 
 The interactive setup asks for language, owner address, neutral role names,
-personas, models, and whether optional Evaluator+ is enabled. It writes only
+personas, models, and whether optional Evaluator+ is enabled. When enabled,
+Evaluator+ is automatically dispatched after Triad approval. It writes only
 after you type `install`.
 
 For non-interactive setup, pass a reviewed team file:

package/docs/npx-installation.md

@@ -37,8 +37,6 @@ when `roles.evaluator.enabled` is `true`.
 
 Open the control workspace and invoke the host-native command with an absolute
 PRD path. The Orchestrator presents feature cards before implementation, then
-delegates normal development and review. Use the optional evaluator form exposed
-by the host only after Triad is approved: invoke the native Triad command with
-`--evaluator` (for example `/triad --evaluator`) and the Orchestrator will either
-run the configured Evaluator+ or state that it is disabled. Users never create
+delegates normal development and review. When `roles.evaluator.enabled` is true,
+the Orchestrator invokes Evaluator+ automatically after Triad is approved. Users never create
 evaluation packets, report paths, or evidence directories manually.

package/docs/opencode-replication.md

@@ -4,5 +4,6 @@ Install with `npx triad-plus init --host opencode --control <path>`. Open the
 control workspace and run `/triad <absolute-prd-path>`. Project-local agent and
 command assets carry the configured role models where OpenCode supports them.
 
-Verification uses explicit Orchestrator dispatch. Evaluator+ is optional and may
-be invoked only after a Reviewer-approved result; it cannot reopen that run.
+Verification uses explicit Orchestrator dispatch. A configured Evaluator+ is
+automatically invoked only after a Reviewer-approved result; it cannot reopen
+that run.

package/docs/operating-guide.it.md

@@ -33,7 +33,8 @@ dopo i goal dichiarati. Avvio e stop della demo restano del proprietario.
 
 ## Evaluator+
 
-Evaluator+ è opzionale e fuori dal loop produttivo. Dopo `approved`, osserva solo
+Evaluator+ è opzionale e fuori dal loop produttivo. Se abilitato in `team.json`,
+l’Orchestrator lo avvia automaticamente dopo `approved`; osserva solo
 goal, target di accettazione, candidato finale ed evidence del verifier. Produce
 `PASS`, `FAIL` oppure `INDETERMINATE`. Un `FAIL` non modifica la run chiusa e non
 avvia rework. Vedi [Evaluator+](evaluator-plus.md).

package/docs/operating-guide.md

@@ -34,7 +34,8 @@ autonomously once declared goals pass. Demo start and stop remain owner-controll
 
 ## Evaluator+
 
-Evaluator+ is optional and outside the production loop. After `approved`, it
+Evaluator+ is optional and outside the production loop. When enabled in
+`team.json`, the Orchestrator dispatches it automatically after `approved`. It
 inspects only the goal, acceptance target, final candidate, and verifier evidence.
 Its report is `PASS`, `FAIL`, or `INDETERMINATE`. A failure does not modify the
 closed run or start repair. See [Evaluator+](evaluator-plus.md).

package/docs/runtimes.md

@@ -22,3 +22,10 @@ adapter instructions. It is supported, not experimental.
 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).
+
+## OpenCode
+
+Use the interactive OpenCode TUI for complete multi-step Triad runs. OpenCode
+1.18.0 validated the full Orchestrator → Developer → verifier → Reviewer →
+configured Evaluator+ lifecycle in the TUI. `opencode run` is useful for
+one-shot work but does not retain that multi-step parent/subagent lifecycle.

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "triad-plus",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "description": "A lightweight, evidence-backed engineering loop for coding agents.",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "type": "module",
   "bin": {
     "triad-plus": "bin/triad-plus.js"

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

@@ -1,6 +1,6 @@
 ---
 name: triad-loop-evaluator
-description: Produce a fresh, blind, post-run Evaluator+ report for an already approved Triad result. Use only when explicitly requested after Triad approval, with a goal, acceptance target, final artifact, and environment-derived verification evidence.
+description: Produce a fresh, blind, post-run Evaluator+ report for an already approved Triad result. Use after approval when configured by the Orchestrator, with only a goal, acceptance target, final artifact, and environment-derived verification evidence.
 ---
 
 # Evaluator+

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

@@ -9,6 +9,15 @@ Maintain the goal and operational context. Decide the next step; do not perform
 ordinary implementation or review. Read `project.yaml`, the frozen PRD, queue,
 decision policy, current records, and `.triad-plus/team.json` when present.
 
+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. Technical role IDs and authority remain
+unchanged.
+
 ## Run one card
 
 1. Verify the PRD hash, declared worktree/branch, repository instructions,
@@ -49,6 +58,11 @@ pull request, publish, release, or start/stop a demo without owner direction.
 Write a final handoff with cards, commits, pushes, verifier evidence, reviewer
 decisions, risks, exceptions, and practical-test instructions.
 
-Evaluator+ is outside this run. Invoke it only after Triad is approved and only
-when the owner/configuration requests a separate post-run evaluation. Its result
-cannot reopen, rework, or change this run automatically.
+Evaluator+ is outside the Triad production run. After final Triad approval,
+read `roles.evaluator.enabled` from `.triad-plus/team.json`: when it is `true`,
+automatically dispatch one fresh `triad-loop-evaluator` with only the approved
+goal, quality target, final candidate, and current verifier evidence. When it is
+false or omitted, finish without evaluation. Record the report separately;
+`PASS`, `FAIL`, and `INDETERMINATE` cannot reopen, rework, assign Developer work,
+or change the already closed Triad run. A per-run `--evaluator` or
+`--no-evaluator` request may override the configuration when the host exposes it.