oh-my-opencode 4.5.1 → 4.6.0

package/packages/omo-codex/plugin/components/start-work-continuation/test/cli.test.ts

@@ -0,0 +1,124 @@
+import { spawnSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execPath } from "node:process";
+import { afterEach, describe, expect, it } from "vitest";
+
+const cleanupRoots: string[] = [];
+
+afterEach(() => {
+	for (const root of cleanupRoots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+describe("start-work continuation CLI", () => {
+	it("#given valid Stop stdin #when CLI runs #then stdout contains block JSON", () => {
+		// given
+		const cwd = createWorkspace(["codex:s1"]);
+		const payload = JSON.stringify(makePayload(cwd, false, "Stop"));
+
+		// when
+		const result = runCli("stop", payload);
+
+		// then
+		if (result.error !== undefined) throw result.error;
+		expect(result.status).toBe(0);
+		expect(result.stdout).toContain('"decision":"block"');
+	});
+
+	it("#given valid SubagentStop stdin #when CLI runs #then stdout contains block JSON", () => {
+		// given
+		const cwd = createWorkspace(["codex:s1"]);
+		const payload = JSON.stringify(makePayload(cwd, false, "SubagentStop"));
+
+		// when
+		const result = runCli("subagent-stop", payload);
+
+		// then
+		if (result.error !== undefined) throw result.error;
+		expect(result.status).toBe(0);
+		expect(result.stdout).toContain('"decision":"block"');
+	});
+
+	it("#given active stop hook stdin #when CLI runs #then stdout is empty and exit is zero", () => {
+		// given
+		const cwd = createWorkspace(["codex:s1"]);
+		const payload = JSON.stringify(makePayload(cwd, true, "Stop"));
+
+		// when
+		const result = runCli("stop", payload);
+
+		// then
+		if (result.error !== undefined) throw result.error;
+		expect(result.status).toBe(0);
+		expect(result.stdout).toBe("");
+	});
+
+	it("#given unrelated session stdin #when CLI runs #then stdout is empty and exit is zero", () => {
+		// given
+		const cwd = createWorkspace(["codex:other"]);
+		const payload = JSON.stringify(makePayload(cwd, false, "Stop"));
+
+		// when
+		const result = runCli("stop", payload);
+
+		// then
+		if (result.error !== undefined) throw result.error;
+		expect(result.status).toBe(0);
+		expect(result.stdout).toBe("");
+	});
+
+	it("#given malformed stdin #when CLI runs #then stdout is empty and exit is zero", () => {
+		// given
+		const payload = "{not-json";
+
+		// when
+		const result = runCli("stop", payload);
+
+		// then
+		if (result.error !== undefined) throw result.error;
+		expect(result.status).toBe(0);
+		expect(result.stdout).toBe("");
+	});
+});
+
+function runCli(subcommand: "stop" | "subagent-stop", input: string) {
+	return spawnSync(execPath, [join(process.cwd(), "dist", "cli.js"), "hook", subcommand], { input, encoding: "utf8" });
+}
+
+function createWorkspace(sessionIds: readonly string[]): string {
+	const root = mkdtempSync(join(tmpdir(), "codex-continuation-cli-"));
+	cleanupRoots.push(root);
+	mkdirSync(join(root, ".omo", "plans"), { recursive: true });
+	writeFileSync(join(root, ".omo", "plans", "plan.md"), "## TODOs\n\n- [ ] Task one\n");
+	const work = {
+		work_id: "w1",
+		active_plan: ".omo/plans/plan.md",
+		plan_name: "cli plan",
+		session_ids: sessionIds,
+		status: "active",
+	};
+	writeFileSync(
+		join(root, ".omo", "boulder.json"),
+		`${JSON.stringify({ schema_version: 2, active_work_id: "w1", works: { w1: work } })}\n`,
+	);
+	return root;
+}
+
+function makePayload(
+	cwd: string,
+	stopHookActive: boolean,
+	eventName: "Stop" | "SubagentStop",
+): Record<string, string | boolean> {
+	return {
+		session_id: "s1",
+		turn_id: "t1",
+		transcript_path: "",
+		cwd,
+		hook_event_name: eventName,
+		model: "gpt-5.5",
+		permission_mode: "default",
+		stop_hook_active: stopHookActive,
+		last_assistant_message: "done",
+	};
+}

package/packages/omo-codex/plugin/components/start-work-continuation/test/codex-hook.test.ts

@@ -0,0 +1,182 @@
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+
+import { runStopHook } from "../src/codex-hook.js";
+import type { ReadonlyFileSystem, StopInput } from "../src/types.js";
+
+const WORKSPACE = "/repo";
+const BOULDER_PATH = join(WORKSPACE, ".omo", "boulder.json");
+const PLAN_PATH = join(WORKSPACE, ".omo", "plans", "plan.md");
+const LEDGER_PATH = join(WORKSPACE, ".omo", "start-work", "ledger.jsonl");
+
+describe("start-work Stop hook", () => {
+	it("#given stop hook is already active #when hook runs #then returns empty output", () => {
+		// given
+		const fs = createMemoryFs();
+		const input = { ...createStopInput(), stop_hook_active: true };
+
+		// when
+		const output = runStopHook(input, fs);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given active codex work with remaining top-level tasks #when hook runs #then returns block JSON", () => {
+		// given
+		const fs = createMemoryFs({
+			[BOULDER_PATH]: createBoulderJson({
+				sessionIds: ["codex:sess_abc"],
+				status: "active",
+				worktreePath: "/tmp/worktree",
+			}),
+			[PLAN_PATH]: ["# Plan", "", "## TODOs", "- [ ] First", "- [x] Done", "- [ ] Second"].join("\n"),
+		});
+
+		// when
+		const output = runStopHook(createStopInput(), fs);
+
+		// then
+		const parsed = parseBlockOutput(output);
+		expect(parsed.decision).toBe("block");
+		expect(parsed.reason).toContain("- Plan: `launch-plan`");
+		expect(parsed.reason).toContain(`- Plan file: \`${PLAN_PATH}\``);
+		expect(parsed.reason).toContain(`- Boulder state: \`${BOULDER_PATH}\``);
+		expect(parsed.reason).toContain("- Remaining top-level checkboxes: `2` of `3`");
+		expect(parsed.reason).toContain("- Next incomplete task: `First`");
+		expect(parsed.reason).toContain("- Worktree: `/tmp/worktree`");
+		expect(parsed.reason).toContain(`- Ledger: \`${LEDGER_PATH}\``);
+		expect(parsed.reason).toContain("- Your session id in boulder.json: `codex:sess_abc`");
+	});
+
+	it("#given active codex work #when continuation directive is emitted #then subagent guidance is reliable", () => {
+		// given
+		const fs = createMemoryFs({
+			[BOULDER_PATH]: createBoulderJson({
+				sessionIds: ["codex:sess_abc"],
+				status: "active",
+			}),
+			[PLAN_PATH]: ["# Plan", "", "## TODOs", "- [ ] First"].join("\n"),
+		});
+
+		// when
+		const output = runStopHook(createStopInput(), fs);
+
+		// then
+		const parsed = parseBlockOutput(output);
+		expect(parsed.reason).toMatch(/TASK:/);
+		expect(parsed.reason).toMatch(/fork_turns:\s*"none"/);
+		expect(parsed.reason).toMatch(/wait_agent.*signal, not proof/);
+		expect(parsed.reason).toMatch(/one targeted followup/);
+		expect(parsed.reason).toMatch(/respawn.*smaller/);
+	});
+
+	it("#given active work belongs to another harness #when hook runs #then returns empty output", () => {
+		// given
+		const fs = createMemoryFs({
+			[BOULDER_PATH]: createBoulderJson({ sessionIds: ["opencode:sess_abc"], status: "active" }),
+			[PLAN_PATH]: "- [ ] First",
+		});
+
+		// when
+		const output = runStopHook(createStopInput(), fs);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given bare legacy session id #when hook runs #then returns empty output", () => {
+		// given
+		const fs = createMemoryFs({
+			[BOULDER_PATH]: createBoulderJson({ sessionIds: ["sess_abc"], status: "active" }),
+			[PLAN_PATH]: "- [ ] First",
+		});
+
+		// when
+		const output = runStopHook(createStopInput(), fs);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given completed boulder work #when hook runs #then returns empty output", () => {
+		// given
+		const fs = createMemoryFs({
+			[BOULDER_PATH]: createBoulderJson({ sessionIds: ["codex:sess_abc"], status: "completed" }),
+			[PLAN_PATH]: "- [ ] First",
+		});
+
+		// when
+		const output = runStopHook(createStopInput(), fs);
+
+		// then
+		expect(output).toBe("");
+	});
+
+	it("#given malformed input #when hook runs #then returns empty output", () => {
+		// given
+		const fs = createMemoryFs();
+
+		// when
+		const output = runStopHook({ hook_event_name: "Stop", session_id: 123 }, fs);
+
+		// then
+		expect(output).toBe("");
+	});
+});
+
+type BoulderInput = {
+	readonly sessionIds: readonly string[];
+	readonly status: "active" | "completed" | "paused" | "abandoned";
+	readonly worktreePath?: string;
+};
+
+function createStopInput(): StopInput {
+	return {
+		hook_event_name: "Stop",
+		session_id: "sess_abc",
+		turn_id: "turn_1",
+		transcript_path: "",
+		cwd: WORKSPACE,
+		model: "gpt-5.5",
+		permission_mode: "default",
+		stop_hook_active: false,
+		last_assistant_message: "done",
+	};
+}
+
+function createBoulderJson(input: BoulderInput): string {
+	const work = {
+		work_id: "work_1",
+		active_plan: ".omo/plans/plan.md",
+		plan_name: "launch-plan",
+		status: input.status,
+		session_ids: input.sessionIds,
+		...(input.worktreePath === undefined ? {} : { worktree_path: input.worktreePath }),
+	};
+	return JSON.stringify({ schema_version: 2, active_work_id: "work_1", works: { work_1: work } });
+}
+
+function createMemoryFs(files: Record<string, string> = {}): ReadonlyFileSystem {
+	return {
+		readFileSync(path, encoding) {
+			expect(encoding).toBe("utf8");
+			const value = files[path];
+			if (value === undefined) throw new Error(`Missing fixture: ${path}`);
+			return value;
+		},
+	};
+}
+
+function parseBlockOutput(output: string): { readonly decision: "block"; readonly reason: string } {
+	const parsed: unknown = JSON.parse(output);
+	if (!isRecord(parsed)) throw new Error("Expected object output");
+	if (parsed["decision"] !== "block") throw new Error("Expected block decision");
+	const reason = parsed["reason"];
+	if (typeof reason !== "string") throw new Error("Expected string reason");
+	return { decision: "block", reason };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/start-work-continuation/test/fixtures/boulder-completed.json

@@ -0,0 +1,19 @@
+{
+	"schema_version": 2,
+	"active_work_id": "work_1",
+	"works": {
+		"work_1": {
+			"work_id": "work_1",
+			"active_plan": "/repo/.omo/plans/plan-with-unchecked.md",
+			"plan_name": "completed-plan",
+			"status": "completed",
+			"started_at": "2026-05-28T00:00:00Z",
+			"session_ids": ["codex:sess_abc"]
+		}
+	},
+	"active_plan": "/repo/.omo/plans/plan-with-unchecked.md",
+	"plan_name": "completed-plan",
+	"started_at": "2026-05-28T00:00:00Z",
+	"status": "completed",
+	"session_ids": ["codex:sess_abc"]
+}

package/packages/omo-codex/plugin/components/start-work-continuation/test/fixtures/boulder-mixed-platforms.json

@@ -0,0 +1,27 @@
+{
+	"schema_version": 2,
+	"active_work_id": "codex_work",
+	"works": {
+		"opencode_work": {
+			"work_id": "opencode_work",
+			"active_plan": "/repo/.omo/plans/opencode-plan.md",
+			"plan_name": "opencode-plan",
+			"status": "active",
+			"started_at": "2026-05-28T00:00:00Z",
+			"session_ids": ["opencode:sess_abc"]
+		},
+		"codex_work": {
+			"work_id": "codex_work",
+			"active_plan": "/repo/.omo/plans/plan-with-unchecked.md",
+			"plan_name": "codex-plan",
+			"status": "paused",
+			"started_at": "2026-05-28T00:00:00Z",
+			"session_ids": ["codex:def"]
+		}
+	},
+	"active_plan": "/repo/.omo/plans/opencode-plan.md",
+	"plan_name": "legacy-opencode-plan",
+	"started_at": "2026-05-28T00:00:00Z",
+	"status": "active",
+	"session_ids": ["opencode:sess_abc"]
+}

package/packages/omo-codex/plugin/components/start-work-continuation/test/fixtures/boulder-single-codex-work.json

@@ -0,0 +1,19 @@
+{
+	"schema_version": 2,
+	"active_work_id": "work_1",
+	"works": {
+		"work_1": {
+			"work_id": "work_1",
+			"active_plan": "/repo/.omo/plans/plan-with-unchecked.md",
+			"plan_name": "launch-plan",
+			"status": "active",
+			"started_at": "2026-05-28T00:00:00Z",
+			"session_ids": ["codex:sess_abc"]
+		}
+	},
+	"active_plan": "/repo/.omo/plans/plan-with-unchecked.md",
+	"plan_name": "legacy-launch-plan",
+	"started_at": "2026-05-28T00:00:00Z",
+	"status": "active",
+	"session_ids": ["codex:sess_legacy"]
+}

package/packages/omo-codex/plugin/components/start-work-continuation/test/fixtures/plan-all-done.md

@@ -0,0 +1,5 @@
+# Launch Plan
+
+## TODOs
+- [x] First
+- [x] Second

package/packages/omo-codex/plugin/components/start-work-continuation/test/fixtures/plan-with-nested-checkboxes.md

@@ -0,0 +1,11 @@
+# Launch Plan
+
+## TODOs
+- [ ] Top-level
+
+### Acceptance Criteria
+  - [ ] Nested under acceptance criteria
+  - [x] Nested done
+
+## Final Checklist
+  - [ ] Nested under final checklist

package/packages/omo-codex/plugin/components/start-work-continuation/test/fixtures/plan-with-unchecked.md

@@ -0,0 +1,6 @@
+# Launch Plan
+
+## TODOs
+- [ ] First
+- [x] Done already
+- [ ] Second

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

@@ -0,0 +1,12 @@
+{
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"allowImportingTsExtensions": false,
+		"declaration": true,
+		"outDir": "dist",
+		"rootDir": "src",
+		"noEmit": false
+	},
+	"include": ["src/**/*"],
+	"exclude": ["test/**/*"]
+}

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

@@ -0,0 +1,27 @@
+{
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "NodeNext",
+		"moduleResolution": "NodeNext",
+		"lib": ["ESNext"],
+		"strict": true,
+		"exactOptionalPropertyTypes": true,
+		"noUncheckedIndexedAccess": true,
+		"noPropertyAccessFromIndexSignature": true,
+		"verbatimModuleSyntax": true,
+		"noImplicitOverride": true,
+		"noImplicitReturns": true,
+		"noFallthroughCasesInSwitch": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": true,
+		"esModuleInterop": true,
+		"allowImportingTsExtensions": true,
+		"skipLibCheck": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"useDefineForClassFields": false,
+		"types": ["node"],
+		"noEmit": true
+	},
+	"include": ["src/**/*", "test/**/*", "vitest.config.ts"]
+}

package/packages/omo-codex/plugin/components/start-work-continuation/vitest.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+	test: {
+		include: ["test/**/*.test.ts"],
+		environment: "node",
+		pool: "threads",
+		isolate: true,
+	},
+});

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

@@ -0,0 +1,37 @@
+# Repository Conventions
+
+Conventions for human contributors and AI agents working on this component.
+
+## Style
+
+- Terse technical prose. No emojis in commits, issues, PR comments, or code.
+- TypeScript strict mode. No `any`, no `@ts-ignore`, no `@ts-expect-error`, no enums.
+- ESM modules with `.js` suffix in runtime import paths.
+- Tabs for indentation. Double quotes for strings.
+- Tests use vitest with `#given .. #when .. #then` descriptions or plain `// given / // when / // then` body comments.
+
+## Commands
+
+- `npm install` - install dependencies.
+- `npm test` - run vitest once.
+- `npm run typecheck` - strict TypeScript check.
+- `npm run check` - type check, biome, and build.
+- `npm run build` - emit `dist/`.
+- `node dist/cli.js hook session-start < fixture.json` - smoke-test the SessionStart hook.
+
+## Constraints
+
+- No Bun APIs. Runtime is Node only because Codex launches plugin hooks with Node.
+- The single hook handler is `runSessionStartHook`. Do not add new hook handlers without also wiring them in `hooks/hooks.json` and `plugin/hooks/hooks.json`.
+- Telemetry MUST be silent on every failure path. The CLI MUST exit 0 with empty stdout even when PostHog construction, capture, or shutdown throws.
+- Telemetry MUST be daily-deduplicated. Adding a new event type requires a new state file slot, not removal of the existing dedup.
+- Hook output MUST stay empty (no `additionalContext`, no `systemMessage`). This component is observability-only and MUST NOT inject context into the Codex conversation.
+- Constants in `src/product-identity.ts` MUST stay byte-equivalent with `packages/omo-codex/src/telemetry/product-identity.ts`. The cross-package equivalence test will fail otherwise.
+- Do not couple this component back to omo internal source paths beyond what `cross-package-equivalence.test.ts` already asserts at the constants layer.
+
+## Don'ts
+
+- No `git add -A` or `git add .`. Stage only the files you changed.
+- No `git commit --no-verify`. No force pushes. No history rewriting on shared branches.
+- No new network calls. PostHog is the only allowed sink.
+- No new env vars without README + privacy-policy update.

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

@@ -0,0 +1,102 @@
+# codex-telemetry
+
+Codex plugin component that emits a single anonymous daily-active event (`omo_codex_daily_active`) to PostHog whenever a Codex session starts.
+
+The event is sent **at most once per UTC day per machine**. It uses a SHA256-hashed installation identifier derived from `omo-codex:${hostname}` and never sends the raw hostname. PostHog person profiles are explicitly disabled.
+
+## Hook Wiring
+
+The component registers a single `SessionStart` hook:
+
+```json
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook session-start",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}
+```
+
+The aggregate `plugin/hooks/hooks.json` mounts this hook alongside `rules` and `ultrawork` so all three fire in parallel at the start of every Codex session.
+
+## What Is Captured
+
+A single PostHog `capture` call with:
+
+- `event: "omo_codex_daily_active"`
+- `distinctId: sha256("omo-codex:" + hostname)`
+- `properties`:
+  - `platform`, `product_name`, `package_name`, `package_version`
+  - `runtime` (`"node"`), `runtime_version`
+  - `source: "plugin"`, `reason: "session_start"`
+  - `$os`, `$os_version`, `os_arch`, `os_type`
+  - `cpu_count`, `cpu_model`, `total_memory_gb`
+  - `locale`, `timezone`, `shell`, `ci`, `terminal`
+  - `day_utc` (today's UTC date)
+  - `$process_person_profile: false`
+
+The component never sends prompt contents, file contents, API keys, raw hostnames, or any user-identifying data.
+
+## Opt-Out
+
+Set any of the following environment variables before launching Codex:
+
+```bash
+# Codex-only opt-out
+export OMO_CODEX_DISABLE_POSTHOG=1
+export OMO_CODEX_SEND_ANONYMOUS_TELEMETRY=0
+
+# Global opt-out (covers both omo and omo-codex)
+export OMO_DISABLE_POSTHOG=1
+export OMO_SEND_ANONYMOUS_TELEMETRY=0
+```
+
+When any of these is set the component creates a no-op PostHog client and exits without any network call.
+
+## Daily Deduplication
+
+The component writes a small JSON state file at:
+
+```
+$XDG_DATA_HOME/omo-codex/posthog-activity.json
+# or, when XDG_DATA_HOME is unset:
+~/.local/share/omo-codex/posthog-activity.json
+```
+
+containing `{ "lastActiveDayUTC": "YYYY-MM-DD" }`. If the stored day matches today (UTC), the hook returns without sending anything. The file is written atomically via `rename(2)`.
+
+## Failure Behavior
+
+Every telemetry path is wrapped in `try`/`catch`. The hook always exits 0 with no stdout output, even when PostHog construction, capture, or shutdown fails. Codex session startup is never blocked or slowed by telemetry failures.
+
+## Endpoint Overrides
+
+| Variable | Default |
+|----------|---------|
+| `POSTHOG_HOST` | `https://us.i.posthog.com` |
+| `POSTHOG_API_KEY` | shared `omo-codex` project key |
+
+## Development
+
+```bash
+npm install
+npm test           # vitest (in-process + subprocess CLI smoke)
+npm run typecheck
+npm run build      # tsc -> dist/
+npm run check      # typecheck + biome + build
+```
+
+The component shares its product identity constants with the `@oh-my-opencode/omo-codex` CLI installer. Drift between the two implementations is guarded by `packages/omo-codex/src/telemetry/cross-package-equivalence.test.ts`.
+
+## Privacy
+
+See [the omo Privacy Policy](https://github.com/code-yeongyu/oh-my-openagent/blob/dev/docs/legal/privacy-policy.md) for the full disclosure.

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

@@ -0,0 +1,48 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.4.15/schema.json",
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true,
+			"style": {
+				"noDefaultExport": "error",
+				"noEnum": "error",
+				"noNonNullAssertion": "error",
+				"useImportType": "error",
+				"useConst": "error",
+				"useNodejsImportProtocol": "off"
+			},
+			"complexity": {
+				"useLiteralKeys": "off"
+			},
+			"suspicious": {
+				"noExplicitAny": "error",
+				"noTsIgnore": "error",
+				"noControlCharactersInRegex": "off",
+				"noEmptyInterface": "off"
+			}
+		}
+	},
+	"formatter": {
+		"enabled": true,
+		"formatWithErrors": false,
+		"indentStyle": "tab",
+		"indentWidth": 3,
+		"lineWidth": 120
+	},
+	"files": {
+		"includes": ["src/**/*.ts", "test/**/*.ts", "vitest.config.ts", "!**/node_modules/**/*", "!**/dist/**/*"]
+	},
+	"overrides": [
+		{
+			"includes": ["vitest.config.ts"],
+			"linter": {
+				"rules": {
+					"style": {
+						"noDefaultExport": "off"
+					}
+				}
+			}
+		}
+	]
+}

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

@@ -0,0 +1,16 @@
+{
+	"hooks": {
+		"SessionStart": [
+			{
+				"hooks": [
+					{
+						"type": "command",
+						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook session-start",
+						"timeout": 5,
+						"statusMessage": "LazyCodex(0.1.0): Recording Session Telemetry"
+					}
+				]
+			}
+		]
+	}
+}