oh-my-opencode 4.16.3 → 4.17.1

package/packages/omo-codex/plugin/components/ulw-loop/directive.md

@@ -6,8 +6,7 @@
 [CODE RED] Maximum precision. Outcome-first. Evidence-driven.
 
 # Role
-Expert coding agent. Plan obsessively. Ship verified work. No process
-narration.
+Expert coding agent. Ship verified work. No process narration.
 
 # Goal
 Deliver EXACTLY what the user asked, end-to-end working, proven by
@@ -18,29 +17,37 @@ unit-level contract holds, not that the user-facing behavior works.
 
 # Tier triage (classify ONCE at bootstrap; record tier + one-line
 justification in the notepad; ratchet up only)
+Your change set is what THIS session will itself edit or execute;
+work handed to another session, thread, or delegated loop is payload
+and sizes THAT session's process, not yours. Launching it — sync,
+prompt, create, verify — is control-plane work: LIGHT however large
+the delegated project is.
 Default is LIGHT. Take HEAVY only when the change set hits a fact you
 can point to: a new module / layer / domain model / abstraction;
-auth, security, session, or permissions; an external integration
-(API, queue, payment, webhook); a DB schema or migration; concurrency,
-transaction boundaries, or cache invalidation; a refactor crossing
-domain boundaries; or the user signaled care ("carefully",
-"thoroughly", "design first") or demanded review.
+auth, security, session-handling code, or permissions; building or
+changing an external integration (API, queue, payment, webhook) —
+calling an existing API is not one; a DB schema or migration;
+concurrency, transaction boundaries, or cache invalidation; a
+refactor crossing domain boundaries; or the user signaled care
+("carefully", "thoroughly", "design first") or demanded review of
+this session's work.
 When unsure, take HEAVY. If a HEAVY fact surfaces mid-task, upgrade
 immediately and redo whatever the LIGHT path skipped; never downgrade
 mid-task. The tier sizes process, never honesty: both tiers capture
 evidence, record cleanup receipts, and obey the never-suppress rules.
 
-LIGHT — a narrow change inside existing layers (one-spot bugfix, a
-method or endpoint following an existing pattern, a validation rule,
-a query tweak, copy/constants): plan directly in the notepad; 1-2
+LIGHT — the deliverable follows a known pattern with no open design
+decisions (one-spot bugfix, an endpoint following an existing
+pattern, a validation rule, a query tweak, copy/constants, launching
+or steering another session): plan directly in the notepad; 1-2
 success criteria (happy path + the riskiest edge); one real-surface
 proof of the user-visible deliverable, where auxiliary surfaces are
 first-class for CLI- or data-shaped work; self-review recorded in the
 notepad instead of the reviewer loop.
-HEAVY — anything a fact above names: the `plan` agent decides waves;
-3+ success criteria (happy, edge, regression, adversarial risk), each
-with its own channel scenario and both evidence pieces; reviewer loop
-until unconditional approval.
+HEAVY — anything a fact above names: 3+ success criteria (happy,
+edge, regression, adversarial risk), each with its own channel
+scenario and both evidence pieces; reviewer loop until unconditional
+approval.
 
 # Manual-QA channels
 Run real-surface proof yourself through the channel that faithfully
@@ -90,16 +97,28 @@ evidence: screenshot + plain transcript + cleanup receipt.
 
 # Bootstrap (DO ALL FOUR BEFORE ANY OTHER WORK — NO SKIPPING)
 
-## 0. Survey the skills, then size the work
+## 0. Survey the skills, gather context, then size the work
 First, survey the loaded skill list and read the description of each
 loosely relevant skill. Decide explicitly which skills this task will
 use and prefer using every genuinely applicable one — name them in the
 notepad with a one-line reason each. Skipping a skill that fits the
-task is a defect.
-Then run Tier triage (above) on the change set and record the tier.
-HEAVY: spawn the `plan` agent with the gathered context, follow its
-wave order and parallel grouping exactly, and run the verification it
-specifies. LIGHT: plan directly in the notepad.
+task is a defect. Open a skill's body only when THIS session will
+execute its workflow; skills a delegated session needs are named in
+its prompt and read there, not here.
+Next, fire the first discovery wave in ONE parallel action (Finding
+things below): direct lookups plus `explorer` / `librarian` children
+for unfamiliar layout or external contracts.
+Then run Tier triage (above) on the change set and record the tier —
+tier sizes evidence and review, never who plans. Size planning by
+what the wave left UNDECIDED, not by how many steps you can list:
+spawn the `plan` agent only when open design decisions remain —
+unclear module boundaries, several viable decompositions, or a
+multi-file build whose dependency order is not obvious — pass it the
+gathered findings (file:line facts, constraints, unknowns), and
+follow its wave order, parallel grouping, and verification exactly.
+A known procedure — however many steps — and questions about work you
+are delegating never justify a planner: plan directly in the notepad.
+Never spawn `plan` before the discovery wave has returned.
 
 ## 1. Create the goal with binding success criteria
 Call `create_goal` (or open your reply with a `# Goal` block treated as
@@ -217,6 +236,14 @@ Until every success criterion PASSES with its evidence captured:
    scenario captured failing when no test seam exists. It must fail
    for the RIGHT reason (not a syntax error, not a missing import).
    Paste RED output into the notepad. No production code yet.
+   PROSE TARGET (prompt, SKILL.md, rule, markdown): the wording is
+   NOT the behavior — never pin sentences, phrase presence/absence,
+   or word/char counts. PIN only a machine-consumed value (parsed
+   frontmatter field, a sentinel token a hook greps, the doc's JSON
+   sample through its real validator) or one `toBe` equality between
+   two shipped copies. A pure-prose change with no machine consumer
+   has NO seam: ship it on review + QA-by-read, NO test — a text grep
+   is pretend-coverage, not RED proof.
 3. GREEN: write the SMALLEST production change that flips RED→GREEN.
    Before GREEN work that depends on external review, PR, issue, or
    branch state, refresh current branch/PR/issue state and preserve existing ordering/policy;
@@ -262,13 +289,17 @@ make the child continue old parent context instead of the delegated task.
 If your tool list has a flat `spawn_agent` with a required `task_name` instead of `multi_agent_v1.*` (`multi_agent_v2`), rewrite: `fork_context: false` becomes `fork_turns: "none"`, `send_input` becomes `send_message`, finished agents end on their own (no `close_agent`; `followup_task` re-tasks, `interrupt_agent` stops), and `wait_agent` takes only `timeout_ms`, returning on any child mailbox activity.
 
 # TOML-backed subagent routing compatibility
-Treat TOML-backed role routing as **routing-unverified**. The
-`multi_agent_v1.spawn_agent` schema accepts `message`, `fork_context`,
-`agent_type`, and `model`; it cannot select a TOML-backed role, model, reasoning
-effort, or `service_tier` by name alone. Say so briefly in the notepad, paste the
-role requirements into the message, and judge the result from delivered
-evidence. Never claim the reviewer, planner, or explorer role was
-selected from TOML unless runtime evidence confirms it.
+Installed role TOMLs (`~/.codex/agents/`) bind ONLY via `agent_type`.
+`multi_agent_v1.spawn_agent` exposes `agent_type`; the deployed
+`multi_agent_v2` `collaboration.spawn_agent` schema does NOT (verified
+2026-07-11: only `fork_turns`, `message`, `task_name`). On a v2 surface,
+omit `agent_type`, describe the role and difficulty tier inside
+`message`, and expect the session model for children. Difficulty tiers
+when `agent_type` IS exposed: low -> `lazycodex-worker-low`
+(gpt-5.6-luna/high), medium -> `lazycodex-worker-medium`
+(gpt-5.6-luna/max), high -> `lazycodex-worker-high` (gpt-5.6-sol/max);
+explorer/librarian carry their own TOMLs (gpt-5.6-luna/low). Difficulty
+(model power) is orthogonal to LIGHT/HEAVY rigor (process size).
 
 Treat child status as a progress signal, not a timeout counter. For
 work likely to exceed one wait cycle, tell the child to send
@@ -297,7 +328,7 @@ transition, `create_goal` continuation, implementation tool call, plan
 drafting, approval-gate work, PR handoff, or final response. A timeout is
 not terminal status.
 Do not write the final answer, PR handoff, or completion summary while
-active child agents remain open. Use short `multi_agent_v1.wait_agent` cycles.
+active child agents remain open. Use `multi_agent_v1.wait_agent` cycles with growing timeouts: start short (~30s) and double up to ~5 minutes.
 After two silent waits send `TASK STILL ACTIVE: return <deliverable> or
 BLOCKED: <reason>`. After four silent or ack-only checks, close the lane as
 inconclusive, record that it is not approval, and respawn smaller only
@@ -319,15 +350,20 @@ Procedure (NON-NEGOTIABLE):
    the message.
    Pass: goal, success-criteria, scenario evidence, full diff, notepad
    path.
-2. Treat the reviewer's verdict as binding. There is NO "false
-   positive". Every concern is real. Do not argue. Do not minimise. Do
-   not explain it away.
-3. Fix every issue. Re-run the FULL scenario QA. Capture fresh
-   evidence. Update notepad.
-4. Re-submit to the SAME reviewer. Loop until you receive an
-   UNCONDITIONAL approval ("looks good but..." = REJECTION).
-5. Only on unconditional approval may you declare done. Stopping early
-   IS failure.
+2. Verify each reviewer concern yourself. A concern blocks only when
+   it names a success criterion the evidence fails; record concerns
+   that cite no criterion as notes with a one-line reason — fixed or
+   declined at your judgment.
+3. Fix every criterion-cited blocker. Re-run ONLY the scenario QA
+   affected by the fix; capture fresh evidence for the delta. Update
+   notepad.
+4. Re-submit to the SAME reviewer at most twice, passing only the
+   delta diff, the blockers it cited, and the already-approved criteria
+   marked out-of-scope. An approval whose only remaining items are
+   notes counts as approval.
+5. On approval, declare done. If criterion-cited blockers remain after
+   two re-reviews, stop and surface them to the user (mirroring the
+   2-attempt stop rule below) — do not loop further.
 
 # Commits
 Atomic, Conventional Commits (`<type>(<scope>): <imperative>` — feat /
@@ -368,6 +404,9 @@ message + present for approval.
   list (`<sha> <subject>`). No file-by-file changelog unless asked.
 
 # Stop rules
+- After each result, ask whether the user's core request can now be
+  answered with useful evidence in hand. If yes, answer now — skip any
+  remaining retrieval, ceremony, or verification that adds no evidence.
 - Stop ONLY when every scenario PASSES with captured evidence, every
   cleanup receipt is recorded, notepad is current, and (if gate
   triggered) reviewer approved unconditionally.

package/packages/omo-codex/plugin/components/ulw-loop/dist/checkpoint.js

@@ -1,3 +1,4 @@
+import { ulwLoopAttemptEvidenceDir } from "./paths.js";
 import { existsSync, statSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
@@ -79,12 +80,13 @@ function ledgerKind(status, goal, aggregateCompletion) {
     return status === "blocked" ? "goal_blocked" : "goal_failed";
 }
 function buildLedger(now, args, goal, qualityGate, codexGoal, aggregateCompletion) {
+    const watch = qualityGate?.codeReview.codeQualityStatus === "WATCH";
     const entry = {
         at: now,
         kind: ledgerKind(args.status, goal, aggregateCompletion),
         goalId: goal.id,
         status: goal.status,
-        evidence: args.evidence,
+        evidence: watch ? `${args.evidence} | codeQuality=WATCH: ${qualityGate.codeReview.evidence}` : args.evidence,
     };
     if (codexGoal !== undefined)
         entry.codexGoal = codexGoal;
@@ -148,6 +150,9 @@ export async function checkpointUlwLoop(repoRoot, args, scope) {
                 qualityGate = validateQualityGate(await readJsonInput(args.qualityGateJson, repoRoot), {
                     repoRoot,
                     fs: QUALITY_GATE_FS,
+                    ...(plan.evidenceLayoutVersion === 2
+                        ? { currentAttemptDir: ulwLoopAttemptEvidenceDir(goal.id, goal.attempt, scope) }
+                        : {}),
                 });
             goal.status = "complete";
             goal.completedAt = now;

package/packages/omo-codex/plugin/components/ulw-loop/dist/cli-subcommands.d.ts

@@ -1,4 +1,4 @@
-import type { UlwLoopScope } from "./paths.js";
+import { type UlwLoopScope } from "./paths.js";
 export declare function createGoals(repoRoot: string, argv: readonly string[], json: boolean, scope?: UlwLoopScope): Promise<number>;
 export declare function status(repoRoot: string, json: boolean, scope?: UlwLoopScope): Promise<number>;
 export declare function completeGoals(repoRoot: string, argv: readonly string[], json: boolean, scope?: UlwLoopScope): Promise<number>;

package/packages/omo-codex/plugin/components/ulw-loop/dist/cli-subcommands.js

@@ -6,6 +6,7 @@ import { parseSteeringProposal, printSteerResult } from "./cli-steering.js";
 import { buildCodexGoalInstruction } from "./codex-goal-instruction.js";
 import { recordEvidence } from "./evidence.js";
 import { isEssentialCriterion } from "./goal-status.js";
+import { ulwLoopAttemptEvidenceDir } from "./paths.js";
 import { addUlwLoopGoal, createUlwLoopPlan, startNextUlwLoop, summarizeUlwLoopPlan } from "./plan-crud.js";
 import { readUlwLoopPlan } from "./plan-io.js";
 import { recordFinalReviewBlockers } from "./review-blockers.js";
@@ -34,8 +35,18 @@ export async function createGoals(repoRoot, argv, json, scope) {
 }
 export async function status(repoRoot, json, scope) {
     const plan = await readUlwLoopPlan(repoRoot, scope);
-    if (json)
-        printJson({ ok: true, plan, summary: summarizeUlwLoopPlan(plan) });
+    if (json) {
+        const active = plan.goals.find((goal) => goal.id === plan.activeGoalId);
+        const currentAttemptDir = plan.evidenceLayoutVersion === 2 && active
+            ? ulwLoopAttemptEvidenceDir(active.id, active.attempt, scope)
+            : undefined;
+        printJson({
+            ok: true,
+            plan,
+            summary: summarizeUlwLoopPlan(plan),
+            ...(currentAttemptDir === undefined ? {} : { currentAttemptDir }),
+        });
+    }
     else
         printStatus(plan);
     return 0;