triad-plus 1.4.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

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triad-plus",
-  "version": "1.4.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/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");