oh-my-opencode 4.11.1 → 4.12.0

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

@@ -1,12 +1,12 @@
 {
 	"name": "@sisyphuslabs/omo-codex-plugin",
-	"version": "4.11.0",
+	"version": "4.11.1",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "@sisyphuslabs/omo-codex-plugin",
-			"version": "4.11.0",
+			"version": "4.11.1",
 			"workspaces": [
 				"components/codegraph",
 				"components/comment-checker",
@@ -23,11 +23,6 @@
 				"@oh-my-opencode/shared-skills": "file:../../shared-skills"
 			}
 		},
-		"../../boulder-state": {
-			"name": "@oh-my-opencode/boulder-state",
-			"version": "0.1.0",
-			"dev": true
-		},
 		"../../comment-checker-core": {
 			"name": "@oh-my-opencode/comment-checker-core",
 			"version": "0.1.0",
@@ -97,7 +92,7 @@
 		},
 		"components/codegraph": {
 			"name": "@sisyphuslabs/codex-codegraph",
-			"version": "4.11.0",
+			"version": "4.11.1",
 			"bin": {
 				"omo-codegraph": "dist/cli.js"
 			},
@@ -113,7 +108,7 @@
 		},
 		"components/comment-checker": {
 			"name": "@code-yeongyu/codex-comment-checker",
-			"version": "4.11.0",
+			"version": "4.11.1",
 			"license": "MIT",
 			"bin": {
 				"omo-comment-checker": "dist/cli.js"
@@ -134,7 +129,7 @@
 		},
 		"components/git-bash": {
 			"name": "@sisyphuslabs/codex-git-bash-hook",
-			"version": "4.11.0",
+			"version": "4.11.1",
 			"bin": {
 				"omo-git-bash-hook": "dist/cli.js"
 			},
@@ -149,7 +144,7 @@
 		},
 		"components/lazycodex-executor-verify": {
 			"name": "@code-yeongyu/codex-lazycodex-executor-verify",
-			"version": "4.11.0",
+			"version": "4.11.1",
 			"license": "MIT",
 			"bin": {
 				"lazycodex-executor-verify": "dist/cli.js"
@@ -166,7 +161,7 @@
 		},
 		"components/lsp": {
 			"name": "@code-yeongyu/codex-lsp",
-			"version": "4.11.0",
+			"version": "4.11.1",
 			"license": "MIT",
 			"dependencies": {
 				"@code-yeongyu/lsp-daemon": "file:../../../../lsp-daemon"
@@ -186,7 +181,7 @@
 		},
 		"components/rules": {
 			"name": "@code-yeongyu/codex-rules",
-			"version": "4.11.0",
+			"version": "4.11.1",
 			"license": "MIT",
 			"dependencies": {
 				"picomatch": "^4.0.3"
@@ -208,14 +203,13 @@
 		},
 		"components/start-work-continuation": {
 			"name": "@code-yeongyu/codex-start-work-continuation",
-			"version": "4.11.0",
+			"version": "4.11.1",
 			"license": "MIT",
 			"bin": {
 				"omo-start-work-continuation": "dist/cli.js"
 			},
 			"devDependencies": {
 				"@biomejs/biome": "2.4.16",
-				"@oh-my-opencode/boulder-state": "file:../../../../boulder-state",
 				"@types/node": "^25.9.3",
 				"typescript": "^6.0.3",
 				"vitest": "^4.1.8"
@@ -226,7 +220,7 @@
 		},
 		"components/telemetry": {
 			"name": "@code-yeongyu/codex-telemetry",
-			"version": "4.11.0",
+			"version": "4.11.1",
 			"license": "MIT",
 			"bin": {
 				"omo-telemetry": "dist/cli.js"
@@ -244,7 +238,7 @@
 		},
 		"components/ultrawork": {
 			"name": "@code-yeongyu/codex-ultrawork",
-			"version": "4.11.0",
+			"version": "4.11.1",
 			"license": "MIT",
 			"bin": {
 				"omo-ultrawork": "dist/cli.js"
@@ -262,7 +256,7 @@
 		},
 		"components/ulw-loop": {
 			"name": "@code-yeongyu/codex-ulw-loop",
-			"version": "4.11.0",
+			"version": "4.11.1",
 			"license": "MIT",
 			"bin": {
 				"omo-ulw-loop": "dist/cli.js"
@@ -562,10 +556,6 @@
 				"@emnapi/runtime": "^1.7.1"
 			}
 		},
-		"node_modules/@oh-my-opencode/boulder-state": {
-			"resolved": "../../boulder-state",
-			"link": true
-		},
 		"node_modules/@oh-my-opencode/comment-checker-core": {
 			"resolved": "../../comment-checker-core",
 			"link": true

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

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

package/packages/omo-codex/plugin/scripts/hook-status-message.mjs

@@ -1,4 +1,4 @@
-const PRODUCT_NAME = "LazyCodex";
+const PRODUCT_PREFIX = "(OmO)";
 
 const WORD_OVERRIDES = new Map([
 	["lazycodex", "LazyCodex"],
@@ -8,13 +8,18 @@ const WORD_OVERRIDES = new Map([
 ]);
 
 export function formatLazyCodexHookStatusMessage(version, label) {
-	return `${PRODUCT_NAME}(${normalizeVersion(version)}): ${normalizeLazyCodexHookStatusLabel(label)}`;
+	void version;
+	return `${PRODUCT_PREFIX} ${normalizeLazyCodexHookStatusLabel(label)}`;
 }
 
 export function normalizeLazyCodexHookStatusLabel(label) {
 	const parsed = parseLazyCodexHookStatusMessage(label);
 	const rawLabel = parsed === null ? label : parsed.label;
-	const normalized = rawLabel.replace(/\bOMO\b/gi, " ").replace(/\s+/g, " ").trim();
+	const normalized = rawLabel
+		.replace(/^\(OmO\)\s*/i, " ")
+		.replace(/\bOMO\b/gi, " ")
+		.replace(/\s+/g, " ")
+		.trim();
 	if (normalized.length === 0) return "";
 	return normalized
 		.split(" ")
@@ -23,17 +28,15 @@ export function normalizeLazyCodexHookStatusLabel(label) {
 }
 
 export function parseLazyCodexHookStatusMessage(message) {
-	const match = /^LazyCodex\(([^)]+)\):\s+(.+)$/.exec(message.trim());
-	if (match === null) return null;
-	const [, version, label] = match;
+	const trimmed = message.trim();
+	const current = /^\(OmO\)\s+(.+)$/.exec(trimmed);
+	if (current !== null) return { version: undefined, label: current[1] };
+	const legacy = /^LazyCodex\(([^)]+)\):\s+(.+)$/.exec(trimmed);
+	if (legacy === null) return null;
+	const [, version, label] = legacy;
 	return { version, label };
 }
 
-function normalizeVersion(version) {
-	const normalized = version.trim();
-	return normalized.length === 0 ? "local" : normalized;
-}
-
 function formatWord(word) {
 	const lower = word.toLowerCase();
 	const override = WORD_OVERRIDES.get(lower);

package/packages/omo-codex/plugin/scripts/sync-hook-status-messages.mjs

@@ -31,6 +31,15 @@ async function readPackageVersion(path) {
 	return packageJson.version;
 }
 
+async function readAggregateHookPaths(root) {
+	const manifest = await readJson(join(root, ".codex-plugin", "plugin.json"));
+	if (typeof manifest.hooks === "string") return [manifest.hooks];
+	if (Array.isArray(manifest.hooks)) {
+		return manifest.hooks.filter((hookPath) => typeof hookPath === "string");
+	}
+	return ["./hooks/hooks.json"];
+}
+
 async function readComponentNames(root) {
 	const componentsRoot = join(root, "components");
 	const entries = await readdir(componentsRoot, { withFileTypes: true });
@@ -79,10 +88,12 @@ export async function syncHookStatusMessages(root = defaultRoot, options = {}) {
 	const releaseVersion = readReleaseVersion(options);
 	const aggregateVersion = releaseVersion ?? (await readPackageVersion(join(root, ".codex-plugin", "plugin.json")));
 	const componentNames = await readComponentNames(root);
-	const aggregateHooksPath = join(root, "hooks", "hooks.json");
-	const aggregateHooks = await readJson(aggregateHooksPath);
-	syncHooksJson(aggregateHooks, () => aggregateVersion);
-	await writeJson(aggregateHooksPath, aggregateHooks);
+	for (const hookPath of await readAggregateHookPaths(root)) {
+		const aggregateHooksPath = join(root, hookPath.replace(/^\.\//, ""));
+		const aggregateHooks = await readJson(aggregateHooksPath);
+		syncHooksJson(aggregateHooks, () => aggregateVersion);
+		await writeJson(aggregateHooksPath, aggregateHooks);
+	}
 
 	for (const componentName of componentNames) {
 		const componentVersion =

package/packages/omo-codex/plugin/scripts/sync-skills.mjs

@@ -12,10 +12,12 @@ const skillSources = [
 	["comment-checker", "components/comment-checker/skills/comment-checker"],
 	["lsp", "components/lsp/skills/lsp"],
 	["rules", "components/rules/skills/rules"],
+	["teammode", "components/teammode/skills/teammode"],
 	["ulw-loop", "components/ulw-loop/skills/ulw-loop"],
 	["ulw-plan", "components/ultrawork/skills/ulw-plan"],
 ];
 const componentSkillNames = new Set(skillSources.map(([name]) => name));
+const skillDisplayPrefix = "(OmO) ";
 
 const opencodeOnlyOrchestrationPattern = /\b(?:call_omo_agent|background_output|team_[a-z_]+|task)\s*\(/;
 
@@ -151,6 +153,40 @@ function applyCodexSkillOverlays(skillName, content) {
 	return content;
 }
 
+function readSkillFrontmatterName(content, fallbackName) {
+	const frontmatter = content.match(/^---\n(?<body>[\s\S]*?)\n---\n+/);
+	const rawName = frontmatter?.groups?.body.match(/^name:\s*"?([^"\n]+)"?\s*$/m)?.[1]?.trim();
+	return rawName && rawName.length > 0 ? rawName : fallbackName;
+}
+
+function upsertDisplayName(metadata, displayName) {
+	const content = metadata.endsWith("\n") ? metadata : `${metadata}\n`;
+	if (/^\s*display_name:/m.test(metadata)) {
+		return content.replace(/^(\s*display_name:\s*).+$/m, `$1"${displayName}"`);
+	}
+	if (/^interface:\s*$/m.test(metadata)) {
+		return content.replace(/^interface:\s*$/m, `interface:\n  display_name: "${displayName}"`);
+	}
+	return `interface:\n  display_name: "${displayName}"\n${content}`;
+}
+
+async function writeCodexSkillDisplayMetadata(skillName) {
+	const skillRoot = join(skillsRoot, skillName);
+	const skillPath = join(skillRoot, "SKILL.md");
+	const content = await readFile(skillPath, "utf8");
+	const frontmatterName = readSkillFrontmatterName(content, skillName);
+	const metadataDir = join(skillRoot, "agents");
+	const metadataPath = join(metadataDir, "openai.yaml");
+	await mkdir(metadataDir, { recursive: true });
+	let metadata = "interface:\n";
+	try {
+		metadata = await readFile(metadataPath, "utf8");
+	} catch (error) {
+		if (!(error instanceof Error && "code" in error && error.code === "ENOENT")) throw error;
+	}
+	await writeFile(metadataPath, upsertDisplayName(metadata, `${skillDisplayPrefix}${frontmatterName}`), "utf8");
+}
+
 async function adaptSkillForCodex(skillName) {
 	const skillPath = join(skillsRoot, skillName, "SKILL.md");
 	const content = await readFile(skillPath, "utf8");
@@ -158,6 +194,7 @@ async function adaptSkillForCodex(skillName) {
 	if (adapted !== content) {
 		await writeFile(skillPath, adapted, "utf8");
 	}
+	await writeCodexSkillDisplayMetadata(skillName);
 }
 
 async function syncSkills() {

package/packages/omo-codex/plugin/skills/ast-grep/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) ast-grep"

package/packages/omo-codex/plugin/skills/comment-checker/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) comment-checker"

package/packages/omo-codex/plugin/skills/debugging/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) debugging"

package/packages/omo-codex/plugin/skills/frontend/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) frontend"

package/packages/omo-codex/plugin/skills/git-master/agents/openai.yaml

@@ -1,5 +1,5 @@
 interface:
-  display_name: "git-master (omo)"
+  display_name: "(OmO) git-master"
   short_description: "Atomic Git commits, history surgery, and source archaeology"
   search_terms:
     - "git-master"

package/packages/omo-codex/plugin/skills/init-deep/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) init-deep"

package/packages/omo-codex/plugin/skills/lcx-contribute-bug-fix/agents/openai.yaml

@@ -1,5 +1,5 @@
 interface:
-  display_name: "lcx-contribute-bug-fix (omo)"
+  display_name: "(OmO) lcx-contribute-bug-fix"
   short_description: "Contribute verified LazyCodex or Codex bug fixes"
   search_terms:
     - "lcx-contribute-bug-fix"

package/packages/omo-codex/plugin/skills/lcx-doctor/agents/openai.yaml

@@ -1,5 +1,5 @@
 interface:
-  display_name: "lcx-doctor (omo)"
+  display_name: "(OmO) lcx-doctor"
   short_description: "Diagnose LazyCodex/Codex install health against latest sources"
   search_terms:
     - "lcx-doctor"

package/packages/omo-codex/plugin/skills/lcx-report-bug/agents/openai.yaml

@@ -1,5 +1,5 @@
 interface:
-  display_name: "lcx-report-bug (omo)"
+  display_name: "(OmO) lcx-report-bug"
   short_description: "Route LazyCodex or Codex bugs with source evidence"
   search_terms:
     - "lcx-report-bug"

package/packages/omo-codex/plugin/skills/lsp/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) lsp"

package/packages/omo-codex/plugin/skills/lsp-setup/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) lsp-setup"

package/packages/omo-codex/plugin/skills/programming/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) programming"

package/packages/omo-codex/plugin/skills/refactor/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) refactor"

package/packages/omo-codex/plugin/skills/remove-ai-slops/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) remove-ai-slops"

package/packages/omo-codex/plugin/skills/review-work/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) review-work"

package/packages/omo-codex/plugin/skills/rules/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) rules"

package/packages/omo-codex/plugin/skills/start-work/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) start-work"

package/packages/omo-codex/plugin/skills/teammode/SKILL.md

@@ -0,0 +1,139 @@
+---
+name: teammode
+description: "Codex-only team orchestration: run a named team of cooperating Codex threads with durable, script-managed state. MUST USE when the user asks Codex to create, run, coordinate, inspect, archive, or delete a team of threads/sessions, or to work on something as a team in parallel. The main session is always the leader; members are defined by a concrete part, ownership area, or perspective - never a vague job role; a bundled cross-platform script writes the .omo/teams state plus an auto-generated member field manual. Use a team when the work is not perfectly isolated but parallelizing helps, or when a task still needs exploration under a clear goal; use plain subagents when scope is perfectly isolated or the goal is ambiguous. Triggers: team mode, teammode, make a team, run as a team, team of agents, coordinate threads, parallel Codex threads, archive the team, delete the team."
+---
+
+# Teammode
+
+Run a named team of cooperating Codex threads under one leader, with durable state on disk.
+This is a Codex-only workflow. It is inspired by the lifecycle concerns in the
+Yeachan-Heo/oh-my-codex team skill, but it does not copy that runtime model and never depends
+on an external terminal runner - it coordinates through Codex's own thread tools plus a bundled
+state script.
+
+## When to use a team (and when to use plain subagents instead)
+
+Use a TEAM when EITHER holds:
+- the work does NOT split into perfectly isolated pieces, but doing it in parallel is clearly
+  more convenient - members will need to see and react to each other's findings; or
+- one task still needs exploration, yet its GOAL is already clear - parallel investigation under
+  a fixed objective.
+
+Use plain subagents (`$ulw` / `multi_agent_v1.spawn_agent`) - NOT a team - when EITHER holds:
+- the work IS perfectly isolated, so there is no coordination cost worth paying; or
+- the GOAL is still ambiguous, where one mind should resolve direction before any fan-out.
+
+A team buys cross-member coordination at a real overhead cost; only spend it when coordination
+is the thing you actually need.
+
+## You are the leader
+
+The main session is ALWAYS the team leader. Do NOT create a separate leader thread - you
+orchestrate directly. Members are the threads you create; they report to you, and you own the
+final synthesis and any integration.
+
+## Compose by part, ownership, or perspective - not by job title
+
+A team is ALWAYS two or more members - never a single-member team. One worker on an isolated
+job is a subagent (`multi_agent_v1.spawn_agent`), not a team; if you end up with a single member,
+either split off a second distinct slice or drop the team and use a subagent.
+
+Compose the team from what you actually KNOW about the work. Ground the split in real knowledge
+of the problem, then divide it into clear, non-overlapping responsibilities - one per aspect of
+the work - and give each member exactly one. No two members may own the same thing. Define each
+member by a concrete slice: a specific part of the codebase, an ownership area, or a distinct
+perspective/lens. Assigning a vague role ("backend dev", "release analyst", "the tester") is an
+anti-pattern - it gives the member no real boundary and invites overlap. Each member's `focus`
+names what they own concretely; the `lens` is one of `area`, `ownership`, or `perspective`.
+
+## Run the script - never hand-write team state
+
+A bundled, dependency-free Node script owns all team state so you never author `team.json` or
+the member manual by hand. Run it with `node` (or `bun`); it works on macOS, Linux, and Windows.
+Replace `<skill-root>` with this skill's own directory.
+
+```
+node "<skill-root>/scripts/team.mjs" init        --name "<team>" --session-name "<session>" [--session <leader_session_id>] [--worktree] [--base-branch dev]
+node "<skill-root>/scripts/team.mjs" add-member  --team <session_id> --id A --focus "<part/ownership/perspective>" --lens area|ownership|perspective --deliverable "<...>" [--branch <branch>]
+node "<skill-root>/scripts/team.mjs" bind-thread  --team <session_id> --id A --thread <thread_id> [--cwd <path>]
+node "<skill-root>/scripts/team.mjs" member-prompt --team <session_id> --id A
+node "<skill-root>/scripts/team.mjs" set-status   --team <session_id> --id A --status reported|blocked|active|archived [--note "<...>"]
+node "<skill-root>/scripts/team.mjs" archive      --team <session_id> [--id A]
+node "<skill-root>/scripts/team.mjs" delete       --team <session_id> [--force]
+node "<skill-root>/scripts/team.mjs" status       --team <session_id>
+```
+
+`init` creates `.omo/teams/{session_id}/` containing `team.json` (the single durable state file:
+team id, the main-session leader, the member roster, status, worktree config, and a lifecycle
+log), `guide.md` (the auto-generated member field manual), and `artifacts/` (a shared exchange
+space). `{session_id}` is the leader's Codex session id when you can pass it via `--session`;
+otherwise the script generates a stable handle. Re-running `init` is a safe no-op. Every mutating
+subcommand rewrites `guide.md`, so the manual always matches the current team.
+
+## Create the team and its threads
+
+1. `init` the team, then `add-member` once per member.
+2. Create a durable thread per member with `codex_app.create_thread` - ALWAYS this tool for every
+   member, never a spawned agent - titled EXACTLY
+   `[team name] {session name}` (keep this convention strictly). If `codex_app.create_thread`
+   accepts a working directory / cwd argument, set it to that member's worktree; otherwise the
+   member's manual tells it to `cd` there first. Use `codex_app.set_thread_title` if the title
+   did not land at creation.
+3. `bind-thread` to record each thread id (and `--cwd`), then send that member's bootstrap
+   trigger (printed by `add-member` / `member-prompt`) as the thread's first message. The trigger
+   is short on purpose: it tells the new thread to READ its `guide.md` and `team.json` rather than
+   carrying the whole protocol inline.
+
+Every team member is a real Codex thread created with `codex_app.create_thread` - this is strict,
+not a preference. NEVER substitute `multi_agent_v1.spawn_agent`, or any other in-process subagent,
+for a team member: a spawned agent is an ephemeral helper that does not show up as a team thread,
+cannot carry the `[team name] {session name}` title, and cannot be inspected, titled, archived, or
+re-opened with the `codex_app.*` thread tools - which defeats the entire point of a durable team.
+A member only counts once you have `bind-thread`-ed it to a real `codex_app.create_thread` thread
+id. If the thread-creation tool is unavailable, STOP and say so (see Stop rules); do not quietly
+fall back to a spawned agent.
+
+## Communication
+
+Coordinate with `codex_app.send_message_to_thread` (leader-to-member and peer digests) and inspect
+status with `codex_app.read_thread`. The generated manual already binds members to the hard rules,
+so you mostly enforce them: all member-to-member and member-to-leader communication is in English;
+when the END user addresses a member, that member replies in the user's own language. Members
+over-communicate relentlessly - constant, small, lean updates that report every finding, hand-off,
+and even the smallest or most trivial step as it happens rather than one final dump - and send
+`WORKING:`/`BLOCKED:` markers so the leader always knows their state; stale, stuck, or
+silently-blocked members are not acceptable, and a finished
+member reports to the leader immediately. Members hand off files and
+memos through the team `artifacts/` directory and reference them by path instead of pasting large
+content. Wait for every required member's final report before you declare the team done.
+
+## Worktrees (optional isolation)
+
+When parallel members would edit overlapping files, enable isolation with `init --worktree`. Create
+one git worktree per member off the base branch, `bind-thread --cwd <worktree>` so each member's
+worktree is recorded in `team.json`, and rely on the manual to direct each member into its own
+worktree. Each member commits inside its worktree so you can integrate.
+
+## Archive, delete, and cleanup
+
+DISBAND the team the moment it is no longer needed. A team exists only to do its work; once that
+work is done, or the user no longer wants it, do not leave it lying around - archive every member,
+then delete the team state. A finished team that is never disbanded is a leak.
+
+- `archive` closes the team: notify each active member, copy anything useful into `artifacts/`,
+  archive each member thread with `codex_app.set_thread_archived`, then `archive` flips the team
+  and all members to archived. If a thread-archive tool is unavailable, record that in the team log
+  and tell the user - never pretend a member was archived.
+- `delete` removes `.omo/teams/{session_id}` and refuses while the team is unarchived or any member
+  is still active unless `--force`.
+- When the work wraps up, integrate each member's worktree the way the user asked - merge directly,
+  or open a fresh PR and merge it - then archive and delete. Cleanup is real work; respect the
+  user's instruction on how to land it.
+
+## Stop rules
+
+- Stop and ask before deleting an unarchived team while any member is still active.
+- Member communication stays English unless the user explicitly requests otherwise; user-facing
+  replies follow the user's language.
+- Stop if the requested operation needs Codex thread tools (create/read/send/title/archive) and
+  they are unavailable; say so instead of faking it.

package/packages/omo-codex/plugin/skills/teammode/agents/openai.yaml

@@ -0,0 +1,2 @@
+interface:
+  display_name: "(OmO) teammode"

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

@@ -0,0 +1,111 @@
+// team-guide.mjs - render the member-facing field manual (guide.md) and the short
+// bootstrap trigger a new thread reads on startup. Pure string builders, no I/O.
+//
+// The manual is the durable, two-channel replacement for per-prompt guidance: the leader
+// writes it once at team creation, and every member thread is told to READ it instead of
+// receiving the rules inline each turn.
+
+function memberLine(member) {
+	const thread = member.threadId ? ` | thread ${member.threadId}` : " | thread not created yet";
+	const wt = member.worktree?.path ? ` | worktree ${member.worktree.path}` : "";
+	return `- **${member.id}** (${member.lens}) - ${member.focus}${member.deliverable ? ` -> ${member.deliverable}` : ""}${thread}${wt} [${member.status}]`;
+}
+
+function worktreeSection(team) {
+	if (!team.worktree?.enabled) {
+		return `## Worktrees
+
+This team does not use isolated git worktrees. Work in the shared repository checkout
+the leader is running from. If your changes would collide with another member's files,
+that is a coordination signal: mark yourself \`blocked\` and tell the leader at once.`;
+	}
+	const lines = team.members
+		.filter((m) => m.worktree?.path || m.worktree?.branch)
+		.map((m) => `- **${m.id}**: worktree \`${m.worktree.path ?? "(assign with bind-thread --cwd)"}\` on branch \`${m.worktree.branch ?? team.worktree.baseBranch}\``);
+	return `## Worktrees (ISOLATION IS ON - this is not optional for you)
+
+This team runs each member in its own git worktree branched off \`${team.worktree.baseBranch}\`.
+**You MUST work only inside your own worktree.** The very first thing you do is \`cd\` into it;
+every edit, command, and commit happens there. Never touch another member's worktree, and
+never edit files outside your assigned scope. Commit your work so the leader can integrate it.
+
+${lines.length ? lines.join("\n") : "- (worktree paths are assigned as threads are bound; read team.json for yours)"}`;
+}
+
+export function buildGuide(team) {
+	const artifacts = team.paths?.artifacts ?? ".omo/teams/<session_id>/artifacts";
+	const teamJson = team.paths?.team ?? ".omo/teams/<session_id>/team.json";
+	const roster = team.members.length ? team.members.map(memberLine).join("\n") : "- (no members yet)";
+	return `# Team ${team.teamName} - Member Field Manual
+
+> Auto-generated by the teammode script. This file is the single source of truth for how
+> this team works. Re-read it whenever you are unsure - do not improvise the protocol.
+
+- Team: **${team.teamName}** (id \`${team.teamId}\`)
+- Team state: \`${teamJson}\`
+- Thread/session title convention (use it EXACTLY): \`${team.threadTitleConvention}\`
+
+## Who you are (your identity is fixed)
+
+**You are a member of team ${team.teamName}, not a generic assistant.** You own exactly one
+slice of this team's work - the focus and deliverable assigned to your id below - and you are
+accountable for it end to end. Read your row, internalize it, and act as that owner for the
+whole session. Do not drift into other members' scope.
+
+${roster}
+
+## Leader
+
+**The main session is the leader. There is no other leader, and you are not it.** You report
+to the leader, take direction from the leader, and send your results to the leader. Peers
+coordinate with each other, but the leader owns the final decision and integration.
+
+## Communication rules (hard rules)
+
+- **All communication between team members, and from you to the leader, is in English.** This
+  is mandatory regardless of the language the task was given in.
+- **Exception: when the END USER addresses you directly, reply in the user's own language.**
+  Team-internal traffic stays English; user-facing replies match the user.
+- **Report to the leader the moment your work is complete.** A finished task that was never
+  reported does not count as done.
+- **Over-communicate relentlessly - report even the trivial.** Message constantly and
+  proactively: every finding, decision, hand-off, and even the smallest or most trivial step, the
+  moment it happens, in short lean notes. Never save it up for one final report. When in doubt,
+  send the message - far more and far smaller updates always beats going quiet. The instant
+  anything changes a peer's assumption, push it to them. Too many messages is correct here; the
+  only failure is going quiet.
+- **Stale, stuck, and silently-blocked states are NOT acceptable.** During long work send
+  \`WORKING: <your focus> - <phase>\` so the leader can see you are alive. If you truly cannot
+  proceed, send \`BLOCKED: <reason>\` immediately and propose the smallest unblock - never sit
+  idle and never disappear. Being quiet is a failure, not a pause.
+
+## Artifacts (how you hand work off)
+
+Exchange files and memos through the team artifacts directory:
+
+\`${artifacts}\`
+
+Drop deliverables, notes, diffs, and findings there as files, and reference them by path in
+your messages instead of pasting large content into a thread. Treat it as the team's shared
+desk: if a peer or the leader needs something from you, leave it in artifacts and point them to it.
+
+${worktreeSection(team)}
+
+## Done means reported and verified
+
+Your slice is done only when (1) the deliverable exists, (2) you have evidence it works, and
+(3) you have reported it to the leader. Until all three are true, keep going.`;
+}
+
+export function buildMemberPrompt(team, id) {
+	const member = team.members.find((m) => m.id === id);
+	if (!member) throw new Error(`no member with id "${id}"`);
+	const guide = team.paths?.guide ?? ".omo/teams/<session_id>/guide.md";
+	const teamJson = team.paths?.team ?? ".omo/teams/<session_id>/team.json";
+	const where = member.cwd ? `Work inside \`${member.cwd}\`.` : "Work from the repository root unless your manual assigns a worktree.";
+	return `You are member ${member.id} of team ${team.teamName} - owner of: ${member.focus}.
+FIRST read your field manual at \`${guide}\`, then the team state at \`${teamJson}\`; they define your scope, deliverable, the leader, the artifacts directory, and the communication rules.
+${where}
+Communicate with the team and leader in English; reply to the end user in the user's own language.
+Start now, send WORKING/BLOCKED updates so you never look stale, and report to the leader the moment you are done.`;
+}