oh-my-opencode 4.18.1 → 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) {
@@ -132,9 +134,10 @@ const startWorkOriginalCompletion = `When all top-level checkboxes in \`## TODOs
 const startWorkCodexCompletion = `When all top-level checkboxes in \`## TODOs\` and \`## Final Verification Wave\` are complete:
 
 1. Run the plan's final verification commands.
-2. Complete the **Global Review and Debugging Gate** before any completion claim, PR creation, PR handoff, branch handoff, or merge. The gate's pass binds to the commit SHA it reviewed and covers every later checkpoint at that same SHA — never re-run it on an already-passed SHA; re-run only when new commits land:
+2. Complete the **Global Review and Debugging Gate** before any completion claim, PR creation, PR handoff, branch handoff, or merge:
    - Invoke the \`review-work\` skill with the final diff, changed files, user goal, constraints, run command, and verification evidence. All five review lanes must return PASS. A timeout, missing deliverable, ack-only child, \`BLOCKED:\`, or inconclusive lane is a gate failure, not approval.
-   - Run a debugging-oriented runtime audit even when the review passes: name at least three plausible failure hypotheses for the changed surface, run the distinguishing checks against the actual artifact, and append the ruled-out or confirmed result to \`.omo/start-work/ledger.jsonl\`.
+   - Each passing review lane binds to the exact full commit SHA it reviewed. Immediately append a durable record to \`.omo/start-work/ledger.jsonl\` with the lane name, full SHA, PASS verdict, and report artifact/source. Before same-SHA reuse after any continuation or compaction, re-read the ledger record and require the exact lane/SHA pair; memory, chat history, or an unstamped report is not coverage. New commits require fresh applicable lane coverage.
+   - Run a debugging-oriented runtime audit even when the review passes: name at least three plausible failure hypotheses for the changed surface, run the distinguishing checks against the actual artifact, and append a separate durable record with the audit name, exact full SHA, verdict, and evidence artifact/source to \`.omo/start-work/ledger.jsonl\`. Reuse it only after re-reading an exact audit/SHA match.
    - If any review lane or debugging hypothesis fails, invoke the \`debugging\` skill, confirm root cause with runtime evidence, add the minimal failing test or reproduction, fix it, rerun the affected verification, then rerun the Global Review and Debugging Gate.
    - Evidence hygiene is mandatory: redact or mask secrets and sensitive user data before writing \`.omo/start-work/ledger.jsonl\`, a PR body, or a handoff. Never include raw tokens, credentials, auth headers, cookies, API keys, env dumps, private logs, or PII; use concise summaries, lengths, hashes, or short non-sensitive prefixes instead.
    - If the work includes creating, updating, or handing off a PR, refresh \`git status\` and the PR/branch state from the task-owned worktree after the gate, and include only redacted review/debugging evidence in the PR body or handoff.
@@ -156,6 +159,13 @@ failed, investigate the underlying uncertainty with the \`debugging\` skill when
 runtime behavior may be wrong, fix with evidence, and rerun the affected lane
 before claiming completion, creating or handing off a PR, or merging.
 
+After each lane reaches PASS, immediately append a durable task-evidence record
+to the active ledger with the lane name, exact full commit SHA, PASS verdict,
+and report artifact/source. Before reusing coverage after continuation or
+compaction, re-read that record and require the exact lane/SHA pair. Memory,
+chat history, or an unstamped report is not coverage; a new commit requires
+fresh applicable lane records.
+
 A rejecting lane must name its blockers inline in its final message — each
 blocker cites the violated goal criterion or requirement plus an evidence
 pointer. A bare REJECT/FAIL token without findings is not a verdict; treat it
@@ -174,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)
@@ -262,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/review-work/SKILL.md

@@ -70,6 +70,13 @@ failed, investigate the underlying uncertainty with the `debugging` skill when
 runtime behavior may be wrong, fix with evidence, and rerun the affected lane
 before claiming completion, creating or handing off a PR, or merging.
 
+After each lane reaches PASS, immediately append a durable task-evidence record
+to the active ledger with the lane name, exact full commit SHA, PASS verdict,
+and report artifact/source. Before reusing coverage after continuation or
+compaction, re-read that record and require the exact lane/SHA pair. Memory,
+chat history, or an unstamped report is not coverage; a new commit requires
+fresh applicable lane records.
+
 A rejecting lane must name its blockers inline in its final message — each
 blocker cites the violated goal criterion or requirement plus an evidence
 pointer. A bare REJECT/FAIL token without findings is not a verdict; treat it

package/packages/omo-codex/plugin/skills/start-work/SKILL.md

@@ -176,9 +176,10 @@ Only after verification passes:
 When all top-level checkboxes in `## TODOs` and `## Final Verification Wave` are complete:
 
 1. Run the plan's final verification commands.
-2. Complete the **Global Review and Debugging Gate** before any completion claim, PR creation, PR handoff, branch handoff, or merge. The gate's pass binds to the commit SHA it reviewed and covers every later checkpoint at that same SHA — never re-run it on an already-passed SHA; re-run only when new commits land:
+2. Complete the **Global Review and Debugging Gate** before any completion claim, PR creation, PR handoff, branch handoff, or merge:
    - Invoke the `review-work` skill with the final diff, changed files, user goal, constraints, run command, and verification evidence. All five review lanes must return PASS. A timeout, missing deliverable, ack-only child, `BLOCKED:`, or inconclusive lane is a gate failure, not approval.
-   - Run a debugging-oriented runtime audit even when the review passes: name at least three plausible failure hypotheses for the changed surface, run the distinguishing checks against the actual artifact, and append the ruled-out or confirmed result to `.omo/start-work/ledger.jsonl`.
+   - Each passing review lane binds to the exact full commit SHA it reviewed. Immediately append a durable record to `.omo/start-work/ledger.jsonl` with the lane name, full SHA, PASS verdict, and report artifact/source. Before same-SHA reuse after any continuation or compaction, re-read the ledger record and require the exact lane/SHA pair; memory, chat history, or an unstamped report is not coverage. New commits require fresh applicable lane coverage.
+   - Run a debugging-oriented runtime audit even when the review passes: name at least three plausible failure hypotheses for the changed surface, run the distinguishing checks against the actual artifact, and append a separate durable record with the audit name, exact full SHA, verdict, and evidence artifact/source to `.omo/start-work/ledger.jsonl`. Reuse it only after re-reading an exact audit/SHA match.
    - If any review lane or debugging hypothesis fails, invoke the `debugging` skill, confirm root cause with runtime evidence, add the minimal failing test or reproduction, fix it, rerun the affected verification, then rerun the Global Review and Debugging Gate.
    - Evidence hygiene is mandatory: redact or mask secrets and sensitive user data before writing `.omo/start-work/ledger.jsonl`, a PR body, or a handoff. Never include raw tokens, credentials, auth headers, cookies, API keys, env dumps, private logs, or PII; use concise summaries, lengths, hashes, or short non-sensitive prefixes instead.
    - If the work includes creating, updating, or handing off a PR, refresh `git status` and the PR/branch state from the task-owned worktree after the gate, and include only redacted review/debugging evidence in the PR body or handoff.