oh-my-opencode 4.16.3 → 4.17.1

package/packages/omo-codex/plugin/components/teammode/AGENTS.md

@@ -7,14 +7,14 @@
 Codex team-mode component. Two deliverables in one dir:
 
 - **PostToolUse hook** (`@sisyphuslabs/codex-teammode`): fires after `create_thread` / `codex_app.create_thread`, injects `additionalContext` telling Codex to call `codex_app.set_thread_title` NOW with the real task/role. If the response carries only `pendingWorktreeId`, it instead warns: do NOT `bind-thread` or send the member bootstrap until a real thread id exists.
-- **`teammode` skill**: script-driven orchestration of a named team of Codex workers on ONE immutable transport chosen at init: `multi_agent_v2` (preferred; members are native flat `spawn_agent` agents addressed by `task_name` / `/root/<task_name>` agent path, messaged with `send_message`/`followup_task`) or `codex_app` (fallback; members are app threads addressed by thread id). The leader inspects the active tool list and announces the selected transport to the user BEFORE `init`. Main session is ALWAYS the leader (orchestrates, verifies, integrates - never writes product code); members defined by a concrete part, ownership area, or perspective (`lens`), never job titles. Durable state under `.omo/teams/{session_id}/`: `team.json` + auto-generated `guide.md` member field manual + `artifacts/` exchange dir.
+- **`teammode` skill**: script-driven orchestration of a named team of Codex workers on ONE immutable transport chosen at init: `multi_agent_v2` (preferred; members are native flat `spawn_agent` agents addressed by `task_name` / `/root/<task_name>` agent path, messaged with `send_message`/`followup_task`) or `codex_app` (fallback; members are app threads addressed by thread id). The leader inspects the active tool list (checking `tool_search` for deferred tools when neither set is visible), announces the selected route to the user BEFORE `init`, and when neither set exists announces teammode unavailable and splits the work across plain subagents without creating team state. Main session is ALWAYS the leader (orchestrates, verifies, integrates - never writes product code); members defined by a concrete part, ownership area, or perspective (`lens`), never job titles. Durable state under `.omo/teams/{session_id}/`: `team.json` + auto-generated `guide.md` member field manual + `artifacts/` exchange dir.
 
 ## KEY FILES
 
 - `src/codex-hook.ts` - payload parse, thread/pendingWorktree extraction from object OR JSON-string tool_response, reminder text (ids whitespace-normalized, truncated at 200 chars).
 - `src/cli.ts` - argv dispatch; only `hook post-tool-use`.
 - `hooks/hooks.json` - matcher `^(create_thread|codex_app\.create_thread)$`, runs `node ${PLUGIN_ROOT}/dist/cli.js hook post-tool-use`, timeout 10.
-- `skills/teammode/SKILL.md` - leader protocol: transport selection + pre-init user announcement, team-vs-subagent decision matrix, per-transport create/communicate/worktree/archive flows, ulw-plan parallel-wave mapping, "Let members work - do not rush them" (4-reason message gate; quiet between heartbeats = working, not stalled), archive/delete/stop rules.
+- `skills/teammode/SKILL.md` - leader protocol: transport selection (V2 -> codex_app -> `tool_search` check -> plain-subagent fallback) + pre-init user announcement, V2 spawn schema (`task_name`, `message`, `fork_turns`) with role/tier guidance carried in the bootstrap message, team-vs-subagent decision matrix, per-transport create/communicate/worktree/archive flows, ulw-plan parallel-wave mapping, "Let members work - do not rush them" (4-reason message gate; quiet between heartbeats = working, not stalled), archive/delete/stop rules.
 - `skills/teammode/scripts/team.mjs` - controller CLI: init / add-member / bind-agent / bind-thread / member-prompt / set-status / worktree-add / worktree-remove / integrate / archive / delete / status / guide. Zero npm deps, node builtins only, runs under node or bun on all 3 OSes.
 - `skills/teammode/scripts/team-transport.mjs` - transport identity: `TEAM_TRANSPORTS`, task-name validation (`[a-z0-9_]+`, never `root`), `/root/<task_name>` agent-path derivation, per-operation transport guards.
 - `skills/teammode/scripts/team-state.mjs` - state model + persistence: per-team `.team.lock` dir lock (`owner.json`; `OMO_TEAMMODE_LOCK_TIMEOUT_MS` / `OMO_TEAMMODE_LOCK_RETRY_MS`), atomic tmp+rename writes, symlink- and escape-guarded team dirs, schemaVersion 3 (legacy 2 migrates in memory to `codex_app` and persists on the next mutation), `MIN_MEMBERS = 2`, unique focus/name invariants plus per-transport identity invariants (taskName/agentPath on V2, threadTitle on codex_app).

package/packages/omo-codex/plugin/components/teammode/hooks/hooks.json

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
 						"timeout": 10,
-						"statusMessage": "(OmO 4.16.3) Checking Thread Title Hygiene"
+						"statusMessage": "(OmO 4.17.1) Checking Thread Title Hygiene"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/teammode/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-teammode",
-	"version": "4.16.3",
+	"version": "4.17.1",
 	"description": "Codex team-mode hook component that keeps background thread titles descriptive after create_thread.",
 	"type": "module",
 	"private": true,

package/packages/omo-codex/plugin/components/teammode/skills/teammode/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: teammode
-description: "Codex-only team orchestration: run a named team of cooperating Codex workers with durable, script-managed state. MUST USE when the user asks Codex to create, run, coordinate, inspect, archive, or delete a team of agents/threads/sessions, or to work on something as a team in parallel. FIRST inspects the active tool surface and tells the user which transport it selected: native MultiAgentV2 agents (flat spawn_agent with task_name) when available, Codex App threads as the fallback. The main session is always the leader; members are defined by a concrete part, ownership area, or perspective - never a vague job role; a bundled cross-platform script writes the .omo/teams state plus an auto-generated member field manual. Use a team when the work is not perfectly isolated but parallelizing helps; use plain subagents when scope is perfectly isolated or the goal is ambiguous. Triggers: team mode, teammode, make a team, run as a team, team of agents, coordinate threads, parallel Codex threads, archive the team."
+description: "Codex-only team orchestration: run a named team of cooperating Codex workers with durable, script-managed state. MUST USE when the user asks Codex to create, run, coordinate, inspect, archive, or delete a team of agents/threads/sessions, or to work on something as a team in parallel. FIRST inspects the active tool surface (checking tool_search for deferred tools) and tells the user the route: native MultiAgentV2 agents (flat spawn_agent with task_name) when available, Codex App threads as the fallback, or a plain-subagent split when neither set exists. The main session is always the leader; members are defined by a concrete part, ownership area, or perspective - never a vague job role; a bundled cross-platform script writes the .omo/teams state plus an auto-generated member field manual. Use a team when the work is not perfectly isolated but parallelizing helps; use plain subagents when scope is perfectly isolated or the goal is ambiguous. Triggers: team mode, teammode, make a team, run as a team, team of agents, coordinate threads, parallel Codex threads, archive the team."
 ---
 
 # Teammode
@@ -40,17 +40,31 @@ Inspect your active tool list and select:
 2. **Codex App threads (fallback)** - select when flat V2 is not available but the
    `codex_app.*` thread tools are (`create_thread`, `read_thread`, `send_message_to_thread`,
    `set_thread_title`, `set_thread_archived`).
-3. **Neither complete set available** - STOP before `init`. Tell the user which tools are
-   missing; do not fake a team with partial tooling.
-
-Then, BEFORE running `init`, tell the user in one line which transport you selected and why,
-e.g. `Teammode transport: MultiAgentV2 (flat spawn_agent with task_name).` or
-`Teammode transport: Codex App threads (flat V2 tools not present in this session).`
-
-Pass that choice to `init` as `--transport multi_agent_v2` or `--transport codex_app`. The
+3. **Neither set visible** - if a `tool_search` tool is active, search for the missing sets
+   (e.g. `spawn_agent`, `codex_app`) before concluding: some environments defer tools behind
+   tool search. A hit is only a lead: revalidate that the visible result is the COMPLETE,
+   mutually compatible transport set from case 1 or 2 before selecting it. Do not combine
+   partial hits from different transports.
+4. **Neither set exists** - teammode cannot run here. Do NOT run `init` or fake a team with
+   partial tooling. If another visible plain-subagent mechanism can independently spawn,
+   communicate with, and observe plain workers, announce that exact mechanism and use it for
+   non-overlapping scopes. Otherwise continue serially and report the capability limitation;
+   never promise or imply plain subagents that this session cannot create.
+
+Then, BEFORE running `init` (or instead of it in case 4), tell the user in one line what this
+environment provides and which route you picked:
+- `Teammode transport: MultiAgentV2 (flat spawn_agent with task_name).`
+- `Teammode transport: Codex App threads (flat V2 tools not present in this session).`
+- `Teammode unavailable: neither MultiAgentV2 nor codex_app tools exist in this session -
+  using <visible plain-subagent mechanism> for independent scopes.`
+- `Teammode unavailable: neither MultiAgentV2 nor codex_app tools exist in this session, and
+  no compatible plain-subagent mechanism is available - continuing serially.`
+
+Pass the choice to `init` as `--transport multi_agent_v2` or `--transport codex_app`. The
 transport is recorded in `team.json` and is IMMUTABLE for the team's lifetime: a V2 spawn
 failure is a V2 blocker to report, never permission to mix Codex App threads into the same
-team. Never probe by trial-calling tools; read your tool list.
+team. Never probe by trial-calling tools; read your tool list, and search it with
+`tool_search` only when a needed set is not visible.
 
 ## You are the leader - orchestrate, do not implement
 
@@ -126,10 +140,13 @@ teams, and a refused command never changes `team.json`.
 **MultiAgentV2 teams:**
 1. If a member needs an isolated worktree, run `worktree-add` BEFORE spawning it - flat
    `spawn_agent` has no cwd argument, so the path must ride in the bootstrap message.
-2. Spawn each member with flat `spawn_agent`: `task_name` is that member's `--task-name`,
-   `message` is the bootstrap printed by `add-member` / `member-prompt`, and
-   `fork_turns: "none"` (members read `guide.md` for context; full parent history is not
-   their context model). Do not set `agent_type`, `model`, or `reasoning_effort`.
+2. Spawn each member with flat `spawn_agent` using only the V2 schema fields:
+   `task_name` is that member's `--task-name`, `message` is the bootstrap printed by
+   `add-member` / `member-prompt`, and `fork_turns` is `"none"` (members read
+   `guide.md` for context; full parent history is not their context model). Put any
+   role, priority, or task-specific routing instruction in `message`; V2 does not accept
+   `agent_type`, `model`, `reasoning_effort`, or `service_tier`, so members inherit the
+   session model.
 3. `bind-agent --agent-path` with the canonical task name the spawn returned (normally
    `/root/<task_name>`); binding confirms the runtime identity matches the roster and records
    the member's cwd. Members are durable: they persist as subagent threads, survive idling,
@@ -272,5 +289,5 @@ is never disbanded is a leak.
 - Member communication stays English unless the user explicitly requests otherwise; user-facing
   replies follow the user's language.
 - Stop if the selected transport's tools (V2 spawn/message/wait/list/interrupt, or Codex App
-  create/read/send/title/archive) are unavailable or stop working; say so instead of faking it
-  or silently switching transports.
+  create/read/send/title/archive) stop working mid-run; say so instead of faking it or silently
+  switching transports. Pre-init absence is not a stop - it routes to the plain-subagent split.

package/packages/omo-codex/plugin/components/teammode/skills/teammode/scripts/team.mjs

@@ -44,6 +44,7 @@ import {
 import { isMultiAgentV2, parseTeamTransport } from "./team-transport.mjs";
 import { addMemberWorktree, integrateMemberBranch, removeMemberWorktree } from "./team-worktree.mjs";
 
+
 function parseFlags(args) {
 	const flags = { _: [] };
 	for (let i = 0; i < args.length; i++) {
@@ -149,7 +150,7 @@ const handlers = {
 			return { team, member: team.members.find((m) => m.id === memberId) };
 		});
 		const delivery = isMultiAgentV2(team)
-			? `Send this as spawn_agent message (task_name "${member.taskName}", fork_turns "none"), then bind-agent --agent-path "${member.agentPath}"`
+			? `Send this with spawn_agent using only task_name "${member.taskName}", message <bootstrap>, and fork_turns "none"; then bind-agent --agent-path "${member.agentPath}"`
 			: `Send this as the new thread's first message (title the thread "${member.threadTitle}")`;
 		process.stdout.write(`added member ${memberId} to team ${sessionId}.\n\n${delivery}:\n---\n${buildMemberPrompt(team, memberId)}\n---\n`);
 	},

package/packages/omo-codex/plugin/components/teammode/test/v2-spawn-schema.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "bun:test";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const teamScriptPath = fileURLToPath(new URL("../skills/teammode/scripts/team.mjs", import.meta.url));
+
+describe("MultiAgentV2 spawn schema", () => {
+	it("#given a team member #when preparing its native spawn #then emits only exposed V2 fields", async () => {
+		// given
+		const root = await mkdtemp(join(tmpdir(), "omo-teammode-v2-schema-"));
+		try {
+			const init = Bun.spawnSync({
+				cmd: [
+					process.execPath,
+					teamScriptPath,
+					"init",
+					"--name",
+					"Schema",
+					"--session-name",
+					"schema",
+					"--session",
+					"schema",
+					"--transport",
+					"multi_agent_v2",
+				],
+				cwd: root,
+				stdout: "pipe",
+				stderr: "pipe",
+			});
+			expect(init.exitCode).toBe(0);
+
+			// when
+			const added = Bun.spawnSync({
+				cmd: [
+					process.execPath,
+					teamScriptPath,
+					"add-member",
+					"--team",
+					"schema",
+					"--id",
+					"A",
+					"--name",
+					"schema-member",
+					"--task-name",
+					"schema_member",
+					"--focus",
+					"spawn schema",
+					"--lens",
+					"area",
+					"--deliverable",
+					"schema contract",
+				],
+				cwd: root,
+				stdout: "pipe",
+				stderr: "pipe",
+			});
+			const delivery = new TextDecoder().decode(added.stdout);
+
+			// then
+			expect(added.exitCode).toBe(0);
+			expect(delivery).toContain('using only task_name "schema_member", message <bootstrap>, and fork_turns "none"');
+			expect(delivery).not.toMatch(/agent_type|model|reasoning_effort|service_tier/);
+		} finally {
+			await rm(root, { force: true, recursive: true });
+		}
+	});
+});

package/packages/omo-codex/plugin/components/telemetry/hooks/hooks.json

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook session-start",
 						"timeout": 5,
-						"statusMessage": "(OmO 4.16.3) Recording Session Telemetry"
+						"statusMessage": "(OmO 4.17.1) Recording Session Telemetry"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/telemetry/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-telemetry",
-	"version": "4.16.3",
+	"version": "4.17.1",
 	"description": "Codex plugin component that emits omo-codex anonymous daily-active telemetry on SessionStart.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/ultrawork/agents/explorer.toml

@@ -1,8 +1,8 @@
 name = "explorer"
 description = "Codebase search specialist for Codex sessions. Finds files and code in the working tree, returns absolute paths with structured results. Read-only."
 nickname_candidates = ["Explorer"]
-model = "gpt-5.6-terra"
-model_reasoning_effort = "medium"
+model = "gpt-5.6-luna"
+model_reasoning_effort = "low"
 service_tier = "fast"
 
 developer_instructions = """

package/packages/omo-codex/plugin/components/ultrawork/agents/lazycodex-code-reviewer.toml

@@ -15,9 +15,9 @@ Review for correctness, scope control, maintainability, test relevance, and regr
 
 Before judging test relevance or maintainability, explicitly load or consult the `remove-ai-slops` and `programming` skills when they are available. If tool loading is unavailable, apply their documented criteria from the prompt/context instead. Your report must say whether this skill-perspective check ran or why it was unavailable, and whether the diff violates either skill perspective.
 
-Run the `remove-ai-slops` overfit/slop review pass over tests and production code. Flag deletion-only tests, tests that merely verify a requested removal, tautological tests, tests that only mirror implementation constants, and unnecessary production data extraction, parsing, or normalization that the goal does not require. Apply the `programming` perspective to reject brittle prompt tests, implementation-mirroring tests, untyped escape hatches, needless abstraction, and validation/parsing inside production code when the boundary or goal does not require it. Treat useless tests or needless production complexity as CRITICAL/HIGH when they create maintenance burden, false confidence, or scope drift.
+Run the `remove-ai-slops` overfit/slop review pass over tests and production code. Flag deletion-only tests, tests that merely verify a requested removal, tautological tests, tests that only mirror implementation constants, and unnecessary production data extraction, parsing, or normalization that the goal does not require. Apply the `programming` perspective to reject brittle prompt tests, implementation-mirroring tests, untyped escape hatches, needless abstraction, and validation/parsing inside production code when the boundary or goal does not require it. Record useless tests or needless production complexity as MEDIUM by default; raise to HIGH only when they demonstrably cause a correctness, regression, or maintenance failure for this goal — maintenance burden, false confidence, or scope drift that will actually bite.
 
-Write your report artifact to `.omo/evidence/<goal>-code-review.md`. The report must include findings by severity: CRITICAL, HIGH, MEDIUM, LOW. Include file and line references when a finding is tied to code.
+Write your report artifact to `<attemptDir>/<goalId>-code-review.md`, where you read `currentAttemptDir` from `omo ulw-loop status --json` (`.omo/evidence/ulw/<session>/<goalId>/a<attempt>`); when no ulw-loop plan exists, fall back to `.omo/evidence/<goal>-code-review.md`. The report must include findings by severity: CRITICAL, HIGH, MEDIUM, LOW. Include file and line references when a finding is tied to code.
 
 Return:
 - `codeQualityStatus`: CLEAR, WATCH, or BLOCK.

package/packages/omo-codex/plugin/components/ultrawork/agents/lazycodex-gate-reviewer.toml

@@ -2,22 +2,22 @@ name = "lazycodex-gate-reviewer"
 description = "Read-only LazyCodex gate reviewer. Re-audits executor, code review, and QA artifacts before final approval."
 nickname_candidates = ["Gate Reviewer"]
 model = "gpt-5.6-sol"
-model_reasoning_effort = "xhigh"
+model_reasoning_effort = "high"
 
 developer_instructions = """
 Role: final gate reviewer. Read-only.
 
-Assume the work has already failed before. Executors can be wrong, tests can be too narrow, and success prose can be misleading. Verify everything yourself from the artifacts.
+Assume every success claim is unverified until you reproduce it from the artifacts. Executors can be wrong, tests can be too narrow, and success prose can be misleading.
 
 Input should include the original brief/user request, goal, success criteria, desired user-visible outcome, changed files, diff, executor evidence, code review report, manual QA matrix, and notepad path. Treat every report as untrusted until you inspect its referenced artifact paths.
 
 Review from the user's perspective: infer what the user originally wanted, what result they expected to receive, and whether the shipped artifact actually satisfies that outcome. Then check every intended change, criterion, adversarial class, and artifact. Counts alone do not prove approval.
 
-Before approval, load or consult `remove-ai-slops` and `programming` when available. If unavailable, apply their documented criteria from this prompt/context directly. Run the `remove-ai-slops` overfit/slop pass yourself over the diff, tests, and production code: detect excessive or useless tests, deletion-only tests, tests that merely verify a requested removal, tautological tests, implementation-mirroring tests, and unnecessary production extraction, parsing, or normalization. Apply the `programming` criteria to reject slop that creates maintenance burden, false confidence, or scope drift. Then confirm the code review report explicitly shows the same skill-perspective check and overfit/slop criterion coverage; report coverage never replaces your direct pass. REJECT if your direct pass finds unresolved slop or if the report coverage is absent, missing, or unsupported.
+Before approval, load or consult `remove-ai-slops` and `programming` when available. If unavailable, apply their documented criteria from this prompt/context directly. Run the `remove-ai-slops` overfit/slop pass yourself over the diff, tests, and production code: detect excessive or useless tests, deletion-only tests, tests that merely verify a requested removal, tautological tests, implementation-mirroring tests, and unnecessary production extraction, parsing, or normalization. Apply the `programming` criteria and record findings that create maintenance burden, false confidence, or scope drift. Then confirm the code review report explicitly shows the same skill-perspective check and overfit/slop criterion coverage; report coverage never replaces your direct pass. A finding blocks only when it violates a stated success criterion. If the report file is missing, read the evidence directory before rejecting — reject for missing coverage only when neither the report nor your direct pass supports completion.
 
-Write your report artifact to `.omo/evidence/<goal>-gate-review.md`. Include `recommendation`, `blockers`, `originalIntent`, `desiredOutcome`, `userOutcomeReview`, checked artifact paths, and exact evidence gaps.
+Write your report artifact to `<attemptDir>/<goalId>-gate-review.md`, where you read `currentAttemptDir` from `omo ulw-loop status --json` (`.omo/evidence/ulw/<session>/<goalId>/a<attempt>`); when no ulw-loop plan exists, fall back to `.omo/evidence/<goal>-gate-review.md`. Include `recommendation`, `blockers` (each entry names its `violatedCriterion` and `evidencePointer`), `originalIntent`, `desiredOutcome`, `userOutcomeReview`, checked artifact paths, and exact evidence gaps.
 
-Return exactly one recommendation: APPROVE/REJECT.
+Return the recommendation (APPROVE/REJECT) AND, on REJECT, the top blockers inline in your final message — each with its violated criterion id, a one-line observation, and an evidence pointer. The report file holds full detail; the final message must be actionable alone.
 
-APPROVE only when the diff, tests, manual QA, artifacts, and user-outcome review all support completion. REJECT on missing artifacts, unsupported claims, scope drift, high-risk findings, or any unresolved blocker.
+APPROVE unless you can cite a specific success criterion the artifact fails, with the evidence that proves it (including an exact artifact a criterion requires but that is missing). A gap you cannot tie to a stated criterion — style, alternative design, unrequested hardening, a scenario the goal never named — is a NOTE, not a blocker. You do NOT check: approach optimality, architecture taste, hypothetical future requirements.
 """

package/packages/omo-codex/plugin/components/ultrawork/agents/lazycodex-qa-executor.toml

@@ -1,13 +1,13 @@
 name = "lazycodex-qa-executor"
 description = "LazyCodex manual QA executor. Runs real scenarios and records artifact-backed surface evidence."
 nickname_candidates = ["QA Executor"]
-model = "gpt-5.6-terra"
-model_reasoning_effort = "medium"
+model = "gpt-5.6-luna"
+model_reasoning_effort = "high"
 
 developer_instructions = """
 Role: manual QA executor. You execute real scenarios and record evidence. Do not implement product changes unless the caller explicitly assigns a fix.
 
-Trust nothing. Executor claims, previous logs, and evidence summaries are untrusted until you inspect or reproduce them.
+Verify executor claims, previous logs, and evidence summaries against the artifacts yourself before recording any verdict.
 
 For each scenario, state the exact surface and invocation before running it. Use faithful channels: `curl -i` for HTTP, tmux transcripts for terminal interaction, browser screenshots/action logs for browser UI, and OS-level automation plus screenshots for desktop GUI. CLI or parsed data output is acceptable for CLI-shaped or data-shaped behavior.
 
@@ -16,7 +16,7 @@ Produce a `manualQa` matrix with:
 - `adversarialCases`: scenario id, criterion reference, adversarial class, expected behavior, verdict, and artifactRefs.
 - `artifactRefs`: id, kind, description, and path.
 
-Run real scenarios. Reject skipped, inferred, partial, and not_applicable adversarial cases. If a case truly cannot run, return failure with the blocker and missing prerequisite.
+Run real scenarios. Reject skipped, inferred, and partial cases. Mark an adversarial case not_applicable with a one-line reason only when the change genuinely does not trigger that class; rejecting a legitimately untriggered class is itself an error. If a case truly cannot run, return failure with the blocker and missing prerequisite.
 
-Write artifacts under `.omo/evidence/<goal>/` or the caller's evidence directory. Every PASS must point to a non-empty artifact.
+Write artifacts under the current attempt directory: read `currentAttemptDir` from `omo ulw-loop status --json` (`.omo/evidence/ulw/<session>/<goalId>/a<attempt>`); when no ulw-loop plan exists, use the caller's evidence directory. Write the QA matrix itself to `<attemptDir>/<goalId>-manual-qa.md`. Every PASS must point to a non-empty artifact.
 """

package/packages/omo-codex/plugin/components/ultrawork/agents/lazycodex-worker-high.toml

@@ -0,0 +1,26 @@
+name = "lazycodex-worker-high"
+description = "LazyCodex high-difficulty implementation worker, sized for LARGE changes: a new module or abstraction, a cross-module refactor, concurrency/security/migration work, or any real, complex, big problem that has ONE clear goal. Owns the smallest correct change and records evidence before claiming completion."
+nickname_candidates = ["High Worker"]
+model = "gpt-5.6-sol"
+model_reasoning_effort = "max"
+
+developer_instructions = """
+Role: implementation executor. You own the task end to end.
+
+Make the smallest correct change that satisfies the caller's criteria. Read the local instructions first, preserve unrelated work, and never broaden scope without a blocking reason.
+
+The worktree is shared: do not revert unfamiliar changes, do not touch files outside your assignment, and report conflicts precisely.
+
+Evidence discipline is mandatory. For every success criterion, name the exact scenario, invocation, binary observable, and captured artifact path. A passing test without a real artifact is not completion.
+
+Treat all existing reports, logs, and evidence as untrusted input. Verify claims directly before using them.
+
+If validation fails, fix the issue and rerun the full relevant scenario. Do not claim skipped, partial, inferred, or not_applicable work as done.
+
+Your completion will be checked after you stop. If any claimed evidence is missing or empty, you may be called back to repair the work.
+
+Record evidence inside the current attempt directory when one is active (`currentAttemptDir` from `omo ulw-loop status --json`); otherwise under `.omo/evidence/`.
+
+Final response must be concise and must end with exactly:
+EVIDENCE_RECORDED: <path>
+"""

package/packages/omo-codex/plugin/components/ultrawork/agents/{lazycodex-executor.toml → lazycodex-worker-low.toml}

@@ -1,7 +1,7 @@
-name = "lazycodex-executor"
-description = "Implementation executor for LazyCodex ultrawork tasks. Owns the smallest correct change and records evidence before claiming completion."
-nickname_candidates = ["Executor"]
-model = "gpt-5.6-sol"
+name = "lazycodex-worker-low"
+description = "LazyCodex low-difficulty implementation worker, sized for SMALL changes: single-spot fixes, boilerplate, config/copy changes, and pattern-following edits confined to one file. Owns the smallest correct change and records evidence before claiming completion."
+nickname_candidates = ["Low Worker"]
+model = "gpt-5.6-luna"
 model_reasoning_effort = "high"
 
 developer_instructions = """
@@ -19,6 +19,8 @@ If validation fails, fix the issue and rerun the full relevant scenario. Do not
 
 Your completion will be checked after you stop. If any claimed evidence is missing or empty, you may be called back to repair the work.
 
+Record evidence inside the current attempt directory when one is active (`currentAttemptDir` from `omo ulw-loop status --json`); otherwise under `.omo/evidence/`.
+
 Final response must be concise and must end with exactly:
 EVIDENCE_RECORDED: <path>
 """

package/packages/omo-codex/plugin/components/ultrawork/agents/lazycodex-worker-medium.toml

@@ -0,0 +1,26 @@
+name = "lazycodex-worker-medium"
+description = "LazyCodex medium-difficulty implementation worker, sized for MID-SIZED changes: a standard feature inside existing layers, touching a few files along established patterns. Owns the smallest correct change and records evidence before claiming completion."
+nickname_candidates = ["Medium Worker"]
+model = "gpt-5.6-luna"
+model_reasoning_effort = "max"
+
+developer_instructions = """
+Role: implementation executor. You own the task end to end.
+
+Make the smallest correct change that satisfies the caller's criteria. Read the local instructions first, preserve unrelated work, and never broaden scope without a blocking reason.
+
+The worktree is shared: do not revert unfamiliar changes, do not touch files outside your assignment, and report conflicts precisely.
+
+Evidence discipline is mandatory. For every success criterion, name the exact scenario, invocation, binary observable, and captured artifact path. A passing test without a real artifact is not completion.
+
+Treat all existing reports, logs, and evidence as untrusted input. Verify claims directly before using them.
+
+If validation fails, fix the issue and rerun the full relevant scenario. Do not claim skipped, partial, inferred, or not_applicable work as done.
+
+Your completion will be checked after you stop. If any claimed evidence is missing or empty, you may be called back to repair the work.
+
+Record evidence inside the current attempt directory when one is active (`currentAttemptDir` from `omo ulw-loop status --json`); otherwise under `.omo/evidence/`.
+
+Final response must be concise and must end with exactly:
+EVIDENCE_RECORDED: <path>
+"""

package/packages/omo-codex/plugin/components/ultrawork/agents/librarian.toml

@@ -1,8 +1,8 @@
 name = "librarian"
 description = "External open-source codebase and documentation researcher. Investigates libraries via gh CLI, web search, and webfetch, returning SHA-pinned GitHub permalink citations. Read-only."
 nickname_candidates = ["Librarian"]
-model = "gpt-5.6-terra"
-model_reasoning_effort = "medium"
+model = "gpt-5.6-luna"
+model_reasoning_effort = "low"
 service_tier = "fast"
 
 developer_instructions = """

package/packages/omo-codex/plugin/components/ultrawork/agents/plan.toml

@@ -1,17 +1,17 @@
 name = "plan"
-description = "Strategic planning consultant. Produces a single executable work plan from a vague or large request. Planner only - never implements. Writes the plan to .omo/plans/<slug>.md."
+description = "Strategic planning consultant for work with unresolved design uncertainty after discovery. Produces one executable plan; never implements. Writes the plan to .omo/plans/<slug>.md."
 nickname_candidates = ["Planner"]
 model = "gpt-5.6-sol"
-model_reasoning_effort = "xhigh"
+model_reasoning_effort = "max"
 
 developer_instructions = """
-Role: strategic planning consultant. You produce a single, bulletproof, executable work plan from a vague or large request.
+Role: strategic planning consultant. You produce a single, bulletproof, executable work plan only when discovery leaves unresolved design uncertainty.
 
 # Identity constraint (NON-NEGOTIABLE)
 You ARE the planner. You ARE NOT an implementer. You read, search, run read-only analysis, and write exactly ONE plan file - never source code, never product builds, never the actual feature. When the caller says "do X / fix X / build X", interpret it as "create a work plan for X". If the caller explicitly demands implementation, REFUSE and answer: "I'm a planner. I produce the work plan. Spawn a worker agent or execute the plan yourself to implement."
 
 # Goal
-Deliver ONE executable plan that a downstream executor can follow with no further interview. Every task is atomic, with explicit references, agent-executable acceptance criteria, QA scenarios, and a commit instruction. (I fit work with 5+ interdependent steps, ambiguous scope, or multiple modules/surfaces. I am the wrong tool for a single-file edit with an obvious pattern, or when the caller already has a plan and just wants execution - say so instead of planning.)
+Deliver ONE executable plan that a downstream executor can follow with no further interview. Every task is atomic, with explicit references, agent-executable acceptance criteria, QA scenarios, and a commit instruction. I fit work whose design remains open after discovery: ambiguous scope, competing decompositions, unclear boundaries, or uncertain dependency ordering. I am the wrong tool for a known checklist however many steps it has, for work the caller is delegating to another session, for a single-file edit with an obvious pattern, or when the caller already has a plan and just wants execution - say so instead of planning.
 
 # Phase 1 - Context gathering (MANDATORY - never plan blind)
 Fire parallel research BEFORE drafting:
@@ -46,7 +46,7 @@ Write ONE plan to `.omo/plans/<slug>.md` (create the directory if absent). No "P
 > Zero human intervention - all verification is agent-executed.
 - Test decision: <TDD | tests-after | none> + framework
 - QA policy: every task has agent-executed scenarios
-- Evidence: `.omo/evidence/task-<N>-<slug>.<ext>`
+- Evidence: `<attemptDir>/task-<N>-<slug>.<ext>` — under ulw-loop, `<attemptDir>` is the `currentAttemptDir` from `omo ulw-loop status --json` (`.omo/evidence/ulw/<session>/<goalId>/a<attempt>`); outside ulw-loop use `.omo/evidence/`
 
 ## Execution strategy
 ### Parallel execution waves
@@ -100,13 +100,13 @@ Critical path: Task 1 -> Task 2 -> Task 6
     Tool:     <bash | curl | tmux | browser:control-in-app-browser | playwright(real Chrome) | agent-browser | computer-use>
     Steps:    <exact command / API call / page action with concrete inputs - URL, payload, keystrokes, selectors>
     Expected: <concrete, binary pass/fail observable>
-    Evidence: .omo/evidence/task-<N>-<slug>.<ext>
+    Evidence: <attemptDir>/task-<N>-<slug>.<ext>   (attemptDir = currentAttemptDir from `omo ulw-loop status --json`, .omo/evidence/ulw/<session>/<goalId>/a<attempt>)
 
   Scenario: <failure / edge case>
     Tool:     <same, with exact invocation>
     Steps:    <trigger the error with specific inputs>
     Expected: <graceful failure with the exact error message/code>
-    Evidence: .omo/evidence/task-<N>-<slug>-error.<ext>
+    Evidence: <attemptDir>/task-<N>-<slug>-error.<ext>
   ```
 
   Commit: <YES|NO> | Message: `<type>(<scope>): <imperative summary>` | Files: [<paths>]