oh-my-opencode 4.11.1 → 4.12.1

package/packages/omo-codex/plugin/components/start-work-continuation/src/boulder-reader.ts

@@ -1,14 +1,30 @@
-import { join } from "node:path";
-import type { BoulderWorkStatus, PlanChecklist } from "@oh-my-opencode/boulder-state";
-import {
-	getBoulderFilePath,
-	getPlanChecklist,
-	getWorkForSession,
-	normalizeSessionId,
-	resolveBoulderPlanPathForWork,
-} from "@oh-my-opencode/boulder-state";
-
-export type { PlanChecklist };
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+
+export type PlanChecklist = {
+	readonly completed: number;
+	readonly remaining: number;
+	readonly total: number;
+	readonly nextTaskLabel: string | null;
+};
+
+type BoulderWorkStatus = "active" | "paused" | "completed" | "abandoned";
+
+type BoulderWork = {
+	readonly activePlan: string;
+	readonly planName: string;
+	readonly status?: BoulderWorkStatus;
+	readonly startedAt?: string;
+	readonly updatedAt?: string;
+	readonly sessionIds: readonly string[];
+	readonly worktreePath?: string;
+};
+
+type BoulderState = {
+	readonly works: readonly BoulderWork[];
+	readonly mirrorWork: BoulderWork | null;
+	readonly hasWorksMap: boolean;
+};
 
 export type ContinuationState = {
 	readonly planName: string;
@@ -19,22 +35,218 @@ export type ContinuationState = {
 	readonly checklist: PlanChecklist;
 };
 
+const TODO_HEADING = "TODOs";
+const FINAL_VERIFICATION_HEADING = "Final Verification Wave";
+const CHECKBOX_PREFIX_LENGTH = "- [ ] ".length;
+const SESSION_ID_PREFIX_PATTERN = /^(codex|opencode):/;
+
 export function readContinuationState(cwd: string, sessionId: string): ContinuationState | null {
-	const work = getWorkForSession(cwd, normalizeSessionId(sessionId, "codex"));
+	const boulderPath = getBoulderFilePath(cwd);
+	const boulderState = readBoulderState(boulderPath);
+	if (boulderState === null) return null;
+
+	const work = getWorkForSession(boulderState, normalizeSessionId(sessionId, "codex"));
 	if (work === null || !isContinuableStatus(work.status)) return null;
+
 	const planPath = resolveBoulderPlanPathForWork(cwd, work);
 	const checklist = getPlanChecklist(planPath);
 	if (checklist.remaining === 0) return null;
+
 	return {
-		planName: work.plan_name,
+		planName: work.planName,
 		planPath,
-		boulderPath: getBoulderFilePath(cwd),
+		boulderPath,
 		ledgerPath: join(cwd, ".omo", "start-work", "ledger.jsonl"),
-		worktreePath: work.worktree_path ?? null,
+		worktreePath: work.worktreePath ?? null,
 		checklist,
 	};
 }
 
+export function getPlanChecklist(planPath: string): PlanChecklist {
+	if (!existsSync(planPath)) return emptyChecklist();
+
+	try {
+		return parsePlanChecklist(readFileSync(planPath, "utf8"));
+	} catch (error) {
+		if (error instanceof Error) return emptyChecklist();
+		throw error;
+	}
+}
+
+function parsePlanChecklist(markdown: string): PlanChecklist {
+	const lines = markdown.split(/\r?\n/);
+	const hasCountedSections = lines.some((line) => isCountedHeading(parseLevelTwoHeading(line)));
+	let completed = 0;
+	let remaining = 0;
+	let nextTaskLabel: string | null = null;
+	let isCountedSection = !hasCountedSections;
+
+	for (const line of lines) {
+		const heading = parseLevelTwoHeading(line);
+		if (heading !== null) {
+			isCountedSection = isCountedHeading(heading);
+			continue;
+		}
+		if (!isCountedSection) continue;
+
+		const checkbox = parseTopLevelCheckbox(line);
+		if (checkbox === null) continue;
+
+		if (checkbox.checked) {
+			completed += 1;
+		} else {
+			remaining += 1;
+			nextTaskLabel = nextTaskLabel ?? checkbox.label;
+		}
+	}
+
+	return { completed, remaining, total: completed + remaining, nextTaskLabel };
+}
+
+function readBoulderState(path: string): BoulderState | null {
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+		return parseBoulderState(parsed);
+	} catch (error) {
+		if (error instanceof Error) return null;
+		throw error;
+	}
+}
+
+function parseBoulderState(value: unknown): BoulderState | null {
+	if (!isRecord(value)) return null;
+
+	const works: BoulderWork[] = [];
+	const worksValue = value["works"];
+	const hasWorksMap = isRecord(worksValue);
+	if (hasWorksMap) {
+		for (const workValue of Object.values(worksValue)) {
+			const work = parseBoulderWork(workValue);
+			if (work !== null) works.push(work);
+		}
+	}
+
+	const mirrorWork = parseBoulderWork(value);
+	if (works.length === 0 && mirrorWork === null) return null;
+	return { works, mirrorWork, hasWorksMap };
+}
+
+function parseBoulderWork(value: unknown): BoulderWork | null {
+	if (!isRecord(value)) return null;
+
+	const activePlan = value["active_plan"];
+	const planName = value["plan_name"];
+	if (typeof activePlan !== "string") return null;
+
+	const status = parseBoulderWorkStatus(value["status"]);
+	const sessionIds = parseSessionIds(value["session_ids"]);
+	const worktreePath = value["worktree_path"];
+	const startedAt = value["started_at"];
+	const updatedAt = value["updated_at"];
+
+	return {
+		activePlan,
+		planName: typeof planName === "string" ? planName : activePlan,
+		sessionIds,
+		...(status === undefined ? {} : { status }),
+		...(typeof startedAt === "string" ? { startedAt } : {}),
+		...(typeof updatedAt === "string" ? { updatedAt } : {}),
+		...(typeof worktreePath === "string" ? { worktreePath } : {}),
+	};
+}
+
+function getWorkForSession(state: BoulderState, normalizedSessionId: string): BoulderWork | null {
+	let newestWork: BoulderWork | null = null;
+	let newestWorkMs = 0;
+
+	for (const work of state.works) {
+		if (!work.sessionIds.includes(normalizedSessionId)) continue;
+
+		const workMs = parseIsoToMs(work.updatedAt ?? work.startedAt) ?? 0;
+		if (newestWork === null || workMs > newestWorkMs) {
+			newestWork = work;
+			newestWorkMs = workMs;
+		}
+	}
+
+	if (newestWork !== null) return newestWork;
+	if (state.hasWorksMap) return null;
+	if (state.mirrorWork?.sessionIds.includes(normalizedSessionId) === true) return state.mirrorWork;
+	return null;
+}
+
+function resolveBoulderPlanPathForWork(cwd: string, work: BoulderWork): string {
+	const absolutePlanPath = resolveTrackedPath(cwd, work.activePlan);
+	const worktreePath = work.worktreePath?.trim();
+	if (worktreePath === undefined || worktreePath.length === 0) return absolutePlanPath;
+
+	const relativePlanPath = relative(resolve(cwd), absolutePlanPath);
+	if (relativePlanPath.length === 0 || relativePlanPath.startsWith("..") || isAbsolute(relativePlanPath)) {
+		return absolutePlanPath;
+	}
+
+	const worktreePlanPath = resolve(resolveTrackedPath(cwd, worktreePath), relativePlanPath);
+	return existsSync(worktreePlanPath) ? worktreePlanPath : absolutePlanPath;
+}
+
+function resolveTrackedPath(baseDirectory: string, trackedPath: string): string {
+	return isAbsolute(trackedPath) ? resolve(trackedPath) : resolve(baseDirectory, trackedPath);
+}
+
+function parseTopLevelCheckbox(line: string): { readonly checked: boolean; readonly label: string } | null {
+	if (line.startsWith("- [ ] ")) return { checked: false, label: line.slice(CHECKBOX_PREFIX_LENGTH) };
+	if (line.startsWith("- [x] ") || line.startsWith("- [X] ")) {
+		return { checked: true, label: line.slice(CHECKBOX_PREFIX_LENGTH) };
+	}
+	return null;
+}
+
+function parseLevelTwoHeading(line: string): string | null {
+	if (!line.startsWith("## ")) return null;
+	return line.slice("## ".length).trim();
+}
+
+function isCountedHeading(heading: string | null): boolean {
+	return heading === TODO_HEADING || heading === FINAL_VERIFICATION_HEADING;
+}
+
+function parseBoulderWorkStatus(value: unknown): BoulderWorkStatus | undefined {
+	if (value === "active" || value === "paused" || value === "completed" || value === "abandoned") return value;
+	return undefined;
+}
+
+function parseSessionIds(value: unknown): readonly string[] {
+	if (!Array.isArray(value)) return [];
+	const sessionIds: string[] = [];
+	for (const item of value) {
+		if (typeof item === "string") sessionIds.push(normalizeSessionId(item));
+	}
+	return sessionIds;
+}
+
+function normalizeSessionId(sessionId: string, platform: "codex" | "opencode" = "opencode"): string {
+	if (SESSION_ID_PREFIX_PATTERN.test(sessionId)) return sessionId;
+	return `${platform}:${sessionId}`;
+}
+
+function parseIsoToMs(value: string | undefined): number | null {
+	if (value === undefined) return null;
+	const parsed = Date.parse(value);
+	return Number.isNaN(parsed) ? null : parsed;
+}
+
 function isContinuableStatus(status: BoulderWorkStatus | undefined): boolean {
 	return status === "active" || status === "paused";
 }
+
+function getBoulderFilePath(cwd: string): string {
+	return join(cwd, ".omo", "boulder.json");
+}
+
+function emptyChecklist(): PlanChecklist {
+	return { completed: 0, remaining: 0, total: 0, nextTaskLabel: null };
+}
+
+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/boulder-reader.test.ts

@@ -1,9 +1,8 @@
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { getPlanChecklist } from "@oh-my-opencode/boulder-state";
 import { afterEach, describe, expect, it } from "vitest";
-import { readContinuationState } from "../src/boulder-reader.js";
+import { getPlanChecklist, readContinuationState } from "../src/boulder-reader.js";
 
 const cleanupRoots: string[] = [];
 
@@ -109,6 +108,21 @@ describe("start-work boulder state reader", () => {
 		expect(state).toBeNull();
 	});
 
+	it("#given paused codex work with remaining checklist #when state is read #then continuation is present", () => {
+		// given
+		const workspace = createWorkspace({
+			boulderJson: createBoulderJson({ status: "paused", sessionIds: ["codex:sess_abc"] }),
+			planMarkdown: "# Plan\n\n## TODOs\n- [ ] First\n",
+		});
+
+		// when
+		const state = readContinuationState(workspace, "sess_abc");
+
+		// then
+		expect(state?.planName).toBe("launch-plan");
+		expect(state?.checklist).toEqual({ completed: 0, remaining: 1, total: 1, nextTaskLabel: "First" });
+	});
+
 	it("#given no remaining top-level checklist items #when state is read #then continuation is absent", () => {
 		// given
 		const workspace = createWorkspace({
@@ -136,6 +150,52 @@ describe("start-work boulder state reader", () => {
 		// then
 		expect(state).toBeNull();
 	});
+
+	it("#given bare boulder session id #when codex state is read #then continuation is absent", () => {
+		// given
+		const workspace = createWorkspace({
+			boulderJson: createBoulderJson({ status: "active", sessionIds: ["sess_abc"] }),
+			planMarkdown: "# Plan\n\n## TODOs\n- [ ] First\n",
+		});
+
+		// when
+		const state = readContinuationState(workspace, "sess_abc");
+
+		// then
+		expect(state).toBeNull();
+	});
+
+	it("#given works omit the codex session but stale mirror matches #when state is read #then continuation is absent", () => {
+		// given
+		const workspace = createWorkspace({
+			boulderJson: JSON.stringify({
+				schema_version: 2,
+				active_work_id: "work_1",
+				works: {
+					work_1: {
+						work_id: "work_1",
+						active_plan: ".omo/plans/plan.md",
+						plan_name: "current-work",
+						status: "active",
+						started_at: "2026-06-13T00:00:00.000Z",
+						session_ids: ["opencode:sess_other"],
+					},
+				},
+				active_plan: ".omo/plans/plan.md",
+				plan_name: "stale-mirror",
+				status: "active",
+				started_at: "2026-06-12T00:00:00.000Z",
+				session_ids: ["codex:sess_abc"],
+			}),
+			planMarkdown: "# Plan\n\n## TODOs\n- [ ] First\n",
+		});
+
+		// when
+		const state = readContinuationState(workspace, "sess_abc");
+
+		// then
+		expect(state).toBeNull();
+	});
 });
 
 type WorkspaceInput = {

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

@@ -1,5 +1,5 @@
 import { spawnSync } from "node:child_process";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { execPath } from "node:process";
@@ -23,7 +23,11 @@ describe("start-work continuation CLI", () => {
 		// then
 		if (result.error !== undefined) throw result.error;
 		expect(result.status).toBe(0);
-		expect(result.stdout).toContain('"decision":"block"');
+		const output = parseStopHookOutput(result.stdout);
+		expect(output.decision).toBe("block");
+		expect(output.reason).toContain("Remaining top-level checkboxes: `2` of `3`");
+		expect(output.reason).toContain("Next incomplete task: `Task one`");
+		expect(output.reason).toContain("Your session id in boulder.json: `codex:s1`");
 	});
 
 	it("#given valid SubagentStop stdin #when CLI runs #then stdout contains block JSON", () => {
@@ -80,6 +84,18 @@ describe("start-work continuation CLI", () => {
 		expect(result.status).toBe(0);
 		expect(result.stdout).toBe("");
 	});
+
+	it("#given built CLI bundle #when inspected #then it does not depend on the monorepo boulder package", () => {
+		// given
+		const cliPath = join(process.cwd(), "dist", "cli.js");
+
+		// when
+		const source = readFileSync(cliPath, "utf8");
+
+		// then
+		expect(source).not.toContain("@oh-my-opencode/boulder-state");
+		expect(source).not.toContain("../../boulder-state");
+	});
 });
 
 function runCli(subcommand: "stop" | "subagent-stop", input: string) {
@@ -90,7 +106,7 @@ 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");
+	writeFileSync(join(root, ".omo", "plans", "plan.md"), "## TODOs\n\n- [ ] Task one\n- [x] Done\n- [ ] Task two\n");
 	const work = {
 		work_id: "w1",
 		active_plan: ".omo/plans/plan.md",
@@ -122,3 +138,18 @@ function makePayload(
 		last_assistant_message: "done",
 	};
 }
+
+type ParsedStopHookOutput = {
+	readonly decision: unknown;
+	readonly reason: string;
+};
+
+function parseStopHookOutput(stdout: string): ParsedStopHookOutput {
+	const parsed: unknown = JSON.parse(stdout);
+	if (!isRecord(parsed) || typeof parsed["reason"] !== "string") throw new Error("CLI did not emit Stop hook JSON");
+	return { decision: parsed["decision"], reason: parsed["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/teammode/dist/cli.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+
+// components/teammode/src/codex-hook.ts
+var CREATE_THREAD_TOOL_NAMES = new Set(["create_thread", "codex_app.create_thread"]);
+function parsePostToolUsePayload(raw) {
+  if (raw.trim().length === 0)
+    return null;
+  try {
+    const parsed = JSON.parse(raw);
+    return isPostToolUsePayload(parsed) ? parsed : null;
+  } catch (error) {
+    if (error instanceof SyntaxError)
+      return null;
+    return null;
+  }
+}
+function runPostToolUseHook(payload) {
+  if (payload.hook_event_name !== "PostToolUse")
+    return "";
+  if (!CREATE_THREAD_TOOL_NAMES.has(payload.tool_name))
+    return "";
+  const threadReference = extractThreadCreationReference(payload.tool_response);
+  if (threadReference === null)
+    return "";
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: "PostToolUse",
+      additionalContext: threadTitleReminder(threadReference)
+    }
+  };
+  return `${JSON.stringify(output)}
+`;
+}
+async function runTeammodeHookCli(stdin, stdout) {
+  const payload = parsePostToolUsePayload(await readAll(stdin));
+  if (payload === null)
+    return;
+  const output = runPostToolUseHook(payload);
+  if (output.length > 0)
+    stdout.write(output);
+}
+function threadTitleReminder(threadReference) {
+  const id = formatIdentifier(threadReference.id);
+  return threadReference.kind === "thread" ? `THREAD ID ${id}: CALL codex_app.set_thread_title NOW. USE THE REAL TASK/ROLE.` : `PENDING WORKTREE ID ${id}: CALL codex_app.set_thread_title AS SOON AS THREAD ID EXISTS. USE THE REAL TASK/ROLE.`;
+}
+function formatIdentifier(value) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return normalized.length <= 200 ? normalized : `${normalized.slice(0, 197)}...`;
+}
+function extractThreadCreationReference(toolResponse) {
+  if (!isRecord(toolResponse))
+    return null;
+  const threadId = toolResponse["threadId"];
+  if (typeof threadId === "string" && threadId.trim().length > 0) {
+    return { kind: "thread", id: threadId };
+  }
+  const pendingWorktreeId = toolResponse["pendingWorktreeId"];
+  if (typeof pendingWorktreeId === "string" && pendingWorktreeId.trim().length > 0) {
+    return { kind: "pendingWorktree", id: pendingWorktreeId };
+  }
+  return null;
+}
+function isPostToolUsePayload(value) {
+  if (!isRecord(value))
+    return false;
+  return value["hook_event_name"] === "PostToolUse" && typeof value["session_id"] === "string" && typeof value["tool_name"] === "string" && Object.hasOwn(value, "tool_input") && Object.hasOwn(value, "tool_response") && optionalString(value["turn_id"]) && optionalString(value["cwd"]) && optionalString(value["model"]) && optionalString(value["permission_mode"]) && optionalString(value["tool_use_id"]) && (value["transcript_path"] === undefined || value["transcript_path"] === null || typeof value["transcript_path"] === "string");
+}
+function optionalString(value) {
+  return value === undefined || typeof value === "string";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readAll(stdin) {
+  return new Promise((resolve, reject) => {
+    let data = "";
+    stdin.setEncoding("utf8");
+    stdin.on("data", (chunk) => {
+      data += chunk instanceof Buffer ? chunk.toString() : String(chunk);
+    });
+    stdin.once("error", reject);
+    stdin.once("end", () => resolve(data));
+  });
+}
+
+// components/teammode/src/cli.ts
+var [command, subcommand] = process.argv.slice(2);
+if (command === "hook" && subcommand === "post-tool-use") {
+  await runTeammodeHookCli(process.stdin, process.stdout);
+} else {
+  process.stderr.write(`Usage: omo-teammode hook post-tool-use
+`);
+  process.exitCode = 2;
+}

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

@@ -0,0 +1,17 @@
+{
+	"hooks": {
+		"PostToolUse": [
+			{
+				"matcher": "^(create_thread|codex_app\\.create_thread)$",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-tool-use",
+						"timeout": 10,
+						"statusMessage": "(OmO) Checking Thread Title Hygiene"
+					}
+				]
+			}
+		]
+	}
+}

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

@@ -0,0 +1,26 @@
+{
+	"name": "@sisyphuslabs/codex-teammode",
+	"version": "4.12.1",
+	"description": "Codex team-mode hook component that keeps background thread titles descriptive after create_thread.",
+	"type": "module",
+	"private": true,
+	"files": [
+		"dist",
+		"hooks",
+		"skills"
+	],
+	"scripts": {
+		"build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && bun build src/cli.ts --target node --format esm --outfile dist/cli.js",
+		"test": "bun test test/*.test.ts",
+		"typecheck": "tsc --noEmit"
+	},
+	"devDependencies": {
+		"@types/node": "^25.9.3",
+		"bun-types": "^1.3.1",
+		"typescript": "^6.0.3",
+		"vitest": "^4.1.8"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	}
+}