oh-my-opencode 4.11.1 → 4.12.1

package/packages/omo-codex/plugin/components/teammode/skills/teammode/scripts/team.mjs

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+// team.mjs - the teammode controller CLI. Thin argv dispatch over team-state.mjs (the
+// state model) and team-guide.mjs (the member field manual). It replaces hand-written
+// team.json / guide.md so the model never has to author those files by hand.
+//
+// Zero external dependencies (node builtins only): runs identically under node and bun on
+// macOS, Linux, and Windows.
+//
+//   node "<skill-root>/scripts/team.mjs" init        --name "<team>" --session-name "<sess>" [--session <id>] [--worktree] [--base-branch dev]
+//   node "<skill-root>/scripts/team.mjs" add-member  --team <id> --id A --focus "<part/ownership/perspective>" --lens area|ownership|perspective --deliverable "<...>" [--branch <b>]
+//   node "<skill-root>/scripts/team.mjs" bind-thread  --team <id> --id A --thread <thread-id> [--cwd <path>]
+//   node "<skill-root>/scripts/team.mjs" member-prompt --team <id> --id A
+//   node "<skill-root>/scripts/team.mjs" set-status   --team <id> --id A --status reported|blocked|active|archived [--note "<...>"]
+//   node "<skill-root>/scripts/team.mjs" archive      --team <id> [--id A] [--note "<...>"]
+//   node "<skill-root>/scripts/team.mjs" delete       --team <id> [--force]
+//   node "<skill-root>/scripts/team.mjs" status       --team <id>
+//   node "<skill-root>/scripts/team.mjs" guide        --team <id>
+
+import { randomUUID } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { buildGuide, buildMemberPrompt } from "./team-guide.mjs";
+import {
+	addMember,
+	archive,
+	assertSafeTeamDir,
+	bindThread,
+	buildTeam,
+	ensureTeamDir,
+	isUnderstaffed,
+	MIN_MEMBERS,
+	readTeam,
+	resolveTeamDir,
+	setMemberStatus,
+	teamExists,
+	writeGuideAtomic,
+	writeTeamAtomic,
+} from "./team-state.mjs";
+
+function parseFlags(args) {
+	const flags = { _: [] };
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (!arg.startsWith("--")) {
+			flags._.push(arg);
+			continue;
+		}
+		const key = arg.slice(2);
+		const next = args[i + 1];
+		if (next === undefined || next.startsWith("--")) {
+			flags[key] = true;
+		} else {
+			flags[key] = next;
+			i++;
+		}
+	}
+	return flags;
+}
+
+function requireFlag(flags, name) {
+	const value = flags[name];
+	if (value === undefined || value === true) throw new Error(`missing required flag --${name}`);
+	return value;
+}
+
+async function loadTeam(cwd, sessionId) {
+	const dir = await assertSafeTeamDir(cwd, sessionId);
+	return { dir, team: await readTeam(dir) };
+}
+
+async function persist(team, dir) {
+	await writeTeamAtomic(team, dir);
+	await writeGuideAtomic(team, buildGuide(team), dir);
+}
+
+const handlers = {
+	async init(cwd, flags) {
+		const teamName = requireFlag(flags, "name");
+		const sessionName = requireFlag(flags, "session-name");
+		const sessionId = typeof flags.session === "string" ? flags.session : `team-${randomUUID().slice(0, 8)}`;
+		const dir = await ensureTeamDir(cwd, sessionId);
+		if (await teamExists(dir)) {
+			process.stdout.write(`exists: ${dir} (left untouched; re-init is a safe no-op)\n`);
+			return;
+		}
+		const team = buildTeam({
+			teamName,
+			sessionName,
+			sessionId,
+			dir,
+			worktreeEnabled: flags.worktree === true,
+			baseBranch: typeof flags["base-branch"] === "string" ? flags["base-branch"] : "dev",
+		});
+		await persist(team, dir);
+		process.stdout.write(`created: ${dir}\n`);
+		process.stdout.write(`team.json + guide.md written; artifacts/ ready. session id: ${sessionId}\n`);
+		process.stdout.write(`next: add-member --team ${sessionId} --id A --focus "<part/ownership/perspective>" --lens area|ownership|perspective --deliverable "<...>"\n`);
+	},
+
+	async "add-member"(cwd, flags) {
+		const sessionId = requireFlag(flags, "team");
+		const { dir, team } = await loadTeam(cwd, sessionId);
+		const memberId = requireFlag(flags, "id").trim();
+		addMember(team, {
+			id: memberId,
+			focus: requireFlag(flags, "focus"),
+			lens: requireFlag(flags, "lens"),
+			deliverable: typeof flags.deliverable === "string" ? flags.deliverable : "",
+			branch: typeof flags.branch === "string" ? flags.branch : null,
+		});
+		await persist(team, dir);
+		process.stdout.write(`added member ${memberId} to team ${sessionId}.\n\nSend this as the new thread's first message (title it "${team.threadTitleConvention}"):\n---\n${buildMemberPrompt(team, memberId)}\n---\n`);
+	},
+
+	async "bind-thread"(cwd, flags) {
+		const sessionId = requireFlag(flags, "team");
+		const { dir, team } = await loadTeam(cwd, sessionId);
+		bindThread(team, {
+			id: requireFlag(flags, "id"),
+			threadId: requireFlag(flags, "thread"),
+			cwd: typeof flags.cwd === "string" ? flags.cwd : null,
+			worktreePath: typeof flags["worktree-path"] === "string" ? flags["worktree-path"] : null,
+		});
+		await persist(team, dir);
+		process.stdout.write(`bound member ${flags.id} to thread ${flags.thread}.\n`);
+	},
+
+	async "member-prompt"(cwd, flags) {
+		const sessionId = requireFlag(flags, "team");
+		const { team } = await loadTeam(cwd, sessionId);
+		process.stdout.write(`${buildMemberPrompt(team, requireFlag(flags, "id"))}\n`);
+	},
+
+	async "set-status"(cwd, flags) {
+		const sessionId = requireFlag(flags, "team");
+		const { dir, team } = await loadTeam(cwd, sessionId);
+		setMemberStatus(team, {
+			id: requireFlag(flags, "id"),
+			status: requireFlag(flags, "status"),
+			note: typeof flags.note === "string" ? flags.note : "",
+		});
+		await persist(team, dir);
+		process.stdout.write(`member ${flags.id} -> ${flags.status}\n`);
+	},
+
+	async archive(cwd, flags) {
+		const sessionId = requireFlag(flags, "team");
+		const { dir, team } = await loadTeam(cwd, sessionId);
+		archive(team, {
+			id: typeof flags.id === "string" ? flags.id : null,
+			note: typeof flags.note === "string" ? flags.note : "",
+		});
+		await persist(team, dir);
+		process.stdout.write(flags.id ? `archived member ${flags.id}\n` : `archived team ${sessionId} and closed all members\n`);
+	},
+
+	async delete(cwd, flags) {
+		const sessionId = requireFlag(flags, "team");
+		const { dir, team } = await loadTeam(cwd, sessionId);
+		const active = team.members.filter((m) => m.status !== "archived");
+		if (flags.force !== true && (team.status !== "archived" || active.length > 0)) {
+			throw new Error(
+				`refused: team "${sessionId}" is not archived or still has ${active.length} active member(s). Archive first, or pass --force to delete anyway.`,
+			);
+		}
+		await rm(dir, { recursive: true, force: true });
+		process.stdout.write(`deleted team state: ${dir}\n`);
+	},
+
+	async status(cwd, flags) {
+		const sessionId = requireFlag(flags, "team");
+		const { team } = await loadTeam(cwd, sessionId);
+		process.stdout.write(`Team ${team.teamName} [${team.status}] - leader: main session - ${team.members.length} member(s)\n`);
+		for (const m of team.members) {
+			process.stdout.write(`  ${m.id} (${m.lens}) ${m.focus} -> ${m.deliverable || "(no deliverable)"} [${m.status}]${m.threadId ? ` thread=${m.threadId}` : ""}${m.cwd ? ` cwd=${m.cwd}` : ""}\n`);
+		}
+		if (isUnderstaffed(team)) {
+			process.stdout.write(
+				`WARNING: a team needs at least ${MIN_MEMBERS} members; this team has ${team.members.length}. A single-member team is not a team - add another distinct slice or use a subagent.\n`,
+			);
+		}
+	},
+
+	async guide(cwd, flags) {
+		const sessionId = requireFlag(flags, "team");
+		const { dir, team } = await loadTeam(cwd, sessionId);
+		await writeGuideAtomic(team, buildGuide(team), dir);
+		process.stdout.write(`${team.paths.guide}\n`);
+	},
+};
+
+async function main() {
+	const [subcommand, ...rest] = process.argv.slice(2);
+	const handler = handlers[subcommand];
+	if (!handler) {
+		throw new Error(`unknown subcommand "${subcommand ?? ""}" - expected one of: ${Object.keys(handlers).join(", ")}`);
+	}
+	await handler(process.cwd(), parseFlags(rest));
+}
+
+// Symlink-robust main-module check: a symlinked install invokes this file through a symlink
+// path while node resolves import.meta.url to the realpath, so compare the resolved real paths
+// (falling back to the literal url comparison if a path cannot be resolved).
+function isInvokedAsScript() {
+	const entry = process.argv[1];
+	if (!entry) return false;
+	try {
+		return realpathSync(fileURLToPath(import.meta.url)) === realpathSync(entry);
+	} catch {
+		return import.meta.url === pathToFileURL(entry).href;
+	}
+}
+
+if (isInvokedAsScript()) {
+	await main().catch((error) => {
+		process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+		process.exit(1);
+	});
+}

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;
+}

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

@@ -0,0 +1,125 @@
+export interface PostToolUsePayload {
+	readonly hook_event_name: "PostToolUse";
+	readonly session_id: string;
+	readonly turn_id?: string;
+	readonly transcript_path?: string | null;
+	readonly cwd?: string;
+	readonly model?: string;
+	readonly permission_mode?: string;
+	readonly tool_name: string;
+	readonly tool_use_id?: string;
+	readonly tool_input: unknown;
+	readonly tool_response: unknown;
+}
+
+interface PostToolUseHookOutput {
+	readonly hookSpecificOutput: {
+		readonly hookEventName: "PostToolUse";
+		readonly additionalContext: string;
+	};
+}
+
+type ThreadCreationReference =
+	| { readonly kind: "thread"; readonly id: string }
+	| { readonly kind: "pendingWorktree"; readonly id: string };
+
+const CREATE_THREAD_TOOL_NAMES = new Set(["create_thread", "codex_app.create_thread"]);
+
+export function parsePostToolUsePayload(raw: string): PostToolUsePayload | null {
+	if (raw.trim().length === 0) return null;
+	try {
+		const parsed: unknown = JSON.parse(raw);
+		return isPostToolUsePayload(parsed) ? parsed : null;
+	} catch (error) {
+		if (error instanceof SyntaxError) return null;
+		return null;
+	}
+}
+
+export function runPostToolUseHook(payload: PostToolUsePayload): string {
+	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: PostToolUseHookOutput = {
+		hookSpecificOutput: {
+			hookEventName: "PostToolUse",
+			additionalContext: threadTitleReminder(threadReference),
+		},
+	};
+	return `${JSON.stringify(output)}\n`;
+}
+
+export async function runTeammodeHookCli(
+	stdin: NodeJS.ReadableStream,
+	stdout: NodeJS.WritableStream,
+): Promise<void> {
+	const payload = parsePostToolUsePayload(await readAll(stdin));
+	if (payload === null) return;
+	const output = runPostToolUseHook(payload);
+	if (output.length > 0) stdout.write(output);
+}
+
+function threadTitleReminder(threadReference: ThreadCreationReference): string {
+	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: string): string {
+	const normalized = value.replace(/\s+/g, " ").trim();
+	return normalized.length <= 200 ? normalized : `${normalized.slice(0, 197)}...`;
+}
+
+function extractThreadCreationReference(toolResponse: unknown): ThreadCreationReference | null {
+	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: unknown): value is PostToolUsePayload {
+	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: unknown): boolean {
+	return value === undefined || typeof value === "string";
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readAll(stdin: NodeJS.ReadableStream): Promise<string> {
+	return new Promise((resolve, reject) => {
+		let data = "";
+		stdin.setEncoding("utf8");
+		stdin.on("data", (chunk: unknown) => {
+			data += chunk instanceof Buffer ? chunk.toString() : String(chunk);
+		});
+		stdin.once("error", reject);
+		stdin.once("end", () => resolve(data));
+	});
+}

package/packages/omo-codex/plugin/components/teammode/test/thread-title-hook.test.ts

@@ -0,0 +1,116 @@
+import { describe, expect, it } from "vitest";
+
+import { runPostToolUseHook } from "../src/codex-hook.js";
+
+describe("thread title PostToolUse guidance", () => {
+	it("#given codex_app.create_thread completed #when the hook runs #then it asks Codex to immediately set a descriptive title", () => {
+		// given
+		const output = runPostToolUseHook({
+			hook_event_name: "PostToolUse",
+			session_id: "s-team",
+			turn_id: "t-team",
+			transcript_path: null,
+			cwd: "/repo",
+			model: "gpt-5.5",
+			permission_mode: "default",
+			tool_name: "create_thread",
+			tool_use_id: "tool-create-thread",
+			tool_input: {
+				prompt: "Investigate package install failures",
+				target: { type: "project", projectId: "/repo", environment: { type: "local" } },
+			},
+			tool_response: { threadId: "thread-123" },
+		});
+
+		// when
+		const parsed: unknown = JSON.parse(output);
+
+		// then
+		expect(isHookOutput(parsed)).toBe(true);
+		if (!isHookOutput(parsed)) return;
+		expect(parsed.hookSpecificOutput.hookEventName).toBe("PostToolUse");
+		expect(parsed.hookSpecificOutput.additionalContext).toBe(
+			"THREAD ID thread-123: CALL codex_app.set_thread_title NOW. USE THE REAL TASK/ROLE.",
+		);
+	});
+
+	it("#given an unrelated tool completed #when the hook runs #then it stays silent", () => {
+		// given
+		const output = runPostToolUseHook({
+			hook_event_name: "PostToolUse",
+			session_id: "s-team",
+			turn_id: "t-team",
+			transcript_path: null,
+			cwd: "/repo",
+			model: "gpt-5.5",
+			permission_mode: "default",
+			tool_name: "read_thread",
+			tool_use_id: "tool-read-thread",
+			tool_input: { threadId: "thread-123" },
+			tool_response: { status: "ok" },
+		});
+
+		// when
+		const actual = output;
+
+		// then
+		expect(actual).toBe("");
+	});
+
+	it("#given worktree-backed thread creation is pending #when the hook runs #then it tells Codex to title the thread once the thread id exists", () => {
+		// given
+		const output = runPostToolUseHook({
+			hook_event_name: "PostToolUse",
+			session_id: "s-team",
+			turn_id: "t-team",
+			transcript_path: null,
+			cwd: "/repo",
+			model: "gpt-5.5",
+			permission_mode: "default",
+			tool_name: "codex_app.create_thread",
+			tool_use_id: "tool-create-thread",
+			tool_input: {
+				prompt: "Fix CodeGraph provisioned launcher skip on Node 25",
+				target: {
+					type: "project",
+					projectId: "/repo",
+					environment: { type: "worktree", startingState: { type: "working-tree" } },
+				},
+			},
+			tool_response: {
+				pendingWorktreeId: "remote-control:env:test-worktree",
+			},
+		});
+
+		// when
+		const parsed: unknown = JSON.parse(output);
+
+		// then
+		expect(isHookOutput(parsed)).toBe(true);
+		if (!isHookOutput(parsed)) return;
+		expect(parsed.hookSpecificOutput.additionalContext).toBe(
+			"PENDING WORKTREE ID remote-control:env:test-worktree: CALL codex_app.set_thread_title AS SOON AS THREAD ID EXISTS. USE THE REAL TASK/ROLE.",
+		);
+	});
+});
+
+interface HookOutput {
+	readonly hookSpecificOutput: {
+		readonly hookEventName: "PostToolUse";
+		readonly additionalContext: string;
+	};
+}
+
+function isHookOutput(value: unknown): value is HookOutput {
+	if (!isRecord(value)) return false;
+	const hookSpecificOutput = value["hookSpecificOutput"];
+	return (
+		isRecord(hookSpecificOutput) &&
+		hookSpecificOutput["hookEventName"] === "PostToolUse" &&
+		typeof hookSpecificOutput["additionalContext"] === "string"
+	);
+}
+
+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/tsconfig.json

@@ -0,0 +1,25 @@
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"module": "Node16",
+		"moduleResolution": "Node16",
+		"lib": ["ES2022"],
+		"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,
+		"types": ["node", "bun-types"],
+		"noEmit": true
+	},
+	"include": ["src/**/*", "test/**/*"]
+}

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

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook session-start",
 						"timeout": 5,
-						"statusMessage": "LazyCodex(4.11.1): Recording Session Telemetry"
+						"statusMessage": "(OmO) Recording Session Telemetry"
 					}
 				]
 			}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-telemetry",
-	"version": "4.11.1",
+	"version": "4.12.1",
 	"description": "Codex plugin component that emits omo-codex anonymous daily-active telemetry on SessionStart.",
 	"type": "module",
 	"packageManager": "npm@11.12.1",

package/packages/omo-codex/plugin/components/test-support/package-smoke-fixture.ts

@@ -0,0 +1,158 @@
+/// <reference path="../../node_modules/@types/node/index.d.ts" />
+
+import { readdirSync, readFileSync } from "node:fs";
+
+export type ComponentPackageJson = {
+	readonly version?: string;
+	readonly type: string;
+	readonly packageManager: string;
+	readonly bin: Readonly<Record<string, string>>;
+	readonly dependencies?: Readonly<Record<string, string>>;
+	readonly optionalDependencies?: Readonly<Record<string, string>>;
+	readonly scripts?: Readonly<Record<string, string>>;
+	readonly files?: readonly string[];
+};
+
+export type HookCommand = {
+	readonly command: string;
+};
+
+export type HookEntry = {
+	readonly matcher?: string;
+	readonly hooks: readonly HookCommand[];
+};
+
+export type HooksJson = {
+	readonly hooks: Record<string, readonly HookEntry[]>;
+};
+
+export type McpServer = {
+	readonly command: string;
+	readonly args: readonly string[];
+};
+
+export type McpJson = {
+	readonly mcpServers: Record<string, McpServer>;
+};
+
+export type PluginJson = {
+	readonly hooks: string;
+};
+
+export function readPackageJson(path: string): ComponentPackageJson {
+	const parsed = readJsonFile(path);
+	if (!isComponentPackageJson(parsed)) throw new TypeError(`Invalid package metadata: ${path}`);
+	return parsed;
+}
+
+export function readHooksJson(path: string): HooksJson {
+	const parsed = readJsonFile(path);
+	if (!isHooksJson(parsed)) throw new TypeError(`Invalid hooks metadata: ${path}`);
+	return parsed;
+}
+
+export function readMcpJson(path: string): McpJson {
+	const parsed = readJsonFile(path);
+	if (!isMcpJson(parsed)) throw new TypeError(`Invalid MCP metadata: ${path}`);
+	return parsed;
+}
+
+export function readPluginJson(path: string): PluginJson {
+	const parsed = readJsonFile(path);
+	if (!isPluginJson(parsed)) throw new TypeError(`Invalid plugin metadata: ${path}`);
+	return parsed;
+}
+
+export function readJsonFile(path: string): unknown {
+	return JSON.parse(readFileSync(path, "utf8"));
+}
+
+export function readTextFile(path: string): string {
+	return readFileSync(path, "utf8");
+}
+
+export function listDirectoryEntries(path: string): readonly string[] {
+	return readdirSync(path);
+}
+
+export function requireFiles(packageJson: ComponentPackageJson, path: string): readonly string[] {
+	if (packageJson.files === undefined) throw new TypeError(`Package metadata missing files: ${path}`);
+	return packageJson.files;
+}
+
+export function requireScripts(packageJson: ComponentPackageJson, path: string): Readonly<Record<string, string>> {
+	if (packageJson.scripts === undefined) throw new TypeError(`Package metadata missing scripts: ${path}`);
+	return packageJson.scripts;
+}
+
+export function collectHookCommandsFromValue(value: unknown): readonly string[] {
+	if (typeof value === "string") return [];
+	if (Array.isArray(value)) return value.flatMap(collectHookCommandsFromValue);
+	if (!isRecord(value)) return [];
+	const ownCommand = typeof value["command"] === "string" ? [value["command"]] : [];
+	return [...ownCommand, ...Object.values(value).flatMap(collectHookCommandsFromValue)];
+}
+
+function isComponentPackageJson(value: unknown): value is ComponentPackageJson {
+	if (!isRecord(value)) return false;
+	const dependencies = value["dependencies"];
+	const optionalDependencies = value["optionalDependencies"];
+	const scripts = value["scripts"];
+	const files = value["files"];
+	return (
+		value["type"] === "module" &&
+		value["packageManager"] === "npm@11.12.1" &&
+		isStringRecord(value["bin"]) &&
+		(dependencies === undefined || isStringRecord(dependencies)) &&
+		(optionalDependencies === undefined || isStringRecord(optionalDependencies)) &&
+		(scripts === undefined || isStringRecord(scripts)) &&
+		(files === undefined || isStringArray(files))
+	);
+}
+
+function isHooksJson(value: unknown): value is HooksJson {
+	if (!isRecord(value) || !isRecord(value["hooks"])) return false;
+	return Object.values(value["hooks"]).every(isHookEntries);
+}
+
+function isHookEntries(value: unknown): value is readonly HookEntry[] {
+	return Array.isArray(value) && value.every(isHookEntry);
+}
+
+function isHookEntry(value: unknown): value is HookEntry {
+	return isRecord(value) && Array.isArray(value["hooks"]) && value["hooks"].every(isHookCommand);
+}
+
+function isHookCommand(value: unknown): value is HookCommand {
+	return isRecord(value) && typeof value["command"] === "string";
+}
+
+function isMcpJson(value: unknown): value is McpJson {
+	if (!isRecord(value) || !isRecord(value["mcpServers"])) return false;
+	return Object.values(value["mcpServers"]).every(isMcpServer);
+}
+
+function isMcpServer(value: unknown): value is McpServer {
+	return (
+		isRecord(value) &&
+		typeof value["command"] === "string" &&
+		Array.isArray(value["args"]) &&
+		value["args"].every((item) => typeof item === "string")
+	);
+}
+
+function isPluginJson(value: unknown): value is PluginJson {
+	return isRecord(value) && typeof value["hooks"] === "string";
+}
+
+function isStringArray(value: unknown): value is readonly string[] {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+
+function isStringRecord(value: unknown): value is Record<string, string> {
+	return isRecord(value) && Object.values(value).every((item) => typeof item === "string");
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -7,7 +7,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook user-prompt-submit",
 						"timeout": 5,
-						"statusMessage": "LazyCodex(4.11.1): Checking Ultrawork Trigger"
+						"statusMessage": "(OmO) Checking Ultrawork Trigger"
 					}
 				]
 			}