ward carries zero hardcoded agent divergence: read an aos-published agent-adapter manifest

coilysiren commented

2026-06-18 04:28:52 +00:00

Owner

Goal

ward should carry zero hardcoded claude/goose (or any) agent divergence. Per-agent knowledge (binary, argv dialect, context wiring, auth, stream format) must stop living as compiled switch branches and bash case arms, and instead be read from a single agent-adapter manifest published by aos and fetched at runtime - the same pattern ward already uses for the aos dev-base image and the preclone-repos.txt substrate manifest. ward stays one generic image; the agent is selected at runtime from manifest data.

Decided architecture (Kai): aos-published manifest, one image (not per-agent images, not a ward-only struct).

Why

The per-agent facts are duplicated across three layers that drift independently:

The ward-kdl guardfiles (docs/ward-kdl.{claude,goose,codex,opencode}.guardfile.md) already declare each agent's CLI dialect declaratively (e.g. goose: goose session interactive, goose run headless).
The Go switches in cmd/ward/container_compute.go re-encode the same facts.
The bash case in cmd/ward/containerassets/entrypoint.sh re-encodes them a third time.

One source of truth (the manifest, unified with / generated from the guardfiles) collapses all three.

Inventory - every divergence point to remove

cmd/ward/container_compute.go (the spine):

containerMode enum modeClaude|modeCodex|modeQwen|modeGoose (closed agent set)
agentBinary() - mode -> binary (claude/codex/opencode/goose)
hostPreflightArgv() - per-agent one-shot argv (claude -p , goose run -t , others none)
contextLevel() - per-agent ladder (qwen 0, codex 1, goose 2, claude 2)
parseMode() - closed-set validation; --mode default "claude" + claude|codex|qwen|goose usage strings

cmd/ward/container.go (claude-only auth, no equivalent for other agents):

claudeKeychainService = "Claude Code-credentials", resolveClaudeCreds, claudeCredsForMode, WARD_CLAUDE_CREDS_B64, the claudeCreds param threaded through writeTokenEnvFile

cmd/ward/agent.go:

agentModes = []containerMode{...} (subcommand set) + "claude is the daily driver" copy
preflight wiring through mode.agentBinary() / mode.hostPreflightArgv()

cmd/ward/container_reap.go:

e.Mode = "claude" default

cmd/ward/containerassets/entrypoint.sh (re-encodes per-agent knowledge a third time):

defaults WARD_MODE/WARD_AGENT=claude
compose_context() always writes ~/.claude/CLAUDE.md, then the if WARD_MODE = goose special-case mirrors to ~/.config/goose/.goosehints
write_claude_creds() claude-only; compose_permissions() writes ~/.claude/settings.json
the case "$WARD_MODE" argv builder (goose -> goose run -t / goose session, default -> -p --verbose --output-format stream-json)
stream_progress() parses claude's stream-json schema specifically

Manifest shape (aos-published, ward-fetched)

agents:
  claude:
    binary: claude
    headless_argv: [-p, --verbose, --output-format, stream-json]
    interactive_argv: []
    preflight_argv: [-p, "{prompt}"]
    context_level: 2
    context_files: [~/.claude/CLAUDE.md]
    stream: claude-json
    auth: keychain:Claude Code-credentials
  goose:
    binary: goose
    headless_argv: [run, -t, "{prompt}"]
    interactive_argv: [session]
    preflight_argv: [run, -t, "{prompt}"]
    context_level: 2
    context_files: [~/.claude/CLAUDE.md, ~/.config/goose/.goosehints]
    stream: raw
    auth: none

ward reads this and becomes a generic driver. The one piece that cannot fully leave the host is claude's keychain credential resolution - it becomes a generic host resolver driven by auth: keychain:<service> manifest data, not a claudeCredsForMode switch.

Work breakdown

aos: author + publish the agent-adapter manifest (alongside the dev-base image / substrate manifest). Single source of truth; reconcile with the existing ward-kdl guardfiles so the argv dialect is declared once. (Cross-repo dependency - file/track in agentic-os.)
ward Go: replace the container_compute.go switches with a manifest-backed adapter lookup; containerMode becomes an opaque string validated against the manifest, not a hardcoded enum. Generic auth resolver replaces claudeCredsForMode/resolveClaudeCreds (keychain service name comes from manifest). Drop e.Mode = "claude" and the agentModes literal in favour of manifest-derived sets.
ward entrypoint: replace the case "$WARD_MODE" argv builder, the goose .goosehints special-case, and the claude-only creds/permissions/context-file writes with manifest-driven loops (context_files, headless_argv, stream). stream_progress becomes conditional on stream: claude-json.
Tests: table-driven coverage that adding an agent is a manifest edit with no Go/bash change; assert no agent name is hardcoded outside the manifest reader.

Out of scope (note, do not fold in)

cmd/ward/hook.go + cmd/ward/install_hooks.go are ward acting as a Claude Code PreToolUse hook (.claude/settings.json) - a distinct feature, not agent-vs-agent dispatch branching. Leave as-is.

The host-side pre-flight (runPreflight -> hostPreflightArgv) runs the agent's one-shot on the host in the dispatcher's cwd. A goose pre-flight for coilyco-flight-deck/ward#131 ran in the agentic-os checkout, found no cmd/ward-kdl, and (correctly, given a wrong cwd) returned NO-GO. claude's -p read does not poke the wrong repo the same way, which is the observed claude/goose behaviour divergence. The pre-flight prompt/cwd contract should be made repo-neutral (reason from the issue, not the host filesystem) or run against the resolved repo. Worth its own issue.

## Goal ward should carry **zero hardcoded claude/goose (or any) agent divergence**. Per-agent knowledge (binary, argv dialect, context wiring, auth, stream format) must stop living as compiled `switch` branches and bash `case` arms, and instead be read from a single **agent-adapter manifest published by aos** and fetched at runtime - the same pattern ward already uses for the aos dev-base image and the `preclone-repos.txt` substrate manifest. ward stays one generic image; the agent is selected at runtime from manifest data. Decided architecture (Kai): **aos-published manifest, one image** (not per-agent images, not a ward-only struct). ## Why The per-agent facts are duplicated across **three** layers that drift independently: - The **ward-kdl guardfiles** (`docs/ward-kdl.{claude,goose,codex,opencode}.guardfile.md`) already declare each agent's CLI dialect declaratively (e.g. goose: `goose session` interactive, `goose run` headless). - The **Go switches** in `cmd/ward/container_compute.go` re-encode the same facts. - The **bash `case`** in `cmd/ward/containerassets/entrypoint.sh` re-encodes them a third time. One source of truth (the manifest, unified with / generated from the guardfiles) collapses all three. ## Inventory - every divergence point to remove **`cmd/ward/container_compute.go`** (the spine): - `containerMode` enum `modeClaude|modeCodex|modeQwen|modeGoose` (closed agent set) - `agentBinary()` - mode -> binary (`claude`/`codex`/`opencode`/`goose`) - `hostPreflightArgv()` - per-agent one-shot argv (`claude -p `, `goose run -t `, others none) - `contextLevel()` - per-agent ladder (qwen 0, codex 1, goose 2, claude 2) - `parseMode()` - closed-set validation; `--mode` default `"claude"` + `claude|codex|qwen|goose` usage strings **`cmd/ward/container.go`** (claude-only auth, no equivalent for other agents): - `claudeKeychainService = "Claude Code-credentials"`, `resolveClaudeCreds`, `claudeCredsForMode`, `WARD_CLAUDE_CREDS_B64`, the `claudeCreds` param threaded through `writeTokenEnvFile` **`cmd/ward/agent.go`:** - `agentModes = []containerMode{...}` (subcommand set) + "claude is the daily driver" copy - preflight wiring through `mode.agentBinary()` / `mode.hostPreflightArgv()` **`cmd/ward/container_reap.go`:** - `e.Mode = "claude"` default **`cmd/ward/containerassets/entrypoint.sh`** (re-encodes per-agent knowledge a third time): - defaults `WARD_MODE`/`WARD_AGENT=claude` - `compose_context()` always writes `~/.claude/CLAUDE.md`, then the `if WARD_MODE = goose` special-case mirrors to `~/.config/goose/.goosehints` - `write_claude_creds()` claude-only; `compose_permissions()` writes `~/.claude/settings.json` - the `case "$WARD_MODE"` argv builder (goose -> `goose run -t` / `goose session`, default -> `-p --verbose --output-format stream-json`) - `stream_progress()` parses **claude's** stream-json schema specifically ## Manifest shape (aos-published, ward-fetched) ```yaml agents: claude: binary: claude headless_argv: [-p, --verbose, --output-format, stream-json] interactive_argv: [] preflight_argv: [-p, "{prompt}"] context_level: 2 context_files: [~/.claude/CLAUDE.md] stream: claude-json auth: keychain:Claude Code-credentials goose: binary: goose headless_argv: [run, -t, "{prompt}"] interactive_argv: [session] preflight_argv: [run, -t, "{prompt}"] context_level: 2 context_files: [~/.claude/CLAUDE.md, ~/.config/goose/.goosehints] stream: raw auth: none ``` ward reads this and becomes a generic driver. The one piece that cannot fully leave the host is claude's keychain credential resolution - it becomes a generic host resolver driven by `auth: keychain:<service>` manifest data, not a `claudeCredsForMode` switch. ## Work breakdown 1. **aos:** author + publish the agent-adapter manifest (alongside the dev-base image / substrate manifest). Single source of truth; reconcile with the existing ward-kdl guardfiles so the argv dialect is declared once. (Cross-repo dependency - file/track in agentic-os.) 2. **ward Go:** replace the `container_compute.go` switches with a manifest-backed adapter lookup; `containerMode` becomes an opaque string validated against the manifest, not a hardcoded enum. Generic `auth` resolver replaces `claudeCredsForMode`/`resolveClaudeCreds` (keychain service name comes from manifest). Drop `e.Mode = "claude"` and the `agentModes` literal in favour of manifest-derived sets. 3. **ward entrypoint:** replace the `case "$WARD_MODE"` argv builder, the goose `.goosehints` special-case, and the claude-only creds/permissions/context-file writes with manifest-driven loops (`context_files`, `headless_argv`, `stream`). `stream_progress` becomes conditional on `stream: claude-json`. 4. **Tests:** table-driven coverage that adding an agent is a manifest edit with no Go/bash change; assert no agent name is hardcoded outside the manifest reader. ## Out of scope (note, do not fold in) - `cmd/ward/hook.go` + `cmd/ward/install_hooks.go` are ward acting *as a Claude Code PreToolUse hook* (`.claude/settings.json`) - a distinct feature, not agent-vs-agent dispatch branching. Leave as-is. ## Related follow-up (separate bug, surfaced from the goose dispatch log) The host-side pre-flight (`runPreflight` -> `hostPreflightArgv`) runs the agent's one-shot **on the host in the dispatcher's cwd**. A goose pre-flight for `coilyco-flight-deck/ward#131` ran in the `agentic-os` checkout, found no `cmd/ward-kdl`, and (correctly, given a wrong cwd) returned NO-GO. claude's `-p` read does not poke the wrong repo the same way, which is the observed claude/goose behaviour divergence. The pre-flight prompt/cwd contract should be made repo-neutral (reason from the issue, not the host filesystem) or run against the resolved repo. Worth its own issue.

coilysiren commented

2026-06-18 04:35:23 +00:00

Author

Owner

🛫 ward pre-flight: NO-GO

ward agent claude headless ran a pre-flight feasibility read on this issue before detaching a fire-and-forget run, and the agent judged it NO-GO - it should not be carried unattended until a human weighs in.

ward's runtime depends on an aos-published manifest that doesn't exist yet (cross-repo step #1), so a ward-only unattended run can't reach a validated merge without a human deciding the two-repo landing order.

No container was launched. Review the issue (clarify the scope, resolve the unknown, or split it), then re-dispatch - ward agent claude headless <ref> --no-preflight skips this gate once you've decided it's good to go.

full pre-flight read

This is a real refactor with a hard cross-repo ordering problem at its center: work item #1 (author + publish the agent-adapter manifest) lives in aos, not ward, and every ward-side change (Go adapter lookup, entrypoint loops, generic auth resolver) reads that manifest at runtime - so I can't validate ward end-to-end, or safely merge ward code that fetches a manifest, until the aos side is authored and published first. The issue itself flags this as a tracked cross-repo dependency, which means the "merge to main, push" done-condition for a ward-only unattended run isn't actually reachable without either sequencing two repos or merging a generic driver against a manifest that doesn't exist yet. Secondary unknowns: the claude keychain credential path is host/macOS-specific and won't exercise inside an ephemeral Linux container, and the surface (closed-enum removal across container_compute.go, container.go, agent.go, container_reap.go, plus the bash case/stream_progress rewrite) is broad enough that "table-driven proof no agent name is hardcoded" is easy to claim but hard to truly close solo. The sequencing fork (which repo lands first, and whether ward ships behind the manifest) is exactly the kind of costly-to-undo decision a human should set before detaching.

NO-GO: ward's runtime depends on an aos-published manifest that doesn't exist yet (cross-repo step #1), so a ward-only unattended run can't reach a validated merge without a human deciding the two-repo landing order.

Posted automatically by ward agent claude headless pre-flight (ward#147).

### 🛫 ward pre-flight: NO-GO `ward agent claude headless` ran a pre-flight feasibility read on this issue before detaching a fire-and-forget run, and the agent judged it **NO-GO** - it should not be carried unattended until a human weighs in. > ward's runtime depends on an aos-published manifest that doesn't exist yet (cross-repo step #1), so a ward-only unattended run can't reach a validated merge without a human deciding the two-repo landing order. No container was launched. Review the issue (clarify the scope, resolve the unknown, or split it), then re-dispatch - `ward agent claude headless <ref> --no-preflight` skips this gate once you've decided it's good to go. <details><summary>full pre-flight read</summary> This is a real refactor with a hard cross-repo ordering problem at its center: work item #1 (author + publish the agent-adapter manifest) lives in **aos**, not ward, and every ward-side change (Go adapter lookup, entrypoint loops, generic auth resolver) reads that manifest at runtime - so I can't validate ward end-to-end, or safely merge ward code that fetches a manifest, until the aos side is authored and published first. The issue itself flags this as a tracked cross-repo dependency, which means the "merge to main, push" done-condition for a ward-only unattended run isn't actually reachable without either sequencing two repos or merging a generic driver against a manifest that doesn't exist yet. Secondary unknowns: the claude keychain credential path is host/macOS-specific and won't exercise inside an ephemeral Linux container, and the surface (closed-enum removal across `container_compute.go`, `container.go`, `agent.go`, `container_reap.go`, plus the bash `case`/`stream_progress` rewrite) is broad enough that "table-driven proof no agent name is hardcoded" is easy to claim but hard to truly close solo. The sequencing fork (which repo lands first, and whether ward ships behind the manifest) is exactly the kind of costly-to-undo decision a human should set before detaching. NO-GO: ward's runtime depends on an aos-published manifest that doesn't exist yet (cross-repo step #1), so a ward-only unattended run can't reach a validated merge without a human deciding the two-repo landing order. </details> --- Posted automatically by `ward agent claude headless` pre-flight (ward#147).

coilysiren referenced this issue

2026-06-18 04:48:53 +00:00

take this issue and create the aos pre-req for it: https://forgejo.coily… #156

coilysiren added the

labels

2026-06-18 06:15:47 +00:00

coilyco-ops added

and removed

labels

2026-06-24 04:11:58 +00:00

coilyco-ops commented

2026-06-24 17:26:22 +00:00

Owner

Re-triage (goose-triage method, claude-macos-kais-macbook-pro-2 as the judgment engine, 2026-06-24)

P2 - Zero-hardcoded-agent-divergence via an aos-published manifest, big architecture, decided by Kai, committed.
consult - Cross-repo contract spanning three layers, human-gated design.

**Re-triage** (goose-triage method, claude-macos-kais-macbook-pro-2 as the judgment engine, 2026-06-24) - **P2** - Zero-hardcoded-agent-divergence via an aos-published manifest, big architecture, decided by Kai, committed. - **consult** - Cross-repo contract spanning three layers, human-gated design.

coilyco-ops commented

2026-06-24 17:28:39 +00:00

Owner

Re-triage (goose-triage method, claude-macos-kais-macbook-pro-2 as the judgment engine, 2026-06-24)

P2 - Zero-hardcoded-agent-divergence via an aos-published manifest, big architecture, decided by Kai, committed.
consult - Cross-repo contract spanning three layers, human-gated design.

**Re-triage** (goose-triage method, claude-macos-kais-macbook-pro-2 as the judgment engine, 2026-06-24) - **P2** - Zero-hardcoded-agent-divergence via an aos-published manifest, big architecture, decided by Kai, committed. - **consult** - Cross-repo contract spanning three layers, human-gated design.

coilysiren added

and removed

labels

2026-07-01 04:29:56 +00:00

coilyco-ops added

and removed

labels

2026-07-02 00:18:43 +00:00

coilyco-ops commented

2026-07-02 00:20:45 +00:00

Owner

Confirmed headless during the mode sweep: architecture already decided in the body (aos-published agent-adapter manifest, one image). Dispatchable as specced. Recorded by Claude Code (Fable) during the 2026-07-01 ward launch triage session with Kai.

coilyco-ops referenced this issue

2026-07-02 00:24:03 +00:00

Push agent specific code down into aos - and clarify API #194

coilysiren commented

2026-07-06 19:57:09 +00:00

Author

Owner

This has moved a TON over the last 2 weeks, but the core need is solid

coilyco-ops commented

2026-07-08 17:09:38 +00:00

Owner

🔒 Reserved by ward agent --harness codex — container engineer-codex-ward-152 on host kais-macbook-pro-2.local is carrying this issue (reserved 2026-07-08T17:09:36Z). Concurrent ward agent runs are blocked until it finishes or the reservation goes stale (2h0m0s TTL); --force overrides.

Do not comment on or edit this issue to steer the run while it is reserved. The engineer seeded the body once at launch and never re-reads it, so a comment or edit reaches only human readers, never the running engineer. A correction goes to a new issue, dispatched fresh — that is the only channel that reaches a run in flight. Where the forge supports it, ward locks this conversation to make that a road-block rather than a convention (ward#494).

run seed context — what this run is carrying (ward#609)

Resolved: coilyco-flight-deck/ward#152 · branch issue-152 · harness codex · workflow direct-main
Run: engineer-codex-ward-152 · ward v0.451.0 · dispatched 2026-07-08T17:09:36Z
Comment thread: 5 included in the pre-flight read, 0 stripped (ward's own automated comments).
- included: @coilysiren (2026-06-18T04:35:23Z), @coilyco-ops (2026-06-24T17:26:22Z), @coilyco-ops (2026-06-24T17:28:39Z), @coilyco-ops (2026-07-02T00:20:45Z), @coilysiren (2026-07-06T19:57:09Z)

Issue body as seeded:

## Goal

ward should carry **zero hardcoded claude/goose (or any) agent divergence**. Per-agent knowledge (binary, argv dialect, context wiring, auth, stream format) must stop living as compiled `switch` branches and bash `case` arms, and instead be read from a single **agent-adapter manifest published by aos** and fetched at runtime - the same pattern ward already uses for the aos dev-base image and the `preclone-repos.txt` substrate manifest. ward stays one generic image; the agent is selected at runtime from manifest data.

Decided architecture (Kai): **aos-published manifest, one image** (not per-agent images, not a ward-only struct).

## Why

The per-agent facts are duplicated across **three** layers that drift independently:

- The **ward-kdl guardfiles** (`docs/ward-kdl.{claude,goose,codex,opencode}.guardfile.md`) already declare each agent's CLI dialect declaratively (e.g. goose: `goose session` interactive, `goose run` headless).
- The **Go switches** in `cmd/ward/container_compute.go` re-encode the same facts.
- The **bash `case`** in `cmd/ward/containerassets/entrypoint.sh` re-encodes them a third time.

One source of truth (the manifest, unified with / generated from the guardfiles) collapses all three.

## Inventory - every divergence point to remove

**`cmd/ward/container_compute.go`** (the spine):
- `containerMode` enum `modeClaude|modeCodex|modeQwen|modeGoose` (closed agent set)
- `agentBinary()` - mode -> binary (`claude`/`codex`/`opencode`/`goose`)
- `hostPreflightArgv()` - per-agent one-shot argv (`claude -p <p>`, `goose run -t <p>`, others none)
- `contextLevel()` - per-agent ladder (qwen 0, codex 1, goose 2, claude 2)
- `parseMode()` - closed-set validation; `--mode` default `"claude"` + `claude|codex|qwen|goose` usage strings

**`cmd/ward/container.go`** (claude-only auth, no equivalent for other agents):
- `claudeKeychainService = "Claude Code-credentials"`, `resolveClaudeCreds`, `claudeCredsForMode`, `WARD_CLAUDE_CREDS_B64`, the `claudeCreds`

… (truncated to 2000 chars; full body is on this issue)

Static container doctrine and seed boilerplate are identical every run and omitted here (they ride ward v0.451.0).

— Codex, via ward agent

🔒 Reserved by `ward agent --harness codex` — container `engineer-codex-ward-152` on host `kais-macbook-pro-2.local` is carrying this issue (reserved 2026-07-08T17:09:36Z). Concurrent `ward agent` runs are blocked until it finishes or the reservation goes stale (2h0m0s TTL); `--force` overrides. **Do not comment on or edit this issue to steer the run while it is reserved.** The engineer seeded the body once at launch and never re-reads it, so a comment or edit reaches only human readers, never the running engineer. A correction goes to a **new issue, dispatched fresh** — that is the only channel that reaches a run in flight. Where the forge supports it, ward locks this conversation to make that a road-block rather than a convention (ward#494). <details><summary>run seed context — what this run is carrying (ward#609)</summary> - **Resolved:** `coilyco-flight-deck/ward#152` · branch `issue-152` · harness `codex` · workflow `direct-main` - **Run:** `engineer-codex-ward-152` · ward `v0.451.0` · dispatched `2026-07-08T17:09:36Z` - **Comment thread:** 5 included in the pre-flight read, 0 stripped (ward's own automated comments). - included: @coilysiren (2026-06-18T04:35:23Z), @coilyco-ops (2026-06-24T17:26:22Z), @coilyco-ops (2026-06-24T17:28:39Z), @coilyco-ops (2026-07-02T00:20:45Z), @coilysiren (2026-07-06T19:57:09Z) **Issue body as seeded:** ``` ## Goal ward should carry **zero hardcoded claude/goose (or any) agent divergence**. Per-agent knowledge (binary, argv dialect, context wiring, auth, stream format) must stop living as compiled `switch` branches and bash `case` arms, and instead be read from a single **agent-adapter manifest published by aos** and fetched at runtime - the same pattern ward already uses for the aos dev-base image and the `preclone-repos.txt` substrate manifest. ward stays one generic image; the agent is selected at runtime from manifest data. Decided architecture (Kai): **aos-published manifest, one image** (not per-agent images, not a ward-only struct). ## Why The per-agent facts are duplicated across **three** layers that drift independently: - The **ward-kdl guardfiles** (`docs/ward-kdl.{claude,goose,codex,opencode}.guardfile.md`) already declare each agent's CLI dialect declaratively (e.g. goose: `goose session` interactive, `goose run` headless). - The **Go switches** in `cmd/ward/container_compute.go` re-encode the same facts. - The **bash `case`** in `cmd/ward/containerassets/entrypoint.sh` re-encodes them a third time. One source of truth (the manifest, unified with / generated from the guardfiles) collapses all three. ## Inventory - every divergence point to remove **`cmd/ward/container_compute.go`** (the spine): - `containerMode` enum `modeClaude|modeCodex|modeQwen|modeGoose` (closed agent set) - `agentBinary()` - mode -> binary (`claude`/`codex`/`opencode`/`goose`) - `hostPreflightArgv()` - per-agent one-shot argv (`claude -p `, `goose run -t `, others none) - `contextLevel()` - per-agent ladder (qwen 0, codex 1, goose 2, claude 2) - `parseMode()` - closed-set validation; `--mode` default `"claude"` + `claude|codex|qwen|goose` usage strings **`cmd/ward/container.go`** (claude-only auth, no equivalent for other agents): - `claudeKeychainService = "Claude Code-credentials"`, `resolveClaudeCreds`, `claudeCredsForMode`, `WARD_CLAUDE_CREDS_B64`, the `claudeCreds` ``` … (truncated to 2000 chars; full body is on this issue) Static container doctrine and seed boilerplate are identical every run and omitted here (they ride ward v0.451.0). </details>  — Codex, via `ward agent`

coilyco-ops referenced this issue from a commit

2026-07-08 17:27:28 +00:00

refactor ward agent adapter manifest

coilyco-ops closed this issue

2026-07-08 17:27:28 +00:00

coilyco-ops commented

2026-07-08 17:28:00 +00:00

Owner

WARD-OUTCOME: done - routed agent launch and context wiring through the manifest seam
The adapter cutover was mostly clean once I matched the real launch contract in the agent packages. The main surprise was the old stream and seed assumptions, and I had to clean up one unrelated lint hotspot in smartdefaults before the repo was fully green. Confidence is good, but the advisory-only review means a second human pass is still worth it.
PR-BODY-NOTE: ADVISORY-ONLY REVIEW: no heterogeneous reviewer family was available besides the worker (codex), so the adversarial panel could not run and did NOT gate this diff. Dropped: opencode (unavailable: opencode not on PATH); codex (worker's own family - never reviews its own diff). A human should review this change with the extra scrutiny an unrun panel would have applied.

WARD-OUTCOME: done - routed agent launch and context wiring through the manifest seam The adapter cutover was mostly clean once I matched the real launch contract in the agent packages. The main surprise was the old stream and seed assumptions, and I had to clean up one unrelated lint hotspot in smartdefaults before the repo was fully green. Confidence is good, but the advisory-only review means a second human pass is still worth it. PR-BODY-NOTE: ADVISORY-ONLY REVIEW: no heterogeneous reviewer family was available besides the worker (codex), so the adversarial panel could not run and did NOT gate this diff. Dropped: opencode (unavailable: opencode not on PATH); codex (worker's own family - never reviews its own diff). A human should review this change with the extra scrutiny an unrun panel would have applied.

coilysiren referenced this issue

2026-07-14 15:27:09 +00:00

director should emit colorized, space buffered, visually distinct messages about the categories of actions its performing on startup #1283