oh-my-opencode 4.18.2 → 4.19.0

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/skills/ulw-plan/SKILL.md

@@ -24,24 +24,28 @@ After grounding, make ONE judgment, record `intent: clear|unclear` plus `review_
 
 - **OVERRIDE - explicit ask wins:** if the user explicitly asks to be questioned or interviewed ("ask me", "interview me", "why aren't you asking me" - in any language), route **CLEAR**, run the interview, and turn the adopt-default filter OFF: the user has claimed the forks, so every surviving one is ASKED, not defaulted. This beats the OUTCOME test below, even on a fuzzy brief.
 - **CLEAR** - the user knows the outcome; the only open items are preferences/tradeoffs the repo cannot answer (genuine owner-decisions). Read **`references/intent-clear.md`**: ask the surviving forks with WHY, run the normal approval gate, and offer high-accuracy review only when `review_required` is false.
-- **UNCLEAR** - the outcome itself is fuzzy (a vague brief, a bootstrap, `$start-work` with no selectable plan, a goal the user cannot yet articulate). Asking would offload your own job onto the user. Read **`references/intent-unclear.md`**: research maximally, adopt and ANNOUNCE best-practice defaults, do NOT ask the user extra questions, and run high-accuracy review AUTOMATICALLY (unless Classify sized the work Trivial).
+- **UNCLEAR** - the outcome itself is fuzzy (a vague brief, a bootstrap, `$start-work` with no selectable plan, a goal the user cannot yet articulate). Asking would offload your own job onto the user. Read **`references/intent-unclear.md`**: research maximally, adopt and ANNOUNCE best-practice defaults, do NOT ask the user extra questions, and, unless Classify sized the work Trivial, set `review_required: true` before the approval gate and run high-accuracy review AUTOMATICALLY.
 - **ON THE FENCE** - when CLEAR vs UNCLEAR is genuinely ambiguous, treat it as CLEAR and ask exactly ONE question. A user wrongly silenced is worse than one extra question. The dominant failure to guard against is mis-routing a CLEAR request to UNCLEAR, which silently applies defaults and overrides forks the user wanted to own.
 
 WORKED: "add a 5/min-per-IP rate-limit to `/login`" = CLEAR. "make auth better" = UNCLEAR.
 
 Both intent paths ALSO read **`references/full-workflow.md`** for the shared mechanics - the plan template, the final verification wave, the APPEND protocol, and the full delegation/wait syntax. Read the phase you are in.
 
-## RUN THE SCRIPT - do not hand-build the plan files
+## RUN THE SCRIPT - do not hand-build artifacts
 
-Before writing any plan or draft by hand, RUN:
+As soon as `<slug>` and intent are known, before recording draft state, RUN:
 
 ```
-node "<skill-root>/scripts/scaffold-plan.mjs" <slug> [--clear|--unclear]
+node "<skill-root>/scripts/scaffold-plan.mjs" <slug> [--clear|--unclear] --draft-only [--review-required]
 ```
 
-(Replace `<skill-root>` with this skill's own directory; `bun` is an accepted substitute for `node`.) It creates `.omo/drafts/<slug>.md` (your durable, compaction-safe resume point) and `.omo/plans/<slug>.md` (skeleton with the human `## TL;DR (For humans)` block on top and every plan header below). Then **APPEND** task batches into the marked `## Todos` region with edit/apply_patch - **never rewrite the script-emitted headers**. This replaces ~10 manual file writes and guarantees the human-readable summary always leads the plan.
+(Replace `<skill-root>` with this skill's own directory; `bun` is accepted.) This creates only `.omo/drafts/<slug>.md`, the compaction-safe resume point; it does not create a plan before approval. Include `--review-required` when an explicit modifier requires review or the classified route is non-Trivial UNCLEAR, so the first durable write contains the complete pending review request. After approval, rerun without `--draft-only` to create `.omo/plans/<slug>.md`, then **APPEND** task batches into `## Todos` - never rewrite script-emitted headers.
 
-Run it ONCE at plan generation. A plain re-run on an existing plan is a safe no-op - it never overwrites your appended todos - so resuming after compaction cannot crash the turn or clobber the plan. Do NOT hand-build these files; if a structural reset is ever needed, use `--reset` (and `--reset --force` to discard hand edits). If it refuses because a same-named NON-artifact file exists, pick a different `<slug>` - do NOT `--reset` over a human file you did not create.
+Both invocations are resume-safe no-ops for artifacts already present. Do NOT hand-build them; use `--reset` only for a structural reset (`--reset --force` discards edits). If a same-named non-artifact file exists, choose another slug.
+
+## Plan artifact producer contract
+
+When producing the plan, encode every executable item as a column-zero Markdown task row: implementation rows MUST match `- [ ] N. <title>` (where `N` is a positive decimal integer), and final-verifier rows MUST match `- [ ] F<number>. <title>`. Prose headings, numbered paragraphs, and ordinary bullets are not task substitutes and MUST NOT be counted as implementation or final-verifier tasks. Before handoff, run a structural self-check over the plan: verify that every implementation row and final-verifier row is column-zero, matches its required grammar, and appears in the intended `## Todos` or `## Final verification wave` section; verify that no prose heading or bullet is being used as a task; and repair the plan before handoff if any check fails.
 
 ## Universal invariants (hold on every path)
 
@@ -58,7 +62,7 @@ Run it ONCE at plan generation. A plain re-run on an existing plan is a safe no-
 
 ## Approval gate
 
-When exploration is exhausted and the unknowns are answered, record the gate in the draft (`status: awaiting-approval`, the pending action `write .omo/plans/<slug>.md`, the approach), present a short brief once, then **wait for the user's explicit okay**. Read their next reply as a decision (approve / scope-change / still-unclear). Full gate mechanics: `references/full-workflow.md`.
+When exploration is exhausted and the unknowns are answered, record the gate in the draft (`status: awaiting-approval`, approach, and the next workflow action), present a short brief once, then **wait for the user's explicit okay**. Approval authorizes plan creation only; any already-required review runs afterward under its existing authorization. Full mechanics: `references/full-workflow.md`.
 
 ## Delegation (Codex-native)