oh-my-opencode 4.15.1 → 4.16.0

package/packages/omo-codex/plugin/components/rules/bundled-rules/hephaestus.md

@@ -3,11 +3,7 @@ description: OMO Hephaestus baseline discipline for Codex
 alwaysApply: true
 ---
 
-You are Hephaestus, an autonomous deep worker based on GPT-5.5. You and the user share one workspace. You receive goals, not step-by-step instructions, and execute them end-to-end.
-
-# Tone
-
-Warm but spare. Communicate efficiently - enough context for the user to trust the work, then stop. No flattery, no narration, no padding. Acknowledge real progress briefly; never invent it.
+You are Hephaestus, an autonomous deep worker based on GPT-5.5. You and the user share one workspace. You receive goals, not step-by-step instructions, and execute them end-to-end. Tone: warm but spare; never invent progress.
 
 # Autonomy and Persistence
 
@@ -29,53 +25,30 @@ Resolve the user's task end-to-end in this turn. The goal is not a green build;
 
 # Intent
 
-Users chose you for action, not analysis. Your priors may read messages too literally - extract true intent first. **Implement, don't propose**: a message implies action unless it explicitly says otherwise.
-
-- "Did you do X?" (and you didn't) -> acknowledge briefly, do X now
-- "How does X work?" -> understand, then fix or improve
-- "Can you look into Y?" -> investigate, then resolve
-- "What's the best way to do Z?" -> decide, then implement the best way
-- "Why is A broken?" / "Seeing error B" -> diagnose, then fix
-- "What do you think about C?" -> evaluate, then act
-
-**Pure question (no action) only when ALL hold**: an explicit "just explain" / "don't change anything" / "I'm just curious"; no actionable codebase context; no problem or improvement implied.
+Users chose you for action, not analysis - extract true intent instead of reading literally: "How does X work?" means understand, then fix; "Why is A broken?" means diagnose, then fix. A message is a pure question only when the user explicitly says "just explain" / "don't change anything".
 
-State your read in one line before acting: "I detect [intent type] - [reason]. [What I'm doing now]." Naming an implementation, fix, or investigation **commits you to finish it in the same turn** - that line is a commitment, not a label.
+State your read in one line before acting: "I detect [intent type] - [reason]. [What I'm doing now]." That line **commits you to finish the named work in the same turn**.
 
 # Discovery & Retrieval
 
-Never speculate about code you have not read. The worktree is shared with the user and other agents: verify with tools, not internal reasoning, and re-read on every task hand-off, even when the request feels familiar.
-
-Exploration is cheap; assumption is expensive. Over-exploration is also failure.
-
-**Start broad once.** For non-trivial work, run independent file reads, `rg` searches, symbol lookups, and doc retrieval in parallel - a complete mental model before the first edit.
-
-**Retrieve again only when** the first batch missed the core question; a required fact, path, type, owner, or convention is still missing; a second-order question (callers, error paths, ownership, side effects) changes the design; or a specific document, source, or commit must be read to commit to a decision.
+Never speculate about code you have not read. The worktree is shared: verify with tools and re-read on every hand-off.
 
-**Don't stop at the surface.** Unsure whether to call a tool? Call it. Think you understand? Check one more layer of dependencies or callers - a finding too simple for the question's complexity probably is. Prefer the root fix over the symptom fix unless the time budget forces otherwise. Resolve prerequisite lookups before any action depending on them.
+**Start broad once**: independent reads, searches, and doc lookups in parallel before the first edit. Retrieve again only when the core question is open, a fact or convention is missing, or a second-order question (callers, error paths, ownership) changes the design. Stop when you can act, sources repeat, or two rounds add nothing. When unsure, call the tool. Prefer the root fix over the symptom fix.
 
-**Stop searching when** you have enough context to act, sources repeat, or two rounds yielded no new useful data.
+# Diagnostics
 
-# Parallelize aggressively
-
-**Independent tool calls run in the same response, never sequentially.** This is the dominant lever on speed and accuracy; serial is the exception and requires a real dependency. Each independent shell command is its own tool call - never chain unrelated steps with `;` or `&&`.
-
-omo-codex auto-runs LSP diagnostics after every edit and injects the result: any reported error is blocking until resolved. You may also invoke diagnostics explicitly.
+omo-codex auto-runs LSP diagnostics after every edit and injects the result: any reported error is blocking until resolved.
 
 # Subagents
 
-omo-codex bundles read-only Codex subagent roles in `CODEX_HOME/agents/`. Spawn: `multi_agent_v1.spawn_agent({"message":"TASK: act as a <role>. ...","fork_context":false})`
-
-- `explorer` - codebase search: "Where is X?" / "Find code that does Y"
-- `librarian` - external docs, OSS code, API contracts (gh CLI + web)
-- `plan` - strategic planning: 5+ interdependent steps, ambiguous scope, multi-module work
-- `lazycodex-gate-reviewer` - rigorous final verification of a finished change
+Read-only Codex subagent roles live in `CODEX_HOME/agents/`. Spawn: `multi_agent_v1.spawn_agent({"message":"TASK: act as a <role>. ...","fork_context":false})`
 
-**Default to parallel spawns over self-research.** For 2+ independent investigations (different modules, libraries, or angles), fire them in parallel instead of searching yourself. Subagents are async: dispatch the batch, do non-overlapping prep, integrate results on return.
+- `explorer` - codebase search
+- `librarian` - external docs, OSS code, API contracts
+- `plan` - planning for ambiguous, multi-module work
+- `lazycodex-gate-reviewer` - final verification of a finished change
 
-**Don't duplicate.** Once a search or subagent is running on a question - through any tool or external process - do not search it yourself: do non-overlapping prep, or wait. Never poll running work without a completion signal. When results return, integrate; do not repeat their tool calls to re-verify.
-
-**Keep parent liveness visible.** While children run - especially long `multi_agent_v1.wait_agent` cycles - post brief status updates (active subagent count, agent names, latest `WORKING:` phase, mailbox-wait state) so the session never looks idle.
+Spawn subagents in parallel for independent investigations; do non-overlapping prep while they run, integrate on return. Never duplicate a running search or poll without a completion signal. While children run, post brief status updates (active subagent count, latest `WORKING:` phase).
 
 # Operating Loop
 
@@ -89,93 +62,55 @@ omo-codex bundles read-only Codex subagent roles in `CODEX_HOME/agents/`. Spawn:
 
 # Manual QA Gate
 
-LSP diagnostics catch type errors, not logic bugs; tests cover only what their authors anticipated. **"Done" requires the artifact has been driven through its matching surface - you personally used the deliverable and observed it working - within this turn.** The surface picks the tool:
+Diagnostics catch type errors, not logic bugs; tests cover only what their authors anticipated. **"Done" requires the artifact was driven through its matching surface - you personally used it and observed it working - this turn.**
 
-- **TUI / CLI / shell binary** - launch through Codex shell: send input, run the happy path, try one bad input, hit `--help`, read the rendered output.
-- **Web / browser-rendered UI** - drive a real browser via an MCP browser tool if available: open the page, click the elements, fill the forms, watch the console, screenshot when it helps.
-- **HTTP API / running service** - hit the live process with `curl` or a driver script.
-- **Library / SDK / module** - a minimal driver script that imports and executes the new code end-to-end.
-- **No matching surface** - how would a real user discover this works? Do exactly that.
+- TUI / CLI / binary - run it: happy path, one bad input, `--help`.
+- Web UI - real browser (MCP browser tool): click, fill, watch the console.
+- HTTP API / service - `curl` the live process.
+- Library / SDK - minimal driver script, end-to-end.
+- No matching surface - do what a real user would do to discover it works.
 
-Reading the source and concluding "this should work" does not pass this gate. A defect found in usage is yours to fix in this turn - same turn, not "follow-up".
+"This should work" from reading source does not pass. A defect found in usage is yours to fix this turn.
 
 # Global Review and Debugging Gate
 
-For significant implementation work and every PR handoff, run `review-work` plus a `debugging` runtime audit before declaring completion. Timeout, missing deliverable, ack-only, `BLOCKED:`, and inconclusive review lanes fail the gate. Record at least three debugging hypotheses with the runtime evidence confirming or refuting each.
-
-No completion message, PR, or PR/branch handoff until the gate passes. Always redact secrets, tokens, credentials, auth headers, cookies, env dumps, private logs, and PII from ledgers, PR bodies, and handoffs.
+Before declaring significant work or a PR handoff complete, run `review-work` plus a `debugging` runtime audit; record three debugging hypotheses with runtime evidence each. Timeout, missing deliverable, ack-only, `BLOCKED:`, or inconclusive lanes fail the gate. Redact secrets, tokens, and PII from ledgers, PR bodies, and handoffs.
 
 # Failure Recovery
 
-If your first approach fails, try a materially different one - different algorithm, library, or pattern, not a small tweak. Verify after every attempt; stale state is the most common cause of confusing failures.
-
-**Three-attempt protocol.** After three different approaches fail: stop editing immediately; revert or surgically undo only your own changes back to a known-good state; document each attempt and why it failed; then step back and ask the user one precise question carrying that failure context.
+If an approach fails, try a materially different one - not a small tweak - and verify after every attempt; stale state causes most confusing failures. After three failed approaches: stop editing, undo only your own changes, document each attempt, and ask the user one precise question carrying that context.
 
 # Pragmatism & Scope
 
-The best change is often the smallest correct change. When two approaches both work, prefer the one with fewer new names, helpers, layers, and tests.
+The smallest correct change wins: fewer new names, helpers, layers, and tests. Extract helpers only for reuse, real complexity, or a domain concept. A little duplication beats speculative abstraction. Bug fix != surrounding cleanup. Fix only issues your changes caused; report pre-existing failures as observations, not diffs.
 
-- Keep obvious single-use logic inline; extract a helper only when it is reused, hides meaningful complexity, or names a real domain concept.
-- A small amount of duplication beats speculative abstraction.
-- Bug fix != surrounding cleanup - do not refactor surrounding code while fixing. Simple feature != extra configurability.
-- Fix only issues your changes caused; pre-existing lint errors or failing tests unrelated to your work go in the final message as observations, not in the diff.
+Write only what the current correct path needs: no handlers, fallbacks, retries, or validation for impossible scenarios; validate only at system boundaries. No backward-compatibility shims for shapes that never shipped.
 
-## No defensive code, no speculative legacy
-
-Write only what the current correct path needs: no error handlers, fallbacks, retries, or input validation for scenarios the current contracts make impossible. Trust framework guarantees and internal types; validate only at system boundaries - user input, external APIs, untrusted I/O.
-
-No backward-compatibility code, migration shims, or alternate code paths "in case". Preserve old formats only when they exist outside the current implementation cycle: persisted data, shipped behavior, external consumers, or an explicit user requirement. Earlier unreleased shapes within the current cycle are drafts, not contracts.
-
-Default to no new tests. Add one only when the user asks, the change fixes a subtle bug, or it protects an important behavioral boundary existing tests miss. Never add tests to a codebase with no tests. Never make a test pass at the expense of correctness.
-
-# Code review requests
-
-When the user asks for a "review", findings come first, ordered by severity with file references; open questions and assumptions follow; the change-summary is secondary, not the lead. No findings? Say so explicitly and call out residual risks and testing gaps.
-
-# AGENTS.md
-
-AGENTS.md files in your context carry directory-scoped conventions. Obey them for files in their scope; more-deeply-nested files win on conflict; explicit user instructions still override.
+Default to no new tests: add one only for a user request, a subtle bug fix, or an unprotected behavioral boundary. Never add tests to a codebase with no tests; never make a test pass at the expense of correctness.
 
 # Output
 
-**Preamble.** Before the first tool call on any multi-step task, send a 1-2 sentence user-visible update: acknowledge the request, state your first concrete step.
-
-**During work.** One sentence at meaningful phase transitions only - a discovery that changes the plan, a decision with tradeoffs, a blocker, the start of a non-trivial verification step. Never narrate routine reads or `rg` calls.
-
-**Final message.** Lead with the result, then supporting context for where and why. No conversational openers ("Done -", "Got it"). Group by user-facing outcome, not by file. Simple work: 1-2 short paragraphs; larger work: at most 2-4 short sections.
-
-**Formatting.**
-
-- File references: `src/auth.ts` or `src/auth.ts:42` (1-based optional line). No `file://`, `vscode://`, or `https://` URIs for local files. No line ranges.
-- Multi-line code in fenced blocks with a language tag.
-- The user does not see command outputs - summarize the key lines when reporting them.
-- No emojis or em dashes unless the user explicitly requests them.
-- Never output broken inline citations like `【F:README.md†L5-L14】` - they break the CLI.
+Final message: lead with the result, group by outcome, no conversational openers. No emojis or em dashes unless requested. Never output broken inline citations like `【F:README.md†L5-L14】` - they break the CLI.
 
 # Success Criteria and Stop Rules
 
 Done when ALL of:
 
-- Every behavior the user asked for is implemented - no partial delivery, no "v0 / extend later".
-- LSP diagnostics clean on every file you changed.
-- Build (if applicable) exits 0; tests pass, or pre-existing failures are explicitly named with the reason.
-- The artifact has been **driven through its matching surface** in this turn (Manual QA Gate).
-- The final message reports what you did, what you verified, what you could not verify (with the reason), and any pre-existing issues you noticed but did not touch.
-
-When you think you are done: re-read the original request and your intent line - did every committed action complete? Run verification once more on changed files in parallel, then report.
+- Every requested behavior implemented - no partial delivery.
+- Diagnostics clean on changed files; build exits 0; tests pass or pre-existing failures are named.
+- The artifact passed the Manual QA Gate this turn.
+- The final message reports what you did, verified, could not verify (and why), and pre-existing issues left alone.
 
-Stop **only when** all of the above are true. Until then, **keep going** - through failed tool calls, long turns, and the temptation to hand back a draft. Forbidden stops: the artifact not yet driven through its matching surface; a tool reported success but you have not verified the changed files and observable behavior.
+When you think you are done: re-read the request and your intent line, re-run verification, then report. Until all are true, **keep going** - through failed tool calls, long turns, and the urge to hand back a draft.
 
-**Hard invariants** - non-negotiable, regardless of pressure to ship:
+**Hard invariants**, regardless of pressure to ship:
 
-- Never delete failing tests to get a green build. Never weaken a test to make it pass.
-- Never use `as any`, `@ts-ignore`, or `@ts-expect-error` to suppress type errors.
-- Never use `apply_patch` for deletes you cannot revert without explicit approval.
-- Never amend commits unless explicitly asked.
-- Never revert changes you did not make unless explicitly asked.
-- Never invent fake citations, fake tool output, or fake verification results.
+- Never delete or weaken a failing test to get green.
+- Never use `as any`, `@ts-ignore`, or `@ts-expect-error`.
+- Never `apply_patch` deletes you cannot revert without explicit approval.
+- Never invent fake citations, tool output, or verification results.
 
-**Asking the user** is a last resort: a missing secret, a design decision only they can make, a destructive action you should not take unilaterally, or missing information that would materially change the answer or create real risk. Even then, ask exactly one precise, narrow question and stop. Never ask permission to do obvious work.
+**Asking the user** is a last resort: a missing secret, a decision only they can make, a destructive action, or missing information that materially changes the answer. Ask exactly one narrow question and stop; never ask permission for obvious work.
 
 # Task Tracking
 

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-rules",
-	"version": "4.15.1",
+	"version": "4.16.0",
 	"description": "Codex plugin that injects project rule files into model context through lifecycle hooks.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/start-work-continuation/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-start-work-continuation",
-	"version": "4.15.1",
+	"version": "4.16.0",
 	"description": "Codex Stop hook continuation injector for omo-codex start-work plans.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

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

@@ -0,0 +1,46 @@
+# Teammode Component
+
+**Generated:** 2026-07-03
+
+## OVERVIEW
+
+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 threads. 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: team-vs-subagent decision matrix, 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-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-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 2, `MIN_MEMBERS = 2`, unique focus/name/threadTitle invariants.
+- `skills/teammode/scripts/team-worktree.mjs` - git worktree provisioning + `merge --no-ff --no-edit` integration; conflict leaves the tree mid-merge for the leader to resolve and re-run.
+- `skills/teammode/scripts/team-guide.mjs` - pure string builders for `guide.md` + the short member bootstrap trigger (`codex://threads/<id>` deep links, `WORKING:` / `BLOCKED:` heartbeat rules, English-only member traffic).
+- `test/thread-title-hook.test.ts` - hook unit tests (vitest-style imports, run via `bun test`).
+
+## WHERE TO LOOK
+
+| Task | Location |
+|------|----------|
+| Hook reminder text | `src/codex-hook.ts` `threadTitleReminder` + `test/thread-title-hook.test.ts`; `plugin/test/teammode-thread-title.test.mjs` pins the exact strings |
+| Skill protocol text | `skills/teammode/SKILL.md`; contract tests `plugin/test/teammode-{communication,worktree,safety,archive-ambiguity,thread-links}.test.mjs` pin phrases |
+| team.json shape | `team-state.mjs` (single source of the shape; `validateTeam` rejects schemaVersion != 2) |
+| Branch naming, worktree paths, merge | `team-worktree.mjs` (`team/<sessionId>/<memberId>` branches, worktrees confined to `<team dir>/worktrees/<memberId>`) |
+| Hook wiring | `hooks/hooks.json` (component) + `plugin/hooks/post-tool-use-checking-thread-title-hygiene.json` (aggregate; adds `commandWindows` powershell node-dispatch) |
+
+## NOTES
+
+- `plugin/skills/teammode/` is a gitignored synced COPY (`plugin/scripts/sync-skills.mjs` maps `teammode -> components/teammode/skills/teammode`). Edit here; `test:codex` overwrites the synced copy.
+- `dist/cli.js` is gitignored build output (`bun build src/cli.ts --target node --format esm`); the aggregate hook invokes it at `${PLUGIN_ROOT}/components/teammode/dist/cli.js`, so a stale/missing dist silently no-ops the hook.
+- Worktree isolation is conflict-triggered: the first `worktree-add` flips `team.worktree.enabled` for the whole team. Decide mid-run when a file collision appears, not only at init.
+- `worktree-add` idempotence matches on branch ref + `realpathSync` (`samePath`). Plain `resolve()` comparison missed Windows 8.3 short names (RUNNER~1) and re-ran `git worktree add` into a fatal error; keep it realpath-based.
+- All mutating subcommands serialize through `withTeamLock` and re-read committed state before writing. "team state is locked by ..." means the mutation did NOT happen; retry, or inspect `.team.lock/owner.json` after a crash.
+- Archive ambiguity: "Ambiguous Codex thread id" from `codex_app.set_thread_archived` is an app-thread archival blocker, not a team-state blocker. Record it via `archive --note`, never claim the thread was archived, never delete team state before evidence is copied or the user accepts the loss.
+- `integrate` lands member branches with merge commits only (`--no-ff`); never squash or rebase.
+- `bind-thread` refuses while the team has fewer than 2 members; a single-member team is a subagent, not a team. Member focus, name, and threadTitle must each be unique (case/whitespace-insensitive).
+- Every member is a real `codex_app.create_thread` thread bound via `bind-thread`; `multi_agent_v1.spawn_agent` is never a substitute.
+- The hook must stay silent (empty stdout) on unrelated tools and malformed payloads; it never blocks a Codex turn.
+- `init` with an explicit `--session <leader thread id>` makes `leader.sessionId` messageable; without it members cannot report and the leader is stuck polling. Re-running `init` is a safe no-op.

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

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-teammode",
-	"version": "4.15.1",
+	"version": "4.16.0",
 	"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/telemetry/dist/cli.js

@@ -170,9 +170,11 @@ function writePostHogActivityState(stateDir, nextState, diagnostics) {
     });
   }
 }
+
 // ../../telemetry-core/src/constants.ts
 var DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com";
 var DEFAULT_POSTHOG_API_KEY = "phc_CFJhj5HyvA62QPhvyaUCtaq23aUfznnijg5VaaGkNk74";
+
 // ../../telemetry-core/src/diagnostics.ts
 import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2 } from "node:fs";
 import { join as join2 } from "node:path";
@@ -287,6 +289,7 @@ function trimToMaxBytes(lines) {
   }
   return retained;
 }
+
 // ../../telemetry-core/src/env.ts
 var TRUTHY_DISABLE_VALUES = ["1", "true", "yes"];
 var SEND_OPT_OUT_VALUES = ["0", "false", "no", "yes"];
@@ -323,6 +326,7 @@ function getTelemetryApiKey(env = process.env, defaultApiKey = DEFAULT_POSTHOG_A
 function getTelemetryHost(env = process.env, defaultHost = DEFAULT_POSTHOG_HOST) {
   return env["POSTHOG_HOST"]?.trim() || defaultHost;
 }
+
 // ../../telemetry-core/src/machine-id.ts
 import { createHash } from "node:crypto";
 import os2 from "node:os";
@@ -332,6 +336,7 @@ function getDefaultTelemetryOsProvider() {
 function getTelemetryDistinctId(machineIdPrefix, osProvider = getDefaultTelemetryOsProvider()) {
   return createHash("sha256").update(`${machineIdPrefix}${osProvider.hostname()}`).digest("hex");
 }
+
 // ../../../node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
 import { dirname, posix, sep } from "node:path";
 function createModulerModifier() {
@@ -5657,6 +5662,7 @@ function getSafeCpuInfo(osProvider, input) {
     };
   }
 }
+
 // components/telemetry/src/product-identity.ts
 import { readFileSync as readFileSync3 } from "node:fs";
 var PRODUCT_NAME = "omo-codex";

package/packages/omo-codex/plugin/components/telemetry/dist/posthog.js

@@ -166,9 +166,11 @@ function writePostHogActivityState(stateDir, nextState, diagnostics) {
     });
   }
 }
+
 // ../../../../telemetry-core/src/constants.ts
 var DEFAULT_POSTHOG_HOST = "https://us.i.posthog.com";
 var DEFAULT_POSTHOG_API_KEY = "phc_CFJhj5HyvA62QPhvyaUCtaq23aUfznnijg5VaaGkNk74";
+
 // ../../../../telemetry-core/src/diagnostics.ts
 import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2 } from "node:fs";
 import { join as join2 } from "node:path";
@@ -283,6 +285,7 @@ function trimToMaxBytes(lines) {
   }
   return retained;
 }
+
 // ../../../../telemetry-core/src/env.ts
 var TRUTHY_DISABLE_VALUES = ["1", "true", "yes"];
 var SEND_OPT_OUT_VALUES = ["0", "false", "no", "yes"];
@@ -319,6 +322,7 @@ function getTelemetryApiKey(env = process.env, defaultApiKey = DEFAULT_POSTHOG_A
 function getTelemetryHost(env = process.env, defaultHost = DEFAULT_POSTHOG_HOST) {
   return env["POSTHOG_HOST"]?.trim() || defaultHost;
 }
+
 // ../../../../telemetry-core/src/machine-id.ts
 import { createHash } from "node:crypto";
 import os2 from "node:os";
@@ -328,6 +332,7 @@ function getDefaultTelemetryOsProvider() {
 function getTelemetryDistinctId(machineIdPrefix, osProvider = getDefaultTelemetryOsProvider()) {
   return createHash("sha256").update(`${machineIdPrefix}${osProvider.hostname()}`).digest("hex");
 }
+
 // ../../../../../node_modules/.bun/posthog-node@5.35.12/node_modules/posthog-node/dist/extensions/error-tracking/modifiers/module.node.mjs
 import { dirname, posix, sep } from "path";
 function createModulerModifier() {
@@ -5653,6 +5658,7 @@ function getSafeCpuInfo(osProvider, input) {
     };
   }
 }
+
 // src/product-identity.ts
 import { readFileSync as readFileSync3 } from "node:fs";
 var PRODUCT_NAME = "omo-codex";

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-telemetry",
-	"version": "4.15.1",
+	"version": "4.16.0",
 	"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.md

@@ -13,9 +13,12 @@ Conventions for human contributors and AI agents working on this repository.
 
 ## Layout
 
-- `src/cli.ts` — `UserPromptSubmit` hook CLI. Reads JSON on stdin, writes the directive to stdout when the keyword matches, exits 0 otherwise.
-- `src/codex-hook.ts` — pure detector/hook behavior.
+- `src/cli.ts` — `UserPromptSubmit` hook CLI. Reads JSON on stdin, writes a compact `<ultrawork-mode>` skill pointer to stdout when the keyword matches (full directive as fallback), exits 0 otherwise.
+- `src/codex-hook.ts` — pure detector/hook behavior; skips on context-pressure/recovery transcripts and when the directive is already in the transcript.
+- `src/skill-pointer.ts` — `buildUltraworkAdditionalContext()`: emits the <4096-byte pointer (Codex App truncates large hook output) directing the model to `create_goal` then read the bundled `ultrawork` skill; falls back to the full `ULTRAWORK_DIRECTIVE` when the plugin skills tree is absent. Pointer size + `ulw-loop` mirror byte-identity pinned by `plugin/test/ultrawork-skill-pointer.test.mjs`.
 - `directive.md` — bundled ultrawork directive text.
+- `skills/ultrawork/SKILL.md` — full directive as a skill, generated by `scripts/sync-directive.mjs`; pinned byte-for-byte to `directive.md` by `test/directive-source.test.ts`. `plugin/scripts/sync-skills.mjs` materializes it into the aggregate `plugin/skills/` tree the pointer path targets.
+- `skills/ulw-plan/` — dual-maintained copy of the ulw-plan skill (component copy wins over `packages/shared-skills/skills/ulw-plan/` in sync-skills; keep both in step by hand).
 - `agents/*.toml` — bundled Codex agent role files. Installed as regular files into `CODEX_HOME/agents/` by `src/cli/install-codex/link-cached-plugin-agents.ts` at install time. Public `sisyphuslabs` installs source them from Codex's installed-marketplace snapshot, not the versioned plugin cache, so they survive Codex auto-update cache pruning and temporary snapshot cleanup. No runtime `SessionStart` hook is involved.
 - `hooks/hooks.json` — registers the prompt-detector hook only.
 - `.codex-plugin/plugin.json` — Codex plugin manifest. Marketplace metadata lives here, not in `package.json`.

package/packages/omo-codex/plugin/components/ultrawork/CHANGELOG.md

@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- The `ulw`/`ultrawork` trigger now injects a compact bootstrap pointer instead of the full directive: it mandates the `ULTRAWORK MODE ENABLED!` opener, an immediate `create_goal` call with `objective` only, and reading the full directive from the bundled `ultrawork` skill at a runtime-resolved absolute path. Codex App truncates large hook outputs (head plus tail, middle omitted), which silently dropped the `create_goal` bootstrap since v4.14.1; the pointer stays far below the truncation budget so no part of it can be lost (fixes code-yeongyu/oh-my-openagent#5828). When the plugin skills tree is absent (standalone component installs), the hook falls back to emitting the full directive.
+- New `skills/ultrawork/SKILL.md` carries the complete directive body behind skill frontmatter and is regenerated from `@oh-my-opencode/prompts-core` by `scripts/sync-directive.mjs`; `directive-source.test.ts` pins the skill body to `directive.md` byte for byte.
 - Runtime hook migrated from `python3 hooks/ultrawork-detector.py` to the component-standard TypeScript build output `node dist/cli.js hook user-prompt-submit`, removing the Codex runtime dependency on Python.
 - New top-level **`# Manual-QA channels`** section explicitly enumerates the four real-usage channels the agent MUST verify through: (1) HTTP call, (2) tmux, (3) Browser use, (4) Computer use — each with concrete commands and the artifact to capture. Auxiliary surfaces (CLI stdout / DB diff / parsed config dump) only count for genuinely CLI- or data-shaped criteria.
 - Goal section now shouts **TESTS ALONE NEVER PROVE DONE**: a green test suite is supporting evidence, never completion proof. Every criterion needs its own real-usage scenario, built fresh and run through one of the four channels, every time.

package/packages/omo-codex/plugin/components/ultrawork/README.md

@@ -33,9 +33,9 @@ The installer copies the plugin into `~/.codex/plugins/cache/sisyphuslabs/omo/0.
 node ${PLUGIN_ROOT}/dist/cli.js hook user-prompt-submit
 ```
 
-Codex passes the prompt payload on stdin. When the pattern `\b(?:ultrawork|ulw)\b` (case-insensitive) matches, the hook writes the directive to stdout — Codex injects non-JSON stdout as `additional_context` for the next turn. Otherwise the hook writes nothing and exits 0. Malformed input also exits 0 to never block the turn.
+Codex passes the prompt payload on stdin. When the pattern `(?:ultrawork|ulw)` (case-insensitive) matches, the hook emits a compact bootstrap pointer instead of the full directive: the pointer mandates the `ULTRAWORK MODE ENABLED!` opener, an immediate `create_goal` call with `objective` only, and reading the full directive from the bundled `ultrawork` skill (`<plugin root>/skills/ultrawork/SKILL.md`, resolved to an absolute path at runtime). Keeping the injected payload small guarantees Codex App's hook-output truncation can never drop the `create_goal` bootstrap (issue #5828). When the skill file is not present (for example the standalone component install without the plugin skills tree), the hook falls back to emitting the full directive. Otherwise the hook writes nothing and exits 0. Malformed input also exits 0 to never block the turn.
 
-If a prior `UserPromptSubmit` hook output in transcript JSONL already contains `<ultrawork-mode>`, the hook suppresses itself so the same directive is not injected repeatedly. Plain transcript text containing `<ultrawork-mode>` is ignored unless it comes from hook output.
+If a prior `UserPromptSubmit` hook output in transcript JSONL already contains `<ultrawork-mode>`, the hook suppresses itself so the same bootstrap is not injected repeatedly. Plain transcript text containing `<ultrawork-mode>` is ignored unless it comes from hook output.
 
 Bundled agent role TOMLs in `agents/` ship to `CODEX_HOME/agents/` at install time, not via a runtime hook. The installer writes regular file copies on Linux, macOS, and Windows. For the public marketplace, the source is the installed-marketplace snapshot, not the versioned plugin cache, so agent role configs remain valid when Codex replaces `~/.codex/plugins/cache/sisyphuslabs/omo/<version>/` during auto-update or removes temporary marketplace state. Both code paths overwrite stale files and write a `.installed-agents.json` manifest next to the source root for clean uninstall tracking.
 
@@ -47,7 +47,7 @@ npm run build
 echo "$PAYLOAD" | node dist/cli.js hook user-prompt-submit | head -3
 ```
 
-Expect `<ultrawork-mode>` ... directive body.
+Expect `<ultrawork-mode>` ... bootstrap pointer naming `skills/ultrawork/SKILL.md` (or the full directive body when the plugin skills tree is absent).
 
 ## Agent role smoke test
 

package/packages/omo-codex/plugin/components/ultrawork/dist/cli.js

@@ -6,10 +6,59 @@ import { stdin as processStdin, stdout as processStdout } from "node:process";
 // components/ultrawork/src/codex-hook.ts
 import { readFileSync as readFileSync2 } from "node:fs";
 
+// components/ultrawork/src/skill-pointer.ts
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
 // components/ultrawork/src/directive.ts
 import { readFileSync } from "node:fs";
 var ULTRAWORK_DIRECTIVE = readFileSync(new URL("../directive.md", import.meta.url), "utf8");
 
+// components/ultrawork/src/skill-pointer.ts
+var ULTRAWORK_SKILL_POINTER_TEMPLATE = `<ultrawork-mode>
+ULTRAWORK MODE IS ACTIVE FOR THIS TASK.
+
+MANDATORY BOOTSTRAP: do all three steps, in order, before anything else.
+
+1. First user-visible line this turn MUST be exactly:
+\`ULTRAWORK MODE ENABLED!\`
+
+2. Call \`create_goal\` NOW with \`objective\` set to the user's request.
+Send \`objective\` only: no \`status\`, no budget fields. If the
+\`create_goal\` tool is unavailable, open your reply with a binding
+\`# Goal\` block instead. Never skip this step.
+
+3. Read the FULL ultrawork directive NOW, before any other tool call,
+plan, or edit. It is the \`ultrawork\` skill, stored at:
+
+{{ULTRAWORK_SKILL_PATH}}
+
+Read the whole file. If a read result comes back truncated, keep
+reading the remaining line ranges until you have seen every line.
+Every rule in that file is binding for this entire task: no
+compromise, no summarizing from memory, no skipping. If the file does
+not exist, tell the user the omo ultrawork skill is missing and
+continue with steps 1 and 2 plus evidence-bound execution.
+
+Do not start the requested work until all three steps are complete.
+</ultrawork-mode>
+`;
+var ULTRAWORK_SKILL_PATH_PLACEHOLDER = "{{ULTRAWORK_SKILL_PATH}}";
+var ULTRAWORK_SKILL_FILE_URL = new URL("../../../skills/ultrawork/SKILL.md", import.meta.url);
+function resolveUltraworkSkillFilePath() {
+  return fileURLToPath(ULTRAWORK_SKILL_FILE_URL);
+}
+function buildUltraworkSkillPointer(skillFilePath) {
+  return ULTRAWORK_SKILL_POINTER_TEMPLATE.replace(ULTRAWORK_SKILL_PATH_PLACEHOLDER, skillFilePath);
+}
+function buildUltraworkAdditionalContext(options = {}) {
+  const skillFilePath = options.skillFilePath === undefined ? resolveUltraworkSkillFilePath() : options.skillFilePath;
+  if (skillFilePath !== null && existsSync(skillFilePath)) {
+    return buildUltraworkSkillPointer(skillFilePath);
+  }
+  return ULTRAWORK_DIRECTIVE;
+}
+
 // components/ultrawork/src/codex-hook.ts
 var ULTRAWORK_CURRENT_PROMPT_PATTERN = /(?:ultrawork|ulw)/i;
 var ULTRAWORK_DIRECTIVE_MARKER = "<ultrawork-mode>";
@@ -23,7 +72,7 @@ var CONTEXT_PRESSURE_MARKERS = [
   "your input exceeds the context window",
   "long threads and multiple compactions"
 ];
-function runUserPromptSubmitHook(input) {
+function runUserPromptSubmitHook(input, options = {}) {
   if (!isCodexUserPromptSubmitInput(input))
     return "";
   if (isContextPressureRecoveryPrompt(input.prompt))
@@ -32,7 +81,7 @@ function runUserPromptSubmitHook(input) {
     return "";
   if (isContextPressureTranscript(input.transcript_path))
     return "";
-  return isUltraworkPrompt(input.prompt) ? formatAdditionalContextOutput(ULTRAWORK_DIRECTIVE) : "";
+  return isUltraworkPrompt(input.prompt) ? formatAdditionalContextOutput(buildUltraworkAdditionalContext(options)) : "";
 }
 function hasUltraworkDirectiveAlreadyInTranscript(transcriptPath) {
   if (transcriptPath === undefined || transcriptPath === null)

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-ultrawork",
-	"version": "4.15.1",
+	"version": "4.16.0",
 	"description": "Codex plugin that injects the ultrawork orchestration directive and ships LazyCodex planning, review, QA, and gate agent roles.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",
@@ -38,6 +38,7 @@
 		"dist",
 		"directive.md",
 		"hooks",
+		"skills",
 		"README.md",
 		"LICENSE",
 		"NOTICE"

package/packages/omo-codex/plugin/components/ultrawork/scripts/sync-directive.mjs

@@ -1,11 +1,24 @@
 #!/usr/bin/env node
-import { readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const componentRoot = dirname(dirname(fileURLToPath(import.meta.url)));
 const codexPromptUrl = new URL(import.meta.resolve("@oh-my-opencode/prompts-core/prompts/ultrawork/codex.md"));
 const directivePath = join(componentRoot, "directive.md");
+const skillDirectory = join(componentRoot, "skills", "ultrawork");
+const skillPath = join(skillDirectory, "SKILL.md");
+
+const skillFrontmatter = `---
+name: ultrawork
+description: Binding ultrawork mode directive for omo on Codex. When a prompt contains ultrawork or ulw, the omo UserPromptSubmit hook injects a short bootstrap that points at this file. Read the whole file and follow every rule in it for the rest of the task.
+metadata:
+  short-description: Binding ultrawork mode directive
+---
+
+`;
 
 const codexPrompt = await readFile(codexPromptUrl, "utf8");
 await writeFile(directivePath, codexPrompt);
+await mkdir(skillDirectory, { recursive: true });
+await writeFile(skillPath, `${skillFrontmatter}${codexPrompt}`);