oh-my-opencode 4.18.2 → 4.19.1

package/packages/omo-codex/plugin/scripts/migrate-codex-config/toml-section-editor.mjs

@@ -0,0 +1,455 @@
+export function findTomlSection(config, headerLine) {
+	const targetHeaderPath = parseTomlTableHeader(headerLine);
+	const lines = config.match(/[^\n]*\n?|$/g) ?? [];
+	let offset = 0;
+	let start = -1;
+	let multilineQuote = null;
+	for (const line of lines) {
+		if (line.length === 0) break;
+		const multilineScan = scanTomlMultilineLine(line, multilineQuote);
+		multilineQuote = multilineScan.nextQuote;
+		if (multilineScan.wasInside) {
+			offset += line.length;
+			continue;
+		}
+		if (start === -1) {
+			if (tomlTableHeaderMatches(line, targetHeaderPath)) start = offset;
+		} else if (isTomlTableHeaderLine(line)) {
+			return { start, end: offset, text: config.slice(start, offset) };
+		}
+		offset += line.length;
+	}
+	if (start === -1) return null;
+	return { start, end: config.length, text: config.slice(start) };
+}
+
+export function hasTomlSetting(config, keyPath) {
+	const targetPath = parseTomlDottedKey(keyPath);
+	if (!targetPath) return false;
+
+	let tablePath = [];
+	let multilineQuote = null;
+	for (const line of config.split("\n")) {
+		const multilineScan = scanTomlMultilineLine(line, multilineQuote);
+		multilineQuote = multilineScan.nextQuote;
+		if (multilineScan.wasInside) continue;
+		const normalizedLine = stripUnquotedInlineComment(line).trim();
+		if (normalizedLine.length === 0) continue;
+
+		const headerPath = parseTomlTableHeader(normalizedLine);
+		if (headerPath) {
+			tablePath = headerPath;
+			continue;
+		}
+		if (isTomlTableHeaderLine(normalizedLine)) {
+			tablePath = null;
+			continue;
+		}
+		if (!tablePath) continue;
+
+		const assignmentIndex = findUnquotedAssignment(normalizedLine);
+		if (assignmentIndex < 0) continue;
+		const settingPath = parseTomlDottedKey(normalizedLine.slice(0, assignmentIndex).trim());
+		if (!settingPath) continue;
+		const fullPath = [...tablePath, ...settingPath];
+		if (fullPath.length !== targetPath.length) continue;
+		if (fullPath.every((part, index) => part === targetPath[index])) return true;
+	}
+	return false;
+}
+
+export function replaceOrInsertRootTomlSetting(config, keyPath, value) {
+	const targetPath = parseTomlDottedKey(keyPath);
+	if (!targetPath) return config;
+	const match = findRootTomlSetting(config, targetPath);
+	if (match) {
+		const commentIndex = findUnquotedComment(match.lineBody, match.assignmentIndex + 1);
+		const comment = commentIndex === -1 ? "" : ` ${match.lineBody.slice(commentIndex).trimStart()}`;
+		const replacement = `${match.lineBody.slice(0, match.assignmentIndex + 1)} ${value}${comment}${match.newline}`;
+		return config.slice(0, match.offset) + replacement + config.slice(match.offset + match.line.length);
+	}
+	const firstTable = findFirstTomlTableStart(config);
+	const root = config.slice(0, firstTable).trimEnd();
+	const suffix = config.slice(firstTable);
+	const replacement = `${root}${root.length > 0 ? "\n" : ""}${keyPath} = ${value}\n`;
+	if (suffix.length === 0) return replacement;
+	return `${replacement.trimEnd()}\n\n${suffix.trimStart()}`;
+}
+
+export function replaceOrInsertTomlSectionSetting(config, section, keyPath, value) {
+	const targetPath = parseTomlDottedKey(keyPath);
+	if (!targetPath) return config;
+	const lines = section.text.match(/[^\n]*\n?|$/g) ?? [];
+	let offset = 0;
+	let multilineQuote = null;
+	for (const line of lines) {
+		if (line.length === 0) break;
+		const multilineScan = scanTomlMultilineLine(line, multilineQuote);
+		multilineQuote = multilineScan.nextQuote;
+		if (multilineScan.wasInside) {
+			offset += line.length;
+			continue;
+		}
+		const assignmentIndex = findUnquotedAssignment(line);
+		if (assignmentIndex >= 0) {
+			const settingPath = parseTomlDottedKey(line.slice(0, assignmentIndex).trim());
+			if (settingPath && tomlPathMatches(settingPath, targetPath)) {
+				const replacement = replaceTomlAssignmentValue(line, assignmentIndex, value);
+				const patched = section.text.slice(0, offset) + replacement + section.text.slice(offset + line.length);
+				return config.slice(0, section.start) + patched + config.slice(section.end);
+			}
+		}
+		offset += line.length;
+	}
+	const headerEnd = section.text.indexOf("\n");
+	const insertAt = headerEnd === -1 ? section.text.length : headerEnd + 1;
+	const patched = `${section.text.slice(0, insertAt)}${headerEnd === -1 ? "\n" : ""}${keyPath} = ${value}\n${section.text.slice(insertAt)}`;
+	return config.slice(0, section.start) + patched + config.slice(section.end);
+}
+
+export function removeTomlSectionSetting(config, section, keyPath, expectedValue) {
+	const targetPath = parseTomlDottedKey(keyPath);
+	if (!targetPath) return config;
+	const lines = section.text.match(/[^\n]*\n?|$/g) ?? [];
+	let offset = 0;
+	let multilineQuote = null;
+	for (const line of lines) {
+		if (line.length === 0) break;
+		const multilineScan = scanTomlMultilineLine(line, multilineQuote);
+		multilineQuote = multilineScan.nextQuote;
+		if (multilineScan.wasInside) {
+			offset += line.length;
+			continue;
+		}
+		const assignmentIndex = findUnquotedAssignment(line);
+		if (assignmentIndex >= 0) {
+			const settingPath = parseTomlDottedKey(line.slice(0, assignmentIndex).trim());
+			if (settingPath && tomlPathMatches(settingPath, targetPath)) {
+				const lineBody = line.endsWith("\n") ? line.slice(0, -1) : line;
+				const commentIndex = findUnquotedComment(lineBody, assignmentIndex + 1);
+				const valueEnd = commentIndex === -1 ? lineBody.length : commentIndex;
+				if (lineBody.slice(assignmentIndex + 1, valueEnd).trim() !== expectedValue) return config;
+				const patched = section.text.slice(0, offset) + section.text.slice(offset + line.length);
+				return config.slice(0, section.start) + patched + config.slice(section.end);
+			}
+		}
+		offset += line.length;
+	}
+	return config;
+}
+
+export function removeRootTomlSetting(config, keyPath, expectedValue) {
+	const targetPath = parseTomlDottedKey(keyPath);
+	if (!targetPath) return config;
+	const match = findRootTomlSetting(config, targetPath);
+	if (!match) return config;
+	const commentIndex = findUnquotedComment(match.lineBody, match.assignmentIndex + 1);
+	const valueEnd = commentIndex === -1 ? match.lineBody.length : commentIndex;
+	if (match.lineBody.slice(match.assignmentIndex + 1, valueEnd).trim() !== expectedValue) return config;
+	return config.slice(0, match.offset) + config.slice(match.offset + match.line.length);
+}
+
+function tomlTableHeaderMatches(line, targetHeaderPath) {
+	if (!targetHeaderPath) return false;
+	const candidateHeaderPath = parseTomlTableHeader(line);
+	if (!candidateHeaderPath || candidateHeaderPath.length !== targetHeaderPath.length) return false;
+	return candidateHeaderPath.every((part, index) => part === targetHeaderPath[index]);
+}
+
+function isTomlTableHeaderLine(line) {
+	const normalizedLine = stripUnquotedInlineComment(line).trim();
+	return normalizedLine.startsWith("[") && normalizedLine.endsWith("]");
+}
+
+function scanTomlMultilineLine(line, currentQuote) {
+	if (currentQuote) {
+		return {
+			wasInside: true,
+			nextQuote: findTomlMultilineDelimiter(line, currentQuote, 0) === -1 ? currentQuote : null,
+		};
+	}
+
+	let quote = null;
+	let index = 0;
+	while (index < line.length) {
+		const char = line[index];
+		if (quote === '"') {
+			if (char === "\\") {
+				index += 2;
+				continue;
+			}
+			if (char === '"') quote = null;
+			index += 1;
+			continue;
+		}
+		if (quote === "'") {
+			if (char === "'") quote = null;
+			index += 1;
+			continue;
+		}
+		if (char === "#") break;
+		const delimiter = line.startsWith('"""', index) ? '"""' : line.startsWith("'''", index) ? "'''" : null;
+		if (delimiter) {
+			const closingIndex = findTomlMultilineDelimiter(line, delimiter, index + delimiter.length);
+			return { wasInside: false, nextQuote: closingIndex === -1 ? delimiter : null };
+		}
+		if (char === '"' || char === "'") quote = char;
+		index += 1;
+	}
+	return { wasInside: false, nextQuote: null };
+}
+
+function findTomlMultilineDelimiter(line, delimiter, startIndex) {
+	let index = line.indexOf(delimiter, startIndex);
+	while (index !== -1) {
+		if (delimiter === "'''" || countPrecedingBackslashes(line, index) % 2 === 0) return index;
+		index = line.indexOf(delimiter, index + 1);
+	}
+	return -1;
+}
+
+function countPrecedingBackslashes(line, index) {
+	let count = 0;
+	let cursor = index - 1;
+	while (cursor >= 0 && line[cursor] === "\\") {
+		count += 1;
+		cursor -= 1;
+	}
+	return count;
+}
+
+function findRootTomlSetting(config, targetPath) {
+	const lines = config.match(/[^\n]*\n?|$/g) ?? [];
+	let offset = 0;
+	let multilineQuote = null;
+	for (const line of lines) {
+		if (line.length === 0) break;
+		const multilineScan = scanTomlMultilineLine(line, multilineQuote);
+		multilineQuote = multilineScan.nextQuote;
+		if (multilineScan.wasInside) {
+			offset += line.length;
+			continue;
+		}
+		if (isTomlTableHeaderLine(line)) break;
+		const assignmentIndex = findUnquotedAssignment(line);
+		if (assignmentIndex >= 0) {
+			const settingPath = parseTomlDottedKey(line.slice(0, assignmentIndex).trim());
+			if (settingPath && tomlPathMatches(settingPath, targetPath)) {
+				const newline = line.endsWith("\n") ? "\n" : "";
+				return { line, lineBody: newline ? line.slice(0, -1) : line, newline, offset, assignmentIndex };
+			}
+		}
+		offset += line.length;
+	}
+	return null;
+}
+
+function findFirstTomlTableStart(config) {
+	const lines = config.match(/[^\n]*\n?|$/g) ?? [];
+	let offset = 0;
+	let multilineQuote = null;
+	for (const line of lines) {
+		if (line.length === 0) break;
+		const multilineScan = scanTomlMultilineLine(line, multilineQuote);
+		multilineQuote = multilineScan.nextQuote;
+		if (!multilineScan.wasInside && isTomlTableHeaderLine(line)) return offset;
+		offset += line.length;
+	}
+	return config.length;
+}
+
+function findUnquotedComment(line, startIndex) {
+	let quote = null;
+	let index = startIndex;
+	while (index < line.length) {
+		const char = line[index];
+		if (quote === '"') {
+			if (char === "\\") {
+				index += 2;
+				continue;
+			}
+			if (char === '"') quote = null;
+			index += 1;
+			continue;
+		}
+		if (quote === "'") {
+			if (char === "'") quote = null;
+			index += 1;
+			continue;
+		}
+		if (char === '"' || char === "'") quote = char;
+		else if (char === "#") return index;
+		index += 1;
+	}
+	return -1;
+}
+
+function tomlPathMatches(candidate, target) {
+	return candidate.length === target.length && candidate.every((part, index) => part === target[index]);
+}
+
+function replaceTomlAssignmentValue(line, assignmentIndex, value) {
+	const newline = line.endsWith("\n") ? "\n" : "";
+	const lineBody = newline ? line.slice(0, -1) : line;
+	const commentIndex = findUnquotedComment(lineBody, assignmentIndex + 1);
+	const comment = commentIndex === -1 ? "" : ` ${lineBody.slice(commentIndex).trimStart()}`;
+	return `${lineBody.slice(0, assignmentIndex + 1)} ${value}${comment}${newline}`;
+}
+
+function parseTomlTableHeader(line) {
+	const normalizedLine = stripUnquotedInlineComment(line).trim();
+	if (!normalizedLine.startsWith("[") || !normalizedLine.endsWith("]") || normalizedLine.startsWith("[[")) {
+		return null;
+	}
+	return parseTomlDottedKey(normalizedLine.slice(1, -1).trim());
+}
+
+function stripUnquotedInlineComment(line) {
+	let quote = null;
+	let index = 0;
+	while (index < line.length) {
+		const char = line[index];
+		if (quote === '"') {
+			if (char === "\\") {
+				index += 2;
+				continue;
+			}
+			if (char === '"') quote = null;
+			index += 1;
+			continue;
+		}
+		if (quote === "'") {
+			if (char === "'") quote = null;
+			index += 1;
+			continue;
+		}
+		if (char === '"' || char === "'") {
+			quote = char;
+			index += 1;
+			continue;
+		}
+		if (char === "#") return line.slice(0, index);
+		index += 1;
+	}
+	return line;
+}
+
+function findUnquotedAssignment(line) {
+	let quote = null;
+	let index = 0;
+	while (index < line.length) {
+		const char = line[index];
+		if (quote === '"') {
+			if (char === "\\") {
+				index += 2;
+				continue;
+			}
+			if (char === '"') quote = null;
+			index += 1;
+			continue;
+		}
+		if (quote === "'") {
+			if (char === "'") quote = null;
+			index += 1;
+			continue;
+		}
+		if (char === '"' || char === "'") {
+			quote = char;
+			index += 1;
+			continue;
+		}
+		if (char === "=") return index;
+		index += 1;
+	}
+	return -1;
+}
+
+function parseTomlDottedKey(input) {
+	const parts = [];
+	let index = 0;
+	while (index < input.length) {
+		index = skipWhitespace(input, index);
+		const parsedKey = parseTomlKeyPart(input, index);
+		if (!parsedKey) return null;
+		parts.push(parsedKey.value);
+		index = skipWhitespace(input, parsedKey.nextIndex);
+		if (index === input.length) return parts;
+		if (input[index] !== ".") return null;
+		index += 1;
+	}
+	return parts.length > 0 ? parts : null;
+}
+
+function parseTomlKeyPart(input, startIndex) {
+	const quote = input[startIndex];
+	if (quote === "'") return parseLiteralTomlString(input, startIndex);
+	if (quote === '"') return parseBasicTomlString(input, startIndex);
+	return parseBareTomlKey(input, startIndex);
+}
+
+function parseLiteralTomlString(input, startIndex) {
+	let index = startIndex + 1;
+	let value = "";
+	while (index < input.length) {
+		const char = input[index];
+		if (char === "'") return { value, nextIndex: index + 1 };
+		value += char;
+		index += 1;
+	}
+	return null;
+}
+
+function parseBasicTomlString(input, startIndex) {
+	let index = startIndex + 1;
+	let value = "";
+	while (index < input.length) {
+		const char = input[index];
+		if (char === '"') return { value, nextIndex: index + 1 };
+		if (char !== "\\") {
+			value += char;
+			index += 1;
+			continue;
+		}
+		const escaped = parseBasicTomlEscape(input, index);
+		if (!escaped) return null;
+		value += escaped.value;
+		index = escaped.nextIndex;
+	}
+	return null;
+}
+
+function parseBasicTomlEscape(input, backslashIndex) {
+	const escape = input[backslashIndex + 1];
+	if (escape === undefined) return null;
+	if (escape === "b") return { value: "\b", nextIndex: backslashIndex + 2 };
+	if (escape === "t") return { value: "\t", nextIndex: backslashIndex + 2 };
+	if (escape === "n") return { value: "\n", nextIndex: backslashIndex + 2 };
+	if (escape === "f") return { value: "\f", nextIndex: backslashIndex + 2 };
+	if (escape === "r") return { value: "\r", nextIndex: backslashIndex + 2 };
+	if (escape === '"') return { value: '"', nextIndex: backslashIndex + 2 };
+	if (escape === "\\") return { value: "\\", nextIndex: backslashIndex + 2 };
+	if (escape === "u") return parseUnicodeEscape(input, backslashIndex + 2, 4);
+	if (escape === "U") return parseUnicodeEscape(input, backslashIndex + 2, 8);
+	return null;
+}
+
+function parseUnicodeEscape(input, digitsStart, digitCount) {
+	const digits = input.slice(digitsStart, digitsStart + digitCount);
+	if (digits.length !== digitCount || !/^[0-9A-Fa-f]+$/.test(digits)) return null;
+	const codePoint = Number.parseInt(digits, 16);
+	if (codePoint > 0x10ffff) return null;
+	return { value: String.fromCodePoint(codePoint), nextIndex: digitsStart + digitCount };
+}
+
+function parseBareTomlKey(input, startIndex) {
+	let index = startIndex;
+	while (index < input.length && /[A-Za-z0-9_-]/.test(input[index])) index += 1;
+	if (index === startIndex) return null;
+	return { value: input.slice(startIndex, index), nextIndex: index };
+}
+
+function skipWhitespace(input, startIndex) {
+	let index = startIndex;
+	while (index < input.length && /\s/.test(input[index])) index += 1;
+	return index;
+}

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

@@ -14,6 +14,9 @@ const ignoredSkillSourceDirNames = new Set([".mypy_cache", ".omo", ".pytest_cach
 const ignoredSkillSourceFileNames = new Set([".gitignore", ".npmignore", "pyrightconfig.json"]);
 const skillSources = [
 	["comment-checker", "components/comment-checker/skills/comment-checker"],
+	["lcx-contribute-bug-fix", "components/lcx/skills/lcx-contribute-bug-fix"],
+	["lcx-doctor", "components/lcx/skills/lcx-doctor"],
+	["lcx-report-bug", "components/lcx/skills/lcx-report-bug"],
 	["lsp", "components/lsp/skills/lsp"],
 	["rules", "components/rules/skills/rules"],
 	["teammode", "components/teammode/skills/teammode"],
@@ -22,7 +25,6 @@ const skillSources = [
 	["ultrawork", "components/ultrawork/skills/ultrawork"],
 ];
 const componentSkillNames = new Set(skillSources.map(([name]) => name));
-const codexHiddenSharedSkillNames = new Set(["ultraresearch"]);
 const skillDisplayPrefix = "(OmO) ";
 
 function shouldCopySkillSource(source) {
@@ -182,22 +184,6 @@ prefixes when identity is needed.
 `;
 
 function applyCodexSkillOverlays(skillName, content) {
-	if (skillName === "ulw-research") {
-		return content
-			.replace(
-				", the legacy alias 'ultraresearch', any 'ulw' research wording,",
-				", any 'ulw' research wording,",
-			)
-			.replace(
-				'the legacy alias "ultraresearch" (also `/ultraresearch`, `$ultraresearch`), ',
-				"",
-			)
-			.replace(
-				"answer those normally, and mention that `ulw-research` is available (legacy alias: `ultraresearch`) when a question would clearly benefit from it.",
-				"answer those normally, and mention that `ulw-research` is available when a question would clearly benefit from it.",
-			)
-			.replace("# Ultraresearch Synthesis: <query>", "# ULW-Research Synthesis: <query>");
-	}
 	if (skillName === "start-work") {
 		return content
 			.replace(startWorkOriginalCompletion, startWorkCodexCompletion)
@@ -270,7 +256,6 @@ async function syncSkills() {
 
 	for (const skillName of sharedSkillNames) {
 		if (componentSkillNames.has(skillName)) continue;
-		if (codexHiddenSharedSkillNames.has(skillName)) continue;
 		await cp(join(sharedSkillsRoot, skillName), join(skillsRoot, skillName), {
 			filter: shouldCopySkillSource,
 			recursive: true,

package/packages/omo-codex/plugin/shared/test/config-loader.test.ts

@@ -85,6 +85,49 @@ describe("getCodexOmoConfig", () => {
 		expect(result.codegraph?.excluded_roots).toEqual(["/tmp/omo-research", "/private/tmp/omo-research"])
 	})
 
+	it("#given no codegraph.daemon key #when loading config #then daemon defaults to off", () => {
+		// given
+		const homeDir = createTemporaryDirectory("omo-codex-shared-daemon-default-home-")
+		const cwd = createTemporaryDirectory("omo-codex-shared-daemon-default-project-")
+		writeOmoConfig(homeDir, JSON.stringify({ codegraph: { enabled: true } }))
+
+		// when
+		const result = getCodexOmoConfig({ cwd, homeDir, env: {} })
+
+		// then
+		expect(result.codegraph?.daemon).toBeUndefined()
+		expect(result.codegraph?.daemon === true).toBe(false)
+		expect(result.warnings).toEqual([])
+	})
+
+	it("#given codex SOT sets codegraph.daemon=true #when loading config #then daemon opt-in is returned", () => {
+		// given
+		const homeDir = createTemporaryDirectory("omo-codex-shared-daemon-on-home-")
+		const cwd = createTemporaryDirectory("omo-codex-shared-daemon-on-project-")
+		writeOmoConfig(homeDir, JSON.stringify({ "[codex]": { codegraph: { daemon: true } } }))
+
+		// when
+		const result = getCodexOmoConfig({ cwd, homeDir, env: {} })
+
+		// then
+		expect(result.codegraph?.daemon).toBe(true)
+		expect(result.warnings).toEqual([])
+	})
+
+	it("#given codex SOT sets codegraph.daemon to a non-boolean #when loading config #then the value is rejected with a warning", () => {
+		// given
+		const homeDir = createTemporaryDirectory("omo-codex-shared-daemon-invalid-home-")
+		const cwd = createTemporaryDirectory("omo-codex-shared-daemon-invalid-project-")
+		writeOmoConfig(homeDir, JSON.stringify({ "[codex]": { codegraph: { daemon: "yes" } } }))
+
+		// when
+		const result = getCodexOmoConfig({ cwd, homeDir, env: {} })
+
+		// then
+		expect(result.codegraph?.daemon).toBeUndefined()
+		expect(result.warnings).toContain("config.[codex].codegraph.daemon must be a boolean")
+	})
+
 	it("#given legacy env override and SOT value #when loading config #then env wins over the SOT", () => {
 		// given
 		const homeDir = createTemporaryDirectory("omo-codex-shared-env-")

package/packages/omo-codex/plugin/skills/programming/scripts/typescript/check-no-excuse-rules.ts

@@ -19,6 +19,10 @@
  * Usage:
  *   bun run scripts/check-no-excuse-rules.ts <file-or-dir>...
  *
+ * The `typescript` package is resolved from the caller project (process.cwd()),
+ * not from this script's location, so the script works when executed from an
+ * installed skill-cache path (e.g. ~/.codex/...) against a project checkout.
+ *
  * Exit codes:
  *   0 - no violations
  *   1 - violations found
@@ -26,9 +30,35 @@
  */
 
 import fs from "node:fs"
+import { createRequire } from "node:module"
 import path from "node:path"
 import process from "node:process"
-import ts from "typescript"
+import type * as tsTypes from "typescript"
+
+type TsModule = typeof import("typescript")
+
+function loadTypescriptFromCaller(): TsModule {
+  // A static `import ts from "typescript"` resolves from this script's location —
+  // an installed skill-cache path (e.g. ~/.codex/...) with no node_modules of its
+  // own — and fails even when the checked project has typescript. Resolve from the
+  // caller project (cwd) instead. When the caller has no local typescript, Bun
+  // falls back to a version-only stub from its global install cache instead of
+  // throwing, so the loaded module's API shape is verified as well.
+  const callerRequire = createRequire(path.join(process.cwd(), "no-excuse-anchor.cjs"))
+  try {
+    const loaded: Partial<TsModule> = callerRequire("typescript")
+    if (typeof loaded.createSourceFile === "function") return loaded as TsModule
+  } catch { // no-excuse-ok: catch
+    // fall through to the clear error below
+  }
+  console.error(
+    `error: cannot resolve "typescript" from the caller project (${process.cwd()}). ` +
+      "Install it in the project being checked (e.g. `bun add -d typescript`) and re-run.",
+  )
+  process.exit(2)
+}
+
+const ts: TsModule = loadTypescriptFromCaller()
 
 type RuleId =
   | "no-any-assertion"
@@ -95,7 +125,7 @@ function discoverFiles(inputs: string[]): string[] {
   return files
 }
 
-function getLineText(sourceFile: ts.SourceFile, line: number): string {
+function getLineText(sourceFile: tsTypes.SourceFile, line: number): string {
   const lineStarts = sourceFile.getLineStarts()
   const start = lineStarts[line]
   const end = line + 1 < lineStarts.length ? lineStarts[line + 1] : sourceFile.getEnd()
@@ -107,17 +137,17 @@ function analyzeFile(filePath: string): Violation[] {
   const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true)
   const violations: Violation[] = []
 
-  function pos(node: ts.Node): { line: number; column: number } {
+  function pos(node: tsTypes.Node): { line: number; column: number } {
     const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile))
     return { line: line + 1, column: character + 1 }
   }
 
-  function lineHasOptOut(node: ts.Node): boolean {
+  function lineHasOptOut(node: tsTypes.Node): boolean {
     const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile))
     return OPT_OUT_RE.test(getLineText(sourceFile, line))
   }
 
-  function visit(node: ts.Node): void {
+  function visit(node: tsTypes.Node): void {
     // ── as any / as unknown ──
     if (ts.isAsExpression(node)) {
       const typeText = node.type.getText(sourceFile)

package/packages/omo-codex/plugin/skills/ulw-loop/references/full-workflow.md

@@ -113,9 +113,9 @@ If `ULW_LOOP_CLI` is empty, open the durable notepad first, record the missing C
 
 Run one form:
 ```sh
-omo ulw-loop create-goals --brief "<brief>" --json
-omo ulw-loop create-goals --brief-file <path> --json
-cat <brief> | omo ulw-loop create-goals --from-stdin --json
+omo ulw-loop create-goals --brief "<brief>" [--validation-batch-json <json-or-path>] --json
+omo ulw-loop create-goals --brief-file <path> [--validation-batch-json <json-or-path>] --json
+cat <brief> | omo ulw-loop create-goals --from-stdin [--validation-batch-json <json-or-path>] --json
 ```
 If the existing aggregate is already complete, do not steer or force the
 completed default state for unrelated new work. Start a fresh run with
@@ -145,7 +145,7 @@ Read pending goals, criteria IDs, current ledger head, blockers, and aggregate C
 Loop per goal. Cap at 5 cycles per goal. Cap identical same-criterion failures at 3.
 
 ### Acquire Next Goal
-1. Run `omo ulw-loop complete-goals --json` and read the handoff, including criteria.
+1. Run `omo ulw-loop complete-goals --json` and read the handoff, including criteria. After the first goal starts, a successful complete checkpoint normally prints the next goal instruction directly; use `complete-goals` as the manual fallback/resume path.
 2. Call `get_goal` and inspect active Codex state.
 3. Apply this table exactly:
 
@@ -177,7 +177,7 @@ Loop per goal. Cap at 5 cycles per goal. Cap identical same-criterion failures a
 ### Goal Completion
 1. Non-final aggregate goal: confirm every `essential` criterion is `pass`; non-essential criteria may remain pending. Final aggregate goal: confirm every criterion across the whole plan is `pass`.
 2. Call `get_goal` for a fresh snapshot.
-3. Run `omo ulw-loop checkpoint --goal-id <id> --status complete --evidence "<criteria evidence summary>" --codex-goal-json <snapshot> --json`.
+3. Run `omo ulw-loop checkpoint --goal-id <id> --status complete --evidence "<criteria evidence summary>" --codex-goal-json <snapshot> --json`; on success it auto-starts and prints the next eligible goal unless `--no-advance` is passed.
 4. If blocked or failed, checkpoint with `--status blocked` or `--status failed` and include diagnosis evidence.
 5. If this is the final goal, run the final quality gate first and pass `--quality-gate-json`.
 
@@ -219,7 +219,9 @@ Use steering only for structured evidence-backed mutation. Reject natural-langua
 | annotate_ledger | Audit-only note | `--evidence`, `--rationale` |
 | mark_blocked_superseded | Old story replaced by new evidence | `--goal-id`, `--replacements?`, `--evidence`, `--rationale` |
 
-Command form: `omo ulw-loop steer --kind <kind> [<kind-specific-fields>] --evidence "<...>" --rationale "<...>" --json`.
+Command form: `omo ulw-loop steer --kind <kind> [<kind-specific-fields>] --evidence "<...>" --rationale "<...>" --json`. For multiple evidence-backed plan-shape changes discovered together, pass `--proposals-json <json-or-path>` with an array of proposals; the batch applies atomically or rejects without partial plan mutation.
+
+Validation batches are optional aggregate-mode review boundaries declared at create time with `--validation-batch-json`. A batch-final member requires all other members resolved, all member criteria pass, and a member-spanning quality gate; split/supersede steering keeps batch membership updated.
 Structured prompt directives accepted: `OMO_ULW_LOOP_STEER: { ... }`, `omo.ulw-loop.steer: {...}`, `omo ulw-loop steer: {...}`.
 
 ## Constraints