oh-my-opencode 4.15.0 → 4.16.0

package/packages/omo-codex/plugin/components/ultrawork/test/skill-pointer.test.ts

@@ -0,0 +1,82 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { runUserPromptSubmitHook } from "../src/codex-hook.js";
+import { ULTRAWORK_DIRECTIVE } from "../src/directive.js";
+import { buildUltraworkAdditionalContext, buildUltraworkSkillPointer } from "../src/skill-pointer.js";
+import { parseHookOutput } from "./codex-hook-test-helpers.js";
+
+const POINTER_MAX_BYTES = 4096;
+const tempDirectories: string[] = [];
+
+function makeTempDirectory(): string {
+	const directory = mkdtempSync(join(tmpdir(), "ultrawork-skill-"));
+	tempDirectories.push(directory);
+	return directory;
+}
+
+function writeSkillFile(): string {
+	const skillFilePath = join(makeTempDirectory(), "SKILL.md");
+	writeFileSync(skillFilePath, "---\nname: ultrawork\n---\n\n<ultrawork-mode>\ndirective body\n</ultrawork-mode>\n");
+	return skillFilePath;
+}
+
+afterEach(() => {
+	for (const directory of tempDirectories.splice(0)) {
+		rmSync(directory, { recursive: true, force: true });
+	}
+});
+
+describe("ultrawork skill pointer", () => {
+	it("#given an existing skill file #when context is built #then emits the compact pointer with the absolute path", () => {
+		// given
+		const skillFilePath = writeSkillFile();
+
+		// when
+		const context = buildUltraworkAdditionalContext({ skillFilePath });
+
+		// then
+		expect(context).toBe(buildUltraworkSkillPointer(skillFilePath));
+		expect(context.startsWith("<ultrawork-mode>")).toBe(true);
+		expect(context).toContain(skillFilePath);
+		expect(context).toContain("First user-visible line this turn MUST be exactly:");
+		expect(context).toContain("create_goal");
+		expect(context).not.toContain("Tier triage");
+		expect(Buffer.byteLength(context, "utf8")).toBeLessThan(POINTER_MAX_BYTES);
+	});
+
+	it("#given a missing skill file #when context is built #then falls back to the full directive", () => {
+		// given
+		const missingSkillFilePath = join(makeTempDirectory(), "SKILL.md");
+
+		// when
+		const context = buildUltraworkAdditionalContext({ skillFilePath: missingSkillFilePath });
+
+		// then
+		expect(context).toBe(ULTRAWORK_DIRECTIVE);
+	});
+
+	it("#given a null skill path #when context is built #then falls back to the full directive", () => {
+		expect(buildUltraworkAdditionalContext({ skillFilePath: null })).toBe(ULTRAWORK_DIRECTIVE);
+	});
+
+	it("#given the hook runs with a skill file #when prompt is ulw #then hook JSON carries the pointer", () => {
+		// given
+		const skillFilePath = writeSkillFile();
+
+		// when
+		const output = runUserPromptSubmitHook(
+			{ hook_event_name: "UserPromptSubmit", prompt: "ulw this change" },
+			{ skillFilePath },
+		);
+		const parsed = parseHookOutput(output);
+
+		// then
+		expect(parsed.hookSpecificOutput.hookEventName).toBe("UserPromptSubmit");
+		expect(parsed.hookSpecificOutput.additionalContext).toMatch(/^<ultrawork-mode>/);
+		expect(parsed.hookSpecificOutput.additionalContext).toContain(skillFilePath);
+	});
+});

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

@@ -2,6 +2,7 @@
 
 ## [0.1.0] - unreleased
 
+- Standalone ultrawork injection (`--with-ultrawork`) now emits the same compact bootstrap pointer as the ultrawork component (opener mandate, `create_goal` with `objective` only, read the bundled `ultrawork` skill at a runtime-resolved absolute path), falling back to the full bundled directive when the plugin skills tree is absent. Keeps the injected payload below Codex App's hook-output truncation budget (code-yeongyu/oh-my-openagent#5828).
 - Initial scaffold of codex-ulw-loop plugin.
 - Per-Criterion Cycle: `EXECUTE` is now **EXECUTE-AS-SCENARIO** — the agent must run the Manual-QA channel scenario the criterion named (HTTP call / tmux / browser use / computer use; see new `## Manual-QA channels` section). Inserted a new **CLEAN (PAIRED, NEVER SKIP)** step that tears down every QA-spawned process / `tmux` session / browser context / container / port / temp dir before recording evidence; the cleanup receipt is embedded in the `--evidence` string. Missing receipt → record BLOCKED, not PASS. Added Constraint #13 and a Stop Rule for leftover state.
 - New top-level **`## Manual-QA channels`** section explicitly enumerates the four channels (HTTP call, tmux, Browser use, Computer use) with concrete commands and required artifacts. Goal section now declares **TESTS ALONE NEVER PROVE DONE**: a green test suite is supporting evidence, never completion proof. Criterion-refinement step 2 requires each criterion to name its channel up front.

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

@@ -2270,8 +2270,57 @@ function commandScope(argv) {
 }
 
 // components/ulw-loop/src/ultrawork-directive.ts
-import { readFileSync } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
+
+// components/ulw-loop/src/ultrawork-skill-pointer.ts
+import { existsSync as existsSync5, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+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);
 var ULTRAWORK_DIRECTIVE = readFileSync(new URL("../directive.md", import.meta.url), "utf8");
+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 && existsSync5(skillFilePath)) {
+    return buildUltraworkSkillPointer(skillFilePath);
+  }
+  return ULTRAWORK_DIRECTIVE;
+}
+
+// components/ulw-loop/src/ultrawork-directive.ts
 var ULTRAWORK_CURRENT_PROMPT_PATTERN = /(?:ultrawork|ulw)/i;
 var ULTRAWORK_DIRECTIVE_MARKER = "<ultrawork-mode>";
 var TRANSCRIPT_SEARCH_BYTES = 512000;
@@ -2284,14 +2333,14 @@ var CONTEXT_PRESSURE_MARKERS = [
   "your input exceeds the context window",
   "long threads and multiple compactions"
 ];
-function buildUltraworkDirectiveOutput(input) {
+function buildUltraworkDirectiveOutput(input, options = {}) {
   if (isContextPressureRecoveryPrompt(input.prompt))
     return "";
   if (hasUltraworkDirectiveAlreadyInTranscript(input.transcript_path))
     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)
@@ -2319,7 +2368,7 @@ function hasUltraworkDirectiveAlreadyInTranscript(transcriptPath) {
   return false;
 }
 function readTranscriptTail(transcriptPath) {
-  const rawTranscript = readFileSync(transcriptPath);
+  const rawTranscript = readFileSync2(transcriptPath);
   return rawTranscript.subarray(Math.max(0, rawTranscript.byteLength - TRANSCRIPT_SEARCH_BYTES)).toString("utf8");
 }
 function isUltraworkPrompt(prompt) {
@@ -2409,7 +2458,9 @@ async function applyUserPromptUlwLoopSteering(payload, options = {}) {
     if (proposal === null) {
       if (hasSteeringDirectiveMarker(payload.prompt))
         return "";
-      return options.includeUltraworkDirective ? buildUltraworkDirectiveOutput(payload) : "";
+      if (!options.includeUltraworkDirective)
+        return "";
+      return options.ultraworkSkillFilePath === undefined ? buildUltraworkDirectiveOutput(payload) : buildUltraworkDirectiveOutput(payload, { skillFilePath: options.ultraworkSkillFilePath });
     }
     const result = await steerUlwLoop(payload.cwd, proposal, payloadScope(payload));
     if (!result.accepted)

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

@@ -10,6 +10,7 @@ export interface UserPromptSubmitPayload {
 }
 export interface UserPromptSubmitHookOptions {
     readonly includeUltraworkDirective?: boolean;
+    readonly ultraworkSkillFilePath?: string | null;
 }
 export interface PreToolUsePayload {
     readonly cwd: string;

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

@@ -36,7 +36,11 @@ export async function applyUserPromptUlwLoopSteering(payload, options = {}) {
         if (proposal === null) {
             if (hasSteeringDirectiveMarker(payload.prompt))
                 return "";
-            return options.includeUltraworkDirective ? buildUltraworkDirectiveOutput(payload) : "";
+            if (!options.includeUltraworkDirective)
+                return "";
+            return options.ultraworkSkillFilePath === undefined
+                ? buildUltraworkDirectiveOutput(payload)
+                : buildUltraworkDirectiveOutput(payload, { skillFilePath: options.ultraworkSkillFilePath });
         }
         const result = await steerUlwLoop(payload.cwd, proposal, payloadScope(payload));
         if (!result.accepted)

package/packages/omo-codex/plugin/components/ulw-loop/dist/ultrawork-directive.d.ts

@@ -1,5 +1,6 @@
+import { type UltraworkAdditionalContextOptions } from "./ultrawork-skill-pointer.js";
 export interface UltraworkDirectiveInput {
     readonly prompt: string;
     readonly transcript_path?: string | null;
 }
-export declare function buildUltraworkDirectiveOutput(input: UltraworkDirectiveInput): string;
+export declare function buildUltraworkDirectiveOutput(input: UltraworkDirectiveInput, options?: UltraworkAdditionalContextOptions): string;

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

@@ -1,5 +1,5 @@
 import { readFileSync } from "node:fs";
-const ULTRAWORK_DIRECTIVE = readFileSync(new URL("../directive.md", import.meta.url), "utf8");
+import { buildUltraworkAdditionalContext } from "./ultrawork-skill-pointer.js";
 const ULTRAWORK_CURRENT_PROMPT_PATTERN = /(?:ultrawork|ulw)/i;
 const ULTRAWORK_DIRECTIVE_MARKER = "<ultrawork-mode>";
 const TRANSCRIPT_SEARCH_BYTES = 512_000;
@@ -12,14 +12,16 @@ const CONTEXT_PRESSURE_MARKERS = [
     "your input exceeds the context window",
     "long threads and multiple compactions",
 ];
-export function buildUltraworkDirectiveOutput(input) {
+export function buildUltraworkDirectiveOutput(input, options = {}) {
     if (isContextPressureRecoveryPrompt(input.prompt))
         return "";
     if (hasUltraworkDirectiveAlreadyInTranscript(input.transcript_path))
         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/ulw-loop/dist/ultrawork-skill-pointer.d.ts

@@ -0,0 +1,7 @@
+export declare const ULTRAWORK_SKILL_POINTER_TEMPLATE = "<ultrawork-mode>\nULTRAWORK MODE IS ACTIVE FOR THIS TASK.\n\nMANDATORY BOOTSTRAP: do all three steps, in order, before anything else.\n\n1. First user-visible line this turn MUST be exactly:\n`ULTRAWORK MODE ENABLED!`\n\n2. Call `create_goal` NOW with `objective` set to the user's request.\nSend `objective` only: no `status`, no budget fields. If the\n`create_goal` tool is unavailable, open your reply with a binding\n`# Goal` block instead. Never skip this step.\n\n3. Read the FULL ultrawork directive NOW, before any other tool call,\nplan, or edit. It is the `ultrawork` skill, stored at:\n\n{{ULTRAWORK_SKILL_PATH}}\n\nRead the whole file. If a read result comes back truncated, keep\nreading the remaining line ranges until you have seen every line.\nEvery rule in that file is binding for this entire task: no\ncompromise, no summarizing from memory, no skipping. If the file does\nnot exist, tell the user the omo ultrawork skill is missing and\ncontinue with steps 1 and 2 plus evidence-bound execution.\n\nDo not start the requested work until all three steps are complete.\n</ultrawork-mode>\n";
+export interface UltraworkAdditionalContextOptions {
+    readonly skillFilePath?: string | null;
+}
+export declare function resolveUltraworkSkillFilePath(): string;
+export declare function buildUltraworkSkillPointer(skillFilePath: string): string;
+export declare function buildUltraworkAdditionalContext(options?: UltraworkAdditionalContextOptions): string;

package/packages/omo-codex/plugin/components/ulw-loop/dist/ultrawork-skill-pointer.js

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+export const 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>
+`;
+const ULTRAWORK_SKILL_PATH_PLACEHOLDER = "{{ULTRAWORK_SKILL_PATH}}";
+const ULTRAWORK_SKILL_FILE_URL = new URL("../../../skills/ultrawork/SKILL.md", import.meta.url);
+const ULTRAWORK_DIRECTIVE = readFileSync(new URL("../directive.md", import.meta.url), "utf8");
+export function resolveUltraworkSkillFilePath() {
+    return fileURLToPath(ULTRAWORK_SKILL_FILE_URL);
+}
+export function buildUltraworkSkillPointer(skillFilePath) {
+    return ULTRAWORK_SKILL_POINTER_TEMPLATE.replace(ULTRAWORK_SKILL_PATH_PLACEHOLDER, skillFilePath);
+}
+export function buildUltraworkAdditionalContext(options = {}) {
+    const skillFilePath = options.skillFilePath === undefined ? resolveUltraworkSkillFilePath() : options.skillFilePath;
+    if (skillFilePath !== null && existsSync(skillFilePath)) {
+        return buildUltraworkSkillPointer(skillFilePath);
+    }
+    return ULTRAWORK_DIRECTIVE;
+}

package/packages/omo-codex/plugin/components/ulw-loop/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-ulw-loop",
-	"version": "4.15.0",
+	"version": "4.16.0",
 	"description": "Codex plugin: durable repo-native multi-goal orchestration with embedded success criteria and observable evidence audit.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/ulw-loop/skills/ulw-loop/references/full-workflow.md

@@ -127,7 +127,7 @@ Gather context BEFORE planning with parallel `explorer` / `librarian` workers pl
 First survey available skills: read every loosely-relevant skill's description, deliberately choose which this work uses, and prefer applying genuinely-relevant skills over working raw.
 Then run tier triage per goal — rigor (LIGHT/HEAVY below) and shape (`delivery` default, or `research` when the deliverable is a cited answer, not an artifact) — and record both in an `annotate_ledger` steering entry. Default is LIGHT — a narrow change inside existing layers. Take HEAVY only on a fact you can point to: a new module / abstraction / domain model; auth, security, or session; an external integration; a DB schema or migration; concurrency, transaction boundaries, or cache invalidation; a cross-domain refactor; or the user signaled care or demanded review. When unsure, take HEAVY; upgrade the moment a HEAVY fact surfaces, never downgrade mid-run.
 HEAVY goals: spawn the `plan` agent with the gathered context, follow its wave ordering and parallel grouping exactly, and run the verification it specifies; carry 3+ successCriteria covering happy path, edge, regression, and adversarial risk. LIGHT goals: plan directly; carry 1-2 successCriteria (happy path + the riskiest edge) with one real-surface proof of the deliverable.
-Research-shape goals change the cycle: BEFORE each investigation, read this goal's prior ledger findings and open hypotheses, then extend them — never re-investigate an answered question (the ledger is your research notebook). Record findings via `annotate_ledger` with their source (`file:line`, command output, doc URL) as `--evidence`. Track hypotheses as `HYPOTHESIS[id]: <claim> | status: open`, flipped to `confirmed`/`refuted` only on an observed source. A research criterion passes on a cited answer — skip QA-channel, cleanup, and commit, but keep source-observability (never "looks correct"). Keep hypotheses inside the user's stated question; a scope-widening one is an `add_subgoal` proposal you surface, never silent creep. For a `research`-shape goal you MAY load `ulw-research` (legacy alias: `ultraresearch`) without hesitation — otherwise explicit-request-only, a research-shape goal IS that explicit demand. Research-only: never for a `delivery` goal. It composes with the librarian routing above — `ulw-research` for saturation (many parallel sources, recursive expansion), a single `librarian` for one lookup.
+Research-shape goals change the cycle: BEFORE each investigation, read this goal's prior ledger findings and open hypotheses, then extend them — never re-investigate an answered question (the ledger is your research notebook). Record findings via `annotate_ledger` with their source (`file:line`, command output, doc URL) as `--evidence`. Track hypotheses as `HYPOTHESIS[id]: <claim> | status: open`, flipped to `confirmed`/`refuted` only on an observed source. A research criterion passes on a cited answer — skip QA-channel, cleanup, and commit, but keep source-observability (never "looks correct"). Keep hypotheses inside the user's stated question; a scope-widening one is an `add_subgoal` proposal you surface, never silent creep. For a `research`-shape goal you MAY load `ulw-research` without hesitation — otherwise explicit-request-only, a research-shape goal IS that explicit demand. Research-only: never for a `delivery` goal. It composes with the librarian routing above — `ulw-research` for saturation (many parallel sources, recursive expansion), a single `librarian` for one lookup.
 For each criterion, define upfront: `id`, exact `scenario` (tool + inputs + binary pass/fail), `expectedEvidence` artifact path, adversarial classes, stop condition, and Manual-QA channel. Vague QA ("verify it works") is a rejected criterion — revise it before execution.
 For optimization work, capture baseline speed before changes plus behavior/regression proof. Every attempt records speed, behavior/regression, and the keep/revert/iterate decision.
 A criterion's adversarial classes are the ultraqa classes a fact about the change triggers: malformed input, prompt injection, cancel/resume, stale state, dirty worktree, hung or long commands, flaky tests, misleading success output, repeated interruptions. Record untriggered classes as not-applicable in one line.

package/packages/omo-codex/plugin/components/ulw-loop/src/codex-hook.ts

@@ -15,6 +15,7 @@ export interface UserPromptSubmitPayload {
 
 export interface UserPromptSubmitHookOptions {
 	readonly includeUltraworkDirective?: boolean;
+	readonly ultraworkSkillFilePath?: string | null;
 }
 
 export interface PreToolUsePayload {
@@ -74,7 +75,10 @@ export async function applyUserPromptUlwLoopSteering(
 		const proposal = parseUlwLoopSteeringDirective(payload.prompt);
 		if (proposal === null) {
 			if (hasSteeringDirectiveMarker(payload.prompt)) return "";
-			return options.includeUltraworkDirective ? buildUltraworkDirectiveOutput(payload) : "";
+			if (!options.includeUltraworkDirective) return "";
+			return options.ultraworkSkillFilePath === undefined
+				? buildUltraworkDirectiveOutput(payload)
+				: buildUltraworkDirectiveOutput(payload, { skillFilePath: options.ultraworkSkillFilePath });
 		}
 		const result = await steerUlwLoop(payload.cwd, proposal, payloadScope(payload));
 		if (!result.accepted) return "";

package/packages/omo-codex/plugin/components/ulw-loop/src/ultrawork-directive.ts

@@ -1,5 +1,7 @@
 import { readFileSync } from "node:fs";
 
+import { buildUltraworkAdditionalContext, type UltraworkAdditionalContextOptions } from "./ultrawork-skill-pointer.js";
+
 export interface UltraworkDirectiveInput {
 	readonly prompt: string;
 	readonly transcript_path?: string | null;
@@ -12,7 +14,6 @@ interface UserPromptSubmitHookOutput {
 	};
 }
 
-const ULTRAWORK_DIRECTIVE = readFileSync(new URL("../directive.md", import.meta.url), "utf8");
 const ULTRAWORK_CURRENT_PROMPT_PATTERN = /(?:ultrawork|ulw)/i;
 const ULTRAWORK_DIRECTIVE_MARKER = "<ultrawork-mode>";
 const TRANSCRIPT_SEARCH_BYTES = 512_000;
@@ -26,11 +27,16 @@ const CONTEXT_PRESSURE_MARKERS = [
 	"long threads and multiple compactions",
 ] as const;
 
-export function buildUltraworkDirectiveOutput(input: UltraworkDirectiveInput): string {
+export function buildUltraworkDirectiveOutput(
+	input: UltraworkDirectiveInput,
+	options: UltraworkAdditionalContextOptions = {},
+): string {
 	if (isContextPressureRecoveryPrompt(input.prompt)) return "";
 	if (hasUltraworkDirectiveAlreadyInTranscript(input.transcript_path)) return "";
 	if (isContextPressureTranscript(input.transcript_path)) return "";
-	return isUltraworkPrompt(input.prompt) ? formatAdditionalContextOutput(ULTRAWORK_DIRECTIVE) : "";
+	return isUltraworkPrompt(input.prompt)
+		? formatAdditionalContextOutput(buildUltraworkAdditionalContext(options))
+		: "";
 }
 
 function hasUltraworkDirectiveAlreadyInTranscript(transcriptPath: string | null | undefined): boolean {

package/packages/omo-codex/plugin/components/ulw-loop/src/ultrawork-skill-pointer.ts

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+
+export const 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>
+`;
+
+const ULTRAWORK_SKILL_PATH_PLACEHOLDER = "{{ULTRAWORK_SKILL_PATH}}";
+const ULTRAWORK_SKILL_FILE_URL = new URL("../../../skills/ultrawork/SKILL.md", import.meta.url);
+const ULTRAWORK_DIRECTIVE = readFileSync(new URL("../directive.md", import.meta.url), "utf8");
+
+export interface UltraworkAdditionalContextOptions {
+	readonly skillFilePath?: string | null;
+}
+
+export function resolveUltraworkSkillFilePath(): string {
+	return fileURLToPath(ULTRAWORK_SKILL_FILE_URL);
+}
+
+export function buildUltraworkSkillPointer(skillFilePath: string): string {
+	return ULTRAWORK_SKILL_POINTER_TEMPLATE.replace(ULTRAWORK_SKILL_PATH_PLACEHOLDER, skillFilePath);
+}
+
+export function buildUltraworkAdditionalContext(options: UltraworkAdditionalContextOptions = {}): string {
+	const skillFilePath = options.skillFilePath === undefined ? resolveUltraworkSkillFilePath() : options.skillFilePath;
+	if (skillFilePath !== null && existsSync(skillFilePath)) {
+		return buildUltraworkSkillPointer(skillFilePath);
+	}
+	return ULTRAWORK_DIRECTIVE;
+}

package/packages/omo-codex/plugin/components/ulw-loop/test/ultrawork-directive.test.ts

@@ -61,4 +61,53 @@ describe("standalone ultrawork directive injection", () => {
 
 		expect(ulwLoopDirective).toBe(ultraworkDirective);
 	});
+
+	it("#given an existing ultrawork skill file #when standalone injection runs #then emits the compact skill pointer", async () => {
+		const skillFilePath = join(await mkdtemp(join(tmpdir(), "ug-skill-")), "SKILL.md");
+		await writeFile(
+			skillFilePath,
+			"---\nname: ultrawork\n---\n\n<ultrawork-mode>\ndirective body\n</ultrawork-mode>\n",
+		);
+
+		const output = await applyUserPromptUlwLoopSteering(payload("ulw this change", "/tmp"), {
+			includeUltraworkDirective: true,
+			ultraworkSkillFilePath: skillFilePath,
+		});
+		const parsed = JSON.parse(output);
+		const context = parsed.hookSpecificOutput.additionalContext;
+
+		expect(context).toMatch(/^<ultrawork-mode>/);
+		expect(context).toContain(skillFilePath);
+		expect(context).toContain("create_goal");
+		expect(context).not.toContain("Tier triage");
+	});
+
+	it("#given a missing ultrawork skill file #when standalone injection runs #then falls back to the full directive", async () => {
+		const missingSkillFilePath = join(await mkdtemp(join(tmpdir(), "ug-skill-")), "SKILL.md");
+
+		const output = await applyUserPromptUlwLoopSteering(payload("ulw this change", "/tmp"), {
+			includeUltraworkDirective: true,
+			ultraworkSkillFilePath: missingSkillFilePath,
+		});
+		const parsed = JSON.parse(output);
+
+		expect(parsed.hookSpecificOutput.additionalContext).toContain("Tier triage");
+	});
+
+	it("#given the ulw-loop pointer template #when compared to ultrawork #then the copy stays byte-identical", async () => {
+		const ulwLoopPointerSource = await readFile(
+			new URL("../src/ultrawork-skill-pointer.ts", import.meta.url),
+			"utf8",
+		);
+		const ultraworkPointerSource = await readFile(
+			new URL("../../ultrawork/src/skill-pointer.ts", import.meta.url),
+			"utf8",
+		);
+		const templatePattern = /export const ULTRAWORK_SKILL_POINTER_TEMPLATE = `[\s\S]*?`;\n/;
+		const ulwLoopTemplate = ulwLoopPointerSource.match(templatePattern)?.[0];
+		const ultraworkTemplate = ultraworkPointerSource.match(templatePattern)?.[0];
+
+		expect(ulwLoopTemplate).toBeDefined();
+		expect(ulwLoopTemplate).toBe(ultraworkTemplate);
+	});
 });

package/packages/omo-codex/plugin/package-lock.json

@@ -1,12 +1,12 @@
 {
 	"name": "@sisyphuslabs/omo-codex-plugin",
-	"version": "4.15.0",
+	"version": "4.16.0",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@sisyphuslabs/omo-codex-plugin",
-			"version": "4.15.0",
+			"version": "4.16.0",
 			"workspaces": [
 				"components/codegraph",
 				"components/comment-checker",
@@ -93,7 +93,7 @@
 		},
 		"components/codegraph": {
 			"name": "@sisyphuslabs/codex-codegraph",
-			"version": "4.15.0",
+			"version": "4.16.0",
 			"bin": {
 				"omo-codegraph": "dist/cli.js"
 			},
@@ -112,7 +112,7 @@
 		},
 		"components/comment-checker": {
 			"name": "@code-yeongyu/codex-comment-checker",
-			"version": "4.15.0",
+			"version": "4.16.0",
 			"license": "MIT",
 			"bin": {
 				"omo-comment-checker": "dist/cli.js"
@@ -133,7 +133,7 @@
 		},
 		"components/git-bash": {
 			"name": "@sisyphuslabs/codex-git-bash-hook",
-			"version": "4.15.0",
+			"version": "4.16.0",
 			"bin": {
 				"omo-git-bash-hook": "dist/cli.js"
 			},
@@ -148,7 +148,7 @@
 		},
 		"components/lazycodex-executor-verify": {
 			"name": "@code-yeongyu/codex-lazycodex-executor-verify",
-			"version": "4.15.0",
+			"version": "4.16.0",
 			"license": "MIT",
 			"bin": {
 				"lazycodex-executor-verify": "dist/cli.js"
@@ -165,7 +165,7 @@
 		},
 		"components/lsp": {
 			"name": "@code-yeongyu/codex-lsp",
-			"version": "4.15.0",
+			"version": "4.16.0",
 			"license": "MIT",
 			"dependencies": {
 				"@code-yeongyu/lsp-daemon": "file:../../../../lsp-daemon"
@@ -185,7 +185,7 @@
 		},
 		"components/rules": {
 			"name": "@code-yeongyu/codex-rules",
-			"version": "4.15.0",
+			"version": "4.16.0",
 			"license": "MIT",
 			"dependencies": {
 				"picomatch": "^4.0.3"
@@ -207,7 +207,7 @@
 		},
 		"components/start-work-continuation": {
 			"name": "@code-yeongyu/codex-start-work-continuation",
-			"version": "4.15.0",
+			"version": "4.16.0",
 			"license": "MIT",
 			"bin": {
 				"omo-start-work-continuation": "dist/cli.js"
@@ -224,7 +224,7 @@
 		},
 		"components/teammode": {
 			"name": "@sisyphuslabs/codex-teammode",
-			"version": "4.15.0",
+			"version": "4.16.0",
 			"devDependencies": {
 				"@types/node": "^25.9.3",
 				"bun-types": "^1.3.1",
@@ -237,7 +237,7 @@
 		},
 		"components/telemetry": {
 			"name": "@code-yeongyu/codex-telemetry",
-			"version": "4.15.0",
+			"version": "4.16.0",
 			"license": "MIT",
 			"bin": {
 				"omo-telemetry": "dist/cli.js"
@@ -255,7 +255,7 @@
 		},
 		"components/ultrawork": {
 			"name": "@code-yeongyu/codex-ultrawork",
-			"version": "4.15.0",
+			"version": "4.16.0",
 			"license": "MIT",
 			"bin": {
 				"omo-ultrawork": "dist/cli.js"
@@ -273,7 +273,7 @@
 		},
 		"components/ulw-loop": {
 			"name": "@code-yeongyu/codex-ulw-loop",
-			"version": "4.15.0",
+			"version": "4.16.0",
 			"license": "MIT",
 			"bin": {
 				"omo-ulw-loop": "dist/cli.js",

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

@@ -1,6 +1,6 @@
 {
   "name": "@sisyphuslabs/omo-codex-plugin",
-  "version": "4.15.0",
+  "version": "4.16.0",
   "description": "Aggregate Codex plugin root for OMO components.",
   "type": "module",
   "packageManager": "npm@11.12.1",