oh-my-opencode 4.14.0 → 4.14.1

package/packages/omo-codex/plugin/components/lsp/dist/daemon-cli-path.js

@@ -0,0 +1,56 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const requireFromHere = createRequire(import.meta.url);
+const PACKAGE_LSP_DAEMON_CLI = "@code-yeongyu/lsp-daemon/dist/cli.js";
+const CODEX_LSP_DAEMON_CLI_ENV = "CODEX_LSP_DAEMON_CLI";
+const CODEX_LSP_DAEMON_VERSION_ENV = "CODEX_LSP_DAEMON_VERSION";
+export function ensureLspDaemonCliEnv(env = process.env) {
+    const configuredCli = env[CODEX_LSP_DAEMON_CLI_ENV]?.trim();
+    const resolution = configuredCli ? resolveConfiguredLspDaemonCli(configuredCli) : resolveLspDaemonCli();
+    if (!configuredCli)
+        env[CODEX_LSP_DAEMON_CLI_ENV] = resolution.cliPath;
+    if (!env[CODEX_LSP_DAEMON_VERSION_ENV]?.trim() && resolution.version !== null) {
+        env[CODEX_LSP_DAEMON_VERSION_ENV] = resolution.version;
+    }
+}
+export function resolveLspDaemonCliPath() {
+    return resolveLspDaemonCli().cliPath;
+}
+function resolveLspDaemonCli() {
+    const packageCli = resolvePackageLspDaemonCliPath();
+    if (packageCli !== null)
+        return resolveConfiguredLspDaemonCli(packageCli);
+    const bundledCli = fileURLToPath(new URL("../../lsp-daemon/dist/cli.js", import.meta.url));
+    if (existsSync(bundledCli))
+        return resolveConfiguredLspDaemonCli(bundledCli);
+    return resolveConfiguredLspDaemonCli(bundledCli);
+}
+function resolvePackageLspDaemonCliPath() {
+    try {
+        return requireFromHere.resolve(PACKAGE_LSP_DAEMON_CLI);
+    }
+    catch {
+        return null;
+    }
+}
+function resolveConfiguredLspDaemonCli(cliPath) {
+    return {
+        cliPath,
+        version: readDaemonPackageVersion(cliPath),
+    };
+}
+function readDaemonPackageVersion(cliPath) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(dirname(cliPath), "package.json"), "utf8"));
+        if (isRecord(parsed) && typeof parsed["version"] === "string" && parsed["version"].length > 0) {
+            return parsed["version"];
+        }
+    }
+    catch { }
+    return null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-lsp",
-	"version": "4.14.0",
+	"version": "4.14.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/lsp/src/cli.ts

@@ -1,12 +1,9 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
-import { createRequire } from "node:module";
 import { argv, execPath, stderr } from "node:process";
 
 import { runPostCompactHookCli, runPostToolUseHookCli } from "./codex-hook-cli.js";
-
-const require = createRequire(import.meta.url);
-const PACKAGE_LSP_MCP_CLI = "@code-yeongyu/lsp-daemon/dist/cli.js";
+import { resolveLspDaemonCliPath } from "./daemon-cli-path.js";
 
 async function main(): Promise<void> {
 	const [command = "mcp", subcommand = ""] = argv.slice(2);
@@ -35,7 +32,7 @@ main().catch((error: unknown) => {
 });
 
 async function runPackageLspMcpCli(): Promise<void> {
-	const cliPath = require.resolve(PACKAGE_LSP_MCP_CLI);
+	const cliPath = resolveLspDaemonCliPath();
 	const child = spawn(execPath, [cliPath, "mcp"], { stdio: "inherit" });
 	await new Promise<void>((resolve, reject) => {
 		child.once("error", reject);

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

@@ -2,6 +2,7 @@ import { readFileSync } from "node:fs";
 
 import { callDiagnosticsViaDaemon, currentRequestContext } from "@code-yeongyu/lsp-daemon";
 
+import { ensureLspDaemonCliEnv } from "./daemon-cli-path.js";
 import {
 	isLspDaemonUnreachableDiagnostics,
 	isUnavailableLspDiagnostics,
@@ -60,6 +61,7 @@ const CONTEXT_PRESSURE_MARKERS = [
 ] as const;
 
 export async function runLspDiagnosticsText(filePath: string): Promise<string> {
+	ensureLspDaemonCliEnv();
 	const result = await callDiagnosticsViaDaemon(filePath, { context: currentRequestContext() });
 	return result.content.map((block) => block.text).join("\n");
 }

package/packages/omo-codex/plugin/components/lsp/src/daemon-cli-path.ts

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const requireFromHere = createRequire(import.meta.url);
+
+const PACKAGE_LSP_DAEMON_CLI = "@code-yeongyu/lsp-daemon/dist/cli.js";
+const CODEX_LSP_DAEMON_CLI_ENV = "CODEX_LSP_DAEMON_CLI";
+const CODEX_LSP_DAEMON_VERSION_ENV = "CODEX_LSP_DAEMON_VERSION";
+
+interface LspDaemonCliResolution {
+	cliPath: string;
+	version: string | null;
+}
+
+export function ensureLspDaemonCliEnv(env: NodeJS.ProcessEnv = process.env): void {
+	const configuredCli = env[CODEX_LSP_DAEMON_CLI_ENV]?.trim();
+	const resolution = configuredCli ? resolveConfiguredLspDaemonCli(configuredCli) : resolveLspDaemonCli();
+	if (!configuredCli) env[CODEX_LSP_DAEMON_CLI_ENV] = resolution.cliPath;
+	if (!env[CODEX_LSP_DAEMON_VERSION_ENV]?.trim() && resolution.version !== null) {
+		env[CODEX_LSP_DAEMON_VERSION_ENV] = resolution.version;
+	}
+}
+
+export function resolveLspDaemonCliPath(): string {
+	return resolveLspDaemonCli().cliPath;
+}
+
+function resolveLspDaemonCli(): LspDaemonCliResolution {
+	const packageCli = resolvePackageLspDaemonCliPath();
+	if (packageCli !== null) return resolveConfiguredLspDaemonCli(packageCli);
+	const bundledCli = fileURLToPath(new URL("../../lsp-daemon/dist/cli.js", import.meta.url));
+	if (existsSync(bundledCli)) return resolveConfiguredLspDaemonCli(bundledCli);
+	return resolveConfiguredLspDaemonCli(bundledCli);
+}
+
+function resolvePackageLspDaemonCliPath(): string | null {
+	try {
+		return requireFromHere.resolve(PACKAGE_LSP_DAEMON_CLI);
+	} catch {
+		return null;
+	}
+}
+
+function resolveConfiguredLspDaemonCli(cliPath: string): LspDaemonCliResolution {
+	return {
+		cliPath,
+		version: readDaemonPackageVersion(cliPath),
+	};
+}
+
+function readDaemonPackageVersion(cliPath: string): string | null {
+	try {
+		const parsed: unknown = JSON.parse(readFileSync(join(dirname(cliPath), "package.json"), "utf8"));
+		if (isRecord(parsed) && typeof parsed["version"] === "string" && parsed["version"].length > 0) {
+			return parsed["version"];
+		}
+	} catch {}
+	return 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/lsp/test/package-smoke.test.ts

@@ -15,6 +15,7 @@ describe("plugin package metadata", () => {
 		const hooksJson = readHooksJson("hooks/hooks.json");
 		const mcpJson = readMcpJson(".mcp.json");
 		const cliSource = readTextFile("src/cli.ts");
+		const daemonCliPathSource = readTextFile("src/daemon-cli-path.ts");
 		const codexHookCliSource = readTextFile("src/codex-hook-cli.ts");
 		const codexHookSource = readTextFile("src/codex-hook.ts");
 		const sourceFiles = listDirectoryEntries("src");
@@ -43,8 +44,12 @@ describe("plugin package metadata", () => {
 		expect(lspServer?.command).toBe("node");
 		expect(lspServer?.args).toEqual(["../../../../lsp-daemon/dist/cli.js", "mcp"]);
 		expect(cliSource).not.toContain("./lazy-lsp-mcp.js");
-		expect(cliSource).toContain("@code-yeongyu/lsp-daemon/dist/cli.js");
+		expect(cliSource).toContain("resolveLspDaemonCliPath");
+		expect(daemonCliPathSource).toContain("@code-yeongyu/lsp-daemon/dist/cli.js");
+		expect(daemonCliPathSource).toContain("../../lsp-daemon/dist/cli.js");
+		expect(daemonCliPathSource).toContain("CODEX_LSP_DAEMON_VERSION");
 		expect(cliSource).not.toContain("../../../../../lsp-daemon/dist/cli.js");
+		expect(codexHookSource).toContain("ensureLspDaemonCliEnv");
 		expect(codexHookCliSource).toContain("@code-yeongyu/lsp-daemon");
 		expect(codexHookSource).toContain("@code-yeongyu/lsp-daemon");
 		expect(codexHookCliSource).not.toContain("../../../../../lsp-daemon");

package/packages/omo-codex/plugin/components/rules/dist/cli.js

@@ -3927,7 +3927,7 @@ function createRulesEngine(options, config = configFromEnvironment(options.env))
 }
 
 // components/rules/src/static-injection.ts
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync4 } from "node:fs";
 
 // components/rules/src/post-compact-directive.ts
 var DIRECTIVE_HEADER = [
@@ -3965,96 +3965,6 @@ function buildPostCompactReadDirective(rulePaths, maxChars) {
 `)}${DIRECTIVE_FOOTER}`;
 }
 
-// components/rules/src/sparkshell-awareness.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { join as join7 } from "node:path";
-var SPARKSHELL_AWARENESS_MARKER = "## Sparkshell Runtime";
-var SPARKSHELL_AWARENESS_DEDUP_KEY = "__omo_sparkshell_awareness__";
-function isCodexAppServerActive(env = process.env) {
-  const originator = env["CODEX_INTERNAL_ORIGINATOR_OVERRIDE"]?.toLowerCase() ?? "";
-  const bundleIdentifier = env["__CFBundleIdentifier"]?.toLowerCase() ?? "";
-  const shellActive = isTruthy2(env["CODEX_SHELL"]);
-  return shellActive && (originator.includes("codex desktop") || originator.includes("codex app") || bundleIdentifier === "com.openai.codex");
-}
-function isSparkShellAppServerConfigured(env = process.env) {
-  const codexSocketPath = env["CODEX_APP_SERVER_SOCKET"]?.trim() ?? "";
-  const omoSocketPath = env["OMO_SPARKSHELL_APP_SERVER_SOCKET"]?.trim() ?? "";
-  return codexSocketPath.length > 0 || omoSocketPath.length > 0;
-}
-function resolveOmoInvocation(env = process.env, deps = {}) {
-  const fileExists = deps.fileExists ?? existsSync4;
-  const platform = deps.platform ?? process.platform;
-  const binNames = platform === "win32" ? ["omo.cmd", "omo.exe", "omo"] : ["omo"];
-  const pathDelimiter = platform === "win32" ? ";" : ":";
-  const pathEntries = (env["PATH"] ?? "").split(pathDelimiter).filter((entry) => entry.trim().length > 0);
-  for (const pathEntry of pathEntries) {
-    for (const binName of binNames) {
-      if (fileExists(join7(pathEntry, binName)))
-        return "omo";
-    }
-  }
-  for (const candidateDir of omoCandidateBinDirs(env)) {
-    for (const binName of binNames) {
-      const candidate = join7(candidateDir, binName);
-      if (fileExists(candidate))
-        return candidate;
-    }
-  }
-  return null;
-}
-function omoCandidateBinDirs(env) {
-  const dirs = [];
-  const localBinDir = env["CODEX_LOCAL_BIN_DIR"]?.trim() ?? "";
-  if (localBinDir.length > 0)
-    dirs.push(localBinDir);
-  const home = env["HOME"]?.trim() || env["USERPROFILE"]?.trim() || "";
-  const codexHome = env["CODEX_HOME"]?.trim() || (home.length > 0 ? join7(home, ".codex") : "");
-  if (codexHome.length > 0)
-    dirs.push(join7(codexHome, "bin"));
-  if (home.length > 0)
-    dirs.push(join7(home, ".local", "bin"));
-  return dirs;
-}
-function getSparkShellRuntimeAwareness(env = process.env, deps = {}) {
-  const override = env["OMO_SPARKSHELL_AWARENESS"] ?? env["LAZYCODEX_SPARKSHELL_AWARENESS"];
-  if (isFalsy(override)) {
-    return "";
-  }
-  if (!isTruthy2(override) && !isCodexAppServerActive(env) && !isSparkShellAppServerConfigured(env)) {
-    return "";
-  }
-  const resolved = resolveOmoInvocation(env, deps);
-  const invocation = resolved ?? (isTruthy2(override) ? "omo" : null);
-  if (invocation === null) {
-    return "";
-  }
-  const command = /\s/.test(invocation) ? `"${invocation}"` : invocation;
-  return [
-    SPARKSHELL_AWARENESS_MARKER,
-    "",
-    `- Use \`${command} sparkshell <command> [args...]\` first for repo inspection, CLI smoke tests, git/history checks, and bounded command output. Pass ordinary commands as executable and arguments in separate argv tokens, for example \`${command} sparkshell rg --files\`; not \`${command} sparkshell 'rg --files'\`, because the quoted string is treated as one executable name. Raw \`rg\`/\`grep\`/\`cat\`/\`git\` are fallbacks when Sparkshell is unavailable or too narrow for the task.`,
-    `- Use \`${command} sparkshell --shell '<command>'\` only for shell syntax such as metacharacters, pipelines, redirects, command substitution, or variable expansion.`,
-    `- Use \`${command} sparkshell --tmux-pane <pane-id> --tail-lines 400\` only to inspect an existing pane, never to launch ordinary commands. Tail lines must stay between 100 and 1000.`,
-    "- When no native sidecar or appserver is available, Sparkshell silently falls back to raw command execution. `OMO_SPARKSHELL_BIN` selects a native sidecar path.",
-    "- When `CODEX_THREAD_ID` identifies a Codex session, Sparkshell feeds recent session context (first/latest user request + last 5 conversation messages) into oversized-output condensation for relevance ranking, but never appends that context to command output. `OMO_SPARKSHELL_SESSION_CONTEXT=0` disables the lookup.",
-    `- Route potentially huge output (full log files, big diffs, \`cat\`/\`grep\` over large artifacts) through \`${command} sparkshell\` instead of reading it raw: oversized output is condensed to a budget while preserving error signatures, repeated patterns, session-goal-relevant lines, and head/tail. Tune with \`--budget <chars>\`; disable with \`OMO_SPARKSHELL_CONDENSE=0\`.`,
-    "- Oversized output is first summarized by the spark model (`codex exec`, default `gpt-5.3-codex-spark`) fed with the shell output plus session context: the summary keeps selected output as-is (no masking) and ends with a `[sparkshell caption]` line describing what ran, what the full output contained, and which lines were omitted. `OMO_SPARKSHELL_SPARK=0` skips the model and uses deterministic condensation directly."
-  ].join(`
-`);
-}
-function isTruthy2(value) {
-  if (value === undefined) {
-    return false;
-  }
-  return ["1", "true", "yes", "on"].includes(value.trim().toLowerCase());
-}
-function isFalsy(value) {
-  if (value === undefined) {
-    return false;
-  }
-  return ["0", "false", "no", "off"].includes(value.trim().toLowerCase());
-}
-
 // components/rules/src/transcript-rule-filter.ts
 function filterRulesAlreadyInTranscript(rules, transcriptPath, markInjected, options = {}) {
   if (rules.length === 0 || transcriptPath === null) {
@@ -4131,8 +4041,7 @@ function runStaticInjection(cwd, transcriptPath, eventName, cachePath, options,
   const rules = filterRulesAlreadyInTranscript(loaded.rules.filter((rule) => !engine.isStaticInjected(rule)), transcriptPath, (rule) => {
     engine.markStaticInjected(rule);
   }, transcriptSearchOptions);
-  const sparkshellAwareness = engine.state.staticDedup.has(SPARKSHELL_AWARENESS_DEDUP_KEY) ? "" : getSparkShellRuntimeAwareness(options.env);
-  if (rules.length === 0 && sparkshellAwareness.length === 0) {
+  if (rules.length === 0) {
     persistEngineState(engine, cachePath);
     return "";
   }
@@ -4140,11 +4049,8 @@ function runStaticInjection(cwd, transcriptPath, eventName, cachePath, options,
   for (const rule of rules) {
     engine.markStaticInjected(rule);
   }
-  if (sparkshellAwareness.length > 0) {
-    engine.state.staticDedup.add(SPARKSHELL_AWARENESS_DEDUP_KEY);
-  }
   persistEngineState(engine, cachePath);
-  return formatAdditionalContextOutput(eventName, combineStaticContext(block, sparkshellAwareness));
+  return formatAdditionalContextOutput(eventName, block);
 }
 function runPostCompactRecovery(input) {
   const effectiveConfig = withPostCompactBudget(input.config, {
@@ -4160,8 +4066,7 @@ function runPostCompactRecovery(input) {
     engine.markStaticInjected(rule);
   });
   const dynamicRulePaths = recoverDynamicRulePaths(engine, transcriptText, loaded.rules);
-  const sparkshellAwareness = engine.state.staticDedup.has(SPARKSHELL_AWARENESS_DEDUP_KEY) ? "" : getSparkShellRuntimeAwareness(input.options.env);
-  if (missingRules.length === 0 && dynamicRulePaths.length === 0 && sparkshellAwareness.length === 0) {
+  if (missingRules.length === 0 && dynamicRulePaths.length === 0) {
     persistEngineState(engine, input.cachePath, input.channel);
     return "";
   }
@@ -4172,11 +4077,8 @@ function runPostCompactRecovery(input) {
   for (const rule of missingRules) {
     engine.markStaticInjected(rule);
   }
-  if (sparkshellAwareness.length > 0) {
-    engine.state.staticDedup.add(SPARKSHELL_AWARENESS_DEDUP_KEY);
-  }
   persistEngineState(engine, input.cachePath, input.channel);
-  return formatAdditionalContextOutput(input.eventName, combineStaticContext(bodyBlock, directive, sparkshellAwareness));
+  return formatAdditionalContextOutput(input.eventName, combineStaticContext(bodyBlock, directive));
 }
 function readRecoveryTranscriptText(transcriptPath) {
   if (transcriptPath === null) {
@@ -4200,7 +4102,7 @@ function recoverDynamicRulePaths(engine, transcriptText, staticRules) {
       if (transcriptText !== null && transcriptText.includes(rulePath)) {
         continue;
       }
-      if (!existsSync5(rulePath)) {
+      if (!existsSync4(rulePath)) {
         continue;
       }
       recoveredPaths.add(rulePath);
@@ -4218,7 +4120,7 @@ function combineStaticContext(...blocks) {
 }
 
 // components/rules/src/tool-paths.ts
-import { existsSync as existsSync6, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync5, statSync as statSync6 } from "node:fs";
 import { isAbsolute as isAbsolute4, resolve as resolve10 } from "node:path";
 var COMMAND_TOOL_NAMES = new Set(["bash", "shell_command", "exec_command"]);
 var TRACKED_TOOL_NAMES = new Set([
@@ -4329,7 +4231,7 @@ function resolvePath(cwd, filePath) {
 }
 function isExistingFile(filePath) {
   try {
-    return existsSync6(filePath) && statSync6(filePath).isFile();
+    return existsSync5(filePath) && statSync6(filePath).isFile();
   } catch {
     return false;
   }

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-rules",
-	"version": "4.14.0",
+	"version": "4.14.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/rules/src/static-injection.ts

@@ -11,7 +11,6 @@ import type { Engine } from "@oh-my-opencode/rules-engine/engine";
 import { isNeverTruncatedRule } from "@oh-my-opencode/rules-engine/engine";
 import type { LoadedRule, PiRulesConfig } from "@oh-my-opencode/rules-engine/engine";
 import { createRulesEngine } from "./rules-engine-factory.js";
-import { getSparkShellRuntimeAwareness, SPARKSHELL_AWARENESS_DEDUP_KEY } from "./sparkshell-awareness.js";
 import { filterRulesAlreadyInTranscript, filterRulesNotInTranscriptText } from "./transcript-rule-filter.js";
 import type { TranscriptSearchOptions } from "./transcript-search.js";
 import { readTranscriptSearchText } from "./transcript-search.js";
@@ -61,10 +60,7 @@ export function runStaticInjection(
 		},
 		transcriptSearchOptions,
 	);
-	const sparkshellAwareness = engine.state.staticDedup.has(SPARKSHELL_AWARENESS_DEDUP_KEY)
-		? ""
-		: getSparkShellRuntimeAwareness(options.env);
-	if (rules.length === 0 && sparkshellAwareness.length === 0) {
+	if (rules.length === 0) {
 		persistEngineState(engine, cachePath);
 		return "";
 	}
@@ -73,11 +69,8 @@ export function runStaticInjection(
 	for (const rule of rules) {
 		engine.markStaticInjected(rule);
 	}
-	if (sparkshellAwareness.length > 0) {
-		engine.state.staticDedup.add(SPARKSHELL_AWARENESS_DEDUP_KEY);
-	}
 	persistEngineState(engine, cachePath);
-	return formatAdditionalContextOutput(eventName, combineStaticContext(block, sparkshellAwareness));
+	return formatAdditionalContextOutput(eventName, block);
 }
 
 interface PostCompactRecoveryInput {
@@ -110,11 +103,8 @@ function runPostCompactRecovery(input: PostCompactRecoveryInput): string {
 		},
 	);
 	const dynamicRulePaths = recoverDynamicRulePaths(engine, transcriptText, loaded.rules);
-	const sparkshellAwareness = engine.state.staticDedup.has(SPARKSHELL_AWARENESS_DEDUP_KEY)
-		? ""
-		: getSparkShellRuntimeAwareness(input.options.env);
 
-	if (missingRules.length === 0 && dynamicRulePaths.length === 0 && sparkshellAwareness.length === 0) {
+	if (missingRules.length === 0 && dynamicRulePaths.length === 0) {
 		persistEngineState(engine, input.cachePath, input.channel);
 		return "";
 	}
@@ -129,13 +119,10 @@ function runPostCompactRecovery(input: PostCompactRecoveryInput): string {
 	for (const rule of missingRules) {
 		engine.markStaticInjected(rule);
 	}
-	if (sparkshellAwareness.length > 0) {
-		engine.state.staticDedup.add(SPARKSHELL_AWARENESS_DEDUP_KEY);
-	}
 	persistEngineState(engine, input.cachePath, input.channel);
 	return formatAdditionalContextOutput(
 		input.eventName,
-		combineStaticContext(bodyBlock, directive, sparkshellAwareness),
+		combineStaticContext(bodyBlock, directive),
 	);
 }
 

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

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/codex-start-work-continuation",
-	"version": "4.14.0",
+	"version": "4.14.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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sisyphuslabs/codex-teammode",
-	"version": "4.14.0",
+	"version": "4.14.1",
 	"description": "Codex team-mode hook component that keeps background thread titles descriptive after create_thread.",
 	"type": "module",
 	"private": true,

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

@@ -68,7 +68,7 @@ node "<skill-root>/scripts/team.mjs" set-status   --team <session_id> --id A --s
 node "<skill-root>/scripts/team.mjs" worktree-add    --team <session_id> --id A [--base-branch <branch>]
 node "<skill-root>/scripts/team.mjs" worktree-remove --team <session_id> --id A [--force]
 node "<skill-root>/scripts/team.mjs" integrate       --team <session_id> [--id A]
-node "<skill-root>/scripts/team.mjs" archive      --team <session_id> [--id A]
+node "<skill-root>/scripts/team.mjs" archive      --team <session_id> [--id A] [--note "<...>"]
 node "<skill-root>/scripts/team.mjs" delete       --team <session_id> [--force]
 node "<skill-root>/scripts/team.mjs" status       --team <session_id>
 ```
@@ -80,6 +80,13 @@ space). `{session_id}` is the leader's Codex session id when you can pass it via
 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.
 
+Mutating subcommands take a per-team state lock before reading and rewriting `team.json`. It is
+safe to run independent `add-member`, `bind-thread`, `set-status`, `archive`, `delete`, `guide`,
+and worktree mutation commands concurrently against the same team: they serialize and each command
+reads the latest committed state before writing. If a command reports that team state is locked,
+do not treat the intended mutation as complete; retry after the named command finishes, or inspect
+`.omo/teams/{session_id}/.team.lock/owner.json` if the previous command crashed.
+
 ## Create the team and its threads
 
 1. `init` the team, then `add-member` once per member.
@@ -183,12 +190,17 @@ result against that todo's acceptance criteria before you integrate.
 
 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.
+then delete the team state only after archival evidence is clean or preserved. 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.
+  then try to archive each member thread with `codex_app.set_thread_archived`. Treat Codex App
+  failures such as "Ambiguous Codex thread id" or a thread id that is ambiguous across hosts as an
+  app-thread archival blocker, not as a team-state blocker: record the failure in the team log,
+  tell the user which member thread was not proven archived, and continue the team-state archive
+  with `archive --note "<blocker>"`. Never pretend a member thread was archived. Do not delete the
+  team state after an app-thread archival blocker unless the evidence has been copied elsewhere or
+  the user explicitly accepts that evidence loss.
 - `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, land it the way the user asked: `integrate --team <id>` for a direct merge

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

@@ -9,8 +9,9 @@
 // this file stays the state concern only.
 
 import { randomUUID } from "node:crypto";
-import { lstat, mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
 
 export const LENSES = ["area", "ownership", "perspective"];
 export const MEMBER_STATUSES = ["pending", "active", "reported", "blocked", "archived"];
@@ -24,6 +25,8 @@ export function isUnderstaffed(team) {
 // A team dir is a single child of .omo/teams. This pattern alone blocks "/", "\", and a
 // leading "." so ".." and "a/b" can never name a team dir (the escape guard).
 const SESSION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const LOCK_TIMEOUT_MS = Number.parseInt(process.env.OMO_TEAMMODE_LOCK_TIMEOUT_MS ?? "10000", 10);
+const LOCK_RETRY_MS = Number.parseInt(process.env.OMO_TEAMMODE_LOCK_RETRY_MS ?? "25", 10);
 
 function isoNow(now) {
 	return now ?? new Date().toISOString();
@@ -233,6 +236,65 @@ async function lstatOrNull(p) {
 	});
 }
 
+function positiveIntegerOrFallback(value, fallback) {
+	return Number.isInteger(value) && value > 0 ? value : fallback;
+}
+
+async function readLockOwner(lockDir) {
+	return readFile(join(lockDir, "owner.json"), "utf8")
+		.then((content) => JSON.parse(content))
+		.catch(() => null);
+}
+
+async function describeLockOwner(lockDir) {
+	const owner = await readLockOwner(lockDir);
+	if (!owner || typeof owner !== "object") return "another team.mjs command";
+	const parts = [];
+	if (owner.command) parts.push(String(owner.command));
+	if (owner.pid) parts.push(`pid ${owner.pid}`);
+	if (owner.createdAt) parts.push(`since ${owner.createdAt}`);
+	return parts.length > 0 ? parts.join(", ") : "another team.mjs command";
+}
+
+export async function withTeamLock(dir, command, fn, options = {}) {
+	const timeoutMs = positiveIntegerOrFallback(options.timeoutMs ?? LOCK_TIMEOUT_MS, 10000);
+	const retryMs = positiveIntegerOrFallback(options.retryMs ?? LOCK_RETRY_MS, 25);
+	const lockDir = join(dir, ".team.lock");
+	const deadline = Date.now() + timeoutMs;
+	let acquired = false;
+	for (;;) {
+		try {
+			await mkdir(lockDir, { mode: 0o700 });
+			acquired = true;
+			await writeFile(
+				join(lockDir, "owner.json"),
+				`${JSON.stringify({ pid: process.pid, command, createdAt: new Date().toISOString() }, null, 2)}\n`,
+				{ encoding: "utf8", flag: "wx" },
+			);
+			break;
+		} catch (error) {
+			if (acquired) {
+				await rm(lockDir, { recursive: true, force: true });
+				throw error;
+			}
+			if (!error || error.code !== "EEXIST") throw error;
+			const st = await lstatOrNull(lockDir);
+			if (st?.isSymbolicLink()) throw new Error(`refused: team lock path is a symlink: ${lockDir}`);
+			if (st && !st.isDirectory()) throw new Error(`refused: team lock path is not a directory: ${lockDir}`);
+			if (Date.now() >= deadline) {
+				const owner = await describeLockOwner(lockDir);
+				throw new Error(`team state is locked by ${owner}; retry after that command completes`);
+			}
+			await delay(Math.min(retryMs, Math.max(1, deadline - Date.now())));
+		}
+	}
+	try {
+		return await fn();
+	} finally {
+		await rm(lockDir, { recursive: true, force: true });
+	}
+}
+
 // Create a directory chain refusing any symlinked component, so team state can never be
 // written through a symlink that escapes the workspace.
 async function mkdirNoSymlink(dir, stopAt) {