@sabaiway/agent-workflow-kit 12.0.0 → 12.2.0

package/bridges/codex-cli-bridge/bin/codex-exec.test.mjs

@@ -194,10 +194,10 @@ describe('codex-exec.sh — quality-first model/effort guard (1.1)', { concurren
 
   it('refuses a non-default CODEX_EFFORT', async () => {
     const sb = makeSandbox();
-    const r = await run(sb, { env: { CODEX_EFFORT: 'high' } });
+    const r = await run(sb, { env: { CODEX_EFFORT: 'xhigh' } });
     rmSync(sb.root, { recursive: true, force: true });
     assert.notEqual(r.status, 0);
-    assert.match(r.stderr, /not the pinned max effort/);
+    assert.match(r.stderr, /not the pinned effort/);
   });
 
   it('CODEX_PROBE=1 allows a non-default model and warns loudly', async () => {
@@ -650,8 +650,8 @@ describe('codex-exec.sh — preflight (unchanged invariants)', { concurrency: 2
 
 describe('codex-exec.sh — resume entrypoint restates every invariant (3.1)', { concurrency: 2 }, () => {
   const RESUME_INVARIANTS = [
-    /(^|\n)resume(\n|$)/, /(^|\n)--ignore-user-config(\n|$)/, /(^|\n)gpt-5\.6-sol(\n|$)/,
-    /model_reasoning_effort=xhigh/, /sandbox_mode=workspace-write/,
+    /(^|\n)resume(\n|$)/, /(^|\n)--ignore-user-config(\n|$)/, /(^|\n)gpt-6-astra(\n|$)/,
+    /model_reasoning_effort=high/, /sandbox_mode=workspace-write/,
     /approval_policy=never/, /sandbox_workspace_write\.network_access=false/,
   ];
 
@@ -1546,7 +1546,7 @@ describe('codex-exec.sh — dispatch-posture labeling (D5, AD-061)', { concurren
     const lines = banners(r.stderr);
     assert.equal(lines.length, 1, 'EXACTLY ONE banner line per run');
     assert.equal(lines[0],
-      'exec posture: model=gpt-5.6-sol effort=xhigh tier=standard sandbox=workspace-write session=fresh timeout=3600s');
+      'exec posture: model=gpt-6-astra effort=high tier=standard sandbox=workspace-write session=fresh timeout=3600s');
   });
 
   it('an ARMED Fast tier rides the banner (tier=priority)', async () => {
@@ -1642,11 +1642,11 @@ describe('codex-exec.sh — dispatch-posture labeling (D5, AD-061)', { concurren
 
   it('a banner field carrying CONTROL BYTES refuses pre-spend (model / effort / tier / timeout / DEL)', async () => {
     const cases = [
-      { CODEX_MODEL: `gpt-5.6-sol${String.fromCharCode(1)}` },
-      { CODEX_EFFORT: `xhigh${String.fromCharCode(2)}` },
+      { CODEX_MODEL: `gpt-6-astra${String.fromCharCode(1)}` },
+      { CODEX_EFFORT: `high${String.fromCharCode(2)}` },
       { CODEX_SERVICE_TIER: `priority${String.fromCharCode(3)}` },
       { CODEX_HARD_TIMEOUT: `3600${String.fromCharCode(4)}` },
-      { CODEX_MODEL: `gpt-5.6-sol${String.fromCharCode(127)}` },
+      { CODEX_MODEL: `gpt-6-astra${String.fromCharCode(127)}` },
     ];
     for (const env of cases) {
       const sb = makeSandbox();
@@ -2047,7 +2047,7 @@ describe('codex-exec.sh — the pre-spend reservation (D1/D8)', { concurrency: 2
     assert.equal(r.status, 71, r.stderr);
     assert.equal(held.state, 'reserved');
     assert.equal(held.wrapperVersion, MANIFEST.version, 'the receipt stamps the bridge version version-sync bumps');
-    assert.deepEqual(held.posture, { model: 'gpt-5.6-sol', effort: 'xhigh', tier: null });
+    assert.deepEqual(held.posture, { model: 'gpt-6-astra', effort: 'high', tier: null });
     assert.equal(held.capS, 3600);
     assert.equal(held.killGraceS, 15);
     assert.match(held.contractDigest, /^[0-9a-f]{64}$/);

package/bridges/codex-cli-bridge/bin/codex-review.sh

@@ -21,7 +21,7 @@
 # back as a validated JSON object, with a raw-text fallback.
 #
 # Auth/policy: subscription-only, identical to codex-exec.sh. Quality-first: the
-# review runs on the PINNED model at max effort (advisory findings still bear on
+# review runs on the PINNED model at the pinned effort (advisory findings still bear on
 # what ships, so the same pin-integrity guard applies; CODEX_PROBE=1 relaxes it for
 # a throwaway probe only).
 #
@@ -39,7 +39,7 @@ set -euo pipefail
 case "${1:-}" in
   --help|-h)
     cat <<'HELP'
-codex-review — read-only ADVISORY review by the OpenAI Codex CLI (subscription-only; the PINNED model at max effort).
+codex-review — read-only ADVISORY review by the OpenAI Codex CLI (subscription-only; the PINNED model at the pinned effort).
 
 Usage:
   codex-review plan <plan-file> [--nonce <n>]
@@ -91,7 +91,7 @@ Receipt:
 
 Settings file (KEY=VALUE, parsed never sourced; env wins over file, file wins over built-in default):
   ${XDG_CONFIG_HOME:-~/.config}/agent-workflow/bridge-settings.conf
-  CODEX_SERVICE_TIER — service tier: 'priority' (Fast — ~1.5x speed at a 2.5x credit rate on gpt-5.6-sol); a consented SPEND knob, default off (standard tier)
+  CODEX_SERVICE_TIER — service tier: 'priority' (Fast — "2x speed, increased usage", the codex catalog's own words for gpt-6-astra, cache fetched 2026-09-05; it states no credit-rate figure); a consented SPEND knob, default off (standard tier)
   CODEX_HARD_TIMEOUT — hard wall-clock cap, integer seconds 1..86400 (built-in default 1800)
   CODEX_REVIEW_MAX_TOTAL_BYTES — inline-payload cap, integer bytes 1..100000000 (default 1500000); above it the diff rides via a git-dir temp file
 
@@ -279,15 +279,15 @@ aw_resolve_timeout_bin() {
   printf '%s' "$bin"
 }
 
-DEFAULT_CODEX_MODEL="gpt-5.6-sol"
-DEFAULT_CODEX_EFFORT="xhigh"
+DEFAULT_CODEX_MODEL="gpt-6-astra"
+DEFAULT_CODEX_EFFORT="high"
 # Review-receipt identity (AD-038). AW_BRIDGE_VERSION mirrors this bridge's SKILL.md/capability.json
 # version (drift-guarded by codex-review.test.mjs against capability.json).
 AW_RECEIPT_BACKEND="codex"
-AW_BRIDGE_VERSION="3.7.0"  # aw-version-anchor
+AW_BRIDGE_VERSION="3.8.0"  # aw-version-anchor
 CODEX_MODEL="${CODEX_MODEL:-$DEFAULT_CODEX_MODEL}"
 CODEX_EFFORT="${CODEX_EFFORT:-$DEFAULT_CODEX_EFFORT}"
-# Generous hard cap for a slow xhigh review (subscription latency varies).
+# Generous hard cap for a slow review at the pinned effort (subscription latency varies).
 CODEX_HARD_TIMEOUT="${CODEX_HARD_TIMEOUT:-1800}"
 # Above this assembled-payload size (bytes), the diff goes via a git-dir-local temp
 # file instead of inline — never truncated.
@@ -298,11 +298,12 @@ CODEX_REVIEW_MAX_TOTAL_BYTES="${CODEX_REVIEW_MAX_TOTAL_BYTES:-1500000}"
 # file), so the budget is pinned at the DEFAULT inline-payload cap — the map can never outgrow the
 # whole payload, and every realistic repo's map assembles byte-unchanged.
 AW_REVIEW_MAP_BUDGET_BYTES=1500000
-# Codex service tier (quality-neutral speed knob; live-probed 2026-07-05): default EMPTY ⇒ no
+# Codex service tier (quality-neutral speed knob): default EMPTY ⇒ no
 # service_tier flag (standard tier) — enabling Fast is a consented per-host SPEND act, never a
 # silent default. The only server-catalog tier id on this subscription is 'priority' (catalog
-# display name "Fast": ~1.5x token speed at a 2.5x credit rate on gpt-5.6-sol; quality-neutral —
-# same model). codex itself accepts ANY -c service_tier string silently (probe-verified), so
+# display name "Fast": "2x speed, increased usage" in the catalog's own words for gpt-6-astra, cache
+# fetched 2026-09-05; it states no credit-rate figure; quality-neutral — same model). codex itself
+# accepts ANY -c service_tier string silently (probe-verified), so
 # the wrapper validates the effective value: an unsupported one warns and runs on the standard
 # tier — a typo can never silently masquerade as Fast.
 CODEX_SERVICE_TIER="${CODEX_SERVICE_TIER:-}"
@@ -365,13 +366,13 @@ if [[ "${CODEX_PROBE:-}" == "1" ]]; then
 else
   if [[ "$CODEX_MODEL" != "$DEFAULT_CODEX_MODEL" ]]; then
     echo "error: CODEX_MODEL='$CODEX_MODEL' is not the pinned model '$DEFAULT_CODEX_MODEL'." >&2
-    echo "       A delegated review must run on the pinned model at max effort (quality-first)." >&2
+    echo "       A delegated review must run on the pinned model at the pinned effort (quality-first)." >&2
     echo "       For a throwaway probe whose result is effort-independent, set CODEX_PROBE=1." >&2
     exit 2
   fi
   if [[ "$CODEX_EFFORT" != "$DEFAULT_CODEX_EFFORT" ]]; then
-    echo "error: CODEX_EFFORT='$CODEX_EFFORT' is not the pinned max effort '$DEFAULT_CODEX_EFFORT'." >&2
-    echo "       A delegated review must run at max reasoning effort (quality-first)." >&2
+    echo "error: CODEX_EFFORT='$CODEX_EFFORT' is not the pinned effort '$DEFAULT_CODEX_EFFORT'." >&2
+    echo "       A delegated review must run at the pinned reasoning effort (quality-first)." >&2
     echo "       For a throwaway probe whose result is effort-independent, set CODEX_PROBE=1." >&2
     exit 2
   fi

package/bridges/codex-cli-bridge/bin/codex-review.test.mjs

@@ -172,10 +172,10 @@ describe('codex-review.sh — quality-first model/effort guard (1.1)', { concurr
 
   it('refuses a non-default CODEX_EFFORT', async () => {
     const sb = makeSandbox();
-    const r = await run(sb, { env: { CODEX_EFFORT: 'high' } });
+    const r = await run(sb, { env: { CODEX_EFFORT: 'xhigh' } });
     rmSync(sb.root, { recursive: true, force: true });
     assert.notEqual(r.status, 0);
-    assert.match(r.stderr, /not the pinned max effort/);
+    assert.match(r.stderr, /not the pinned effort/);
   });
 
   it('CODEX_PROBE=1 relaxes the guard and warns', async () => {
@@ -1646,8 +1646,8 @@ describe('codex-review.sh — dispatch-posture labeling (D5)', { concurrency: 2
     const receipts = readReceipts(sb.repo);
     rmSync(sb.root, { recursive: true, force: true });
     assert.equal(r.status, 0, r.stderr);
-    assert.match(r.stderr, /review posture: model=gpt-5\.6-sol effort=xhigh tier=standard/, 'the banner states the actual run posture');
-    assert.deepEqual(receipts[0].posture, { model: 'gpt-5.6-sol', effort: 'xhigh', tier: null }, 'banner ↔ receipt parity (standard tier = null)');
+    assert.match(r.stderr, /review posture: model=gpt-6-astra effort=high tier=standard/, 'the banner states the actual run posture');
+    assert.deepEqual(receipts[0].posture, { model: 'gpt-6-astra', effort: 'high', tier: null }, 'banner ↔ receipt parity (standard tier = null)');
     assert.deepEqual(Object.keys(receipts[0]), Object.keys(RECEIPT_FIXTURE), 'fixture key set + order');
   });
 
@@ -1657,7 +1657,7 @@ describe('codex-review.sh — dispatch-posture labeling (D5)', { concurrency: 2
     const receipts = readReceipts(sb.repo);
     rmSync(sb.root, { recursive: true, force: true });
     assert.equal(r.status, 0, r.stderr);
-    assert.match(r.stderr, /review posture: model=gpt-5\.6-sol effort=xhigh tier=priority/);
+    assert.match(r.stderr, /review posture: model=gpt-6-astra effort=high tier=priority/);
     assert.equal(receipts[0].posture.tier, 'priority');
   });
 
@@ -1674,7 +1674,7 @@ describe('codex-review.sh — dispatch-posture labeling (D5)', { concurrency: 2
 
   it('a posture value carrying CONTROL BYTES refuses pre-spend, BEFORE the pinned-model guard', async () => {
     const sb = makeSandbox();
-    const r = await run(sb, { env: { CODEX_MODEL: `gpt-5.6-sol${String.fromCharCode(1)}` } });
+    const r = await run(sb, { env: { CODEX_MODEL: `gpt-6-astra${String.fromCharCode(1)}` } });
     const receipts = readReceipts(sb.repo);
     rmSync(sb.root, { recursive: true, force: true });
     assert.notEqual(r.status, 0);
@@ -1689,7 +1689,7 @@ describe('codex-review.sh — dispatch-posture labeling (D5)', { concurrency: 2
     const receipts = readReceipts(sb.repo);
     rmSync(sb.root, { recursive: true, force: true });
     assert.equal(r.status, 0, r.stderr);
-    assert.match(r.stderr, /^review posture: model=gpt-5\.6-sol effort=xhigh tier=standard timeout=1800s$/m);
+    assert.match(r.stderr, /^review posture: model=gpt-6-astra effort=high tier=standard timeout=1800s$/m);
     assert.deepEqual(Object.keys(receipts[0].posture), ['model', 'effort', 'tier'], 'timeout never enters the receipt posture');
   });
 
@@ -1715,7 +1715,7 @@ describe('codex-review.sh — dispatch-posture labeling (D5)', { concurrency: 2
 
   it('a DEL (0x7f) byte in a banner field refuses pre-spend like the C0 range', async () => {
     const sb = makeSandbox();
-    const r = await run(sb, { env: { CODEX_MODEL: `gpt-5.6-sol${String.fromCharCode(127)}` } });
+    const r = await run(sb, { env: { CODEX_MODEL: `gpt-6-astra${String.fromCharCode(127)}` } });
     const receipts = readReceipts(sb.repo);
     rmSync(sb.root, { recursive: true, force: true });
     assert.notEqual(r.status, 0);

package/bridges/codex-cli-bridge/capability.json

@@ -3,8 +3,8 @@
   "schema": 1,
   "name": "codex-cli-bridge",
   "kind": "execution-backend",
-  "version": "3.7.0",
-  "posture": { "model": "gpt-5.6-sol", "effort": "xhigh", "tier": null },
+  "version": "3.8.0",
+  "posture": { "model": "gpt-6-astra", "effort": "high", "tier": null },
   "provides": ["execute", "review"],
   "roles": {
     "execute": {
@@ -141,7 +141,7 @@
       ],
       "guardrails": [
         { "value": "read-only sandbox — codex cannot edit, create or delete a file", "enforcement": "enforced", "source": "bin/codex-review.sh" },
-        { "value": "runs on the pinned model at max effort", "enforcement": "enforced", "condition": "unless CODEX_PROBE=1 relaxes the guard for a throwaway probe", "source": "bin/codex-review.sh" },
+        { "value": "runs on the pinned model at the pinned effort", "enforcement": "enforced", "condition": "unless CODEX_PROBE=1 relaxes the guard for a throwaway probe", "source": "bin/codex-review.sh" },
         { "value": "a successful review appends one receipt line the review-state gate reads", "enforcement": "enforced", "condition": "a receipt write failure warns and the review still succeeds — the tree then reads un-receipted", "source": "capability.json roles.review.contract.receipt" }
       ],
       "customHooks": ["CODEX_PROBE"]
@@ -193,7 +193,7 @@
       "values": ["priority"],
       "default": null,
       "appliesTo": ["codex-exec", "codex-review"],
-      "effect": "codex service tier; 'priority' (catalog display name Fast) = ~1.5x token speed at a 2.5x credit rate on gpt-5.6-sol — quality-neutral (same model), live-probed 2026-07-05. Unset/empty ⇒ no service_tier flag (standard tier). SPEND KNOB: enabling it is a consented per-host act, never a default. codex itself accepts any -c service_tier string silently, so the wrapper validates the value."
+      "effect": "codex service tier; 'priority' (catalog display name Fast) = \"2x speed, increased usage\" in the codex catalog's own words for gpt-6-astra (cache fetched 2026-09-05); it states no credit-rate figure — quality-neutral (same model). Unset/empty ⇒ no service_tier flag (standard tier). SPEND KNOB: enabling it is a consented per-host act, never a default. codex itself accepts any -c service_tier string silently, so the wrapper validates the value."
     },
     {
       "key": "CODEX_HARD_TIMEOUT",

package/bridges/codex-cli-bridge/references/driving-codex.md

@@ -20,7 +20,7 @@ judgment.
 
 ## Quality-first: model & effort are pinned
 
-Delegated codex work ALWAYS runs on the PINNED model at max effort: `gpt-5.6-sol` / `xhigh` are **pinned**
+Delegated codex work ALWAYS runs on the PINNED model at the pinned effort: `gpt-6-astra` / `high` are **pinned**
 and a non-default `CODEX_MODEL`/`CODEX_EFFORT` is **refused** (exit 2). That the pinned id is still the
 strongest selectable model is a hand-checked claim with no automated gate and no recorded date — see
 SKILL.md. Do not try to "tune down" the
@@ -92,7 +92,7 @@ codex-exec --resume <session-id> <file|->  # explicit session id
 
 Resume continues the SAME codex session, so you avoid re-sending the original context. It runs through
 the wrapper, which **re-establishes every invariant** (subscription-only `*_API_KEY` scrub,
-`--ignore-user-config`, the pinned `gpt-5.6-sol`/`xhigh`) and **restates the full posture via `-c`** —
+`--ignore-user-config`, the pinned `gpt-6-astra`/`high`) and **restates the full posture via `-c`** —
 because `codex exec resume` resets the sandbox/approval/network posture and rejects `-s`/`--add-dir`/`-C`,
 the wrapper passes `-c sandbox_mode=workspace-write -c approval_policy=never -c
 sandbox_workspace_write.network_access=false` explicitly. A resume takes no passthrough flags and an

package/bridges/codex-cli-bridge/references/sandbox-and-flags.md

@@ -47,7 +47,7 @@ carries the session id) into the run trace, with stderr merged into it; `--color
 `--color`, which stays on the fresh lane), so the resume lane is no longer the odd one out: it used
 to print its final message straight to stdout with the event stream nowhere, which left the very
 mode a nested-sandbox incident fired on without a structured evidence surface. Net effect: the wrapper prints just the final answer. **Reasoning still runs at
-`xhigh`** — quality is unchanged; only the *noise* is dropped. On success `codex-exec` extracts the
+the pinned effort** — quality is unchanged; only the *noise* is dropped. On success `codex-exec` extracts the
 session id from the trace and records it to `${CODEX_SESSION_FILE:-./.codex-last-session}` (so
 `--resume-last` can find it) and echoes `session: <id>` to stderr. On a missing/empty final-message
 file it falls back to the trace tail (loud, never silent).
@@ -63,8 +63,8 @@ failure is proven.
 
 ## Quality-first guard (pinned model & effort)
 
-The wrappers default `CODEX_MODEL=gpt-5.6-sol` and `CODEX_EFFORT=xhigh` and **refuse** (exit 2, loud) any
-non-default — delegated work always uses the PINNED model at max effort; quality is never traded for
+The wrappers default `CODEX_MODEL=gpt-6-astra` and `CODEX_EFFORT=high` and **refuse** (exit 2, loud) any
+non-default — delegated work always uses the PINNED model at the pinned effort; quality is never traded for
 quota. (Whether the pinned id is still the strongest selectable model is a hand-checked claim with no
 automated gate — see SKILL.md.) `CODEX_PROBE=1` relaxes this for a throwaway, effort-independent probe only (echoed loudly), and
 a probe still runs on the subscription, in the sandbox, with clean capture.
@@ -164,7 +164,7 @@ EVIDENCE posture as a fresh run — `-o` for the final message, `--json` into th
 
 A backgrounded/hung run survives otherwise, so both wrappers wrap codex in `timeout`/`gtimeout`
 (`--kill-after=15s`): `CODEX_HARD_TIMEOUT` defaults to **3600s (exec)** / **1800s (review)**, sized for a
-slow `xhigh` run. Exit 124/137 ⇒ "exceeded the hard cap" (raise the cap or narrow the task). If neither
+slow run at the pinned effort. Exit 124/137 ⇒ "exceeded the hard cap" (raise the cap or narrow the task). If neither
 `timeout` nor `gtimeout` is on `PATH`, `codex-exec` **warns loudly and runs uncapped** — never a silent
 no-op — while `codex-review` **refuses pre-spend** (the fail-closed hard-timeout preflight).
 
@@ -205,8 +205,8 @@ exec` over the precomputed diff instead, keeping every invariant intact.
 | `-o, --output-last-message <f>` | write ONLY the final message (clean capture) |
 | `--json` | structured event stream (`thread.started` ⇒ session id) |
 | `--output-schema <f>` | constrain output to a JSON schema (`CODEX_REVIEW_SCHEMA=1`) |
-| `-m <model>` | model (wrapper default `gpt-5.6-sol`, pinned via `CODEX_MODEL`) |
-| `-c model_reasoning_effort=<effort>` | reasoning effort (wrapper default `xhigh`, pinned via `CODEX_EFFORT`) |
+| `-m <model>` | model (wrapper default `gpt-6-astra`, pinned via `CODEX_MODEL`) |
+| `-c model_reasoning_effort=<effort>` | reasoning effort (wrapper default `high`, pinned via `CODEX_EFFORT`) |
 | `--ignore-user-config` | do NOT load `$CODEX_HOME/config.toml`; auth still uses `CODEX_HOME` |
 | `--color never` | disable ANSI colour in output |
 

package/capability.json

@@ -3,7 +3,7 @@
   "schema": 1,
   "name": "agent-workflow-kit",
   "kind": "composition-root",
-  "version": "12.0.0",
+  "version": "12.2.0",
   "provides": [],
   "roles": {},
   "detect": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sabaiway/agent-workflow-kit",
-  "version": "12.0.0",
+  "version": "12.2.0",
   "description": "Portable, cross-agent memory & workflow for AI coding agents — Claude Code, Codex, Cursor, Devin Desktop. One command deploys an AGENTS.md entry point + docs/ai context with cap/archive/index enforcement into any repo.",
   "keywords": [
     "ai-agents",

package/references/modes/bridge-settings.md

@@ -8,7 +8,7 @@ The reader + consent-gated **writer** for the **host-level** bridge settings fil
 
 | key | bridge | values | note |
 |---|---|---|---|
-| `CODEX_SERVICE_TIER` | codex | `priority` | **SPEND KNOB** — the "Fast" tier: ~1.5× token speed at a **2.5× credit rate** on gpt-5.6-sol, quality-neutral (same model). Default unset ⇒ standard tier. |
+| `CODEX_SERVICE_TIER` | codex | `priority` | **SPEND KNOB** — the "Fast" tier: "2x speed, **increased usage**" in the codex catalog's own words for gpt-6-astra (cache fetched 2026-09-05); it states no credit-rate figure; quality-neutral (same model). Default unset ⇒ standard tier. |
 | `CODEX_HARD_TIMEOUT` | codex | integer `1..86400` | hard wall-clock cap (seconds) via `timeout(1)`. |
 | `CODEX_REVIEW_MAX_TOTAL_BYTES` | codex | integer `1..100000000` | codex-review payload size above which the diff rides a temp file (never truncated). |
 | `AGY_HARD_TIMEOUT` | agy | duration `5m`/`30m`/`90s` (unit required, nonzero) | hard wall-clock cap via `timeout(1)`. |
@@ -25,7 +25,7 @@ The reader + consent-gated **writer** for the **host-level** bridge settings fil
 
 **Refusals (the guarded contract):** an **unknown key** or an **invalid / out-of-range value** → exit `2` (nothing read of the file, nothing written). A file that already carries **duplicate keys** → exit `1`, named and left **byte-untouched** (fix the duplicates by hand first — the writer never edits blindly around them). A **symlinked / non-regular / unreadable** settings file → exit `1` (refuses to write through it). `--apply` with `--dry-run`, a duplicate op for one key, or a malformed `--set` → usage exit `2`.
 
-**Spend consent (D4):** enabling `CODEX_SERVICE_TIER=priority` costs a **2.5× credit rate** — a per-host, consented act, never a default. The preview shows the caveat (from the manifest `effect`); confirm with the user before `--apply`. The tool also warns when an env var currently shadows the key you are writing (the env value wins for that session until unset).
+**Spend consent (D4):** enabling `CODEX_SERVICE_TIER=priority` costs **increased usage** (the catalog states no credit-rate figure) — a per-host, consented act, never a default. The preview shows the caveat (from the manifest `effect`); confirm with the user before `--apply`. The tool also warns when an env var currently shadows the key you are writing (the env value wins for that session until unset).
 
 Output is **English/structured** — **localize it to the user's conversational language** when you narrate.
 

package/references/modes/now.md

@@ -0,0 +1,30 @@
+### Mode: now
+
+<!-- opt-in-capability: none — an inspection surface that configures nothing -->
+
+Read-only. The single answer to where the work stands. It writes no file, cache, receipt, lock or git state; it never commits and never runs a subscription CLI.
+
+Run `node ${CLAUDE_SKILL_DIR}/tools/now-cli.mjs --dir <project> --json`. For a direct terminal render, use `--format=plain|ansi|json`; `--json` is strict sugar for `--format=json`.
+
+Render the returned envelope compactly in the user's conversational language. Never paste the JSON and never expose an internal field name. Preserve every fact, evidence label, annotation and withheld cause while translating only the prose around source-language commands, paths and identifiers.
+
+The four blocks keep this order:
+
+1. **NOW** — every plan in flight, its derived phase, current and next step, then the tree fingerprint, clean state, review verdict lines, final run and red-proof currency. No plan and several plans are rendered states; never pick one silently.
+2. **STEPS** — every ledger row with one of `landed`, `in progress`, `pending` or `unjudged`. The rows are the steps; invent no numbering.
+3. **QUEUE** — every work-carrying row (live, parked, ambiguous) under the full line-numbered heading path it carries, with per-class counts covering every row of the bucket, terminal and record included, and names rather than ids. Only a path through `## Pending / backlog` calls its position priority; every other bucket is archive and calls it position.
+4. **CAMPAIGN** — source-size config state (`absent`, `authored`, `incomplete`, `minted`), caps, roots, recorded over-cap files and aggregate lines. An absent opt-in config is a rendered state.
+
+Evidence alone sets a ledger status: the row's path and verb, then the path fact, changed set and exclusion fact. The plan's prose never sets a status. A checked box or terminal marker is only a claim; when evidence contradicts it, print the claim beside the evidence-derived status. Keep anomaly and current red-proof annotations beside the same status too. Every status line names its evidence source.
+
+A block that cannot be derived is `WITHHELD` and prints its cause on one line. NOW has two halves, plans and tree, each independently a value or `WITHHELD`; NOW itself is `WITHHELD` only when both are. Render every other block normally.
+
+Exit codes:
+
+| Code | Meaning |
+|------|---------|
+| 0 | Anything rendered, including default states, contradictions and a WITHHELD block. |
+| 1 | Nothing rendered: every block withheld, each cause printed on stderr; the usual cause is a `--dir` that is not a git work tree. |
+| 2 | Usage: an unknown flag, an invalid or missing value, conflicting `--json` / `--format`, or `--help` combined with anything. |
+
+**Invariants:** read-only · the plan's prose never sets status · evidence is shown beside every status · compact user-language render with no JSON or internal field names · `process.exitCode`, never `process.exit()`.

package/tools/bridge-settings.mjs

@@ -273,7 +273,7 @@ export const main = (argv = [], ctx = {}) => {
     const body = joinLines(newLines);
 
     // The machine surface carries the SAME spend/credit-rate caveats the human preview prints (D4) — a
-    // --json consumer must not miss the 2.5x-credit consent warning the human render shows.
+    // --json consumer must not miss the spend consent warning the human render shows.
     const jsonBody = (wrote) => ({ path, wrote, noop, changes: changes.map((c) => ({ key: c.key, kind: c.kind, before: c.before, after: c.after })), envShadows, caveats });
 
     if (!apply || noop) {

package/tools/commands.mjs

@@ -84,6 +84,13 @@ const CATALOG = [
     kind: READ_ONLY,
     oneLine: 'Show what is installed and at what version, your settings and backends, and what is deployed in this project.',
   },
+  {
+    key: 'now',
+    invocation: invocationOf('now'),
+    group: 'Inspect',
+    kind: READ_ONLY,
+    oneLine: 'Show where work stands: NOW answers the plan and tree, STEPS the evidence-derived ledger state, QUEUE its named positions, and CAMPAIGN its size-practice figures; the plan’s own text never sets a status.',
+  },
   {
     key: 'backends',
     invocation: invocationOf('backends'),

package/tools/feedback-record.mjs

@@ -18,7 +18,11 @@ const NOTES_HEADING = '## Notes';
 const TABLE_HEADER = '| # | Claim | Evidence | Verdict | Disposition |';
 const OBJECT_ID = /^(?:[0-9a-f]{40}|[0-9a-f]{64})$/iu;
 const ANCHOR = /^`([^`,\s]+):([1-9][0-9]*)(?:-([1-9][0-9]*))?`$/u;
-const ROW_ID = '[A-Z0-9][A-Z0-9-]*';
+// The row id a checked record hands over, and the ONE home of that grammar: the queue's name
+// judge reads it back for the EXPLICITLY marked form (`— id <ID>`), so every id this writer may
+// legally emit round-trips through the judge — including `FOO`, `TASK-123` and `1-TASK`, which
+// the judge's own heuristic deliberately does not read unmarked.
+export const ROW_ID = '[A-Z0-9][A-Z0-9-]*';
 const QUEUE = new RegExp(`^queue (${ROW_ID})$`, 'u');
 const ALREADY_QUEUED = new RegExp(`^already-queued (${ROW_ID})$`, 'u');
 const REASONED_DISPOSITION = /^(?:declined|folded): (.+)$/u;
@@ -227,7 +231,7 @@ export const renderRows = (record, { date, recordPath }) => {
   return ids.map((id) => {
     const claims = record.claims.filter((claim) => QUEUE.exec(claim.disposition)?.[1] === id);
     return [
-      `- [ ] ${id}: ${claims[0].claim} (${date})`,
+      `- [ ] ${claims[0].claim} — id ${id} (${date})`,
       ...claims.map((claim) => `  - ${claim.claim}; verdict ${claim.verdict}; evidence ${claim.anchors.map(rendersAnchor).join(', ')}`),
       `  - record: ${recordPath}`,
       `  - head: ${record.head}`,

package/tools/now-cli.mjs

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+// The CLI half of `now`: argv, the io seam and the pipeline. The rules live in now-status.mjs, the
+// facts in now-facts.mjs, the phrases in now-render.mjs.
+
+import { resolve } from 'node:path';
+import { fail } from '../references/scripts/markdown-blocks.mjs';
+import { isDirectRun } from './direct-run.mjs';
+import { FORMATS, detectSurface } from './surface.mjs';
+import { gatherNowFacts } from './now-facts.mjs';
+import { isWithheld } from './now-status.mjs';
+import { renderNow, toNowViewModel } from './now-render.mjs';
+
+const BLOCKS = Object.freeze(['now', 'steps', 'queue', 'campaign']);
+const SCHEMA = 1;
+const FORMAT_FLAG = '--format=';
+const HELP = `now — read-only: where the work stands, in four blocks.
+
+Usage:
+  node now-cli.mjs [--dir <project>] [--format=<${FORMATS.join('|')}>] [--json]
+
+--dir     the project to read (default: the current directory).
+--format  the output surface; --json is strict sugar for --format=json, and naming both with
+          different values is usage.
+--help    answered only when it is the whole invocation.
+
+Blocks: NOW (the plans in flight, the phase, the current and the next step, the tree), STEPS (the
+ledger rows, one status each), QUEUE (the backlog folded under each row's heading path), CAMPAIGN
+(the size practice). A block that cannot be derived is WITHHELD with its cause on one line.
+
+A status is a function of the row's (path, verb) pair and the evidence at that path; the row's prose
+is printed as a claim beside a status it never moves.
+
+Exit codes: 0 anything rendered, a withheld block included; 1 nothing rendered at all (a --dir that
+is not a git work tree); 2 usage.
+
+Reads only: no store, no receipt, no cache, no lock.`;
+
+const valueAt = (argv, index, flag) => {
+  const value = argv[index + 1];
+  if (value === undefined || value === '' || value.startsWith('-')) throw fail(2, `${flag} takes a value`);
+  return value;
+};
+
+export const parseArgv = (argv) => {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    if (argv.length !== 1) throw fail(2, '--help is answered only when it is the whole invocation');
+    return { help: true, dir: null, formats: [] };
+  }
+  const parsed = argv.reduce((state, arg, index) => {
+    if (state.skip) return { ...state, skip: false };
+    if (arg === '--dir') return { ...state, dir: valueAt(argv, index, arg), skip: true };
+    if (arg === '--format') return { ...state, formats: [...state.formats, valueAt(argv, index, arg)], skip: true };
+    if (arg.startsWith(FORMAT_FLAG)) return { ...state, formats: [...state.formats, arg.slice(FORMAT_FLAG.length)] };
+    if (arg === '--json') return { ...state, formats: [...state.formats, 'json'], json: true };
+    throw fail(2, `unknown argument "${arg}" — run with --help`);
+  }, { help: false, dir: null, formats: [], json: false, skip: false });
+  if (parsed.json && parsed.formats.some((format) => format !== 'json')) {
+    throw fail(2, '--json is strict sugar for --format=json — naming both with different values is usage');
+  }
+  return parsed;
+};
+
+const resolveSurface = (formats, env, io) => detectSurface({
+  argv: formats.map((format) => `${FORMAT_FLAG}${format}`),
+  env,
+  isTTY: io.isTTY ?? Boolean(process.stdout.isTTY),
+  columns: io.columns ?? process.stdout.columns,
+  platform: io.platform ?? process.platform,
+});
+
+const toEnvelope = (dir, vm) => ({ schema: SCHEMA, command: 'now', dir, ...vm });
+
+export const main = (argv, io = {}) => {
+  const log = io.log ?? console.log;
+  const error = io.error ?? console.error;
+  const env = io.env ?? process.env;
+  const start = (() => {
+    try {
+      const options = parseArgv(argv);
+      return options.help ? { help: true } : { options, surface: resolveSurface(options.formats, env, io) };
+    } catch (err) {
+      error(err?.message ?? String(err));
+      return { code: err?.exitCode ?? 2 };
+    }
+  })();
+  if (start.code !== undefined) return start.code;
+  if (start.help) {
+    log(HELP);
+    return 0;
+  }
+  const cwd = resolve(io.cwd ?? process.cwd(), start.options.dir ?? '.');
+  // The composed readers spawn git under process.env alone, so the flag must reach them there too.
+  process.env.GIT_OPTIONAL_LOCKS = '0';
+  const vm = toNowViewModel(gatherNowFacts({ cwd, env: { ...env, GIT_OPTIONAL_LOCKS: '0' } }));
+  const blocks = BLOCKS.map((name) => vm[name]);
+  if (blocks.every(isWithheld)) {
+    for (const cause of new Set(blocks.map(({ withheld }) => withheld))) error(cause);
+    return 1;
+  }
+  log(start.surface.mode === 'json' ? JSON.stringify(toEnvelope(cwd, vm), null, 2) : renderNow(vm, start.surface));
+  return 0;
+};
+
+if (isDirectRun(import.meta.url)) process.exitCode = main(process.argv.slice(2));

package/tools/now-facts.mjs

@@ -0,0 +1,67 @@
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+import { buildSummaryState, isTreeClean } from './core-evidence.mjs';
+import { readRegularFileNoFollow } from './fs-read-nofollow.mjs';
+import { resolveGitLocation } from './git-env.mjs';
+import { auditQueue } from './queue-audit.mjs';
+import { loadSourceSizeConfig, practiceFacts } from './source-size-config.mjs';
+import { gatherPlanFacts, readSummaryFacts } from './now-plan-facts.mjs';
+import { isWithheld } from './now-status.mjs';
+
+const QUEUE_REL = 'docs/plans/queue.md';
+const BLOCKS = Object.freeze(['plans', 'tree', 'queue', 'campaign']);
+
+const attempt = (label, read) => {
+  try {
+    return read();
+  } catch (error) {
+    return { withheld: `${label}: ${error?.message ?? error}` };
+  }
+};
+
+const readQueueFacts = (cwd, deps) => {
+  const read = readRegularFileNoFollow(join(cwd, QUEUE_REL), deps.io ?? {});
+  if (read.outcome !== 'ok') throw new Error(`${QUEUE_REL} is not a readable regular file (${read.className ?? read.code ?? read.outcome})`);
+  const { rows, counts, total } = auditQueue(read.content, { label: QUEUE_REL });
+  return { path: QUEUE_REL, rows, counts, total };
+};
+
+// The practice is opt-in: an absent declaration is a rendered STATE, only an unreadable one is withheld.
+const readCampaignFacts = (cwd, deps) => {
+  const loaded = loadSourceSizeConfig(cwd, deps);
+  return loaded.state === 'absent' ? { state: loaded.state } : { state: loaded.state, ...practiceFacts(loaded.config) };
+};
+
+// A store the summary cannot trust never attests: the tree is withheld with the store's own cause.
+const describeUntrustedStore = (summary) => {
+  if (summary.evidenceUnavailable) return `the core-evidence store is malformed or unreadable (${summary.storeReadError ?? `${summary.storeMalformed} malformed line(s)`})`;
+  if (summary.receiptsUnavailable) return `the review receipts store is malformed or unreadable (${summary.receiptsReadError ?? `${summary.receiptsMalformed} malformed line(s)`})`;
+  return null;
+};
+
+const toTreeFacts = (summary, clean) => {
+  const untrusted = describeUntrustedStore(summary);
+  if (untrusted) return { withheld: untrusted };
+  const { redProofs, receipts } = readSummaryFacts(summary);
+  return { fingerprint: summary.fingerprint, clean, verdicts: receipts.verdicts, finalRun: receipts.finalRun, redProofs };
+};
+
+export const gatherNowFacts = ({ cwd, env: given = process.env, deps = {} }) => {
+  // Every reader honouring an env argument spawns under this one: a plain `git diff` rewrites .git/index without the flag.
+  const env = { ...given, GIT_OPTIONAL_LOCKS: '0' };
+  const location = resolveGitLocation(cwd, { spawn: deps.spawn ?? spawnSync, env });
+  if (location.state !== 'work-tree') {
+    const withheld = `${cwd} is not a git work tree (${location.state}: ${location.cause})`;
+    return Object.fromEntries(BLOCKS.map((block) => [block, { withheld }]));
+  }
+  const root = location.top;
+  const summary = attempt('the evidence summary', () => deps.summary ?? buildSummaryState({ cwd: root, env }));
+  return {
+    plans: attempt('the plans in flight', () => ({
+      entries: gatherPlanFacts({ cwd: root, env, deps }).plans,
+    })),
+    tree: isWithheld(summary) ? summary : attempt('the tree state', () => toTreeFacts(summary, isTreeClean(root, { env }))),
+    queue: attempt('the queue', () => readQueueFacts(root, deps)),
+    campaign: attempt('the practice', () => readCampaignFacts(root, deps)),
+  };
+};