@lannguyensi/harness 0.59.2 → 0.61.0

package/dist/cli/apply/install-codex-config.js

@@ -65,11 +65,6 @@ const HOOK_ID_LINE_RE = /^# harness hook: (.+) \(budget_ms=\d+\)$/;
 // the two apart by the `# harness hook:` comment above the header instead
 // (see `scanOwnedContentEnd`).
 const HOOK_ARRAY_HEADER_RE = /^\[\[hooks\./;
-/** True when a run of comment/blank lines holds a line the generator writes
- * above every hook table (`# harness hook: <id> (budget_ms=N)`). */
-function runHoldsHarnessHookComment(run) {
-    return run.split("\n").some((line) => line.trim().startsWith(HARNESS_HOOK_COMMENT_PREFIX));
-}
 export function defaultCodexConfigPath(homeDir) {
     return path.join(homeDir ?? os.homedir(), ".codex", "config.toml");
 }
@@ -189,35 +184,65 @@ function nextTripleDelim(rawLine, delimIn) {
     return delim;
 }
 /**
- * The first line, at or after `from`, whose TRIMMED content is byte-equal
- * to `target` (not a raw substring search). A raw `text.indexOf(target,
- * from)` would also match `target` sitting mid-line inside unrelated
- * content; matching only whole trimmed lines rules that out. A line that
- * BEGAN inside an open TOML multi-line string (tracked via
- * `nextTripleDelim`, correctly distinguishing `"""` from `'''` and
- * ignoring delimiters inside a comment or a single-line string) is never
- * treated as a possible match, regardless of its trimmed text: a foreign
- * table's own multi-line string value may legitimately contain a line
- * that reads exactly like the harness END marker (task 6a037359) without
- * that being a real stray END. The triple-quote state is tracked only
- * from `from` onward (a string open before `from` is not detected), which
- * is correct for the caller's one use: `from` is always the start of the
- * first foreign table in the zone being searched, so any multi-line
- * string that matters here opens inside that zone, not before it.
+ * The one rule every managed-block marker is located by (task 36d962d2): a
+ * line is a marker line only when its trimmed text is the marker (`whole`)
+ * or starts with it (`prefix`) AND it sits at the top level of the document
+ * (`createTopLevelProbe`). Marker text anywhere else is operator content:
+ * inside a single-line or multi-line string (basic or literal), after a
+ * content line as a trailing comment, inside an inline table, or on a line
+ * inside a multi-line array (an element, or a comment line between
+ * elements). Treating such text as a marker made the install replace,
+ * delete, or splice a fresh block into the operator's value. Every lookup
+ * of BEGIN, END, the source prefix, the generated header and the
+ * `# harness hook:` comment goes through this probe or `findMarkerLine`, and
+ * so does the `[[hooks.` header line that lets a generated header open a
+ * legacy block (`findManagedRange`).
+ * Two marker searches stay outside it on purpose: the split-block refusal's
+ * candidate list (`assertNoSplitBlock`), which can only refuse, never
+ * install, and the trailing comment run of `scanOwnedContentEnd`, whose
+ * lines are whole top-level comment lines by construction. That run (blank
+ * and comment lines ending the file after a block with no END marker) is
+ * consumed as stale harness output when the source prefix, the generated
+ * header or the `# harness hook:` text appears anywhere in it, so an
+ * operator comment there that mentions such text mid-line is removed with
+ * the block.
+ *
+ * The returned probe answers for line starts queried in non-decreasing
+ * order (the top-level probe's contract, which a line that fails the text
+ * test never touches).
  */
-function findExactLine(text, target, from) {
+function createMarkerLineProbe(text) {
+    const topLevel = createTopLevelProbe(text);
+    return (lineStart, marker, shape) => {
+        const trimmed = text.slice(lineStart, lineEndAfter(text, lineStart)).trim();
+        const textMatches = shape === "whole" ? trimmed === marker : trimmed.startsWith(marker);
+        return textMatches && topLevel(lineStart);
+    };
+}
+/** The start of the first marker line (`createMarkerLineProbe`) at or after
+ * the line start `from`, or -1. Candidates are visited in order, one line
+ * each, so the probe's non-decreasing-offset contract holds. */
+function findMarkerLine(text, marker, shape, from = 0) {
+    const isMarkerLine = createMarkerLineProbe(text);
     let pos = from;
-    let delim = null;
-    while (pos < text.length) {
-        const lineEnd = lineEndAfter(text, pos);
-        const rawLine = text.slice(pos, lineEnd);
-        const startedInsideString = delim !== null;
-        delim = nextTripleDelim(rawLine, delim);
-        if (!startedInsideString && rawLine.trim() === target)
-            return pos;
-        pos = lineEnd;
+    for (;;) {
+        const idx = text.indexOf(marker, pos);
+        if (idx === -1)
+            return -1;
+        const lineStart = lineStartAt(text, idx);
+        if (isMarkerLine(lineStart, marker, shape))
+            return lineStart;
+        pos = lineEndAfter(text, lineStart);
     }
-    return -1;
+}
+/** True when a line in `[from, to)` is a marker line for the prefix
+ * `marker`. */
+function rangeHoldsMarkerLine(text, from, to, marker, isMarkerLine) {
+    for (let pos = from; pos < to; pos = lineEndAfter(text, pos)) {
+        if (isMarkerLine(pos, marker, "prefix"))
+            return true;
+    }
+    return false;
 }
 /** Answers, for a line start in `text`, whether that line sits at the top
  * level of the document, that is, not inside a multi-line array, a multi-line
@@ -399,6 +424,7 @@ function scanOwnedContentEnd(text, start) {
     let sawOwnedContent = false;
     let sawMarkedHookTable = false;
     const classify = createLineClassifier(text);
+    const isMarkerLine = createMarkerLineProbe(text);
     while (pos < text.length) {
         const lineEnd = lineEndAfter(text, pos);
         const rawLine = text.slice(pos, lineEnd);
@@ -409,7 +435,7 @@ function scanOwnedContentEnd(text, start) {
             pos = lineEnd;
             continue;
         }
-        if (rawLine.trim() === CODEX_MANAGED_END) {
+        if (isMarkerLine(pos, CODEX_MANAGED_END, "whole")) {
             return { end: lineEnd, sawEndMarker: true };
         }
         if (kind === "comment") {
@@ -423,7 +449,7 @@ function scanOwnedContentEnd(text, start) {
         }
         if (kind === "hookHeader") {
             const marked = commentRunStart !== null &&
-                runHoldsHarnessHookComment(text.slice(commentRunStart, pos));
+                rangeHoldsMarkerLine(text, commentRunStart, pos, HARNESS_HOOK_COMMENT_PREFIX, isMarkerLine);
             if (marked) {
                 sawMarkedHookTable = true;
             }
@@ -449,6 +475,11 @@ function scanOwnedContentEnd(text, start) {
     if (commentRunStart !== null && sawOwnedContent) {
         const run = text.slice(commentRunStart, pos);
         const hasComment = /(^|\n)[ \t]*#/.test(run);
+        // Matched as substrings on purpose, outside `createMarkerLineProbe`:
+        // every line of this run is a whole comment or blank line at the top
+        // level (a string line resets the run, and at the end of a document that
+        // parses nothing is still open), so marker text here is never inside a
+        // value, and a comment that mentions a marker is stale harness output.
         const harnessAuthored = run.includes(HARNESS_HOOK_COMMENT_PREFIX) ||
             run.includes(CODEX_MANAGED_SOURCE_PREFIX) ||
             run.includes(GENERATED_HEADER);
@@ -458,6 +489,33 @@ function scanOwnedContentEnd(text, start) {
     }
     return { end: pos, sawEndMarker: false };
 }
+/**
+ * True when a harness-commented hook table (a `# harness hook:` comment line
+ * followed, later in the zone, by a `[[hooks.` header or a hook event array
+ * header spelled without that prefix, `[[ hooks.SessionStart ]]`) lies after the named
+ * table's header line, before `to`. The comment is found as a marker line
+ * (`createMarkerLineProbe`), so a value that merely contains the marker text
+ * does not count. Used only to pick the fix guidance of a refusal (task
+ * 36d962d2).
+ */
+function harnessHookTableFollows(text, header, to) {
+    if (header === null)
+        return false;
+    let pos = lineEndAfter(text, header.start);
+    let sawComment = false;
+    const isMarkerLine = createMarkerLineProbe(text);
+    while (pos < to) {
+        const lineEnd = Math.min(lineEndAfter(text, pos), to);
+        const trimmed = text.slice(pos, lineEnd).trim();
+        if (isMarkerLine(pos, HARNESS_HOOK_COMMENT_PREFIX, "prefix"))
+            sawComment = true;
+        else if (sawComment && (HOOK_ARRAY_HEADER_RE.test(trimmed) || isHookEventArrayHeader(trimmed))) {
+            return true;
+        }
+        pos = lineEnd;
+    }
+    return false;
+}
 /**
  * Refuses loudly (mirror case of the stray-END bug) when the zone between
  * `from` and `to` still contains a recognizable fragment of a harness
@@ -471,7 +529,8 @@ function scanOwnedContentEnd(text, start) {
  * `scanOwnedContentEnd`; when only blank or comment lines precede the found
  * marker in the zone -- so the pre-marker lookup finds no content line to
  * report -- the header is looked up again just past that marker's own
- * line, since the wedged table then sits after it, not before; printed
+ * line, since the wedged table then sits after it, not before, and the
+ * message says the marker line sits above the table (task e8f4fc03); printed
  * through `describeTableHeader`, so only the header's own bracketed key
  * path appears, never a trailing comment), and
  * the line number and marker of the first line beyond it
@@ -485,14 +544,33 @@ function scanOwnedContentEnd(text, start) {
  * document (`to` is `text.length`), telling the operator to move something
  * below a marker that does not exist would be nonsensical, so a different
  * fix (add one, or move the table below the last harness hook table) is
- * offered instead (task 6a037359). `blockOpening` names the line the block
+ * offered instead (task 6a037359). Adding one is offered only when no
+ * harness-commented hook table follows the named table
+ * (`harnessHookTableFollows`): an END placed before the named table would
+ * leave that later table running next to the fresh block (task 36d962d2).
+ * When the named table is a hook event table spelled without the `[[hooks.`
+ * prefix, the guidance offers deleting it if harness wrote it, since the scan
+ * reads such a table as foreign with or without a comment line above it
+ * (task e8f4fc03). The legacy paths call
+ * this too, so the substring matching above applies there as well: a value
+ * holding marker text refuses. This candidate list and the trailing comment
+ * run of `scanOwnedContentEnd` are the two marker searches that do not go
+ * through `createMarkerLineProbe`, on purpose. This one can only refuse,
+ * never install, so matching marker text in a value costs a refusal, never
+ * operator content. The comment run's lines are whole top-level comment
+ * lines, so marker text there is never inside a value, but that run (blank
+ * and comment lines ending the file after a block with no END marker) is
+ * consumed when the source prefix, the generated header or the
+ * `# harness hook:` text appears anywhere in it, so an operator comment
+ * there that mentions such text mid-line is removed with the block.
+ * `blockOpening` names the line the block
  * starts at in the delete-the-lines fix: the BEGIN marker by default; a
  * legacy config (no BEGIN marker) whose END marker survived passes its
  * source-prefix line or generated header instead, since a BEGIN marker it
  * does not have is no line to delete from (task 01053b27). For the generated
  * header the fix deletes that line and the END marker line too: a generated
  * header left alone above END no longer marks a harness block
- * (`findManagedRange` needs a `[[hooks.` line after it), so the install
+ * (`findManagedRange` needs a top-level `[[hooks.` header line after it), so the install
  * would add a fresh block and leave that pair behind as an orphan. Exported for
  * direct tests only: the scan
  * that feeds it never hands it a line that is not a real header, so its own
@@ -526,9 +604,15 @@ export function assertNoSplitBlock(text, from, to, configPath, hasEndMarker, blo
     // the foreign table that split the block is wedged after the marker's own
     // line instead, so look there.
     const markerLineEnd = lineEndAfter(text, zoneStart + markerOffset);
-    const foreignHeaderLine = firstContentLine(text, zoneStart, zoneStart + markerOffset) ??
-        firstContentLine(text, markerLineEnd, zoneEnd);
+    const headerBeforeMarker = firstContentLine(text, zoneStart, zoneStart + markerOffset);
+    const foreignHeaderLine = headerBeforeMarker ?? firstContentLine(text, markerLineEnd, zoneEnd);
     const firstForeignHeader = describeForeignHeaderLine(text, foreignHeaderLine);
+    // Where the marker line sits relative to the named table, so the message
+    // stays true when the table was found past the marker (a respelled hook
+    // table with its own '# harness hook:' comment line above it, say).
+    const placement = headerBeforeMarker === null
+        ? `below harness-owned content: line ${offendingLineNumber}, above it, contains '${marker}'`
+        : `sitting before more harness-owned content: line ${offendingLineNumber} contains '${marker}'`;
     const fixes = hasEndMarker
         ? [
             `move ${firstForeignHeader} below the '${CODEX_MANAGED_END}' marker`,
@@ -538,23 +622,37 @@ export function assertNoSplitBlock(text, from, to, configPath, hasEndMarker, blo
                 : `delete the lines between ${blockOpening} and '${CODEX_MANAGED_END}' so only ` +
                     "harness-owned tables remain between them",
         ]
-        : [
-            `add a '${CODEX_MANAGED_END}' marker line right after the last harness hook table ` +
-                `(before ${firstForeignHeader})`,
-            `move ${firstForeignHeader} below the last harness hook table`,
-        ];
+        : harnessHookTableFollows(text, foreignHeaderLine, zoneEnd)
+            ? // An END marker placed before the named table would leave the
+                // harness-commented hook table after it running next to the fresh
+                // block, so the only fix offered is moving the named table past it
+                // (task 36d962d2).
+                [`move ${firstForeignHeader} below the last harness hook table`]
+            : [
+                `add a '${CODEX_MANAGED_END}' marker line right after the last harness hook table ` +
+                    `(before ${firstForeignHeader})`,
+                `move ${firstForeignHeader} below the last harness hook table`,
+            ];
     // An uncommented hook table in the middle may be a harness table whose
     // comment line was deleted, so moving it (the operator-table fix) is only
     // right for an operator-owned one; name the restore option first (task
     // 01053b27).
     const isHookTable = HOOK_ARRAY_HEADER_RE.test(foreignHeaderLine?.line ?? "");
+    // A hook event table spelled another way (`[[ hooks.Stop ]]`) is read as
+    // foreign with or without a comment line above it, so restoring one does
+    // not help; deleting it does, if harness wrote it (task e8f4fc03).
+    const isRespelledHookTable = isHookEventArrayHeader(foreignHeaderLine?.line ?? "");
     const guidance = isHookTable
         ? `If ${firstForeignHeader} is a harness hook table whose '${HARNESS_HOOK_COMMENT_PREFIX}<id> ` +
             "(budget_ms=<n>)' comment line was deleted, restore that comment line directly above it. " +
             `If it is an operator-owned table, ${fixes.join(", or ")}`
-        : fixes.join(", or ").replace(/^./, (c) => c.toUpperCase());
-    throw new CodexInstallRefusalError(`Codex config ${configPath} has a foreign table (${firstForeignHeader}) sitting before ` +
-        `more harness-owned content: line ${offendingLineNumber} contains '${marker}' and still ` +
+        : isRespelledHookTable
+            ? `If ${firstForeignHeader} is a harness hook table, delete it together with any ` +
+                `'${HARNESS_HOOK_COMMENT_PREFIX}<id> (budget_ms=<n>)' comment line above it (the install ` +
+                "replaces only hook tables spelled '[[hooks.<Event>]]' with that comment line above " +
+                `them, and writes the fresh block). If it is an operator-owned table, ${fixes.join(", or ")}`
+            : fixes.join(", or ").replace(/^./, (c) => c.toUpperCase());
+    throw new CodexInstallRefusalError(`Codex config ${configPath} has a foreign table (${firstForeignHeader}) ${placement} and still ` +
         "looks like part of the harness-managed hook block; refusing to guess the block " +
         `boundaries. ${guidance}, then re-run \`harness apply --runtime codex --install\`. As a ` +
         `last resort, restore ${configPath} from the most recent .harness-backup-* file (if one exists), but ` +
@@ -638,18 +736,22 @@ function foreignSectionRootKey(headerLine) {
  * so the operator reads "a whole namespace, N tables" rather than
  * mistaking the printed header for the only table kept; exactly one table
  * under a root prints its own header. Headers print through
- * `describeTableHeader` (no trailing comment). */
-function collectForeignSectionHeaders(text, from, to) {
+ * `describeTableHeader` (no trailing comment). A header that is one of the
+ * `kept` operator hook tables (a hook event table spelled without the
+ * `[[hooks.` prefix, see `collectKeptHookTables`) is named there instead and
+ * not listed twice. */
+function collectForeignSectionHeaders(text, from, to, kept = []) {
     const seenRoots = new Set();
     const headers = [];
     const counts = new Map();
+    const keptStarts = new Set(kept.map((t) => t.start));
     let pos = Math.max(from, 0);
     const limit = Math.max(to, from);
     const classify = createLineClassifier(text);
     while (pos < limit) {
         const lineEnd = Math.min(lineEndAfter(text, pos), limit);
         const rawLine = text.slice(pos, lineEnd);
-        if (classify(pos, rawLine) === "foreignHeader") {
+        if (classify(pos, rawLine) === "foreignHeader" && !keptStarts.has(pos)) {
             const trimmed = rawLine.trim();
             const root = foreignSectionRootKey(trimmed);
             counts.set(root, (counts.get(root) ?? 0) + 1);
@@ -666,27 +768,44 @@ function collectForeignSectionHeaders(text, from, to) {
         return count > 1 ? `[${root}.*] (${count} tables)` : header;
     });
 }
-function extractHookIds(content) {
+/** The hook ids named by the `# harness hook:` marker lines
+ * (`createMarkerLineProbe`) in `[from, to)` of `text`, so a value holding
+ * that text is never reported as a removed hook. */
+function extractHookIds(text, from = 0, to = text.length) {
     const ids = new Set();
-    for (const rawLine of content.split(/\r?\n/)) {
-        const m = HOOK_ID_LINE_RE.exec(rawLine.trim());
+    const isMarkerLine = createMarkerLineProbe(text);
+    for (let pos = from; pos < to; pos = lineEndAfter(text, pos)) {
+        if (!isMarkerLine(pos, HARNESS_HOOK_COMMENT_PREFIX, "prefix"))
+            continue;
+        const m = HOOK_ID_LINE_RE.exec(text.slice(pos, lineEndAfter(text, pos)).trim());
         if (m?.[1] !== undefined)
             ids.add(m[1]);
     }
     return ids;
 }
 /**
- * The operator-authored hook tables directly after a managed range that
- * ended at one (`scanOwnedContentEnd`'s `endedAtOperatorHookTable`): every
- * `[[hooks.*]]` header from `from` up to the first non-hook table header or
- * `to`, each by header, line number and offset. Lines are read by
+ * The operator-authored hook tables directly after a managed range: every
+ * hook event table header from `from` up to the first non-hook table header
+ * or `to`, each by header, line number and offset. A hook event table is a
+ * `[[hooks.*]]` header, or an array-of-tables header spelled another way
+ * whose first key resolves to `hooks` and that names an event
+ * (`isHookEventArrayHeader`: `[[ hooks.Stop ]]`, `[["hooks".Stop]]`,
+ * `[[hooks . Stop]]`). The ownership scan reads such a respelled header as a
+ * foreign table, so it ends the managed range there; collected here, it is
+ * named and its commands are checked like any kept hook table, instead of
+ * being kept as a foreign section whose harness command would then run next
+ * to the fresh block's (task e8f4fc03). Lines are read by
  * `createLineClassifier`, so an array element on its own line inside a kept
  * table's multi-line value neither ends the run nor is named, and a hook
- * table after it is still collected (task 01053b27). Empty for any other ending
- * (the first header at `from` is then a non-hook table, or there is none).
- * The caller has already refused a zone that holds a harness marker
- * (`assertNoSplitBlock`), so no header found here carries a `# harness
- * hook:` comment.
+ * table after it is still collected (task 01053b27). Empty when the first
+ * header at `from` is a non-hook table, or there is none. A hook table after
+ * the first non-hook table is not collected: it is kept, not named and not
+ * checked, a deliberate boundary (only the run of hook tables directly after
+ * the harness tables is examined). The caller refuses a zone that holds a
+ * harness marker (`assertNoSplitBlock`) before it uses the tables: over the
+ * whole zone on the BEGIN path and when an END marker follows, over the run
+ * of hook tables (up to the returned `end`) on the legacy path without one,
+ * so no table the install keeps carries a `# harness hook:` comment.
  */
 function collectKeptHookTables(text, from, to) {
     const tables = [];
@@ -696,14 +815,15 @@ function collectKeptHookTables(text, from, to) {
         const lineEnd = Math.min(lineEndAfter(text, pos), to);
         const rawLine = text.slice(pos, lineEnd);
         const kind = classify(pos, rawLine);
-        if (kind === "foreignHeader")
+        const hookTable = kind === "hookHeader" || (kind === "foreignHeader" && isHookEventArrayHeader(rawLine.trim()));
+        if (kind === "foreignHeader" && !hookTable)
             break;
-        if (kind === "hookHeader") {
+        if (hookTable) {
             tables.push({ header: describeTableHeader(rawLine), line: lineNumberAt(text, pos), start: pos });
         }
         pos = lineEnd;
     }
-    return tables;
+    return { tables, end: pos };
 }
 /** A kept table as the install names it: its header, its 1-based line
  * number in the config before the install and in the config the install
@@ -729,19 +849,19 @@ function startPastBom(text, start) {
  * `blockOpening` is the line the split-block refusal names as the start of
  * the block (`assertNoSplitBlock`; the BEGIN marker when omitted).
  */
-function rangeBeforeStrayEnd(text, start, end, configPath, blockOpening) {
-    const strayIdx = findExactLine(text, CODEX_MANAGED_END, end);
+function rangeBeforeStrayEnd(text, start, end, configPath, blockOpening, zoneFrom = end) {
+    const strayIdx = findMarkerLine(text, CODEX_MANAGED_END, "whole", end);
     if (strayIdx === -1) {
         assertNoSplitBlock(text, end, text.length, configPath, false);
-        const foreignSectionsPreserved = collectForeignSectionHeaders(text, end, text.length);
-        const keptHookTables = collectKeptHookTables(text, end, text.length);
+        const keptHookTables = collectKeptHookTables(text, end, text.length).tables;
+        const foreignSectionsPreserved = collectForeignSectionHeaders(text, end, text.length, keptHookTables);
         return { start, end, foreignSectionsPreserved, keptHookTables };
     }
     const strayLineStart = lineStartAt(text, strayIdx);
     const strayLineEnd = lineEndAfter(text, strayIdx);
-    assertNoSplitBlock(text, end, strayLineStart, configPath, true, blockOpening);
-    const foreignSectionsPreserved = collectForeignSectionHeaders(text, end, strayLineStart);
-    const keptHookTables = collectKeptHookTables(text, end, strayLineStart);
+    assertNoSplitBlock(text, zoneFrom, strayLineStart, configPath, true, blockOpening);
+    const keptHookTables = collectKeptHookTables(text, end, strayLineStart).tables;
+    const foreignSectionsPreserved = collectForeignSectionHeaders(text, end, strayLineStart, keptHookTables);
     return {
         start,
         end,
@@ -753,39 +873,73 @@ function rangeBeforeStrayEnd(text, start, end, configPath, blockOpening) {
 /**
  * The range of a legacy (no BEGIN marker) config: the source-prefix or
  * generated-header paths. When the scan ended at an operator hook table,
- * the zone after it is handled like the BEGIN path's
- * (`rangeBeforeStrayEnd`): an END marker that survived its deleted BEGIN
- * line, sitting after the kept tables, is excised like a drifted END, so
- * the install leaves no orphan END line below the kept tables and the
- * kept-table refusal offers moving an operator-owned table below that END;
- * a harness-commented table after the kept tables refuses through the
- * split-block check instead of being kept as if it were operator content
- * (the fresh block would repeat it) when it sits before that END, or
- * anywhere later when no END follows. Content below that END is untouched,
- * as on the BEGIN path, so a harness-commented table there is kept and not
- * named. The split-block refusal names `blockOpening` (the source-prefix
- * line or the generated header) as the start of the block, since there is
- * no BEGIN marker (task 01053b27). Other endings keep the legacy behaviour.
+ * or at a foreign table with an END marker after it, the zone after it is
+ * handled like the BEGIN path's (`rangeBeforeStrayEnd`): an END marker that
+ * survived its deleted BEGIN line, sitting after the kept tables or the
+ * foreign table, is excised like a drifted END, so the install leaves no
+ * orphan END line and the kept-table refusal offers moving an operator-owned
+ * table below that END; a harness-commented table after the kept tables or
+ * the foreign table refuses through the split-block check instead of being
+ * kept as if it were operator content (the fresh block would repeat it)
+ * when it sits before that END, or, after kept tables, anywhere later when
+ * no END follows (task e8f4fc03 extends the END case to a foreign table).
+ * Content below that END is untouched, as on the BEGIN path, so a
+ * harness-commented table there is kept and not named. The split-block
+ * refusal names `blockOpening` (the source-prefix line or the generated
+ * header) as the start of the block, since there is no BEGIN marker (task
+ * 01053b27); the split-block zone starts after that opening line, so a block
+ * with no hook table in it (the source prefix directly above an operator
+ * table) is not refused for its own opening line (task 36d962d2). The opening
+ * line is a marker line (`createMarkerLineProbe`), so marker text inside a
+ * value or after a content line opens no block.
+ * A scan that ended at a foreign table with no END marker anywhere after it
+ * keeps the legacy behaviour (no split-block check), except that hook event tables directly after the block are collected, named and
+ * checked (`collectKeptHookTables`), and a harness marker in their run
+ * refuses through the split-block check. The END marker is looked up as a
+ * marker line too, so END text in a foreign table's value does not route a
+ * config here. Like the BEGIN path,
+ * the split-block check matches its markers as substrings, so a value in the
+ * zone that holds marker text refuses too (see `assertNoSplitBlock`).
  */
 function legacyManagedRange(text, start, scan, configPath, blockOpening) {
-    if (scan.endedAtOperatorHookTable) {
-        return rangeBeforeStrayEnd(text, start, scan.end, configPath, blockOpening);
+    if (scan.sawEndMarker) {
+        return { start, end: scan.end, foreignSectionsPreserved: [], keptHookTables: [] };
     }
-    const foreignSectionsPreserved = scan.sawEndMarker
-        ? []
-        : collectForeignSectionHeaders(text, scan.end, text.length);
-    return { start, end: scan.end, foreignSectionsPreserved, keptHookTables: [] };
+    // The split-block zone starts after the block's own opening line: when the
+    // scan owned nothing (the generated header or a foreign table directly
+    // follows the source prefix), `scan.end` is that opening line itself, which
+    // is a split-block marker and would refuse a block with nothing in it
+    // (task 36d962d2).
+    const zoneFrom = Math.max(scan.end, lineEndAfter(text, start));
+    if (scan.endedAtOperatorHookTable || findMarkerLine(text, CODEX_MANAGED_END, "whole", scan.end) !== -1) {
+        return rangeBeforeStrayEnd(text, start, scan.end, configPath, blockOpening, zoneFrom);
+    }
+    const run = collectKeptHookTables(text, scan.end, text.length);
+    // The scan ended at a hook table spelled without the `[[hooks.` prefix: a
+    // harness marker in the run of hook tables after it (a harness-commented
+    // table, or the respelled table's own comment line) is harness content the
+    // scan could not read, so refuse through the split-block check, as the
+    // BEGIN path does, instead of naming a table with that comment line above it
+    // as one without (task e8f4fc03). The run stops at the first non-hook table:
+    // past it the legacy reading below stays unchanged.
+    if (run.tables.length > 0)
+        assertNoSplitBlock(text, zoneFrom, run.end, configPath, false);
+    const keptHookTables = run.tables;
+    const foreignSectionsPreserved = collectForeignSectionHeaders(text, scan.end, text.length, keptHookTables);
+    return { start, end: scan.end, foreignSectionsPreserved, keptHookTables };
 }
 function findManagedRange(text, configPath) {
-    const begin = text.indexOf(CODEX_MANAGED_BEGIN);
+    // BEGIN is found as a marker line (`createMarkerLineProbe`): BEGIN text in
+    // an operator value (a string, a trailing comment) is neither the block nor
+    // a second marker, so the install neither deletes operator content after
+    // it nor splices the fresh block into the value (task 36d962d2).
+    const begin = findMarkerLine(text, CODEX_MANAGED_BEGIN, "prefix");
     if (begin !== -1) {
-        const secondBegin = text.indexOf(CODEX_MANAGED_BEGIN, begin + CODEX_MANAGED_BEGIN.length);
+        const secondBegin = findMarkerLine(text, CODEX_MANAGED_BEGIN, "prefix", lineEndAfter(text, begin));
         if (secondBegin !== -1) {
             // Names the second marker's line number only, never that line's own
-            // text: the marker is found by a substring search, so the line may be
-            // foreign content (a value holding a token, say) that merely contains
-            // the marker text, and this refusal is printed to stderr and `--json`.
-            const secondBeginLineNumber = lineNumberAt(text, lineStartAt(text, secondBegin));
+            // text, since this refusal is printed to stderr and `--json`.
+            const secondBeginLineNumber = lineNumberAt(text, secondBegin);
             throw new CodexInstallRefusalError(`Codex config ${configPath} has more than one '${CODEX_MANAGED_BEGIN}' marker ` +
                 `(a second one at line ${secondBeginLineNumber}); refusing to ` +
                 "guess which one is current. Delete the entire unwanted BEGIN/END pair -- including " +
@@ -796,14 +950,14 @@ function findManagedRange(text, configPath) {
                 "but that discards any Codex state (hook trust entries, marketplaces, plugins) " +
                 "written to the file since that backup.", configPath);
         }
-        let start = lineStartAt(text, begin);
+        let start = begin;
         const prev = previousLine(text, start);
-        if (prev) {
-            // A BOM sitting before the source-prefix comment on line 1 must not
-            // hide the prefix from this check (task b34ed105).
-            const prevText = prev.start === 0 ? prev.text.replace(/^\uFEFF/, "") : prev.text;
-            if (prevText.startsWith(CODEX_MANAGED_SOURCE_PREFIX))
-                start = prev.start;
+        // Only a marker line is the block's source prefix: the closing line of a
+        // multi-line string that ends with the prefix text is the operator's
+        // value, not part of the block (task 36d962d2). Trimming also drops a BOM
+        // sitting before the source-prefix comment on line 1 (task b34ed105).
+        if (prev && createMarkerLineProbe(text)(prev.start, CODEX_MANAGED_SOURCE_PREFIX, "prefix")) {
+            start = prev.start;
         }
         start = startPastBom(text, start);
         const contentStart = lineEndAfter(text, begin);
@@ -814,19 +968,24 @@ function findManagedRange(text, configPath) {
         }
         return rangeBeforeStrayEnd(text, start, end, configPath);
     }
-    const source = text.indexOf(CODEX_MANAGED_SOURCE_PREFIX);
+    const source = findMarkerLine(text, CODEX_MANAGED_SOURCE_PREFIX, "prefix");
     if (source !== -1) {
-        const start = startPastBom(text, lineStartAt(text, source));
+        const start = startPastBom(text, source);
         return legacyManagedRange(text, start, scanOwnedContentEnd(text, start), configPath, `the '${CODEX_MANAGED_SOURCE_PREFIX}' source-prefix line`);
     }
-    const generated = text.indexOf(GENERATED_HEADER);
+    const generated = findMarkerLine(text, GENERATED_HEADER, "prefix");
     if (generated !== -1) {
-        const start = startPastBom(text, lineStartAt(text, generated));
+        const start = startPastBom(text, generated);
         const scan = scanOwnedContentEnd(text, start);
-        const end = scan.end;
-        const candidate = text.slice(start, end);
-        if (candidate.includes("[[hooks.") ||
-            candidate.includes("[[hooks.pre_tool_use]]")) {
+        // The generated header opens a legacy block only when a hook table header
+        // line (`[[hooks.`, the older `[[hooks.pre_tool_use]]` included) follows
+        // it inside the scanned range, found by the same top-level line rule as
+        // the markers: `[[hooks.` text in a value, a multi-line string line or a
+        // comment under an operator table is operator content, and taking it for
+        // a header made the install replace the operator's keys after the header
+        // line with the fresh block (task 36d962d2).
+        const hookHeader = findMarkerLine(text, "[[hooks.", "prefix", start);
+        if (hookHeader !== -1 && hookHeader < scan.end) {
             return legacyManagedRange(text, start, scan, configPath, GENERATED_HEADER_OPENING);
         }
     }
@@ -1189,6 +1348,17 @@ function resolvedKeyName(segment) {
 function hooksRooted(trimmed) {
     return resolvedKeyName(parseTableHeader(trimmed)?.keys[0] ?? "") === "hooks";
 }
+/** Whether a header line is an array-of-tables header that appends to a
+ * hook event array or below one (`[[hooks.Stop]]`, `[[ hooks.Stop ]]`,
+ * `[["hooks".Stop]]`, `[[hooks . Stop.hooks]]`): double brackets, a first key
+ * that resolves to `hooks` (`hooksRooted`) and at least an event key after
+ * it. A one-key line (`[["hooks"]]`, which may also be an array element on
+ * its own line) is not one. Used by `collectKeptHookTables` for the
+ * spellings the `[[hooks.` prefix does not catch (task e8f4fc03). */
+function isHookEventArrayHeader(trimmed) {
+    const parsed = parseTableHeader(trimmed);
+    return (parsed !== null && parsed.header.startsWith("[[") && parsed.keys.length >= 2 && hooksRooted(trimmed));
+}
 function subKey(event, index) {
     return `${event}\u0000${index}`;
 }
@@ -1210,11 +1380,12 @@ function subKey(event, index) {
  * scan resolves has the root `hooks` (a `[[hooks.` line has it by its
  * prefix), a table outside `hooks` never shifts the order match, and an
  * array element on its own line (`["x"]`, `[1]`) costs no parse in this
- * scan, unless the element is the string `hooks` (`["hooks"]`,
- * `['hooks']`): that line reads as a `hooks` root, so it is probed like the
- * `hooks`-rooted spellings that `[[hooks.` does not catch
- * (`[[ hooks.Stop ]]`, `[["hooks".Stop]]`, `[hooks.Stop]`), and the probe
- * finds it inside the array.
+ * scan, unless the element line reads as a header whose first key is
+ * `hooks` (`["hooks"]`, `['hooks']`, `[["hooks"]]`, `[[ 'hooks' ]]`): that
+ * line reads as a `hooks` root, so it is probed like the `hooks`-rooted
+ * spellings that `[[hooks.` does not catch (`[[ hooks.Stop ]]`,
+ * `[["hooks".Stop]]`, `[hooks.Stop]`), and the probe finds it inside the
+ * array.
  */
 function mapHookArrayHeaders(text) {
     const map = { slots: new Map(), eventCounts: new Map(), subCounts: new Map() };
@@ -1375,14 +1546,22 @@ function assertKeptHookTablesAreOperatorOwned(kept, currentContent, generatedCon
         const harnessShaped = commands.some((command) => freshCommands.has(command) || command.startsWith("harness "));
         if (!harnessShaped)
             continue;
+        // harness writes every hook table as `[[hooks.<Event>]]`; a table spelled
+        // another way (`[[ hooks.Stop ]]`) never was one, and with the comment
+        // line restored above it the scan would still read it as a foreign
+        // table, so the restore fix is offered only for the harness spelling
+        // (task e8f4fc03).
+        const fix = HOOK_ARRAY_HEADER_RE.test(table.header)
+            ? `Restore the comment line directly above ${table.header}, so the install replaces the table ` +
+                `with the fresh block${moveBelowEndOption(hasEndMarker)}, or delete the table`
+            : "Delete the table (the install replaces only hook tables spelled '[[hooks.<Event>]]' with " +
+                `that comment line above them)${moveBelowEndOption(hasEndMarker)}`;
         throw new CodexInstallRefusalError(`Codex config ${configPath} has a hook table ${table.header} (line ${table.line}) with no ` +
             `'${HARNESS_HOOK_COMMENT_PREFIX}<id> (budget_ms=<n>)' comment line above it, placed after the ` +
             "harness hook tables, whose command is one harness itself writes. harness cannot tell it " +
             "from a harness hook table whose comment line was deleted, and keeping it next to the " +
             "fresh harness block would run that hook twice (or keep a retired harness hook running). " +
-            `Restore the comment line directly above ${table.header}, so the install replaces the table ` +
-            `with the fresh block${moveBelowEndOption(hasEndMarker)}, or delete the table, then re-run ` +
-            `\`harness apply --runtime codex --install\`. The file is untouched.`, configPath);
+            `${fix}, then re-run \`harness apply --runtime codex --install\`. The file is untouched.`, configPath);
     }
 }
 export function planCodexConfigInstall(opts) {
@@ -1412,7 +1591,7 @@ export function planCodexConfigInstall(opts) {
     let keptTableDescriptions = [];
     let hasEndMarkerAfterKept = false;
     if (range) {
-        const oldHookIds = extractHookIds(currentContent.slice(range.start, range.end));
+        const oldHookIds = extractHookIds(currentContent, range.start, range.end);
         const newHookIds = extractHookIds(managedBlock);
         removedHookIds = [...oldHookIds].filter((id) => !newHookIds.has(id));
         keptHookTables = range.keptHookTables;