oh-my-opencode 4.12.0 → 4.12.1

package/packages/omo-codex/plugin/components/codegraph/src/session-start-worker.ts

@@ -103,13 +103,10 @@ async function resolveOrProvisionCommand(
 	nodeSupport: CodegraphNodeSupport,
 ): Promise<ResolutionResult> {
 	const resolved = deps.resolveCommand({ env, homeDir, provisioned: () => provisionedBinFromInstallDir(config.install_dir) });
-	if (resolved.exists) {
-		if (codegraphCommandRequiresSupportedLocalNode(resolved) && !nodeSupport.supported) {
-			return { kind: "unsupported-node" };
-		}
+	if (resolved.exists && canUseResolvedCommand(resolved, nodeSupport)) {
 		return { kind: "resolved", resolution: resolved };
 	}
-	if (!nodeSupport.supported) return { kind: "unsupported-node" };
+	if (resolved.exists && config.auto_provision === false) return { kind: "unsupported-node" };
 	if (config.auto_provision === false) return { error: "codegraph binary unavailable and auto_provision is disabled", kind: "unavailable", source: resolved.source };
 
 	const installDir = config.install_dir ?? join(homeDir, ".omo", "codegraph");
@@ -120,6 +117,10 @@ async function resolveOrProvisionCommand(
 	return { kind: "resolved", resolution: { argsPrefix: [], command: provisioned.binPath, exists: true, source: "provisioned" } };
 }
 
+function canUseResolvedCommand(resolved: CodegraphCommandResolution, nodeSupport: CodegraphNodeSupport): boolean {
+	return !codegraphCommandRequiresSupportedLocalNode(resolved) || nodeSupport.supported;
+}
+
 function decideStartupAction(status: CodegraphCommandResult): { readonly kind: "init" } | { readonly kind: "skip"; readonly reason: string } | { readonly kind: "sync" } {
 	if (status.timedOut) return { kind: "skip", reason: "status timed out" };
 	const text = `${status.stdout}\n${status.stderr ?? ""}`.toLowerCase();

package/packages/omo-codex/plugin/components/codegraph/test/hook.test.ts

@@ -9,6 +9,7 @@ import { runCodegraphCli } from "../src/cli.ts";
 import {
 	executeCodegraphSessionStartHook,
 	resolveCodegraphCommandInvocation,
+	runCodegraphPostToolUseHook,
 	runCodegraphSessionStartWorker,
 	type WorkerSpawnInvocation,
 } from "../src/hook.ts";
@@ -48,6 +49,54 @@ describe("CodeGraph SessionStart hook", () => {
 		}
 	});
 
+	it("#given CodeGraph MCP reports an uninitialized project #when PostToolUse fires #then it emits OMO global-store init guidance", async () => {
+		// given
+		const output = runCodegraphPostToolUseHook(
+			{
+				cwd: "/Users/me/project",
+				tool_name: "codegraph.codegraph_status",
+				tool_response: {
+					error: [
+						"Tool execution failed: CodeGraph not initialized in /Users/me/project.",
+						"Run 'codegraph init' in that project first.",
+					].join(" "),
+				},
+			},
+			{ homeDir: "/Users/me" },
+		);
+
+		// when
+		const parsed = JSON.parse(output);
+
+		// then
+		expect(parsed).toEqual({
+			hookSpecificOutput: {
+				hookEventName: "PostToolUse",
+				additionalContext: expect.stringContaining('"/Users/me/.omo/codegraph/projects/project-'),
+			},
+		});
+		expect(parsed.hookSpecificOutput.additionalContext).toContain('run `codegraph init` from "/Users/me/project"');
+	});
+
+	it("#given real CodeGraph status output has no MCP path phrase #when PostToolUse fires #then it emits OMO global-store init guidance", async () => {
+		// given
+		const output = runCodegraphPostToolUseHook(
+			{
+				cwd: "/Users/me/project",
+				tool_name: "mcp__codegraph__codegraph_status",
+				tool_response: ['Project: /Users/me/project', "Not initialized", 'Run "codegraph init" to initialize'].join("\n"),
+			},
+			{ homeDir: "/Users/me" },
+		);
+
+		// when
+		const parsed = JSON.parse(output);
+
+		// then
+		expect(parsed.hookSpecificOutput.additionalContext).toContain('CodeGraph is not initialized for "/Users/me/project"');
+		expect(parsed.hookSpecificOutput.additionalContext).toContain('"/Users/me/.omo/codegraph/projects/project-');
+	});
+
 	it("#given CodeGraph is disabled by Codex SOT config #when SessionStart fires #then it skips without spawning", async () => {
 		// given
 		const stdout: string[] = [];
@@ -198,93 +247,6 @@ describe("CodeGraph SessionStart hook", () => {
 		}
 	});
 
-	it("#given an unsupported local Node and a PATH CodeGraph command #when worker runs #then it skips without touching the workspace", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-home-"));
-		const outcomes: unknown[] = [];
-
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				cwd: workspace,
-				env: { HOME: homeDir },
-				nodeVersion: "26.3.0",
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					resolveCommand: () => {
-						return { argsPrefix: [], command: "/usr/local/bin/codegraph", exists: true, source: "path" };
-					},
-					ensureProvisioned: () => {
-						throw new Error("ensureProvisioned should not run on unsupported Node");
-					},
-					prepareWorkspace: () => {
-						throw new Error("prepareWorkspace should not run on unsupported Node");
-					},
-					runCommand: () => {
-						throw new Error("runCommand should not run on unsupported Node");
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-unsupported-node" });
-			expect(existsSync(join(workspace, ".codegraph"))).toBe(false);
-			expect(outcomes).toEqual([{ action: "skipped-unsupported-node", projectRoot: workspace }]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given an unsupported local Node but bundled CodeGraph resolves through CODEGRAPH_NODE_BIN #when worker runs #then it bootstraps with the compatible runtime", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-compatible-node-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-compatible-node-home-"));
-		const nodeBin = "/opt/node22/bin/node";
-		const calls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
-		const outcomes: unknown[] = [];
-
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				cwd: workspace,
-				env: { CODEGRAPH_NODE_BIN: nodeBin, HOME: homeDir },
-				nodeVersion: "26.3.0",
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					ensureGitignored: () => true,
-					ensureProvisioned: () => {
-						throw new Error("provisioning should not run when bundled CodeGraph resolved");
-					},
-					prepareWorkspace: () => ({
-						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-						dataRoot: join(homeDir, ".omo/codegraph"),
-						linked: true,
-						mode: "global-linked",
-						projectLink: join(workspace, ".codegraph"),
-					}),
-					resolveCommand: () => ({ argsPrefix: ["codegraph.js"], command: nodeBin, exists: true, source: "bundled" }),
-					runCommand: (_projectRoot, command, args) => {
-						calls.push({ args, command });
-						return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? '{"initialized":false}' : "", timedOut: false });
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "initialized" });
-			expect(calls).toEqual([
-				{ args: ["codegraph.js", "status", "--json"], command: nodeBin },
-				{ args: ["codegraph.js", "init"], command: nodeBin },
-			]);
-			expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "bundled", timedOut: false }]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
 	it("#given CodeGraph cannot be resolved or provisioned #when worker runs #then it logs a graceful skip", async () => {
 		// given
 		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-"));

package/packages/omo-codex/plugin/components/codegraph/test/provisioned-node-guard.test.ts

@@ -35,7 +35,7 @@ describe("CodeGraph provisioned launcher Node guard", () => {
 		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node25-"));
 		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node25-home-"));
 		const installDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node25-install-"));
-		const binPath = join(installDir, "bin", "codegraph");
+		const binPath = join(installDir, "bin", process.platform === "win32" ? "codegraph.cmd" : "codegraph");
 		const calls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
 		const outcomes: unknown[] = [];
 

package/packages/omo-codex/plugin/components/codegraph/test/serve-provision.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, it } from "bun:test";
+import { join } from "node:path";
+
+import { runCodegraphServe } from "../src/serve.ts";
+
+describe("runCodegraphServe provisioning", () => {
+	it("#given CodeGraph is unresolved #when serving MCP #then provisions CodeGraph before spawning", async () => {
+		// given
+		const binPath = join("/tmp/home/.omo/codegraph", "bin", "codegraph");
+		const calls: Array<{
+			readonly args: readonly string[];
+			readonly command: string;
+			readonly env: Record<string, string | undefined>;
+		}> = [];
+		const stderr: string[] = [];
+
+		// when
+		const exitCode = await runCodegraphServe({
+			config: { codegraph: { enabled: true }, sources: [], warnings: [] },
+			env: { PATH: "/bin" },
+			homeDir: "/tmp/home",
+			nodeVersion: "22.14.0",
+			buildEnv: () => ({}),
+			resolve: () => ({ argsPrefix: [], command: "codegraph", exists: false, source: "path" }),
+			ensureProvisioned: (options) =>
+				Promise.resolve({
+					binPath: join(options.installDir ?? "/tmp/home/.omo/codegraph", "bin", "codegraph"),
+					provisioned: true,
+				}),
+			runProcess: (command, args, options) => {
+				calls.push({ args, command, env: options.env });
+				return Promise.resolve(0);
+			},
+			stderr: { write: (chunk: string) => stderr.push(chunk) },
+		});
+
+		// then
+		expect(exitCode).toBe(0);
+		expect(stderr).toEqual([]);
+		expect(calls).toEqual([
+			{
+				args: ["serve", "--mcp"],
+				command: binPath,
+				env: { PATH: "/bin" },
+			},
+		]);
+	});
+});

package/packages/omo-codex/plugin/components/codegraph/test/serve.test.ts

@@ -17,6 +17,7 @@ describe("runCodegraphServe", () => {
 
 		// when
 		const exitCode = await runCodegraphServe({
+			config: { codegraph: { auto_provision: false, enabled: true }, sources: [], warnings: [] },
 			env: { PATH: "/bin" },
 			buildEnv: () => ({}),
 			resolve: () => ({ argsPrefix: [], command: "codegraph", exists: false, source: "path" }),

package/packages/omo-codex/plugin/components/codegraph/test/session-start-node-support.test.ts

@@ -0,0 +1,142 @@
+import { describe, expect, it } from "bun:test";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { runCodegraphSessionStartWorker } from "../src/hook.ts";
+
+describe("CodeGraph SessionStart worker Node support", () => {
+	it("#given an unsupported local Node and a PATH CodeGraph command with auto provisioning disabled #when worker runs #then it skips without touching the workspace", async () => {
+		// given
+		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-"));
+		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-home-"));
+		const outcomes: unknown[] = [];
+
+		try {
+			// when
+			const result = await runCodegraphSessionStartWorker({
+				config: { codegraph: { auto_provision: false, enabled: true }, sources: [], warnings: [] },
+				cwd: workspace,
+				env: { HOME: homeDir },
+				nodeVersion: "26.3.0",
+				logOutcome: (outcome) => outcomes.push(outcome),
+				deps: {
+					resolveCommand: () => {
+						return { argsPrefix: [], command: "/usr/local/bin/codegraph", exists: true, source: "path" };
+					},
+					ensureProvisioned: () => {
+						throw new Error("ensureProvisioned should not run on unsupported Node");
+					},
+					prepareWorkspace: () => {
+						throw new Error("prepareWorkspace should not run on unsupported Node");
+					},
+					runCommand: () => {
+						throw new Error("runCommand should not run on unsupported Node");
+					},
+				},
+			});
+
+			// then
+			expect(result).toEqual({ action: "skipped-unsupported-node" });
+			expect(existsSync(join(workspace, ".codegraph"))).toBe(false);
+			expect(outcomes).toEqual([{ action: "skipped-unsupported-node", projectRoot: workspace }]);
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+			rmSync(homeDir, { recursive: true, force: true });
+		}
+	});
+
+	it("#given an unsupported local Node and a PATH CodeGraph command #when auto provisioning succeeds #then it bootstraps with the provisioned binary", async () => {
+		// given
+		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-provision-"));
+		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-provision-home-"));
+		const binPath = join(homeDir, ".omo", "codegraph", "bin", "codegraph");
+		const calls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
+		const outcomes: unknown[] = [];
+
+		try {
+			// when
+			const result = await runCodegraphSessionStartWorker({
+				cwd: workspace,
+				env: { HOME: homeDir },
+				nodeVersion: "26.3.0",
+				logOutcome: (outcome) => outcomes.push(outcome),
+				deps: {
+					ensureGitignored: () => true,
+					ensureProvisioned: () => Promise.resolve({ binPath, provisioned: true }),
+					prepareWorkspace: () => ({
+						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
+						dataRoot: join(homeDir, ".omo/codegraph"),
+						linked: true,
+						mode: "global-linked",
+						projectLink: join(workspace, ".codegraph"),
+					}),
+					resolveCommand: () => ({ argsPrefix: [], command: "/usr/local/bin/codegraph", exists: true, source: "path" }),
+					runCommand: (_projectRoot, command, args) => {
+						calls.push({ args, command });
+						return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? '{"initialized":false}' : "", timedOut: false });
+					},
+				},
+			});
+
+			// then
+			expect(result).toEqual({ action: "initialized" });
+			expect(calls).toEqual([
+				{ args: ["status", "--json"], command: binPath },
+				{ args: ["init"], command: binPath },
+			]);
+			expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "provisioned", timedOut: false }]);
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+			rmSync(homeDir, { recursive: true, force: true });
+		}
+	});
+
+	it("#given an unsupported local Node but bundled CodeGraph resolves through CODEGRAPH_NODE_BIN #when worker runs #then it bootstraps with the compatible runtime", async () => {
+		// given
+		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-compatible-node-"));
+		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-compatible-node-home-"));
+		const nodeBin = "/opt/node22/bin/node";
+		const calls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
+		const outcomes: unknown[] = [];
+
+		try {
+			// when
+			const result = await runCodegraphSessionStartWorker({
+				cwd: workspace,
+				env: { CODEGRAPH_NODE_BIN: nodeBin, HOME: homeDir },
+				nodeVersion: "26.3.0",
+				logOutcome: (outcome) => outcomes.push(outcome),
+				deps: {
+					ensureGitignored: () => true,
+					ensureProvisioned: () => {
+						throw new Error("provisioning should not run when bundled CodeGraph resolved");
+					},
+					prepareWorkspace: () => ({
+						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
+						dataRoot: join(homeDir, ".omo/codegraph"),
+						linked: true,
+						mode: "global-linked",
+						projectLink: join(workspace, ".codegraph"),
+					}),
+					resolveCommand: () => ({ argsPrefix: ["codegraph.js"], command: nodeBin, exists: true, source: "bundled" }),
+					runCommand: (_projectRoot, command, args) => {
+						calls.push({ args, command });
+						return Promise.resolve({ exitCode: 0, stdout: calls.length === 1 ? '{"initialized":false}' : "", timedOut: false });
+					},
+				},
+			});
+
+			// then
+			expect(result).toEqual({ action: "initialized" });
+			expect(calls).toEqual([
+				{ args: ["codegraph.js", "status", "--json"], command: nodeBin },
+				{ args: ["codegraph.js", "init"], command: nodeBin },
+			]);
+			expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "bundled", timedOut: false }]);
+		} finally {
+			rmSync(workspace, { recursive: true, force: true });
+			rmSync(homeDir, { recursive: true, force: true });
+		}
+	});
+});

package/packages/omo-codex/plugin/components/comment-checker/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-comment-checker",
-	"version": "4.12.0",
+	"version": "4.12.1",
 	"description": "Codex plugin that runs comment-checker after edit-like PostToolUse hooks.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/git-bash/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-git-bash-hook",
-	"version": "4.12.0",
+	"version": "4.12.1",
 	"description": "Codex hook component that reminds Windows sessions to prefer the OMO git_bash MCP.",
 	"type": "module",
 	"private": true,

package/packages/omo-codex/plugin/components/lazycodex-executor-verify/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-lazycodex-executor-verify",
-	"version": "4.12.0",
+	"version": "4.12.1",
 	"description": "Codex SubagentStop evidence verifier for LazyCodex executor completions.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-lsp",
-	"version": "4.12.0",
+	"version": "4.12.1",
 	"description": "Codex plugin that exposes Language Server Protocol tools and post-edit diagnostics.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-rules",
-	"version": "4.12.0",
+	"version": "4.12.1",
 	"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.12.0",
+	"version": "4.12.1",
 	"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/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"
+	}
+}

package/packages/omo-codex/plugin/components/teammode/src/cli.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import { runTeammodeHookCli } from "./codex-hook.js";
+
+const [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\n");
+	process.exitCode = 2;
+}