oh-my-codex 0.20.1 → 0.20.3

package/dist/config/generator.js

@@ -16,7 +16,7 @@ import TOML from "@iarna/toml";
 import { DEFAULT_FRONTIER_MODEL } from "./models.js";
 import { DEFAULT_CODEX_HOOK_FEATURE_FLAG, CODEX_HOOK_FEATURE_FLAGS, CODEX_PLUGIN_SCOPED_HOOKS_FEATURE_FLAG, formatCodexHookFeatureFlagLine, normalizeCodexHookFeatureFlag, } from "./codex-feature-flags.js";
 import { OMX_FIRST_PARTY_MCP_SERVER_NAMES, getOmxFirstPartySetupMcpServers, } from "./omx-first-party-mcp.js";
-import { buildManagedCodexHookTrustState, escapeTomlBasicString, } from "./codex-hooks.js";
+import { buildManagedCodexHookTrustState, escapeTomlBasicString, ManagedCodexHooksPlanError, scanManagedCodexHookTrustStateFromContent, } from "./codex-hooks.js";
 function escapeTomlString(value) {
     return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
 }
@@ -37,8 +37,8 @@ const LEGACY_SEEDED_MODEL_CONTEXT_WINDOW = 250000;
 const LEGACY_SEEDED_MODEL_AUTO_COMPACT_TOKEN_LIMIT = 200000;
 const OMX_SEEDED_BEHAVIORAL_DEFAULTS_START_MARKER = "# oh-my-codex seeded behavioral defaults (uninstall removes unchanged defaults)";
 const OMX_SEEDED_BEHAVIORAL_DEFAULTS_END_MARKER = "# End oh-my-codex seeded behavioral defaults";
-export const OMX_DEVELOPER_INSTRUCTIONS = "You have oh-my-codex installed. AGENTS.md is the orchestration brain and main control surface. Follow AGENTS.md for skill/keyword routing, $name workflow invocation, and role-specialized subagents; when spawning native subagents, set `agent_type` to an installed role and never omit it for OMX work. Use outcome-first, concise progress updates: state the target result, constraints, validation evidence, and stop condition before adding process detail. Native subagents live in .codex/agents and may handle independent parallel subtasks within one Codex session or team pane. Skills load from .codex/skills, not native-agent TOMLs. Treat installed prompts as narrower execution surfaces under AGENTS.md authority.";
-export const OMX_PLUGIN_DEVELOPER_INSTRUCTIONS = '<omx version="1">You have oh-my-codex installed through Codex plugin mode. AGENTS.md is the orchestration brain and main control surface. Follow AGENTS.md for skill/keyword routing and $name workflow invocation. When spawning native subagents, set `agent_type` to an installed role and never omit it for OMX work. Registered Codex plugin marketplace surfaces supply OMX workflows and plugin-scoped companion resources when the plugin is installed; native agent roles are installed as setup-owned Codex agent TOML files in plugin mode so agent_type routing works. User-installed skills may still live under ~/.codex/skills. Use outcome-first, concise progress updates: state the target result, constraints, validation evidence, and stop condition before adding process detail.</omx>';
+export const OMX_DEVELOPER_INSTRUCTIONS = "You have oh-my-codex installed. AGENTS.md is the orchestration brain and main control surface. Follow AGENTS.md for skill/keyword routing, $name workflow invocation, and role-specialized subagents; when the native surface exposes `agent_type` role routing, set `agent_type` to an installed role and never omit it for OMX work. When it reports `role_routing_unavailable`, do not fabricate `agent_type`; before Ralplan planning, state, HUD, runtime, or delegation work, run `omx ralplan preflight --json` and stop on `unsupported_documented_leader_proof`. Never fake the role via a prompt label or infer authority from session/thread/pointer/transcript/cwd state. Use outcome-first, concise progress updates: state the target result, constraints, validation evidence, and stop condition before adding process detail. Native subagents live in .codex/agents and may handle independent parallel subtasks within one Codex session or team pane. Skills load from .codex/skills, not native-agent TOMLs. Treat installed prompts as narrower execution surfaces under AGENTS.md authority.";
+export const OMX_PLUGIN_DEVELOPER_INSTRUCTIONS = '<omx version="1">You have oh-my-codex installed through Codex plugin mode. AGENTS.md is the orchestration brain and main control surface. Follow AGENTS.md for skill/keyword routing and $name workflow invocation. When the native surface exposes `agent_type` role routing, set `agent_type` to an installed role and never omit it for OMX work. When it reports `role_routing_unavailable`, do not fabricate `agent_type`; before Ralplan planning, state, HUD, runtime, or delegation work, run `omx ralplan preflight --json` and stop on `unsupported_documented_leader_proof`. Never fake the role via a prompt label or infer authority from session/thread/pointer/transcript/cwd state. Registered Codex plugin marketplace surfaces supply OMX workflows and plugin-scoped companion resources when the plugin is installed; native agent roles are installed as setup-owned Codex agent TOML files in plugin mode so agent_type routing works. User-installed skills may still live under ~/.codex/skills. Use outcome-first, concise progress updates: state the target result, constraints, validation evidence, and stop condition before adding process detail.</omx>';
 const SHARED_MCP_REGISTRY_MARKER = "oh-my-codex (OMX) Shared MCP Registry Sync";
 const SHARED_MCP_REGISTRY_END_MARKER = "# End oh-my-codex shared MCP registry sync";
 const LEGACY_MULTI_AGENT_KEYS = [
@@ -136,6 +136,7 @@ const LEGACY_OMX_STATUS_LINE = statusLineForPreset(DEFAULT_STATUS_LINE_PRESET);
 const OMX_PRESET_STATUS_LINE_VALUES = new Set(Object.keys(STATUS_LINE_PRESETS).map((preset) => statusLineForPreset(preset)));
 const LEGACY_OMX_TEAM_RUN_TABLE_PATTERN = /^\s*\[mcp_servers\.(?:"omx_team_run"|omx_team_run)\]\s*$/m;
 const OMX_CONFIG_MARKER = "oh-my-codex (OMX) Configuration";
+const OMX_CONFIG_START_MARKER = `# ${OMX_CONFIG_MARKER}`;
 const OMX_CONFIG_END_MARKER = "# End oh-my-codex";
 const CODEX_MODEL_AVAILABILITY_NUX_TABLE_PATTERN = /^\s*\[tui\.model_availability_nux\]\s*(?:#.*)?$/;
 const TOML_TABLE_HEADER_PATTERN = /^\s*\[\[?[^\]]+\]?\]\s*(?:#.*)?$/;
@@ -652,246 +653,1366 @@ const OMX_HOOK_TRUST_START_MARKER = "# OMX-owned Codex hook trust state";
 const OMX_HOOK_TRUST_END_MARKER = "# End OMX-owned Codex hook trust state";
 const OMX_PROJECT_TRUST_START_MARKER = "# OMX-synced Codex project trust state (from runtime CODEX_HOME)";
 const OMX_PROJECT_TRUST_END_MARKER = "# End OMX-synced Codex project trust state";
-function extractMarkerBlockContent(config, startMarker, endMarker) {
-    const lines = config.split(/\r?\n/);
-    for (let i = 0; i < lines.length; i++) {
-        if (lines[i].trim() !== startMarker)
-            continue;
-        const nextEndIdx = lines.findIndex((line, index) => index > i && line.trim() === endMarker);
-        const nextStartIdx = lines.findIndex((line, index) => index > i && line.trim() === startMarker);
-        if (nextEndIdx === -1 || (nextStartIdx !== -1 && nextStartIdx < nextEndIdx)) {
+function isPlainTomlRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function safeParseToml(content) {
+    try {
+        const parsed = TOML.parse(content);
+        return isPlainTomlRecord(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function projectHookTrustState(config) {
+    const hooks = safeParseToml(config)?.hooks;
+    const state = isPlainTomlRecord(hooks) ? hooks.state : undefined;
+    return isPlainTomlRecord(state) ? state : undefined;
+}
+function projectTrustSemanticView(config) {
+    const hasLeadingBom = config.startsWith("\uFEFF");
+    const source = hasLeadingBom ? config.slice(1) : config;
+    if (source.includes("\uFEFF"))
+        return undefined;
+    return { source, prefix: hasLeadingBom ? "\uFEFF" : "" };
+}
+function projectTrustMarkerRange(config) {
+    const lexical = analyzeTomlSource(config);
+    if (!lexical.isUnambiguous)
+        return undefined;
+    const lines = sourceLines(config);
+    const starts = lines.filter((line, index) => lexical.lineStartsOutsideMultiline[index] && line.content.trim() === OMX_PROJECT_TRUST_START_MARKER);
+    const ends = lines.filter((line, index) => lexical.lineStartsOutsideMultiline[index] && line.content.trim() === OMX_PROJECT_TRUST_END_MARKER);
+    if (starts.length === 0 && ends.length === 0)
+        return { start: config.length, end: config.length, payloadStart: config.length, payloadEnd: config.length };
+    if (starts.length !== 1 || ends.length !== 1 || starts[0].start >= ends[0].start)
+        return undefined;
+    const start = starts[0];
+    const end = ends[0];
+    return { start: start.start, end: end.end, payloadStart: start.end, payloadEnd: end.start };
+}
+function hasInlineProjectTrustMarkerComment(config) {
+    const lexical = analyzeTomlSource(config);
+    return sourceLines(config).some((line, index) => {
+        if (!lexical.lineStartsOutsideMultiline[index])
+            return false;
+        const trimmed = line.content.trim();
+        return (trimmed.startsWith(OMX_PROJECT_TRUST_START_MARKER) && trimmed !== OMX_PROJECT_TRUST_START_MARKER) ||
+            (trimmed.startsWith(OMX_PROJECT_TRUST_END_MARKER) && trimmed !== OMX_PROJECT_TRUST_END_MARKER);
+    });
+}
+function projectTrustHeaderPath(line) {
+    if (/^\s*\[\[/.test(line))
+        return undefined;
+    const header = parseTomlSourceTableHeader(line);
+    if (!header?.parsed)
+        return undefined;
+    const path = [];
+    let cursor = header.parsed;
+    while (isPlainTomlRecord(cursor)) {
+        const keys = Object.keys(cursor);
+        if (keys.length === 0)
+            return path;
+        if (keys.length !== 1)
             return undefined;
-        }
-        return lines.slice(i + 1, nextEndIdx).join("\n").trim();
+        const key = keys[0];
+        path.push(key);
+        cursor = cursor[key];
     }
-    return undefined;
+    return path;
 }
-function stripMarkerBlock(config, startMarker, endMarker) {
-    const lines = config.split(/\r?\n/);
-    const kept = [];
-    for (let i = 0; i < lines.length;) {
-        if (lines[i].trim() !== startMarker) {
-            kept.push(lines[i]);
-            i += 1;
+function dominantProjectTrustEol(source) {
+    const crlfCount = (source.match(/\r\n/g) ?? []).length;
+    const lfCount = (source.match(/(?<!\r)\n/g) ?? []).length;
+    return crlfCount > lfCount ? "\r\n" : "\n";
+}
+function projectTrustPayloadIsSemanticallyEmpty(payload) {
+    const parsed = safeParseToml(payload);
+    return parsed !== undefined && Object.keys(parsed).length === 0;
+}
+function projectTrustValueAtPath(source, path) {
+    let value = source;
+    for (const key of path) {
+        if (!isPlainTomlRecord(value))
+            return undefined;
+        value = value[key];
+    }
+    return value;
+}
+/**
+ * Marker contents are an ownership boundary, not general TOML. Reject every
+ * source form that OMX did not emit rather than rebuilding it and losing data.
+ */
+function inventoryProjectTrustPayload(payload, projectHooksPath) {
+    const parsed = safeParseToml(payload);
+    const lexical = analyzeTomlSource(payload);
+    const headers = projectTrustHeaders(payload, { start: 0, end: payload.length });
+    if (!parsed || !lexical.isUnambiguous || !headers)
+        return undefined;
+    if (Object.keys(parsed).some((key) => key !== "projects" && key !== "hooks"))
+        return undefined;
+    const lines = sourceLines(payload);
+    const headerStarts = new Set(headers.map((header) => header.start));
+    for (const [index, line] of lines.entries()) {
+        if (!lexical.lineStartsOutsideMultiline[index])
+            return undefined;
+        const isHeader = headerStarts.has(line.start);
+        const isBlankOrComment = line.content.trim() === "" || /^\s*#/.test(line.content);
+        if (isHeader || isBlankOrComment) {
+            if (isHeader && lexical.lineHasTomlComment[index])
+                return undefined;
             continue;
         }
-        const nextEndIdx = lines.findIndex((line, index) => index > i && line.trim() === endMarker);
-        const nextStartIdx = lines.findIndex((line, index) => index > i && line.trim() === startMarker);
-        if (nextEndIdx === -1 || (nextStartIdx !== -1 && nextStartIdx < nextEndIdx)) {
-            kept.push(lines[i]);
-            i += 1;
+        if (lexical.lineHasTomlComment[index])
+            return undefined;
+        const priorHeader = headers.some((header) => header.start < line.start);
+        if (!priorHeader)
+            return undefined;
+    }
+    const managedHeaders = [];
+    for (const header of headers) {
+        if (header.path[0] === "projects" && header.path.length >= 2) {
+            if (!isPlainTomlRecord(projectTrustValueAtPath(parsed, header.path)))
+                return undefined;
+            managedHeaders.push({ ...header, kind: "project" });
             continue;
         }
-        i = nextEndIdx + 1;
+        if (header.path[0] === "hooks" &&
+            header.path[1] === "state" &&
+            header.path.length === 3 &&
+            header.path[2].startsWith(`${projectHooksPath}:`)) {
+            const value = projectTrustValueAtPath(parsed, header.path);
+            if (!isPlainTomlRecord(value) || typeof value.trusted_hash !== "string" || value.trusted_hash.length === 0 || Object.keys(value).some((key) => key !== "trusted_hash"))
+                return undefined;
+            managedHeaders.push({ ...header, kind: "hook" });
+            continue;
+        }
+        return undefined;
     }
-    return kept.join("\n").replace(/\n{3,}/g, "\n\n").trimEnd();
+    if (!projectTrustPayloadProjectFamiliesAreValid(managedHeaders))
+        return undefined;
+    if (!projectTrustPayloadNestedStructuresAreExplicit(parsed, managedHeaders))
+        return undefined;
+    return { parsed, headers: managedHeaders };
 }
-function isPlainTomlRecord(value) {
-    return (typeof value === "object" &&
-        value !== null &&
-        !Array.isArray(value) &&
-        Object.getPrototypeOf(value) === Object.prototype);
+function projectTrustSourceNestedStructuresAreExplicit(parsed, headers) {
+    const projects = parsed.projects;
+    if (projects === undefined)
+        return true;
+    if (!isPlainTomlRecord(projects))
+        return false;
+    const hasHeader = (path) => headers.some((header) => projectTrustEqual(header.path, path));
+    const visit = (value, path) => {
+        for (const [key, child] of Object.entries(value)) {
+            if (!isPlainTomlRecord(child))
+                continue;
+            const childPath = [...path, key];
+            if (!hasHeader(childPath) || !visit(child, childPath))
+                return false;
+        }
+        return true;
+    };
+    return Object.entries(projects).every(([key, value]) => isPlainTomlRecord(value) && hasHeader(["projects", key]) && visit(value, ["projects", key]));
 }
-function safeParseToml(content) {
-    try {
-        const parsed = TOML.parse(content);
-        return isPlainTomlRecord(parsed) ? parsed : undefined;
+function projectTrustPayloadNestedStructuresAreExplicit(parsed, headers) {
+    const hasHeader = (path) => headers.some((header) => header.kind === "project" && projectTrustEqual(header.path, path));
+    const visit = (value, path) => {
+        for (const [key, child] of Object.entries(value)) {
+            if (!isPlainTomlRecord(child))
+                continue;
+            const childPath = [...path, key];
+            if (!hasHeader(childPath) || !visit(child, childPath))
+                return false;
+        }
+        return true;
+    };
+    return headers
+        .filter((header) => header.kind === "project" && header.path.length === 2)
+        .every((header) => {
+        const value = projectTrustValueAtPath(parsed, header.path);
+        return isPlainTomlRecord(value) && visit(value, header.path);
+    });
+}
+function projectTrustPayloadTableSpan(source) {
+    const lines = sourceLines(source);
+    const lastBodyLine = lines
+        .slice(1)
+        .reverse()
+        .find((line) => line.content.trim() !== "" && !/^\s*#/.test(line.content));
+    if (!lastBodyLine)
+        return { source, gap: "" };
+    const bodyEnd = lastBodyLine.end;
+    return { source: source.slice(0, bodyEnd), gap: source.slice(bodyEnd) };
+}
+function projectTrustPayloadTableBodyHasCommentsOrBlanks(source) {
+    return sourceLines(source).some((line) => line.content.trim() === "" || /^\s*#/.test(line.content));
+}
+function reconcileProjectTrustPayload(payload, payloadInventory, externalProjects, runtimeProjects, runtimeHooksState, externalHookTrustState, projectHooksPath, eol) {
+    const { headers } = payloadInventory;
+    const payloadProjectKeys = new Set(headers.filter((header) => header.kind === "project").map((header) => header.path[1]));
+    const replacementByHeader = new Map();
+    for (const key of payloadProjectKeys) {
+        const projectHeaders = headers.filter((header) => header.kind === "project" && header.path[1] === key);
+        const parent = projectHeaders.find((header) => header.path.length === 2);
+        const payloadValue = projectTrustValueAtPath(payloadInventory.parsed, ["projects", key]);
+        const externalValue = externalProjects[key];
+        const runtimeValue = runtimeProjects[key];
+        if (externalValue !== undefined) {
+            if (!projectTrustEqual(payloadValue, externalValue) || (runtimeValue !== undefined && !projectTrustEqual(runtimeValue, externalValue)))
+                return undefined;
+            for (const header of projectHeaders)
+                replacementByHeader.set(header.start, undefined);
+            continue;
+        }
+        if (runtimeValue === undefined) {
+            for (const header of projectHeaders)
+                replacementByHeader.set(header.start, undefined);
+            continue;
+        }
+        if (!parent || projectHeaders.length !== 1 || !isPlainTomlRecord(runtimeValue))
+            return undefined;
+        const rendered = renderProjectTrust(key, runtimeValue);
+        if (!rendered)
+            return undefined;
+        replacementByHeader.set(parent.start, rendered.replaceAll("\n", eol));
+    }
+    for (const header of headers.filter((candidate) => candidate.kind === "hook")) {
+        const key = header.path[2];
+        const payloadValue = projectTrustValueAtPath(payloadInventory.parsed, header.path);
+        const runtimeValue = runtimeHooksState?.[key];
+        const externalValue = externalHookTrustState?.[key];
+        if (externalValue !== undefined) {
+            if (!projectTrustEqual(payloadValue, externalValue))
+                return undefined;
+            replacementByHeader.set(header.start, undefined);
+            continue;
+        }
+        if (!isPlainTomlRecord(runtimeValue) || typeof runtimeValue.trusted_hash !== "string" || runtimeValue.trusted_hash.length === 0) {
+            replacementByHeader.set(header.start, undefined);
+            continue;
+        }
+        replacementByHeader.set(header.start, `[hooks.state."${escapeTomlBasicString(key)}"]${eol}trusted_hash = "${escapeTomlBasicString(runtimeValue.trusted_hash)}"`);
+    }
+    const leadingGap = payload.slice(0, headers[0]?.start ?? payload.length);
+    const parts = headers.length === 0 ? [] : [leadingGap];
+    let trailingGap = headers.length === 0 ? leadingGap : "";
+    const appendPart = (part) => {
+        if (!part)
+            return;
+        const previous = parts.at(-1);
+        if (previous && !/(?:\r\n|\n)$/.test(previous) && !/^(?:\r\n|\n)/.test(part))
+            parts.push(eol);
+        parts.push(part);
+    };
+    for (const [index, header] of headers.entries()) {
+        const next = headers[index + 1];
+        const segmentEnd = next?.start ?? payload.length;
+        const replacement = replacementByHeader.get(header.start);
+        const span = projectTrustPayloadTableSpan(payload.slice(header.start, segmentEnd));
+        const tableBody = span.source.slice(header.end - header.start);
+        if (replacement !== undefined &&
+            replacement !== span.source &&
+            projectTrustPayloadTableBodyHasCommentsOrBlanks(tableBody)) {
+            return undefined;
+        }
+        if (!next) {
+            trailingGap = span.gap;
+            if (replacement !== undefined)
+                appendPart(replacement);
+            continue;
+        }
+        if (replacement !== undefined)
+            appendPart(replacement);
+        if (span.gap)
+            appendPart(span.gap);
     }
-    catch {
+    const additions = [];
+    for (const [key, value] of Object.entries(runtimeProjects).sort(([left], [right]) => left.localeCompare(right))) {
+        if (externalProjects[key] !== undefined || payloadProjectKeys.has(key))
+            continue;
+        if (!isPlainTomlRecord(value))
+            return undefined;
+        const rendered = renderProjectTrust(key, value);
+        if (!rendered)
+            return undefined;
+        additions.push(`${rendered.replaceAll("\n", eol)}${eol}`);
+    }
+    for (const [key, value] of Object.entries(runtimeHooksState ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
+        if (!key.startsWith(`${projectHooksPath}:`) || externalHookTrustState?.[key] !== undefined || headers.some((header) => header.kind === "hook" && header.path[2] === key))
+            continue;
+        if (!isPlainTomlRecord(value) || typeof value.trusted_hash !== "string" || value.trusted_hash.length === 0)
+            continue;
+        additions.push(`[hooks.state."${escapeTomlBasicString(key)}"]${eol}trusted_hash = "${escapeTomlBasicString(value.trusted_hash)}"${eol}`);
+    }
+    let reconciled = parts.join("");
+    if (additions.length > 0 && reconciled && !/(?:\r\n|\n)$/.test(reconciled))
+        reconciled += eol;
+    reconciled += additions.join("");
+    if (trailingGap && reconciled && !/(?:\r\n|\n)$/.test(reconciled) && !/^(?:\r\n|\n)/.test(trailingGap))
+        reconciled += eol;
+    reconciled += trailingGap;
+    reconciled = reconciled.replace(/(?:\r\n|\n)$/, "");
+    return Object.keys(safeParseToml(reconciled) ?? {}).length === 0 ? "" : reconciled;
+}
+function projectTrustHeaders(config, region) {
+    const lexical = analyzeTomlSource(config);
+    if (!lexical.isUnambiguous)
         return undefined;
+    const lines = sourceLines(config);
+    const headers = [];
+    for (const [index, line] of lines.entries()) {
+        if (line.start < region.start || line.start >= region.end || !lexical.lineStartsOutsideMultiline[index])
+            continue;
+        if (!/^\s*\[/.test(line.content))
+            continue;
+        const path = projectTrustHeaderPath(line.content);
+        if (!path) {
+            if (/^\s*\[\[?\s*(?:projects|"projects"|'projects')/.test(line.content))
+                return undefined;
+            continue;
+        }
+        headers.push({ start: line.start, end: line.end, path });
     }
+    return headers;
 }
-function collectProjectHookTrustStateKeys(config) {
-    const keys = new Set();
+function inventoryProjectTrustSource(config) {
     const parsed = safeParseToml(config);
-    const hooksTable = isPlainTomlRecord(parsed) ? parsed.hooks : undefined;
-    const hooksState = isPlainTomlRecord(hooksTable) ? hooksTable.state : undefined;
-    if (!isPlainTomlRecord(hooksState))
-        return keys;
-    for (const [key, entry] of Object.entries(hooksState)) {
-        if (!isPlainTomlRecord(entry))
+    if (!parsed)
+        return undefined;
+    const projects = parsed.projects;
+    if (projects !== undefined && !isPlainTomlRecord(projects))
+        return undefined;
+    const headers = projectTrustHeaders(config, { start: 0, end: config.length });
+    if (!headers)
+        return undefined;
+    const projectHeaders = headers.filter((header) => header.path[0] === "projects");
+    if (projectHeaders.some((header) => header.path.length < 2))
+        return undefined;
+    for (const key of Object.keys(projects ?? {})) {
+        if (projectHeaders.filter((header) => header.path.length === 2 && header.path[1] === key).length !== 1) {
+            return undefined;
+        }
+    }
+    if (!projectTrustSourceNestedStructuresAreExplicit(parsed, projectHeaders))
+        return undefined;
+    return { projects: projects ?? {}, headers };
+}
+function projectTrustCandidateIsSafe(candidate, external, runtimeProjects) {
+    const marker = projectTrustMarkerRange(candidate);
+    const inventory = inventoryProjectTrustSource(candidate);
+    const externalInventory = inventoryProjectTrustSource(external);
+    if (!inventory || !externalInventory)
+        return false;
+    const hasMarker = marker !== undefined && marker.start !== marker.end;
+    const hasEquivalentExternalBytes = (actual) => {
+        if (actual === external)
+            return true;
+        return splitProjectTrustTrailingEols(actual).body === splitProjectTrustTrailingEols(external).body;
+    };
+    if (hasMarker) {
+        const candidateExternal = `${candidate.slice(0, marker.start)}${candidate.slice(marker.end)}`;
+        if (!hasEquivalentExternalBytes(candidateExternal) && !(candidate.startsWith(external) && candidate.slice(marker.end).length === 0 && /^(?:\r\n|\n)+$/.test(candidate.slice(external.length, marker.start))))
+            return false;
+    }
+    else if (!hasEquivalentExternalBytes(candidate)) {
+        return false;
+    }
+    const expectedProjects = { ...externalInventory.projects, ...runtimeProjects };
+    if (!projectTrustEqual(inventory.projects, expectedProjects))
+        return false;
+    for (const [key, value] of Object.entries(expectedProjects)) {
+        if (!projectTrustEqual(inventory.projects[key], value))
+            return false;
+        if (inventory.headers.filter((header) => header.path[0] === "projects" && header.path.length === 2 && header.path[1] === key).length !== 1)
+            return false;
+    }
+    return true;
+}
+function projectTrustPayloadProjectFamiliesAreValid(headers) {
+    const projectKeys = new Set(headers.filter((header) => header.kind === "project").map((header) => header.path[1]));
+    for (const key of projectKeys) {
+        const family = headers.filter((header) => header.kind === "project" && header.path[1] === key);
+        const parents = family.filter((header) => header.path.length === 2);
+        if (parents.length !== 1 || !projectTrustFamilyIsContiguous(headers, parents[0]))
+            return false;
+    }
+    return true;
+}
+function projectTrustFamilyIsContiguous(headers, parent) {
+    const first = headers.indexOf(parent);
+    let ended = false;
+    for (let index = first + 1; index < headers.length; index += 1) {
+        const path = headers[index].path;
+        const belongsToFamily = path[0] === "projects" && path[1] === parent.path[1];
+        if (!belongsToFamily) {
+            ended = true;
             continue;
-        keys.add(key);
+        }
+        if (ended || path.length < 3)
+            return false;
     }
-    return keys;
+    return true;
 }
-/**
- * Repairs project configs from the 0.18.3 relaunch regression where a
- * project-synced trust block could duplicate setup-owned hook trust tables and
- * make the next runtime CODEX_HOME config.toml invalid before Codex started.
- */
+function projectTrustEqual(left, right) {
+    if (Object.is(left, right))
+        return true;
+    if (left instanceof Date || right instanceof Date) {
+        return left instanceof Date && right instanceof Date && left.constructor === right.constructor && String(left) === String(right);
+    }
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => projectTrustEqual(value, right[index]));
+    }
+    if (!isPlainTomlRecord(left) || !isPlainTomlRecord(right))
+        return false;
+    const leftKeys = Object.keys(left).sort();
+    const rightKeys = Object.keys(right).sort();
+    return leftKeys.length === rightKeys.length && leftKeys.every((key, index) => key === rightKeys[index] && projectTrustEqual(left[key], right[key]));
+}
+function canRenderFlatProjectTrust(entry) {
+    const isValue = (value) => {
+        if (Array.isArray(value))
+            return value.every(isValue);
+        return !isPlainTomlRecord(value);
+    };
+    return Object.values(entry).every(isValue);
+}
+function renderProjectTrust(projectKey, entry) {
+    if (!canRenderFlatProjectTrust(entry))
+        return undefined;
+    const serialized = TOML.stringify({ [projectKey]: entry });
+    const body = serialized.split(/\r?\n/).filter((line) => !/^\s*\[/.test(line) && line.trim() !== "").join("\n");
+    return body ? `[projects."${escapeTomlBasicString(projectKey)}"]\n${body}` : undefined;
+}
+function splitProjectTrustTrailingEols(source) {
+    const match = source.match(/(?:(?:\r\n|\n))*$/);
+    const trailingEols = match?.[0] ?? "";
+    return { body: source.slice(0, source.length - trailingEols.length), trailingEols };
+}
+function appendProjectTrustMarker(base, payload, eol, trailingEols) {
+    if (!payload)
+        return `${splitProjectTrustTrailingEols(base).body}${trailingEols}`;
+    const { body } = splitProjectTrustTrailingEols(base);
+    const separator = body ? `${eol}${eol}` : "";
+    const block = `${OMX_PROJECT_TRUST_START_MARKER}${eol}${payload}${eol}${OMX_PROJECT_TRUST_END_MARKER}`;
+    return `${body}${separator}${block}${trailingEols}`;
+}
+function reconcileProjectScopeTrustState(projectConfig, runtimeConfig, projectHooksPath, requireExistingPayload) {
+    const durable = projectTrustSemanticView(projectConfig);
+    const runtime = projectTrustSemanticView(runtimeConfig);
+    if (!durable || !runtime)
+        return projectConfig;
+    if (hasInlineProjectTrustMarkerComment(durable.source) || hasInlineProjectTrustMarkerComment(runtime.source))
+        return projectConfig;
+    const parsedRuntime = safeParseToml(runtime.source);
+    const runtimeInventory = inventoryProjectTrustSource(runtime.source);
+    if (!parsedRuntime || !runtimeInventory)
+        return projectConfig;
+    const marker = projectTrustMarkerRange(durable.source);
+    if (!marker)
+        return projectConfig;
+    const hasMarker = marker.start !== marker.end;
+    const payload = durable.source.slice(marker.payloadStart, marker.payloadEnd);
+    const payloadIsEmpty = projectTrustPayloadIsSemanticallyEmpty(payload);
+    const payloadInventory = hasMarker
+        ? inventoryProjectTrustPayload(payload, projectHooksPath)
+        : { parsed: {}, headers: [] };
+    if (!payloadInventory)
+        return projectConfig;
+    if (requireExistingPayload && (!hasMarker || payloadIsEmpty))
+        return projectConfig;
+    const external = hasMarker
+        ? `${durable.source.slice(0, marker.start)}${durable.source.slice(marker.end)}`
+        : durable.source;
+    const trailingEols = splitProjectTrustTrailingEols(durable.source).trailingEols;
+    const externalInventory = inventoryProjectTrustSource(external);
+    if (!externalInventory)
+        return projectConfig;
+    const projects = runtimeInventory.projects;
+    const externalProjects = externalInventory.projects;
+    const headersBeforeMarker = projectTrustHeaders(durable.source, { start: 0, end: marker.start });
+    const headersAfterMarker = projectTrustHeaders(durable.source, { start: marker.end, end: durable.source.length });
+    if (!headersBeforeMarker || !headersAfterMarker)
+        return projectConfig;
+    const headers = [...headersBeforeMarker, ...headersAfterMarker];
+    for (const key of Object.keys(externalProjects)) {
+        const family = headers.filter((header) => header.path[0] === "projects" && header.path[1] === key);
+        const parents = family.filter((header) => header.path.length === 2);
+        if (parents.length !== 1)
+            return projectConfig;
+        const parentIsBeforeMarker = parents[0].start < marker.start;
+        if (family.some((header) => (header.start < marker.start) !== parentIsBeforeMarker))
+            return projectConfig;
+        if (!projectTrustFamilyIsContiguous(headers, parents[0]))
+            return projectConfig;
+    }
+    const eol = dominantProjectTrustEol(durable.source);
+    const hooks = parsedRuntime.hooks;
+    const hooksState = isPlainTomlRecord(hooks) && isPlainTomlRecord(hooks.state) ? hooks.state : undefined;
+    const nextPayload = reconcileProjectTrustPayload(payload, payloadInventory, externalProjects, projects, hooksState, projectHookTrustState(external), projectHooksPath, eol);
+    if (nextPayload === undefined)
+        return projectConfig;
+    if (!inventoryProjectTrustPayload(nextPayload, projectHooksPath))
+        return projectConfig;
+    const candidate = appendProjectTrustMarker(external, nextPayload, eol, trailingEols);
+    if (!projectTrustCandidateIsSafe(candidate, external, projects))
+        return projectConfig;
+    return `${durable.prefix}${candidate}`;
+}
+/** Repairs only a uniquely parseable, nonempty project-sync payload before mirror creation. */
 export function repairProjectScopeTrustStateForLaunch(projectConfig, projectHooksPath) {
-    const syncedTrustBlock = extractMarkerBlockContent(projectConfig, OMX_PROJECT_TRUST_START_MARKER, OMX_PROJECT_TRUST_END_MARKER);
-    if (!syncedTrustBlock)
+    const durable = projectTrustSemanticView(projectConfig);
+    if (!durable)
+        return projectConfig;
+    const marker = projectTrustMarkerRange(durable.source);
+    if (!marker || marker.start === marker.end)
         return projectConfig;
-    const stripped = stripMarkerBlock(projectConfig, OMX_PROJECT_TRUST_START_MARKER, OMX_PROJECT_TRUST_END_MARKER);
-    const repaired = syncProjectScopeTrustStateFromRuntime(stripped, syncedTrustBlock, projectHooksPath);
-    return repaired === stripped ? projectConfig : repaired;
+    const payload = durable.source.slice(marker.payloadStart, marker.payloadEnd);
+    return reconcileProjectScopeTrustState(projectConfig, payload, projectHooksPath, true);
+}
+/** Conservatively persists runtime project and hook trust without rewriting external TOML. */
+export function syncProjectScopeTrustStateFromRuntime(projectConfig, runtimeConfig, projectHooksPath) {
+    return reconcileProjectScopeTrustState(projectConfig, runtimeConfig, projectHooksPath, false);
+}
+function isMultilineTomlString(mode) {
+    return mode === "multiline-basic" || mode === "multiline-literal";
 }
 /**
- * Project-scope launches mirror the durable project config.toml into an
- * ephemeral runtime CODEX_HOME. Codex writes its workspace-trust ledger and
- * hook trust ledger into the runtime config.toml during the session. Without
- * persistence, those entries die with the runtime, so Codex prompts to trust
- * the workspace and hooks on every launch (issue #2470).
- *
- * This function extracts only trust-state tables (`[projects."<cwd>"]` and
- * `[hooks.state."<projectHooksPath>:..."]`) from the runtime config.toml and
- * upserts them into the durable project config.toml inside a marker-fenced
- * block, preserving any surrounding user-managed content and comments and
- * ignoring Codex's NUX counters or other ephemeral runtime-only writes.
+ * Tracks only lexical boundaries needed to safely associate source lines with
+ * TOML statements. TOML's parser gives us semantics; this prevents source
+ * repair from treating table-like text in a multiline value as syntax.
  */
-export function syncProjectScopeTrustStateFromRuntime(projectConfig, runtimeConfig, projectHooksPath) {
-    const parsed = safeParseToml(runtimeConfig);
-    if (!parsed)
-        return projectConfig;
-    const stripped = stripMarkerBlock(projectConfig, OMX_PROJECT_TRUST_START_MARKER, OMX_PROJECT_TRUST_END_MARKER);
-    const existingHookTrustStateKeys = collectProjectHookTrustStateKeys(stripped);
-    const trustBlockLines = [];
-    const projectsTable = parsed.projects;
-    if (isPlainTomlRecord(projectsTable)) {
-        for (const [projectKey, entry] of Object.entries(projectsTable).sort(([a], [b]) => a.localeCompare(b))) {
-            if (!isPlainTomlRecord(entry))
+function analyzeTomlSource(config) {
+    const lines = config.split(/\r?\n/);
+    const lineStartsOutsideMultiline = [];
+    const lineHasTomlComment = [];
+    let mode;
+    let isUnambiguous = true;
+    for (const line of lines) {
+        lineStartsOutsideMultiline.push(!isMultilineTomlString(mode));
+        let hasComment = false;
+        for (let index = 0; index < line.length; index += 1) {
+            const character = line[index];
+            if (mode === "basic") {
+                if (character === "\\") {
+                    index += 1;
+                }
+                else if (character === "\"") {
+                    mode = undefined;
+                }
                 continue;
-            const serialized = TOML.stringify({ [projectKey]: entry });
-            const renderedHeader = `[projects."${escapeTomlBasicString(projectKey)}"]`;
-            const body = serialized
-                .split(/\r?\n/)
-                .filter((line) => !/^\s*\[/.test(line) && line.trim() !== "")
-                .join("\n");
-            if (body.length === 0)
+            }
+            if (mode === "literal") {
+                if (character === "'")
+                    mode = undefined;
                 continue;
-            trustBlockLines.push(renderedHeader, body, "");
-        }
-    }
-    const hooksTable = parsed.hooks;
-    const hooksState = isPlainTomlRecord(hooksTable) ? hooksTable.state : undefined;
-    if (isPlainTomlRecord(hooksState)) {
-        for (const [stateKey, entry] of Object.entries(hooksState).sort(([a], [b]) => a.localeCompare(b))) {
-            if (!isPlainTomlRecord(entry))
+            }
+            if (mode === "multiline-basic" || mode === "multiline-literal") {
+                const delimiter = mode === "multiline-basic" ? "\"" : "'";
+                if (mode === "multiline-basic" && character === "\\") {
+                    index += 1;
+                    continue;
+                }
+                if (character !== delimiter)
+                    continue;
+                let runEnd = index + 1;
+                while (line[runEnd] === delimiter)
+                    runEnd += 1;
+                if (runEnd - index >= 3) {
+                    // TOML permits one or two delimiter characters immediately before
+                    // the closing triple delimiter as string content.
+                    mode = undefined;
+                    index = runEnd - 1;
+                }
                 continue;
-            if (!stateKey.startsWith(`${projectHooksPath}:`))
+            }
+            if (character === "#") {
+                hasComment = true;
+                break;
+            }
+            if (character !== "\"" && character !== "'")
                 continue;
-            if (existingHookTrustStateKeys.has(stateKey))
+            const isMultiline = line[index + 1] === character && line[index + 2] === character;
+            if (isMultiline) {
+                mode = character === "\"" ? "multiline-basic" : "multiline-literal";
+                index += 2;
+            }
+            else {
+                mode = character === "\"" ? "basic" : "literal";
+            }
+        }
+        lineHasTomlComment.push(hasComment);
+        if (mode === "basic" || mode === "literal")
+            isUnambiguous = false;
+    }
+    if (isMultilineTomlString(mode))
+        isUnambiguous = false;
+    return { lines, lineStartsOutsideMultiline, lineHasTomlComment, isUnambiguous };
+}
+function skipTomlSourceWhitespace(line, index) {
+    let cursor = index;
+    while (line[cursor] === " " || line[cursor] === "\t")
+        cursor += 1;
+    return cursor;
+}
+function parseTomlSourceKeySegment(line, index) {
+    const start = skipTomlSourceWhitespace(line, index);
+    const first = line[start];
+    if (!first)
+        return undefined;
+    if (first !== '"' && first !== "'") {
+        const match = /^[A-Za-z0-9_-]+/.exec(line.slice(start));
+        if (!match)
+            return undefined;
+        return { key: match[0], end: start + match[0].length, incomplete: false };
+    }
+    let cursor = start + 1;
+    let escaped = false;
+    for (; cursor < line.length; cursor += 1) {
+        const character = line[cursor];
+        if (first === '"' && escaped) {
+            escaped = false;
+            continue;
+        }
+        if (first === '"' && character === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (character !== first)
+            continue;
+        const token = line.slice(start, cursor + 1);
+        const parsed = safeParseToml(`${token} = true`);
+        const keys = parsed ? Object.keys(parsed) : [];
+        const hasKey = keys.length === 1;
+        return {
+            ...(hasKey ? { key: keys[0] } : {}),
+            end: cursor + 1,
+            incomplete: !hasKey,
+        };
+    }
+    return { end: line.length, incomplete: true };
+}
+function isTomlSourceKey(segment, key) {
+    return segment.key === key;
+}
+function findTomlSourceAssignmentSeparator(line) {
+    let segment = parseTomlSourceKeySegment(line, 0);
+    if (!segment || segment.incomplete)
+        return undefined;
+    let cursor = skipTomlSourceWhitespace(line, segment.end);
+    while (line[cursor] === ".") {
+        segment = parseTomlSourceKeySegment(line, cursor + 1);
+        if (!segment || segment.incomplete)
+            return undefined;
+        cursor = skipTomlSourceWhitespace(line, segment.end);
+    }
+    return line[cursor] === "=" ? cursor : undefined;
+}
+function advancePastInlineTomlValue(line, index) {
+    let braces = 0;
+    let brackets = 0;
+    let quote;
+    let escaped = false;
+    for (let cursor = index; cursor < line.length; cursor += 1) {
+        const character = line[cursor];
+        if (quote) {
+            if (quote === '"' && escaped) {
+                escaped = false;
+            }
+            else if (quote === '"' && character === "\\") {
+                escaped = true;
+            }
+            else if (character === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (character === '"' || character === "'") {
+            quote = character;
+            continue;
+        }
+        if (character === "#")
+            return line.length;
+        if (character === "{") {
+            braces += 1;
+            continue;
+        }
+        if (character === "}") {
+            if (braces === 0 && brackets === 0)
+                return cursor;
+            braces = Math.max(0, braces - 1);
+            continue;
+        }
+        if (character === "[") {
+            brackets += 1;
+            continue;
+        }
+        if (character === "]") {
+            brackets = Math.max(0, brackets - 1);
+            continue;
+        }
+        if (character === "," && braces === 0 && brackets === 0)
+            return cursor + 1;
+    }
+    return line.length;
+}
+function inlineTomlTableMaySpellStateKey(line, index) {
+    let cursor = index;
+    while (cursor < line.length) {
+        cursor = skipTomlSourceWhitespace(line, cursor);
+        // A comment cannot close the surrounding inline table.
+        if (line[cursor] === "#")
+            return true;
+        if (line[cursor] === "}")
+            return false;
+        const segment = parseTomlSourceKeySegment(line, cursor);
+        if (!segment)
+            return true;
+        if (segment.incomplete || isTomlSourceKey(segment, "state"))
+            return true;
+        cursor = skipTomlSourceWhitespace(line, segment.end);
+        if (line[cursor] !== "=")
+            return true;
+        cursor = advancePastInlineTomlValue(line, cursor + 1);
+        if (line[cursor] === "}")
+            return false;
+    }
+    // The unclosed inline table can acquire a state member on a following
+    // unparsed line, so it is not safe to strip the containing marker block.
+    return true;
+}
+function lineMaySpellHooksState(line) {
+    let cursor = skipTomlSourceWhitespace(line, 0);
+    if (line[cursor] === "[") {
+        if (line[cursor + 1] === "[") {
+            cursor = skipTomlSourceWhitespace(line, cursor + 2);
+        }
+        else {
+            cursor = skipTomlSourceWhitespace(line, cursor + 1);
+        }
+    }
+    const hooks = parseTomlSourceKeySegment(line, cursor);
+    if (!hooks || !isTomlSourceKey(hooks, "hooks"))
+        return false;
+    cursor = skipTomlSourceWhitespace(line, hooks.end);
+    if (line[cursor] === ".") {
+        const state = parseTomlSourceKeySegment(line, cursor + 1);
+        // A dangling dot can be completed by a following unparsed state key.
+        return state === undefined || state.incomplete || isTomlSourceKey(state, "state");
+    }
+    if (line[cursor] !== "=")
+        return false;
+    cursor = skipTomlSourceWhitespace(line, cursor + 1);
+    // A bare assignment or comment cannot prove that a following unparsed line
+    // does not continue an inline hooks table with a state member.
+    if (cursor >= line.length || line[cursor] === "#")
+        return true;
+    return line[cursor] === "{" && inlineTomlTableMaySpellStateKey(line, cursor + 1);
+}
+/**
+ * Detects a potential array-table opener without accepting malformed spacing
+ * or extra opening brackets as TOML syntax. Array tables rooted at `hooks`
+ * have no proof-owned representation, so their first key segment is enough
+ * to retain a managed marker block rather than strip it.
+ */
+function parseTomlSourceArrayTableOpener(line) {
+    let cursor = skipTomlSourceWhitespace(line, 0);
+    if (line[cursor] !== "[")
+        return undefined;
+    const hasExactAdjacentOpener = line[cursor + 1] === "[";
+    if (hasExactAdjacentOpener) {
+        cursor += 2;
+    }
+    else {
+        cursor = skipTomlSourceWhitespace(line, cursor + 1);
+        if (line[cursor] !== "[")
+            return undefined;
+        cursor += 1;
+    }
+    cursor = skipTomlSourceWhitespace(line, cursor);
+    while (line[cursor] === "[") {
+        cursor = skipTomlSourceWhitespace(line, cursor + 1);
+    }
+    const firstKey = parseTomlSourceKeySegment(line, cursor);
+    return {
+        firstKey,
+        openerOnly: firstKey === undefined &&
+            (cursor >= line.length || line[cursor] === "#"),
+    };
+}
+function hasIncompleteTomlSourceHooksKeyPrefix(line) {
+    let cursor = skipTomlSourceWhitespace(line, 0);
+    let tableHeader = false;
+    let arrayTableHeader = false;
+    if (line[cursor] === "[") {
+        tableHeader = true;
+        if (line[cursor + 1] === "[") {
+            arrayTableHeader = true;
+            cursor = skipTomlSourceWhitespace(line, cursor + 2);
+        }
+        else {
+            cursor = skipTomlSourceWhitespace(line, cursor + 1);
+        }
+    }
+    const hooks = parseTomlSourceKeySegment(line, cursor);
+    if (!hooks || !isTomlSourceKey(hooks, "hooks"))
+        return false;
+    cursor = skipTomlSourceWhitespace(line, hooks.end);
+    if (!tableHeader)
+        return cursor >= line.length || line[cursor] === "#";
+    if (line[cursor] !== "]" || (arrayTableHeader && line[cursor + 1] !== "]")) {
+        return true;
+    }
+    const suffix = line.slice(cursor + (arrayTableHeader ? 2 : 1)).trimStart();
+    return suffix.length > 0 && !suffix.startsWith("#");
+}
+function isTomlSourceHooksKeyContinuationSeparator(line) {
+    const cursor = skipTomlSourceWhitespace(line, 0);
+    return line[cursor] === "." || line[cursor] === "=" || line[cursor] === "[";
+}
+function isTomlSourceBlankOrComment(line) {
+    return /^\s*(?:#.*)?$/.test(line);
+}
+function isTomlSourceStandaloneOpeningBracket(line) {
+    const cursor = skipTomlSourceWhitespace(line, 0);
+    if (line[cursor] !== "[")
+        return false;
+    const next = skipTomlSourceWhitespace(line, cursor + 1);
+    return next >= line.length || line[next] === "#";
+}
+function firstTomlSourceKeyFollowingOpeningBrackets(line) {
+    let cursor = skipTomlSourceWhitespace(line, 0);
+    while (line[cursor] === "[") {
+        cursor = skipTomlSourceWhitespace(line, cursor + 1);
+    }
+    return parseTomlSourceKeySegment(line, cursor);
+}
+function lineMaySpellStateKey(line) {
+    const state = parseTomlSourceKeySegment(line, 0);
+    return state !== undefined && (state.incomplete || isTomlSourceKey(state, "state"));
+}
+function isTomlSourceHooksTableHeader(parsed) {
+    const hooks = parsed?.hooks;
+    return parsed !== undefined &&
+        Object.keys(parsed).length === 1 &&
+        isPlainTomlRecord(hooks) &&
+        Object.keys(hooks).length === 0;
+}
+function hasUnprovenManagedMarkerHooksStateSyntax(source, managedMarkerRanges, parsedStatementSpans, parsedAssignmentSpans) {
+    const parsedLines = new Set();
+    const parsedStatementStartLines = new Set();
+    for (const span of parsedStatementSpans) {
+        parsedStatementStartLines.add(span.start);
+        for (let index = span.start; index < span.end; index += 1)
+            parsedLines.add(index);
+    }
+    const parsedAssignmentLines = new Set();
+    for (const span of parsedAssignmentSpans) {
+        for (let index = span.start; index < span.end; index += 1) {
+            parsedAssignmentLines.add(index);
+        }
+    }
+    const managedContentLines = new Set();
+    for (const range of managedMarkerRanges) {
+        for (let index = range.start + 1; index < range.end; index += 1) {
+            managedContentLines.add(index);
+        }
+    }
+    let insideHooksTable = false;
+    let hasIncompleteHooksKeyPrefix = false;
+    let hasIncompleteHooksArrayTableOpener = false;
+    for (let index = 0; index < source.lines.length; index += 1) {
+        if (!source.lineStartsOutsideMultiline[index]) {
+            hasIncompleteHooksKeyPrefix = false;
+            hasIncompleteHooksArrayTableOpener = false;
+            continue;
+        }
+        const line = source.lines[index] ?? "";
+        const isParsedAssignmentLine = parsedAssignmentLines.has(index);
+        if (!isParsedAssignmentLine) {
+            const header = parseTomlSourceTableHeader(line);
+            if (header?.parsed) {
+                insideHooksTable = isTomlSourceHooksTableHeader(header.parsed);
+            }
+        }
+        if (!managedContentLines.has(index)) {
+            hasIncompleteHooksKeyPrefix = false;
+            hasIncompleteHooksArrayTableOpener = false;
+            continue;
+        }
+        const isParsedStatementLine = parsedLines.has(index);
+        const isParsedStatementStartLine = parsedStatementStartLines.has(index);
+        if (hasIncompleteHooksKeyPrefix) {
+            if (isTomlSourceBlankOrComment(line))
                 continue;
-            const trusted = entry.trusted_hash;
-            if (typeof trusted !== "string" || trusted.length === 0)
+            if (isTomlSourceHooksKeyContinuationSeparator(line))
+                return true;
+            hasIncompleteHooksKeyPrefix = false;
+        }
+        // Parsed statements can contain nested arrays whose standalone brackets and
+        // quoted "hooks" values must not contribute to malformed-header tracking.
+        if (hasIncompleteHooksArrayTableOpener && !isParsedStatementLine) {
+            if (isTomlSourceBlankOrComment(line))
                 continue;
-            trustBlockLines.push(`[hooks.state."${escapeTomlBasicString(stateKey)}"]`, `trusted_hash = "${escapeTomlBasicString(trusted)}"`, "");
+            const firstKey = firstTomlSourceKeyFollowingOpeningBrackets(line);
+            if (firstKey) {
+                if (isTomlSourceKey(firstKey, "hooks"))
+                    return true;
+                hasIncompleteHooksArrayTableOpener = false;
+            }
         }
+        const arrayTableOpener = !isParsedStatementLine || isParsedStatementStartLine
+            ? parseTomlSourceArrayTableOpener(line)
+            : undefined;
+        if (arrayTableOpener?.firstKey && isTomlSourceKey(arrayTableOpener.firstKey, "hooks")) {
+            return true;
+        }
+        if (arrayTableOpener?.openerOnly && !isParsedStatementLine) {
+            hasIncompleteHooksArrayTableOpener = true;
+        }
+        if (!isParsedStatementLine && isTomlSourceStandaloneOpeningBracket(line)) {
+            hasIncompleteHooksArrayTableOpener = true;
+        }
+        if (isParsedStatementLine)
+            continue;
+        if (lineMaySpellHooksState(line) || (insideHooksTable && lineMaySpellStateKey(line))) {
+            return true;
+        }
+        const hasIncompleteHooksPrefix = hasIncompleteTomlSourceHooksKeyPrefix(line);
+        if (hasIncompleteHooksPrefix && /^\s*\[\[?/.test(line))
+            return true;
+        hasIncompleteHooksKeyPrefix = hasIncompleteHooksPrefix;
     }
-    if (trustBlockLines.length === 0) {
-        return stripped.length === 0 ? "" : `${stripped}\n`;
-    }
-    const block = [
-        OMX_PROJECT_TRUST_START_MARKER,
-        ...trustBlockLines,
-        OMX_PROJECT_TRUST_END_MARKER,
-        "",
-    ].join("\n");
-    if (stripped.length === 0)
-        return block;
-    return `${stripped}\n\n${block}`;
+    return false;
 }
-function decodeTomlBasicString(raw) {
-    try {
-        const parsed = TOML.parse(`value = "${raw}"`);
-        return typeof parsed.value === "string" ? parsed.value : undefined;
+function managedHookTrustStateExpectations(...states) {
+    const expectations = new Map();
+    for (const state of states) {
+        if (!state)
+            continue;
+        for (const [key, entry] of Object.entries(state)) {
+            const hashes = expectations.get(key) ?? new Set();
+            hashes.add(entry.trusted_hash);
+            expectations.set(key, hashes);
+        }
     }
-    catch {
+    return expectations;
+}
+function managedHookTrustCoordinateFamily(key) {
+    const match = /^(.*):([a-z_]+):\d+:\d+$/.exec(key);
+    return match ? `${match[1]}:${match[2]}` : undefined;
+}
+function expectedManagedHookTrustHashes(expectations, key, allowCoordinateDrift) {
+    const exact = expectations.get(key);
+    if (exact || !allowCoordinateDrift)
+        return exact;
+    const family = managedHookTrustCoordinateFamily(key);
+    if (!family)
         return undefined;
+    const hashes = new Set();
+    for (const [expectedKey, expectedHashes] of expectations) {
+        if (managedHookTrustCoordinateFamily(expectedKey) !== family)
+            continue;
+        for (const hash of expectedHashes)
+            hashes.add(hash);
     }
+    return hashes.size > 0 ? hashes : undefined;
 }
-function parseHooksStateHeader(line) {
-    const match = line.match(/^\s*\[hooks\.state\."((?:\\.|[^"\\])*)"\]\s*(#.*)?$/);
-    if (!match)
+function tomlHooksStateValue(parsed) {
+    if (!parsed)
         return undefined;
-    const key = decodeTomlBasicString(match[1] ?? "");
-    if (key === undefined)
+    const hooks = parsed.hooks;
+    if (!isPlainTomlRecord(hooks) || !Object.hasOwn(hooks, "state")) {
         return undefined;
-    return { key, hasInlineComment: match[2] !== undefined };
+    }
+    return hooks.state;
 }
-function isTomlTableHeader(line) {
-    return /^\s*\[\[?[^\]]+\]?\]\s*(?:#.*)?$/.test(line);
+function tomlHooksStateEntries(parsed) {
+    const state = tomlHooksStateValue(parsed);
+    return isPlainTomlRecord(state) ? state : undefined;
 }
-function isExactlyManagedHookTrustBody(bodyLines, expectedHash) {
-    const nonBlank = bodyLines.filter((line) => line.trim().length > 0);
-    if (nonBlank.length !== 1)
+function hasOnlyManagedHookTrustStateField(parsed, key) {
+    if (!parsed || Object.keys(parsed).length !== 1 || !Object.hasOwn(parsed, "hooks")) {
+        return false;
+    }
+    const hooks = parsed.hooks;
+    if (!isPlainTomlRecord(hooks) || Object.keys(hooks).length !== 1 || !Object.hasOwn(hooks, "state")) {
         return false;
-    const expected = expectedHash.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    return new RegExp(`^\\s*trusted_hash\\s*=\\s*"${expected}"\\s*$`).test(nonBlank[0] ?? "");
+    }
+    const state = hooks.state;
+    return isPlainTomlRecord(state) &&
+        Object.keys(state).length === 1 &&
+        Object.hasOwn(state, key);
 }
-function stripProofManagedCodexHookTrustStateTables(config, managedTrustState) {
-    if (Object.keys(managedTrustState).length === 0) {
-        return { config, preservedConflictKeys: new Set() };
+function parseTomlSourceTableHeader(line) {
+    const start = line.search(/\S/);
+    if (start === -1 || line[start] !== "[")
+        return undefined;
+    const array = line[start + 1] === "[";
+    let quote;
+    let escaped = false;
+    for (let index = start + (array ? 2 : 1); index < line.length; index += 1) {
+        const character = line[index];
+        if (quote === "\"") {
+            if (escaped) {
+                escaped = false;
+            }
+            else if (character === "\\") {
+                escaped = true;
+            }
+            else if (character === quote) {
+                quote = undefined;
+            }
+            continue;
+        }
+        if (quote === "'") {
+            if (character === quote)
+                quote = undefined;
+            continue;
+        }
+        if (character === "\"" || character === "'") {
+            quote = character;
+            continue;
+        }
+        if (character !== "]")
+            continue;
+        const end = array ? index + 2 : index + 1;
+        if (array && line[index + 1] !== "]")
+            return undefined;
+        const suffix = line.slice(end).trimStart();
+        if (suffix.length > 0 && !suffix.startsWith("#"))
+            return undefined;
+        return { parsed: safeParseToml(line.slice(start, end)) };
     }
-    const lines = config.split(/\r?\n/);
-    const kept = [];
-    const preservedConflictKeys = new Set();
-    for (let i = 0; i < lines.length;) {
-        const header = parseHooksStateHeader(lines[i] ?? "");
-        if (!header) {
-            kept.push(lines[i]);
-            i += 1;
+    return undefined;
+}
+function sourceRangeHasTomlComment(source, start, end) {
+    for (let index = start; index < end; index += 1) {
+        if (source.lineHasTomlComment[index])
+            return true;
+    }
+    return false;
+}
+function collectMarkerRanges(source, startMarker, endMarker, includeUnterminatedRange = false, inertAssignmentSpans = []) {
+    const isInsideInertAssignment = (line) => inertAssignmentSpans.some((span) => span.start <= line && line < span.end);
+    const ranges = [];
+    for (let start = 0; start < source.lines.length; start += 1) {
+        if (!source.lineStartsOutsideMultiline[start] ||
+            isInsideInertAssignment(start) ||
+            source.lines[start]?.trim() !== startMarker)
+            continue;
+        const end = source.lines.findIndex((line, index) => index > start &&
+            source.lineStartsOutsideMultiline[index] &&
+            !isInsideInertAssignment(index) &&
+            line.trim() === endMarker);
+        const nestedStart = source.lines.findIndex((line, index) => index > start &&
+            source.lineStartsOutsideMultiline[index] &&
+            !isInsideInertAssignment(index) &&
+            line.trim() === startMarker);
+        if (end === -1 || (nestedStart !== -1 && nestedStart < end)) {
+            if (includeUnterminatedRange)
+                ranges.push({ start, end: source.lines.length });
             continue;
         }
-        let tableEnd = lines.length;
-        for (let next = i + 1; next < lines.length; next += 1) {
-            if (isTomlTableHeader(lines[next] ?? "")) {
-                tableEnd = next;
-                break;
+        ranges.push({ start, end });
+        start = end;
+    }
+    return ranges;
+}
+function recordManagedMarkerHooksStateSourceSpan(spans, invalidSpans, start, end, parsed, insideManagedMarkerBlock) {
+    if (!insideManagedMarkerBlock)
+        return;
+    const state = tomlHooksStateValue(parsed);
+    if (state === undefined)
+        return;
+    const span = { start, end };
+    spans.push(span);
+    if (!isPlainTomlRecord(state) || Object.keys(state).length === 0) {
+        invalidSpans.push(span);
+    }
+}
+function addManagedHookTrustStateSourceRepresentations(representations, markerContainedHooksStateSpans, invalidMarkerContainedHooksStateSpans, source, start, end, parsed, insideManagedMarkerBlock, containingTableScope, fallbackKeys = []) {
+    recordManagedMarkerHooksStateSourceSpan(markerContainedHooksStateSpans, invalidMarkerContainedHooksStateSpans, start, end, parsed, insideManagedMarkerBlock);
+    const state = tomlHooksStateEntries(parsed);
+    const hasComment = sourceRangeHasTomlComment(source, start, end);
+    if (state) {
+        const stateEntryCount = Object.keys(state).length;
+        for (const [key, value] of Object.entries(state)) {
+            const hasExactSemanticScope = hasOnlyManagedHookTrustStateField(parsed, key) &&
+                (!containingTableScope ||
+                    (!containingTableScope.hasComment &&
+                        hasOnlyManagedHookTrustStateField(containingTableScope.parsed, key)));
+            const entries = representations.get(key) ?? [];
+            entries.push({
+                start,
+                end,
+                stateEntryCount,
+                value,
+                hasComment,
+                hasExactSemanticScope,
+                insideManagedMarkerBlock,
+            });
+            representations.set(key, entries);
+        }
+        return;
+    }
+    for (const key of fallbackKeys) {
+        const entries = representations.get(key) ?? [];
+        entries.push({
+            start,
+            end,
+            stateEntryCount: 0,
+            value: undefined,
+            hasComment,
+            hasExactSemanticScope: false,
+            insideManagedMarkerBlock,
+        });
+        representations.set(key, entries);
+    }
+}
+function collectManagedHookTrustStateSourceRepresentations(config) {
+    const source = analyzeTomlSource(config);
+    const { lines } = source;
+    const parsedAssignmentSpans = [];
+    for (let cursor = 0; cursor < lines.length; cursor += 1) {
+        if (!source.lineStartsOutsideMultiline[cursor])
+            continue;
+        const line = lines[cursor] ?? "";
+        if (findTomlSourceAssignmentSeparator(line) === undefined)
+            continue;
+        for (let statementEnd = cursor + 1; statementEnd <= lines.length; statementEnd += 1) {
+            if (!safeParseToml(lines.slice(cursor, statementEnd).join("\n")))
+                continue;
+            parsedAssignmentSpans.push({ start: cursor, end: statementEnd });
+            cursor = statementEnd - 1;
+            break;
+        }
+    }
+    const headers = [];
+    for (const [index, line] of lines.entries()) {
+        if (!source.lineStartsOutsideMultiline[index])
+            continue;
+        const header = parseTomlSourceTableHeader(line);
+        if (parsedAssignmentSpans.some((span) => span.start < index && index < span.end))
+            continue;
+        if (header)
+            headers.push({ index, header });
+    }
+    const boundaries = new Set(headers.map(({ index }) => index));
+    for (const [index, line] of lines.entries()) {
+        if (source.lineStartsOutsideMultiline[index] &&
+            (line.trim() === OMX_HOOK_TRUST_END_MARKER ||
+                line.trim() === OMX_CONFIG_END_MARKER)) {
+            boundaries.add(index);
+        }
+    }
+    const sortedBoundaries = [...boundaries].sort((left, right) => left - right);
+    const representations = new Map();
+    const markerContainedHooksStateSpans = [];
+    const invalidMarkerContainedHooksStateSpans = [];
+    const parsedStatementSpans = [];
+    const managedMarkerRanges = [
+        ...collectMarkerRanges(source, OMX_HOOK_TRUST_START_MARKER, OMX_HOOK_TRUST_END_MARKER, false, parsedAssignmentSpans),
+        ...collectMarkerRanges(source, OMX_CONFIG_START_MARKER, OMX_CONFIG_END_MARKER, true, parsedAssignmentSpans),
+    ];
+    const isInsideManagedMarkerBlock = (start, end) => managedMarkerRanges.some((range) => start > range.start && end <= range.end);
+    const collectAssignments = (start, end, prefix, containingTableScope) => {
+        for (let cursor = start; cursor < end;) {
+            const line = lines[cursor] ?? "";
+            if (!source.lineStartsOutsideMultiline[cursor] ||
+                line.trim().length === 0 ||
+                line.trim() === OMX_HOOK_TRUST_START_MARKER ||
+                line.trim() === OMX_CONFIG_START_MARKER) {
+                cursor += 1;
+                continue;
+            }
+            let parsed;
+            let statementEnd = cursor + 1;
+            for (; statementEnd <= end; statementEnd += 1) {
+                const statement = lines.slice(cursor, statementEnd).join("\n");
+                parsed = safeParseToml(prefix ? `${prefix}\n${statement}` : statement);
+                if (parsed)
+                    break;
             }
+            if (!parsed) {
+                cursor += 1;
+                continue;
+            }
+            parsedStatementSpans.push({ start: cursor, end: statementEnd });
+            addManagedHookTrustStateSourceRepresentations(representations, markerContainedHooksStateSpans, invalidMarkerContainedHooksStateSpans, source, cursor, statementEnd, parsed, isInsideManagedMarkerBlock(cursor, statementEnd), containingTableScope);
+            cursor = statementEnd;
         }
-        const expectedState = managedTrustState[header.key];
-        const removable = expectedState !== undefined &&
-            !header.hasInlineComment &&
-            isExactlyManagedHookTrustBody(lines.slice(i + 1, tableEnd), expectedState.trusted_hash);
-        if (removable) {
-            i = tableEnd;
+    };
+    const rootEnd = sortedBoundaries[0] ?? lines.length;
+    collectAssignments(0, rootEnd, undefined);
+    for (const { index, header } of headers) {
+        const boundaryIndex = sortedBoundaries.findIndex((boundary) => boundary === index);
+        const end = boundaryIndex === -1
+            ? lines.length
+            : (sortedBoundaries[boundaryIndex + 1] ?? lines.length);
+        const tableScope = {
+            parsed: safeParseToml(lines.slice(index, end).join("\n")),
+            hasComment: sourceRangeHasTomlComment(source, index, end),
+        };
+        if (tableScope.parsed)
+            parsedStatementSpans.push({ start: index, end });
+        const insideManagedMarkerBlock = isInsideManagedMarkerBlock(index, end);
+        recordManagedMarkerHooksStateSourceSpan(markerContainedHooksStateSpans, invalidMarkerContainedHooksStateSpans, index, end, tableScope.parsed, insideManagedMarkerBlock);
+        const headerState = tomlHooksStateEntries(header.parsed);
+        const directKeys = Object.keys(headerState ?? {});
+        if (directKeys.length > 0) {
+            addManagedHookTrustStateSourceRepresentations(representations, markerContainedHooksStateSpans, invalidMarkerContainedHooksStateSpans, source, index, end, tableScope.parsed, insideManagedMarkerBlock, undefined, directKeys);
             continue;
         }
-        if (expectedState !== undefined) {
-            preservedConflictKeys.add(header.key);
+        collectAssignments(index + 1, end, lines[index], tableScope);
+    }
+    return {
+        source,
+        representations,
+        managedMarkerRanges,
+        markerContainedHooksStateSpans,
+        invalidMarkerContainedHooksStateSpans,
+        parsedStatementSpans,
+        parsedAssignmentSpans,
+    };
+}
+function isExactlyManagedHookTrustStateValue(value, expectedHashes) {
+    return isPlainTomlRecord(value) &&
+        Object.keys(value).length === 1 &&
+        Object.hasOwn(value, "trusted_hash") &&
+        typeof value.trusted_hash === "string" &&
+        expectedHashes.has(value.trusted_hash);
+}
+function managedMarkerTrustStateConflicts(source, representations, managedMarkerRanges, markerContainedHooksStateSpans, invalidMarkerContainedHooksStateSpans, parsedStatementSpans, parsedAssignmentSpans, expectations) {
+    const conflicts = new Set();
+    const isInsideManagedMarkerRange = (span) => managedMarkerRanges.some((range) => span.start > range.start && span.end <= range.end);
+    if (invalidMarkerContainedHooksStateSpans.some(isInsideManagedMarkerRange) ||
+        hasUnprovenManagedMarkerHooksStateSyntax(source, managedMarkerRanges, [...markerContainedHooksStateSpans, ...parsedStatementSpans], parsedAssignmentSpans)) {
+        conflicts.add("marker-contained hooks.state");
+    }
+    for (const [key, sourceRepresentations] of representations) {
+        for (const representation of sourceRepresentations) {
+            if (!isInsideManagedMarkerRange(representation))
+                continue;
+            const expectedHashes = expectedManagedHookTrustHashes(expectations, key, true);
+            const isExactOwnedRepresentation = expectedHashes !== undefined &&
+                representation.stateEntryCount === 1 &&
+                !representation.hasComment &&
+                representation.hasExactSemanticScope &&
+                isExactlyManagedHookTrustStateValue(representation.value, expectedHashes);
+            if (!source.isUnambiguous || !isExactOwnedRepresentation)
+                conflicts.add(key);
         }
-        kept.push(...lines.slice(i, tableEnd));
-        i = tableEnd;
     }
-    return { config: kept.join("\n"), preservedConflictKeys };
+    return conflicts;
 }
-function stripManagedCodexHookTrustStateWithResult(config, options = {}) {
-    const lines = config.split(/\r?\n/);
-    const kept = [];
-    for (let i = 0; i < lines.length;) {
-        const trimmed = lines[i].trim();
-        if (trimmed !== OMX_HOOK_TRUST_START_MARKER) {
-            kept.push(lines[i]);
-            i += 1;
+function removeEmptyManagedHookTrustStateMarkerBlocks(source, removed) {
+    const { lines } = source;
+    for (let start = 0; start < lines.length; start += 1) {
+        if (!source.lineStartsOutsideMultiline[start] ||
+            lines[start]?.trim() !== OMX_HOOK_TRUST_START_MARKER)
+            continue;
+        const end = lines.findIndex((line, index) => index > start &&
+            source.lineStartsOutsideMultiline[index] &&
+            line.trim() === OMX_HOOK_TRUST_END_MARKER);
+        const nestedStart = lines.findIndex((line, index) => index > start &&
+            source.lineStartsOutsideMultiline[index] &&
+            line.trim() === OMX_HOOK_TRUST_START_MARKER);
+        if (end === -1 || (nestedStart !== -1 && nestedStart < end))
             continue;
+        let onlyOwnedMarkerContent = true;
+        for (let index = start + 1; index < end; index += 1) {
+            const trimmed = lines[index].trim();
+            if (removed.has(index) ||
+                trimmed.length === 0 ||
+                trimmed === "# Trusts only setup-managed native hook wrappers.")
+                continue;
+            onlyOwnedMarkerContent = false;
+            break;
         }
-        const nextEndIdx = lines.findIndex((line, index) => index > i && line.trim() === OMX_HOOK_TRUST_END_MARKER);
-        const nextStartIdx = lines.findIndex((line, index) => index > i && line.trim() === OMX_HOOK_TRUST_START_MARKER);
-        if (nextEndIdx === -1 || (nextStartIdx !== -1 && nextStartIdx < nextEndIdx)) {
-            kept.push(lines[i]);
-            i += 1;
+        if (!onlyOwnedMarkerContent)
             continue;
+        removed.add(start);
+        removed.add(end);
+        for (let index = start + 1; index < end; index += 1) {
+            if (lines[index]?.trim() === "# Trusts only setup-managed native hook wrappers.") {
+                removed.add(index);
+            }
+        }
+        start = end;
+    }
+}
+function stripProofManagedCodexHookTrustStateTables(config, expectations) {
+    const { source, representations, managedMarkerRanges, markerContainedHooksStateSpans, invalidMarkerContainedHooksStateSpans, parsedStatementSpans, parsedAssignmentSpans, } = collectManagedHookTrustStateSourceRepresentations(config);
+    const preservedConflictKeys = managedMarkerTrustStateConflicts(source, representations, managedMarkerRanges, markerContainedHooksStateSpans, invalidMarkerContainedHooksStateSpans, parsedStatementSpans, parsedAssignmentSpans, expectations);
+    if (!source.isUnambiguous) {
+        return { config, preservedConflictKeys };
+    }
+    const { lines } = source;
+    const removals = new Map();
+    const parsedConfigState = tomlHooksStateEntries(safeParseToml(config));
+    for (const key of Object.keys(parsedConfigState ?? {})) {
+        if (expectations.has(key) && !representations.has(key)) {
+            preservedConflictKeys.add(key);
+        }
+    }
+    for (const [key, sourceRepresentations] of representations) {
+        const isExactOwnedRepresentation = (representation) => {
+            const expectedHashes = expectedManagedHookTrustHashes(expectations, key, representation.insideManagedMarkerBlock);
+            return expectedHashes !== undefined &&
+                representation.stateEntryCount === 1 &&
+                !representation.hasComment &&
+                representation.hasExactSemanticScope &&
+                isExactlyManagedHookTrustStateValue(representation.value, expectedHashes);
+        };
+        if (!sourceRepresentations.some((representation) => expectedManagedHookTrustHashes(expectations, key, representation.insideManagedMarkerBlock) !== undefined))
+            continue;
+        const mayRemoveAll = sourceRepresentations.length === 1
+            ? isExactOwnedRepresentation(sourceRepresentations[0])
+            : sourceRepresentations.every((representation) => representation.insideManagedMarkerBlock &&
+                isExactOwnedRepresentation(representation));
+        if (!mayRemoveAll) {
+            preservedConflictKeys.add(key);
+            continue;
+        }
+        for (const representation of sourceRepresentations) {
+            removals.set(`${representation.start}:${representation.end}`, {
+                start: representation.start,
+                end: representation.end,
+            });
+        }
+    }
+    if (removals.size === 0) {
+        return { config, preservedConflictKeys };
+    }
+    const removed = new Set();
+    for (const range of removals.values()) {
+        for (let index = range.start; index < range.end; index += 1) {
+            removed.add(index);
         }
-        i = nextEndIdx + 1;
     }
-    const withoutFenced = kept.join("\n");
-    const proofStripped = options.managedTrustState
-        ? stripProofManagedCodexHookTrustStateTables(withoutFenced, options.managedTrustState)
-        : { config: withoutFenced, preservedConflictKeys: new Set() };
+    removeEmptyManagedHookTrustStateMarkerBlocks(source, removed);
     return {
-        config: proofStripped.config.replace(/\n{3,}/g, "\n\n").trimEnd(),
-        preservedConflictKeys: proofStripped.preservedConflictKeys,
+        config: lines.filter((_, index) => !removed.has(index)).join("\n").trimEnd(),
+        preservedConflictKeys,
     };
 }
+function stripManagedCodexHookTrustStateForRefresh(config, priorManagedTrustState, finalManagedTrustState) {
+    return stripProofManagedCodexHookTrustStateTables(config, managedHookTrustStateExpectations(priorManagedTrustState, finalManagedTrustState));
+}
+function rejectManagedCodexHookTrustStateConflicts(conflicts) {
+    if (conflicts.size === 0)
+        return;
+    const keys = [...conflicts].sort((left, right) => left.localeCompare(right));
+    throw new ManagedCodexHooksPlanError("managed_trust_key_conflict", `Refusing to replace existing Codex hook trust state for ${keys.join(", ")}. Remove or reconcile the conflicting [hooks.state] entry before running setup.`, { keys });
+}
 export function stripManagedCodexHookTrustState(config, options = {}) {
-    return stripManagedCodexHookTrustStateWithResult(config, options).config;
+    const stripped = stripManagedCodexHookTrustStateForRefresh(config, options.priorManagedHookTrustState, options.managedTrustState ?? {});
+    rejectManagedCodexHookTrustStateConflicts(stripped.preservedConflictKeys);
+    return stripped.config;
 }
-function renderManagedCodexHookTrustToml(managedTrustState, excludedKeys = new Set()) {
+function renderManagedCodexHookTrustToml(managedTrustState) {
     return Object.entries(managedTrustState)
-        .filter(([key]) => !excludedKeys.has(key))
         .sort(([left], [right]) => left.localeCompare(right))
         .flatMap(([key, hookState]) => [
         `[hooks.state."${escapeTomlBasicString(key)}"]`,
@@ -901,21 +2022,92 @@ function renderManagedCodexHookTrustToml(managedTrustState, excludedKeys = new S
         .join("\n")
         .trimEnd();
 }
-function buildManagedCodexHookTrustStateForConfig(codexHooksFile, pkgRoot, options = {}) {
+function identicalLegacyHookTrustStateEntry(existing, expected) {
+    if (!isPlainTomlRecord(existing))
+        return false;
+    if (!Object.hasOwn(existing, "trusted_hash") ||
+        typeof existing.trusted_hash !== "string" ||
+        existing.trusted_hash !== expected.trusted_hash ||
+        Object.keys(existing).some((key) => key !== "trusted_hash" && key !== "enabled")) {
+        return false;
+    }
+    return Object.hasOwn(existing, "enabled") === Object.hasOwn(expected, "enabled") &&
+        existing.enabled === expected.enabled;
+}
+function legacyHookTrustStateConflict(keys, reason) {
+    throw new ManagedCodexHooksPlanError("managed_trust_key_conflict", `Refusing to migrate legacy Codex hook trust state into conflicting config.toml entries for ${keys.join(", ")}.`, { keys: [...keys], ...(reason ? { reason } : {}) });
+}
+function appendLegacyHookTrustState(config, legacyTrustState) {
+    if (!legacyTrustState || Object.keys(legacyTrustState).length === 0) {
+        return config;
+    }
+    const parsed = safeParseToml(config);
+    const keys = Object.keys(legacyTrustState).sort((left, right) => left.localeCompare(right));
+    if (!parsed)
+        legacyHookTrustStateConflict(keys, "config_parse_failure");
+    const hooks = parsed.hooks;
+    if (hooks !== undefined && !isPlainTomlRecord(hooks)) {
+        legacyHookTrustStateConflict(keys, "hooks_table_invalid");
+    }
+    const hookState = isPlainTomlRecord(hooks) ? hooks.state : undefined;
+    if (hookState !== undefined && !isPlainTomlRecord(hookState)) {
+        legacyHookTrustStateConflict(keys, "hooks_state_table_invalid");
+    }
+    const existingTrustState = isPlainTomlRecord(hookState) ? hookState : {};
+    const entriesToAppend = Object.entries(legacyTrustState)
+        .filter(([key]) => !Object.hasOwn(existingTrustState, key));
+    const conflictingKeys = Object.entries(legacyTrustState)
+        .filter(([key, expected]) => Object.hasOwn(existingTrustState, key) &&
+        !identicalLegacyHookTrustStateEntry(existingTrustState[key], expected))
+        .map(([key]) => key)
+        .sort((left, right) => left.localeCompare(right));
+    if (conflictingKeys.length > 0)
+        legacyHookTrustStateConflict(conflictingKeys);
+    const trustToml = entriesToAppend
+        .sort(([left], [right]) => left.localeCompare(right))
+        .flatMap(([key, state]) => [
+        `[hooks.state."${escapeTomlBasicString(key)}"]`,
+        `trusted_hash = "${escapeTomlBasicString(state.trusted_hash)}"`,
+        ...(typeof state.enabled === "boolean" ? [`enabled = ${state.enabled}`] : []),
+        "",
+    ])
+        .join("\n")
+        .trimEnd();
+    if (!trustToml)
+        return config;
+    const base = config.trimEnd();
+    return [
+        base,
+        base ? "" : null,
+        "# Migrated from legacy hooks.json state; kept in Codex config.toml because Codex 0.140 rejects top-level hooks.json state.",
+        trustToml,
+        "",
+    ].filter((line) => line !== null).join("\n");
+}
+function managedCodexHookOptionsFromMergeOptions(options) {
+    return {
+        codexHomeDir: options.codexHomeDir,
+        platform: options.hookCommandPlatform,
+        hooksContent: options.codexHooksContent,
+    };
+}
+function buildManagedCodexHookTrustStateForConfig(codexHooksFile, pkgRoot, options = {}, precomputedTrustState) {
+    if (precomputedTrustState)
+        return precomputedTrustState;
     if (!codexHooksFile)
         return {};
     return buildManagedCodexHookTrustState(codexHooksFile, pkgRoot, options);
 }
 export function upsertManagedCodexHookTrustState(config, pkgRoot, codexHooksFile, options = {}) {
-    const managedTrustState = buildManagedCodexHookTrustStateForConfig(codexHooksFile, pkgRoot, options);
-    const strippedResult = stripManagedCodexHookTrustStateWithResult(config, {
-        managedTrustState,
-    });
-    const stripped = strippedResult.config;
-    const hookTrustToml = renderManagedCodexHookTrustToml(managedTrustState, strippedResult.preservedConflictKeys);
-    if (!hookTrustToml)
-        return `${stripped}\n`;
-    return [
+    const managedTrustState = buildManagedCodexHookTrustStateForConfig(codexHooksFile, pkgRoot, options, options.managedTrustState);
+    const strippedResult = stripManagedCodexHookTrustStateForRefresh(config, options.priorManagedHookTrustState, managedTrustState);
+    rejectManagedCodexHookTrustStateConflicts(strippedResult.preservedConflictKeys);
+    const stripped = strippedResult.config.trimEnd();
+    const hookTrustToml = renderManagedCodexHookTrustToml(managedTrustState);
+    if (!hookTrustToml) {
+        return appendLegacyHookTrustState(`${stripped}\n`, options.legacyHookTrustState);
+    }
+    return appendLegacyHookTrustState([
         stripped,
         "",
         OMX_HOOK_TRUST_START_MARKER,
@@ -923,7 +2115,7 @@ export function upsertManagedCodexHookTrustState(config, pkgRoot, codexHooksFile
         hookTrustToml,
         OMX_HOOK_TRUST_END_MARKER,
         "",
-    ].filter((line, index) => index !== 0 || line.length > 0).join("\n");
+    ].filter((line, index) => index !== 0 || line.length > 0).join("\n"), options.legacyHookTrustState);
 }
 export function upsertPluginModeRuntimeFeatureFlags(config, codexHookFeatureFlag = DEFAULT_CODEX_HOOK_FEATURE_FLAG, options = {}) {
     const lines = config.split(/\r?\n/);
@@ -936,6 +2128,9 @@ export function upsertPluginModeRuntimeFeatureFlags(config, codexHookFeatureFlag
         const featureBlock = [
             "[features]",
             hookFeatureFlagLine,
+            ...(options.pluginScopedHooks && options.preserveNativeHooks
+                ? [formatCodexHookFeatureFlagLine(codexHookFeatureFlag)]
+                : []),
             "goals = true",
             "",
         ].join("\n");
@@ -959,9 +2154,15 @@ export function upsertPluginModeRuntimeFeatureFlags(config, codexHookFeatureFlag
             sectionEnd -= 1;
         }
     }
-    ({ sectionEnd } = options.pluginScopedHooks
-        ? upsertPluginScopedHookFeatureFlagInSection(lines, featuresStart, sectionEnd)
-        : upsertCodexHookFeatureFlagInSection(lines, featuresStart, sectionEnd, codexHookFeatureFlag));
+    if (options.pluginScopedHooks) {
+        ({ sectionEnd } = upsertPluginScopedHookFeatureFlagInSection(lines, featuresStart, sectionEnd));
+        if (options.preserveNativeHooks) {
+            ({ sectionEnd } = upsertCodexHookFeatureFlagInSection(lines, featuresStart, sectionEnd, codexHookFeatureFlag));
+        }
+    }
+    else {
+        ({ sectionEnd } = upsertCodexHookFeatureFlagInSection(lines, featuresStart, sectionEnd, codexHookFeatureFlag));
+    }
     let goalsIdx = -1;
     for (let i = featuresStart + 1; i < sectionEnd; i++) {
         if (/^\s*goals\s*=/.test(lines[i])) {
@@ -1425,35 +2626,45 @@ function upsertTuiStatusLine(config, preset = DEFAULT_STATUS_LINE_PRESET, option
 // ---------------------------------------------------------------------------
 // OMX [table] sections block (appended at end of file)
 // ---------------------------------------------------------------------------
-export function stripExistingOmxBlocks(config) {
-    let cleaned = config;
-    let removed = 0;
-    while (true) {
-        const markerIdx = cleaned.indexOf(OMX_CONFIG_MARKER);
-        if (markerIdx < 0)
-            break;
-        let blockStart = cleaned.lastIndexOf("\n", markerIdx);
-        blockStart = blockStart >= 0 ? blockStart + 1 : 0;
-        const previousLineEnd = blockStart - 1;
-        if (previousLineEnd >= 0) {
-            const previousLineStart = cleaned.lastIndexOf("\n", previousLineEnd - 1);
-            const previousLine = cleaned.slice(previousLineStart + 1, previousLineEnd);
-            if (/^# =+$/.test(previousLine.trim())) {
-                blockStart = previousLineStart >= 0 ? previousLineStart + 1 : 0;
-            }
-        }
-        let blockEnd = cleaned.length;
-        const endIdx = cleaned.indexOf(OMX_CONFIG_END_MARKER, markerIdx);
-        if (endIdx >= 0) {
-            const endLineBreak = cleaned.indexOf("\n", endIdx);
-            blockEnd = endLineBreak >= 0 ? endLineBreak + 1 : cleaned.length;
-        }
-        const before = cleaned.slice(0, blockStart).trimEnd();
-        const after = cleaned.slice(blockEnd).trimStart();
-        cleaned = [before, after].filter(Boolean).join("\n\n");
-        removed += 1;
-    }
-    return { cleaned, removed };
+export function stripExistingOmxBlocks(config, options = {}) {
+    const inventory = collectManagedHookTrustStateSourceRepresentations(config);
+    const { source } = inventory;
+    const markerRanges = collectMarkerRanges(source, OMX_CONFIG_START_MARKER, OMX_CONFIG_END_MARKER, false, inventory.parsedAssignmentSpans);
+    if (markerRanges.length === 0)
+        return { cleaned: config, removed: 0 };
+    const conflicts = managedMarkerTrustStateConflicts(source, inventory.representations, markerRanges, inventory.markerContainedHooksStateSpans, inventory.invalidMarkerContainedHooksStateSpans, inventory.parsedStatementSpans, inventory.parsedAssignmentSpans, managedHookTrustStateExpectations(options.priorManagedHookTrustState, options.managedTrustState));
+    rejectManagedCodexHookTrustStateConflicts(conflicts);
+    if (!source.isUnambiguous)
+        return { cleaned: config, removed: 0 };
+    const lines = sourceLines(config);
+    if (markerRanges.some((range) => !lines[range.start] || !lines[range.end])) {
+        return { cleaned: config, removed: 0 };
+    }
+    const removalRanges = markerRanges.map((range) => {
+        const startLine = lines[range.start];
+        const endLine = lines[range.end];
+        const previousLine = lines[range.start - 1];
+        const start = previousLine && /^# =+$/.test(previousLine.content.trim())
+            ? previousLine.start
+            : startLine.start;
+        return { start, end: endLine.end };
+    });
+    const segments = [];
+    let cursor = 0;
+    for (const range of removalRanges) {
+        segments.push(config.slice(cursor, range.start));
+        cursor = range.end;
+    }
+    segments.push(config.slice(cursor));
+    const cleaned = segments
+        .map((segment, index) => index === 0
+        ? segment.trimEnd()
+        : index === segments.length - 1
+            ? segment.trimStart()
+            : segment.trim())
+        .filter(Boolean)
+        .join("\n\n");
+    return { cleaned, removed: markerRanges.length };
 }
 export function stripExistingSharedMcpRegistryBlock(config) {
     let cleaned = config;
@@ -1688,7 +2899,7 @@ export function mergeSharedMcpRegistryBlock(config, servers, sourcePath) {
  * OMX table-section block (MCP servers, TUI).
  * Contains ONLY [table] sections — no bare keys.
  */
-function getOmxTablesBlock(pkgRoot, includeTui = true, statusLinePreset = DEFAULT_STATUS_LINE_PRESET, codexHooksFile, hookOptions = {}, includeFirstPartyMcp = false, excludedHookTrustStateKeys = new Set()) {
+function getOmxTablesBlock(pkgRoot, includeTui = true, statusLinePreset = DEFAULT_STATUS_LINE_PRESET, codexHooksFile, hookOptions = {}, managedHookTrustState, includeFirstPartyMcp = false) {
     const lines = [
         "",
         "# ============================================================",
@@ -1711,7 +2922,7 @@ function getOmxTablesBlock(pkgRoot, includeTui = true, statusLinePreset = DEFAUL
             }
         }
     }
-    const hookTrustToml = renderManagedCodexHookTrustToml(buildManagedCodexHookTrustStateForConfig(codexHooksFile, pkgRoot, hookOptions), excludedHookTrustStateKeys);
+    const hookTrustToml = renderManagedCodexHookTrustToml(buildManagedCodexHookTrustStateForConfig(codexHooksFile, pkgRoot, hookOptions, managedHookTrustState));
     if (hookTrustToml) {
         lines.push("");
         lines.push("# OMX-owned Codex hook trust state");
@@ -1750,6 +2961,10 @@ function getOmxTablesBlock(pkgRoot, includeTui = true, statusLinePreset = DEFAUL
  */
 export function buildMergedConfig(existingConfig, pkgRoot, options = {}) {
     let existing = stripOmxSeededBehavioralDefaults(existingConfig);
+    const hookOptions = managedCodexHookOptionsFromMergeOptions(options);
+    const managedTrustState = buildManagedCodexHookTrustStateForConfig(options.codexHooksFile, pkgRoot, hookOptions, options.managedHookTrustState);
+    const preflightHookTrustStrip = stripManagedCodexHookTrustStateForRefresh(existing, options.priorManagedHookTrustState, managedTrustState);
+    rejectManagedCodexHookTrustStateConflicts(preflightHookTrustStrip.preservedConflictKeys);
     const preservedFirstPartyMcpSections = options.preserveExistingFirstPartyMcp === true &&
         options.includeFirstPartyMcp !== true
         ? extractFirstPartyOmxMcpSections(existing)
@@ -1758,7 +2973,10 @@ export function buildMergedConfig(existingConfig, pkgRoot, options = {}) {
     const statusLinePreset = options.statusLinePreset ?? DEFAULT_STATUS_LINE_PRESET;
     const customizedManagedTuiSections = extractCustomizedTuiSectionsFromOmxBlocks(existing);
     if (existing.includes(OMX_CONFIG_MARKER)) {
-        const stripped = stripExistingOmxBlocks(existing);
+        const stripped = stripExistingOmxBlocks(existing, {
+            managedTrustState,
+            priorManagedHookTrustState: options.priorManagedHookTrustState,
+        });
         existing = stripped.cleaned;
         if (customizedManagedTuiSections.length > 0) {
             existing = `${existing.trimEnd()}\n\n${customizedManagedTuiSections.join("\n\n")}\n`;
@@ -1777,13 +2995,8 @@ export function buildMergedConfig(existingConfig, pkgRoot, options = {}) {
         existing = `${`notify = ${formatTomlStringArray(userNotifyToPreserve)}`}\n${existing.trimStart()}`;
     }
     existing = stripOrphanedManagedNotify(existing, pkgRoot).trimStart();
-    const managedTrustState = buildManagedCodexHookTrustStateForConfig(options.codexHooksFile, pkgRoot, {
-        codexHomeDir: options.codexHomeDir,
-        platform: options.hookCommandPlatform,
-    });
-    const hookTrustStrip = stripManagedCodexHookTrustStateWithResult(existing, {
-        managedTrustState,
-    });
+    const hookTrustStrip = stripManagedCodexHookTrustStateForRefresh(existing, options.priorManagedHookTrustState, managedTrustState);
+    rejectManagedCodexHookTrustStateConflicts(hookTrustStrip.preservedConflictKeys);
     existing = hookTrustStrip.config;
     if (options.modelOverride) {
         existing = stripRootLevelKeys(existing, ["model"]);
@@ -1803,17 +3016,15 @@ export function buildMergedConfig(existingConfig, pkgRoot, options = {}) {
     const topLines = getOmxTopLevelLines(pkgRoot, existing, options.modelOverride, options.notifyCommand === undefined
         ? getDefaultNotifyCommand(pkgRoot)
         : options.notifyCommand);
-    const tablesBlock = getOmxTablesBlock(pkgRoot, includeTui && !tuiUpsert.hadExistingTui, statusLinePreset, options.codexHooksFile, {
-        codexHomeDir: options.codexHomeDir,
-        platform: options.hookCommandPlatform,
-    }, options.includeFirstPartyMcp === true, hookTrustStrip.preservedConflictKeys);
+    const tablesBlock = getOmxTablesBlock(pkgRoot, includeTui && !tuiUpsert.hadExistingTui, statusLinePreset, options.codexHooksFile, hookOptions, managedTrustState, options.includeFirstPartyMcp === true);
     const sharedRegistryBlock = getSharedMcpRegistryBlock(options.sharedMcpServers ?? [], options.sharedMcpRegistrySource, existing);
     let body = existing.trim();
     if (sharedRegistryBlock) {
         body = body ? `${body}\n\n${sharedRegistryBlock}` : sharedRegistryBlock;
     }
     const bodySeparator = body.length > 0 && !/^\s*\[/.test(body) ? "\n" : "\n\n";
-    return addDefaultLauncherMcpStartupTimeouts(topLines.join("\n") + bodySeparator + body + "\n" + tablesBlock);
+    const merged = addDefaultLauncherMcpStartupTimeouts(topLines.join("\n") + bodySeparator + body + "\n" + tablesBlock);
+    return appendLegacyHookTrustState(merged, options.legacyHookTrustState);
 }
 /**
  * Detect and repair upgrade-era managed config incompatibilities in config.toml.
@@ -1826,6 +3037,33 @@ export function buildMergedConfig(existingConfig, pkgRoot, options = {}) {
  *
  * Returns `true` if a repair was performed.
  */
+function managedHookTrustProofRequiredForRepair(config) {
+    const inventory = collectManagedHookTrustStateSourceRepresentations(config);
+    return managedMarkerTrustStateConflicts(inventory.source, inventory.representations, inventory.managedMarkerRanges, inventory.markerContainedHooksStateSpans, inventory.invalidMarkerContainedHooksStateSpans, inventory.parsedStatementSpans, inventory.parsedAssignmentSpans, managedHookTrustStateExpectations()).size > 0;
+}
+async function launchRepairOptionsWithManagedHookTrustProof(configPath, config, options) {
+    if (!managedHookTrustProofRequiredForRepair(config)) {
+        return options;
+    }
+    const hooksPath = options.codexHooksFile ?? resolve(configPath, "..", "hooks.json");
+    let hooksContent;
+    try {
+        hooksContent = await readFile(hooksPath, "utf-8");
+    }
+    catch (error) {
+        throw new ManagedCodexHooksPlanError("invalid_document", `Cannot safely repair config.toml because the current hooks artifact at ${hooksPath} could not be read.`, { cause: String(error), hooksPath });
+    }
+    const trustScan = scanManagedCodexHookTrustStateFromContent(hooksContent, hooksPath, managedCodexHookOptionsFromMergeOptions(options));
+    if (!trustScan.ok)
+        throw trustScan.error;
+    return {
+        ...options,
+        codexHooksFile: hooksPath,
+        codexHooksContent: hooksContent,
+        managedHookTrustState: trustScan.trustState,
+        priorManagedHookTrustState: trustScan.trustState,
+    };
+}
 export async function repairConfigIfNeeded(configPath, pkgRoot, options = {}) {
     if (!existsSync(configPath))
         return false;
@@ -1835,8 +3073,10 @@ export async function repairConfigIfNeeded(configPath, pkgRoot, options = {}) {
     const hasLauncherTimeoutGap = findLauncherTimeoutRepairTargets(content).length > 0;
     if (tuiCount <= 1 && !hasLegacyTeamRunTable && !hasLauncherTimeoutGap)
         return false;
-    // Managed config compatibility issue detected — run full merge to repair
-    const repaired = buildMergedConfig(content, pkgRoot, options);
+    // Managed config compatibility issue detected — derive proof from the current
+    // hooks artifact before any marker stripping can replace managed trust state.
+    const repairOptions = await launchRepairOptionsWithManagedHookTrustProof(configPath, content, options);
+    const repaired = buildMergedConfig(content, pkgRoot, repairOptions);
     if (repaired === content)
         return false;
     await writeFile(configPath, repaired);
@@ -1847,12 +3087,6 @@ export async function mergeConfig(configPath, pkgRoot, options = {}) {
     if (existsSync(configPath)) {
         existing = await readFile(configPath, "utf-8");
     }
-    if (existing.includes("oh-my-codex (OMX) Configuration")) {
-        const stripped = stripExistingOmxBlocks(existing);
-        if (options.verbose && stripped.removed > 0) {
-            console.log("  Updating existing OMX config block.");
-        }
-    }
     const finalConfig = buildMergedConfig(existing, pkgRoot, options);
     await writeFile(configPath, finalConfig);
     if (options.verbose) {