kimi-plugin-cc 2.5.4 → 2.5.5

package/plugins/kimi-codex/dist/hooks/managed-block.js

@@ -26,6 +26,12 @@
 import { parse as parseToml } from "../vendor/smol-toml/parse.js";
 import { classifyHookCommandDrift, describeHookCommandDrift, hostIdFromHookCommand, isOurApprovalHookCommand, } from "./install-paths.js";
 const MARKER_TAG = "kimi-plugin-cc-managed";
+/**
+ * Plain install removes unpaired marker comments for every host and leaves each
+ * host's hook table in place. A scoped uninstall removes only this host's
+ * markers, so it would disarm a healthy block and keep another host's orphan.
+ */
+export const ORPHAN_MARKER_REMEDY = "Run /kimi:setup (without --uninstall or --check) to repair: install removes orphaned managed marker comments for every host and keeps each host's hook table. A scoped --uninstall does not remove another host's orphan marker. Another tool rewriting ~/.kimi-code/config.toml usually causes this.";
 /**
  * Strict BEGIN matcher. Accepts `# === BEGIN kimi-plugin-cc-managed`
  * with an optional `:<host-id>` suffix, an optional ` (vX.Y.Z)` suffix,
@@ -135,40 +141,41 @@ function findMarkers(lines) {
     return hits;
 }
 /**
- * Pair BEGIN/END markers into well-formed blocks. Return the first orphan
- * (BEGIN-without-END or END-without-BEGIN); verification fails closed on either.
+ * Pair BEGIN/END markers into well-formed blocks. A block is a BEGIN followed
+ * immediately (in marker order) by an END with the same host suffix; every
+ * other marker is an orphan. Nested or interleaved markers therefore orphan
+ * both sides rather than being guessed into a block. Callers decide which
+ * orphans fail closed (see `parseManagedBlock`).
  */
 function pairBlocks(lines) {
     const markers = findMarkers(lines);
     const blocks = [];
-    let open = null;
-    for (const marker of markers) {
-        if (marker.kind === "begin") {
-            // A second BEGIN before the previous one closed → the previous is orphaned.
-            if (open !== null)
-                return { orphan: "BEGIN-without-END" };
-            open = marker;
+    const orphans = [];
+    let i = 0;
+    while (i < markers.length) {
+        const marker = markers[i];
+        const next = markers[i + 1];
+        if (marker.kind === "begin" && next !== undefined && next.kind === "end" && next.hostId === marker.hostId) {
+            const body = validateBlockBody(lines.slice(marker.index + 1, next.index));
+            blocks.push({
+                hostId: marker.hostId,
+                beginLine: marker.index,
+                endLine: next.index,
+                commandPath: body.commandPath,
+                valid: body.valid,
+                invalidReason: body.invalidReason,
+            });
+            i += 2;
             continue;
         }
-        // end
-        if (open === null)
-            return { orphan: "END-without-BEGIN" };
-        if (open.hostId !== marker.hostId)
-            return { orphan: "BEGIN-without-END" };
-        const body = validateBlockBody(lines.slice(open.index + 1, marker.index));
-        blocks.push({
-            hostId: open.hostId,
-            beginLine: open.index,
-            endLine: marker.index,
-            commandPath: body.commandPath,
-            valid: body.valid,
-            invalidReason: body.invalidReason,
+        orphans.push({
+            line: marker.index,
+            detail: marker.kind === "begin" ? "BEGIN-without-END" : "END-without-BEGIN",
+            hostId: marker.hostId,
         });
-        open = null;
+        i += 1;
     }
-    if (open !== null)
-        return { orphan: "BEGIN-without-END" };
-    return { blocks };
+    return { blocks, orphans };
 }
 /** Validate the lines BETWEEN a BEGIN/END pair against the safety grammar. */
 function validateBlockBody(rawBody) {
@@ -274,24 +281,30 @@ function validateBlockBody(rawBody) {
 export function parseManagedBlock(contents, hostId) {
     const rawLines = contents.split("\n");
     const lines = rawLines.map((line) => line.replace(/\r$/, ""));
-    const paired = pairBlocks(lines);
-    if ("orphan" in paired) {
-        return { state: { kind: "orphan", detail: paired.orphan }, blocks: [], lines };
+    const { blocks, orphans } = pairBlocks(lines);
+    // An orphan suffixed for ANOTHER host cannot be part of this host's block:
+    // this host's verdict still rests on its own well-formed pair, the whole-file
+    // hook-set validation, and the real-parser cleanliness check. Legacy and own
+    // orphans stay fail-closed because they may be this host's damaged block.
+    const ownOrphan = orphans.find((o) => o.hostId === null || o.hostId === hostId);
+    const foreignOrphans = orphans.filter((o) => o.hostId !== null && o.hostId !== hostId);
+    if (ownOrphan !== undefined) {
+        return { state: { kind: "orphan", detail: ownOrphan.detail }, blocks: [], lines, foreignOrphans };
     }
-    const blocks = paired.blocks;
     // A block belongs to this host when its marker suffix matches or, for a
     // legacy un-suffixed block, its command derives to this host. An unattributable
     // legacy command is claimable by the next installer; a command attributed to
     // another host is ignored so its block remains untouched.
     const relevant = blocks.filter((b) => effectiveHost(b, hostId) === hostId);
     if (relevant.length === 0) {
-        return { state: { kind: "absent" }, blocks, lines };
+        return { state: { kind: "absent" }, blocks, lines, foreignOrphans };
     }
     if (relevant.length > 1) {
         return {
             state: { kind: "duplicate", beginLines: relevant.map((b) => b.beginLine) },
             blocks,
             lines,
+            foreignOrphans,
         };
     }
     const block = relevant[0];
@@ -307,6 +320,7 @@ export function parseManagedBlock(contents, hostId) {
         },
         blocks,
         lines,
+        foreignOrphans,
     };
 }
 /**
@@ -335,27 +349,6 @@ export function decodeManagedCommandLine(trimmedLine) {
         return literal[1];
     return null;
 }
-/**
- * Return `contents` with every well-formed managed BEGIN/END block removed
- * (inclusive), so what remains is only the bare/root TOML. Used by
- * `hasCleanEnforcingHookEntry` to enforce host isolation. If the markers are
- * unbalanced (orphan), returns the input unchanged — the caller is only reached
- * in the `absent` state, where a well-formed foreign block is the norm.
- */
-function stripManagedBlockLines(contents) {
-    const lines = contents.split("\n").map((line) => line.replace(/\r$/, ""));
-    const paired = pairBlocks(lines);
-    if (!("blocks" in paired))
-        return contents;
-    const inBlock = new Set();
-    for (const block of paired.blocks) {
-        for (let i = block.beginLine; i <= block.endLine; i += 1)
-            inBlock.add(i);
-    }
-    if (inBlock.size === 0)
-        return contents;
-    return lines.filter((_, i) => !inBlock.has(i)).join("\n");
-}
 /**
  * True if a parsed `hooks[]` array contains a clean enforcing entry for
  * `expectedCommand`: `event="PreToolUse"`, byte-exact `command`, NO `matcher`
@@ -364,10 +357,11 @@ function stripManagedBlockLines(contents) {
  * kimi-code's strict schema). Each host's hook path is distinct, so the command
  * uniquely identifies this host's entry.
  */
-function hooksArrayHasCleanEntry(hooks, expectedCommand) {
+function countCleanEntries(hooks, expectedCommand) {
     if (!Array.isArray(hooks))
-        return false;
+        return 0;
     const allowedKeys = new Set(["event", "command", "timeout"]);
+    let count = 0;
     for (const entry of hooks) {
         if (entry === null || typeof entry !== "object")
             continue;
@@ -380,29 +374,37 @@ function hooksArrayHasCleanEntry(hooks, expectedCommand) {
             continue;
         if (!Object.keys(rec).every((k) => allowedKeys.has(k)))
             continue;
-        return true;
+        count += 1;
     }
-    return false;
+    return count;
+}
+function hooksArrayHasCleanEntry(hooks, expectedCommand) {
+    return countCleanEntries(hooks, expectedCommand) > 0;
 }
 /**
- * Parser-based fallback used only in the absent state. Strip every managed
- * block first so another host's live hook cannot count for this host, then parse
- * the remaining bare/root TOML with the real parser rather than the prune line
- * scanner. `hooksArrayHasCleanEntry` requires the exact event and command, no
- * matcher in any spelling, and no foreign keys. Parse errors fail closed.
- * Callers run whole-file schema validation first, including timeout ranges.
+ * Parser-based fallback used only in the absent state. Parse the WHOLE file
+ * exactly as kimi-code does: deleting managed-block lines first would change
+ * which table their keys bind to (a `matcher` written before another host's
+ * `[[hooks]]` header belongs to the preceding table, possibly this host's bare
+ * one). Host isolation is kept by counting: every managed block whose body
+ * carries this exact command may account for one clean entry, so only a clean
+ * entry beyond those can be this host's marker-less table. Requires the exact
+ * event and command, no matcher in any spelling, and no foreign keys. Parse
+ * errors fail closed. Callers run whole-file schema validation first.
  */
 export function hasCleanEnforcingHookEntry(contents, expectedCommand) {
     let parsed;
     try {
-        parsed = parseToml(stripManagedBlockLines(contents));
+        parsed = parseToml(contents);
     }
     catch {
         return false;
     }
     if (parsed === null || typeof parsed !== "object")
         return false;
-    return hooksArrayHasCleanEntry(parsed.hooks, expectedCommand);
+    const lines = contents.split("\n").map((line) => line.replace(/\r$/, ""));
+    const managedWithCommand = pairBlocks(lines).blocks.filter((block) => block.commandPath === expectedCommand).length;
+    return countCleanEntries(parsed.hooks, expectedCommand) > managedWithCommand;
 }
 /**
  * Whole-file parser check for the FOUND (marked-block present) path. The line
@@ -468,7 +470,7 @@ export function evaluateInstalled(contents, expectedCommand, opts) {
     if (state.kind === "orphan") {
         return {
             installed: false,
-            reason: `${state.detail} marker. Run /kimi:setup --uninstall to clear.`,
+            reason: `${state.detail} marker. ${ORPHAN_MARKER_REMEDY}`,
             state,
         };
     }
@@ -516,12 +518,9 @@ export function findBareApprovalHookTables(contents) {
     const lines = contents.split("\n").map((line) => line.replace(/\r$/, ""));
     const tableLines = scanTomlLines(contents).tables;
     const managed = new Set();
-    const paired = pairBlocks(lines);
-    if ("blocks" in paired) {
-        for (const block of paired.blocks) {
-            for (let i = block.beginLine; i <= block.endLine; i += 1)
-                managed.add(i);
-        }
+    for (const block of pairBlocks(lines).blocks) {
+        for (let i = block.beginLine; i <= block.endLine; i += 1)
+            managed.add(i);
     }
     const ranges = [];
     for (let i = 0; i < lines.length; i += 1) {

package/plugins/kimi-codex/dist/kimi-version-probe.js

@@ -194,23 +194,41 @@ export function maxTestedMinor() {
         ? entry
         : max);
 }
+function compareVersions(a, b) {
+    const pa = a.split(".").map((part) => Number.parseInt(part, 10));
+    const pb = b.split(".").map((part) => Number.parseInt(part, 10));
+    for (let i = 0; i < 3; i += 1) {
+        const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (diff !== 0)
+            return diff;
+    }
+    return 0;
+}
 /**
  * Format a user-facing warning line for an out-of-range version probe.
  * Setup itself may complete, but the execution-plan gate will refuse model
  * spawns until the operator selects a certified binary or updates the plugin.
+ * `nativeV2Certified` is the exact native-v2 table; both engines are named so
+ * the newest certified version is not misreported as the legacy-v1 bound.
  */
-export function formatVersionOutOfRangeWarning(probe, pluginVersion) {
+export function formatVersionOutOfRangeWarning(probe, pluginVersion, nativeV2Certified = []) {
     const tested = KIMI_TESTED_MINORS.map((entry) => `${entry.major}.${entry.minor}.x`).join(", ");
     const max = maxTestedMinor();
-    const aboveMax = probe.major > max.major || (probe.major === max.major && probe.minor > max.minor);
+    const newestNative = [...nativeV2Certified].sort(compareVersions).at(-1);
+    const probeRaw = `${probe.major}.${probe.minor}.${probe.patch}`;
+    const aboveMax = newestNative !== undefined
+        ? compareVersions(probeRaw, newestNative) > 0
+        : probe.major > max.major || (probe.major === max.major && probe.minor > max.minor);
+    const certified = nativeV2Certified.length > 0
+        ? `legacy-v1 ${tested}; native-v2 exact ${nativeV2Certified.join(", ")}`
+        : tested;
     const lines = [
-        `WARNING: kimi-code version ${probe.version} is outside the range kimi-plugin-cc ${pluginVersion} was tested against (${tested}).`,
+        `WARNING: kimi-code version ${probe.version} is outside the versions kimi-plugin-cc ${pluginVersion} certifies (${certified}).`,
     ];
     if (aboveMax) {
-        // Above the legacy-v1 tested upper bound is a release newer than the last
-        // legacy compatibility audit, commonly from out-of-band auto-upgrade drift.
-        lines.push(`  This is NEWER than the newest version we have tested (${max.major}.${max.minor}.x) and is not yet certified for model execution.`);
+        // Commonly out-of-band auto-upgrade drift past the last certification.
+        lines.push(`  This is NEWER than the newest certified version (${newestNative ?? `${max.major}.${max.minor}.x`}) and is not yet certified for model execution.`);
     }
-    lines.push(`  Setup can complete, but model-spawning commands will refuse before Kimi starts rather than run an unreviewed engine/version route.`, `  Update kimi-plugin-cc to a release that certifies this minor, or point KIMI_PLUGIN_CC_KIMI_BIN at a certified kimi-code binary and retry setup.`, `  KIMI_PLUGIN_CC_SKIP_VERSION_PROBE is a test/smoke seam, not a production compatibility override.`);
+    lines.push(`  Setup can complete, but model-spawning commands will refuse before Kimi starts rather than run an unreviewed engine/version route.`, `  Update kimi-plugin-cc to a release that certifies this version, or point KIMI_PLUGIN_CC_KIMI_BIN at a certified kimi-code binary and retry setup.`, `  KIMI_PLUGIN_CC_SKIP_VERSION_PROBE is a test/smoke seam, not a production compatibility override.`);
     return lines.join("\n");
 }

package/plugins/kimi-codex/dist/version.js

@@ -4,4 +4,4 @@
 // and AGENTS.md on every release. A future improvement would read this from
 // package.json at build time, but that adds a build-step dependency we
 // don't want yet.
-export const KIMI_PLUGIN_CC_VERSION = "2.5.4";
+export const KIMI_PLUGIN_CC_VERSION = "2.5.5";

package/plugins/kimi-dsh/dist/commands/setup.js

@@ -26,9 +26,9 @@ import { readPluginConfig, writePluginConfig } from "../config.js";
 import { RuntimeError } from "../errors.js";
 import { normalizeTopLevelInlineHooks, validateKimiHookSetForEnvironment, withKimiConfigLock, } from "../hooks/config-safety.js";
 import { buildHookShellCommand, hostIdFromHookCommand, resolveHookScriptPath, resolveHostId, resolveNodeBinary, } from "../hooks/install-paths.js";
-import { decodeManagedCommandLine, effectiveHost, evaluateInstalled, findUnmanagedApprovalHookBlocks, markerCommentLines, MARKERS, parseManagedBlock, } from "../hooks/managed-block.js";
+import { decodeManagedCommandLine, effectiveHost, evaluateInstalled, findUnmanagedApprovalHookBlocks, markerCommentLines, MARKERS, ORPHAN_MARKER_REMEDY, parseManagedBlock, } from "../hooks/managed-block.js";
 import { formatVersionOutOfRangeWarning, probeKimiVersion, } from "../kimi-version-probe.js";
-import { isNativeV2CertifiedVersion } from "../kimi-engine.js";
+import { isNativeV2CertifiedVersion, NATIVE_V2_CERTIFIED_VERSIONS } from "../kimi-engine.js";
 import { resolveKimiHome } from "../kimi-home.js";
 import { ensurePluginPaths, resolvePluginPaths } from "../paths.js";
 import { KIMI_PLUGIN_CC_VERSION } from "../version.js";
@@ -180,7 +180,7 @@ async function runInstall(configPath, hookScriptPath, hostId, reviewGateEnabled,
         const block = buildManagedBlock(hookScriptPath, context.env, lineEnding, hostId);
         const next = state.kind === "found"
             ? spliceBlock(existing, state.beginLine, state.endLine, block, lineEnding)
-            : appendBlock(existing, block, lineEnding);
+            : insertBlockNearManagedBlocks(existing, blocks, block, lineEnding);
         await assertKimiHookSetValid(next, configPath, "setup.install", context.env);
         const blockWritten = next !== original;
         if (blockWritten)
@@ -256,7 +256,10 @@ async function runCheck(configPath, hookScriptPath, hostId, reviewGateEnabled, w
         nodeExists: (binPath) => existsSync(binPath),
     });
     // Non-blocking coexistence + cruft notices.
-    const { blocks: allBlocks } = parseManagedBlock(existing, hostId);
+    const { blocks: allBlocks, foreignOrphans } = parseManagedBlock(existing, hostId);
+    for (const orphan of foreignOrphans) {
+        warnings.push(`Host "${orphan.hostId}" has an orphaned ${orphan.detail} managed marker at line ${orphan.line + 1}; that host's commands refuse until it is repaired. ${ORPHAN_MARKER_REMEDY}`);
+    }
     const otherHosts = [
         ...new Set(allBlocks.map((b) => effectiveHost(b, hostId)).filter((h) => h !== hostId)),
     ];
@@ -303,7 +306,9 @@ async function runCheck(configPath, hookScriptPath, hostId, reviewGateEnabled, w
             reviewGateEnabled,
             nextStep: installedCheck.state.kind === "absent"
                 ? "Run /kimi:setup (without --check) to install the managed block."
-                : "Run /kimi:setup --uninstall, then /kimi:setup to repair.",
+                : installedCheck.state.kind === "orphan"
+                    ? ORPHAN_MARKER_REMEDY
+                    : "Run /kimi:setup --uninstall, then /kimi:setup to repair.",
             details: buildDetails({
                 configPath,
                 hookScriptPath,
@@ -535,6 +540,52 @@ function spliceBlock(contents, beginLine, endLine, replacement, lineEnding) {
     const replacementWithEnding = replacement.endsWith(lineEnding) ? replacement : `${replacement}${lineEnding}`;
     return `${beforeWithSep}${replacementWithEnding}${after}`;
 }
+// Keep every host's block in one contiguous run. Magpie's table rewrite drops
+// comments that follow a table it owns (yetone/magpie#5614): a block appended
+// after such a table loses its BEGIN marker and header, leaving an orphan END.
+// Insert after the last managed END only when nothing but blanks/comments
+// precedes the next header AND the real parser proves the result equals the
+// appended form apart from hook order, so no field can rebind and no value can
+// be split; otherwise append.
+function insertBlockNearManagedBlocks(contents, blocks, block, lineEnding) {
+    if (blocks.length === 0)
+        return appendBlock(contents, block, lineEnding);
+    const anchor = Math.max(...blocks.map((b) => b.endLine));
+    const lines = splitPreservingEnding(contents);
+    for (let i = anchor + 1; i < lines.length; i += 1) {
+        const trimmed = lines[i].trim();
+        if (trimmed.startsWith("["))
+            break;
+        if (trimmed.length > 0 && !trimmed.startsWith("#"))
+            return appendBlock(contents, block, lineEnding);
+    }
+    const rawLines = contents.split(/(?<=\n)/);
+    const head = rawLines.slice(0, anchor + 1).join("");
+    const tail = rawLines.slice(anchor + 1).join("");
+    const appended = appendBlock(contents, block, lineEnding);
+    if (tail.length === 0)
+        return appended;
+    const headWithEnding = head.endsWith("\n") ? head : `${head}${lineEnding}`;
+    const body = block.endsWith(lineEnding) ? block : `${block}${lineEnding}`;
+    const tailSeparator = /^\r?\n/.test(tail) ? "" : lineEnding;
+    const inserted = `${headWithEnding}${lineEnding}${body}${tailSeparator}${tail}`;
+    return sameTomlIgnoringHookOrder(inserted, appended) ? inserted : appended;
+}
+function sameTomlIgnoringHookOrder(a, b) {
+    const canonical = (text) => {
+        const parsed = parseToml(text);
+        const hooks = Array.isArray(parsed.hooks)
+            ? parsed.hooks.map((entry) => JSON.stringify(entry)).sort()
+            : parsed.hooks;
+        return JSON.stringify({ ...parsed, hooks });
+    };
+    try {
+        return canonical(a) === canonical(b);
+    }
+    catch {
+        return false;
+    }
+}
 function appendBlock(contents, block, lineEnding) {
     const base = contents.length === 0 || contents.endsWith(lineEnding) ? contents : `${contents}${lineEnding}`;
     const separator = base.length === 0 ? "" : lineEnding;
@@ -928,7 +979,7 @@ async function collectKimiVersionWarnings(env, warnings) {
     // v2-certified binary would wrongly warn "not certified, commands will refuse".
     if (probe.inTestedRange || isNativeV2CertifiedVersion(probe.version))
         return;
-    warnings.push(formatVersionOutOfRangeWarning(probe, KIMI_PLUGIN_CC_VERSION));
+    warnings.push(formatVersionOutOfRangeWarning(probe, KIMI_PLUGIN_CC_VERSION, NATIVE_V2_CERTIFIED_VERSIONS));
 }
 /**
  * Non-blocking notice for kimi-code's own enabled plugins from

package/plugins/kimi-dsh/dist/hooks/managed-block.js

@@ -26,6 +26,12 @@
 import { parse as parseToml } from "../vendor/smol-toml/parse.js";
 import { classifyHookCommandDrift, describeHookCommandDrift, hostIdFromHookCommand, isOurApprovalHookCommand, } from "./install-paths.js";
 const MARKER_TAG = "kimi-plugin-cc-managed";
+/**
+ * Plain install removes unpaired marker comments for every host and leaves each
+ * host's hook table in place. A scoped uninstall removes only this host's
+ * markers, so it would disarm a healthy block and keep another host's orphan.
+ */
+export const ORPHAN_MARKER_REMEDY = "Run /kimi:setup (without --uninstall or --check) to repair: install removes orphaned managed marker comments for every host and keeps each host's hook table. A scoped --uninstall does not remove another host's orphan marker. Another tool rewriting ~/.kimi-code/config.toml usually causes this.";
 /**
  * Strict BEGIN matcher. Accepts `# === BEGIN kimi-plugin-cc-managed`
  * with an optional `:<host-id>` suffix, an optional ` (vX.Y.Z)` suffix,
@@ -135,40 +141,41 @@ function findMarkers(lines) {
     return hits;
 }
 /**
- * Pair BEGIN/END markers into well-formed blocks. Return the first orphan
- * (BEGIN-without-END or END-without-BEGIN); verification fails closed on either.
+ * Pair BEGIN/END markers into well-formed blocks. A block is a BEGIN followed
+ * immediately (in marker order) by an END with the same host suffix; every
+ * other marker is an orphan. Nested or interleaved markers therefore orphan
+ * both sides rather than being guessed into a block. Callers decide which
+ * orphans fail closed (see `parseManagedBlock`).
  */
 function pairBlocks(lines) {
     const markers = findMarkers(lines);
     const blocks = [];
-    let open = null;
-    for (const marker of markers) {
-        if (marker.kind === "begin") {
-            // A second BEGIN before the previous one closed → the previous is orphaned.
-            if (open !== null)
-                return { orphan: "BEGIN-without-END" };
-            open = marker;
+    const orphans = [];
+    let i = 0;
+    while (i < markers.length) {
+        const marker = markers[i];
+        const next = markers[i + 1];
+        if (marker.kind === "begin" && next !== undefined && next.kind === "end" && next.hostId === marker.hostId) {
+            const body = validateBlockBody(lines.slice(marker.index + 1, next.index));
+            blocks.push({
+                hostId: marker.hostId,
+                beginLine: marker.index,
+                endLine: next.index,
+                commandPath: body.commandPath,
+                valid: body.valid,
+                invalidReason: body.invalidReason,
+            });
+            i += 2;
             continue;
         }
-        // end
-        if (open === null)
-            return { orphan: "END-without-BEGIN" };
-        if (open.hostId !== marker.hostId)
-            return { orphan: "BEGIN-without-END" };
-        const body = validateBlockBody(lines.slice(open.index + 1, marker.index));
-        blocks.push({
-            hostId: open.hostId,
-            beginLine: open.index,
-            endLine: marker.index,
-            commandPath: body.commandPath,
-            valid: body.valid,
-            invalidReason: body.invalidReason,
+        orphans.push({
+            line: marker.index,
+            detail: marker.kind === "begin" ? "BEGIN-without-END" : "END-without-BEGIN",
+            hostId: marker.hostId,
         });
-        open = null;
+        i += 1;
     }
-    if (open !== null)
-        return { orphan: "BEGIN-without-END" };
-    return { blocks };
+    return { blocks, orphans };
 }
 /** Validate the lines BETWEEN a BEGIN/END pair against the safety grammar. */
 function validateBlockBody(rawBody) {
@@ -274,24 +281,30 @@ function validateBlockBody(rawBody) {
 export function parseManagedBlock(contents, hostId) {
     const rawLines = contents.split("\n");
     const lines = rawLines.map((line) => line.replace(/\r$/, ""));
-    const paired = pairBlocks(lines);
-    if ("orphan" in paired) {
-        return { state: { kind: "orphan", detail: paired.orphan }, blocks: [], lines };
+    const { blocks, orphans } = pairBlocks(lines);
+    // An orphan suffixed for ANOTHER host cannot be part of this host's block:
+    // this host's verdict still rests on its own well-formed pair, the whole-file
+    // hook-set validation, and the real-parser cleanliness check. Legacy and own
+    // orphans stay fail-closed because they may be this host's damaged block.
+    const ownOrphan = orphans.find((o) => o.hostId === null || o.hostId === hostId);
+    const foreignOrphans = orphans.filter((o) => o.hostId !== null && o.hostId !== hostId);
+    if (ownOrphan !== undefined) {
+        return { state: { kind: "orphan", detail: ownOrphan.detail }, blocks: [], lines, foreignOrphans };
     }
-    const blocks = paired.blocks;
     // A block belongs to this host when its marker suffix matches or, for a
     // legacy un-suffixed block, its command derives to this host. An unattributable
     // legacy command is claimable by the next installer; a command attributed to
     // another host is ignored so its block remains untouched.
     const relevant = blocks.filter((b) => effectiveHost(b, hostId) === hostId);
     if (relevant.length === 0) {
-        return { state: { kind: "absent" }, blocks, lines };
+        return { state: { kind: "absent" }, blocks, lines, foreignOrphans };
     }
     if (relevant.length > 1) {
         return {
             state: { kind: "duplicate", beginLines: relevant.map((b) => b.beginLine) },
             blocks,
             lines,
+            foreignOrphans,
         };
     }
     const block = relevant[0];
@@ -307,6 +320,7 @@ export function parseManagedBlock(contents, hostId) {
         },
         blocks,
         lines,
+        foreignOrphans,
     };
 }
 /**
@@ -335,27 +349,6 @@ export function decodeManagedCommandLine(trimmedLine) {
         return literal[1];
     return null;
 }
-/**
- * Return `contents` with every well-formed managed BEGIN/END block removed
- * (inclusive), so what remains is only the bare/root TOML. Used by
- * `hasCleanEnforcingHookEntry` to enforce host isolation. If the markers are
- * unbalanced (orphan), returns the input unchanged — the caller is only reached
- * in the `absent` state, where a well-formed foreign block is the norm.
- */
-function stripManagedBlockLines(contents) {
-    const lines = contents.split("\n").map((line) => line.replace(/\r$/, ""));
-    const paired = pairBlocks(lines);
-    if (!("blocks" in paired))
-        return contents;
-    const inBlock = new Set();
-    for (const block of paired.blocks) {
-        for (let i = block.beginLine; i <= block.endLine; i += 1)
-            inBlock.add(i);
-    }
-    if (inBlock.size === 0)
-        return contents;
-    return lines.filter((_, i) => !inBlock.has(i)).join("\n");
-}
 /**
  * True if a parsed `hooks[]` array contains a clean enforcing entry for
  * `expectedCommand`: `event="PreToolUse"`, byte-exact `command`, NO `matcher`
@@ -364,10 +357,11 @@ function stripManagedBlockLines(contents) {
  * kimi-code's strict schema). Each host's hook path is distinct, so the command
  * uniquely identifies this host's entry.
  */
-function hooksArrayHasCleanEntry(hooks, expectedCommand) {
+function countCleanEntries(hooks, expectedCommand) {
     if (!Array.isArray(hooks))
-        return false;
+        return 0;
     const allowedKeys = new Set(["event", "command", "timeout"]);
+    let count = 0;
     for (const entry of hooks) {
         if (entry === null || typeof entry !== "object")
             continue;
@@ -380,29 +374,37 @@ function hooksArrayHasCleanEntry(hooks, expectedCommand) {
             continue;
         if (!Object.keys(rec).every((k) => allowedKeys.has(k)))
             continue;
-        return true;
+        count += 1;
     }
-    return false;
+    return count;
+}
+function hooksArrayHasCleanEntry(hooks, expectedCommand) {
+    return countCleanEntries(hooks, expectedCommand) > 0;
 }
 /**
- * Parser-based fallback used only in the absent state. Strip every managed
- * block first so another host's live hook cannot count for this host, then parse
- * the remaining bare/root TOML with the real parser rather than the prune line
- * scanner. `hooksArrayHasCleanEntry` requires the exact event and command, no
- * matcher in any spelling, and no foreign keys. Parse errors fail closed.
- * Callers run whole-file schema validation first, including timeout ranges.
+ * Parser-based fallback used only in the absent state. Parse the WHOLE file
+ * exactly as kimi-code does: deleting managed-block lines first would change
+ * which table their keys bind to (a `matcher` written before another host's
+ * `[[hooks]]` header belongs to the preceding table, possibly this host's bare
+ * one). Host isolation is kept by counting: every managed block whose body
+ * carries this exact command may account for one clean entry, so only a clean
+ * entry beyond those can be this host's marker-less table. Requires the exact
+ * event and command, no matcher in any spelling, and no foreign keys. Parse
+ * errors fail closed. Callers run whole-file schema validation first.
  */
 export function hasCleanEnforcingHookEntry(contents, expectedCommand) {
     let parsed;
     try {
-        parsed = parseToml(stripManagedBlockLines(contents));
+        parsed = parseToml(contents);
     }
     catch {
         return false;
     }
     if (parsed === null || typeof parsed !== "object")
         return false;
-    return hooksArrayHasCleanEntry(parsed.hooks, expectedCommand);
+    const lines = contents.split("\n").map((line) => line.replace(/\r$/, ""));
+    const managedWithCommand = pairBlocks(lines).blocks.filter((block) => block.commandPath === expectedCommand).length;
+    return countCleanEntries(parsed.hooks, expectedCommand) > managedWithCommand;
 }
 /**
  * Whole-file parser check for the FOUND (marked-block present) path. The line
@@ -468,7 +470,7 @@ export function evaluateInstalled(contents, expectedCommand, opts) {
     if (state.kind === "orphan") {
         return {
             installed: false,
-            reason: `${state.detail} marker. Run /kimi:setup --uninstall to clear.`,
+            reason: `${state.detail} marker. ${ORPHAN_MARKER_REMEDY}`,
             state,
         };
     }
@@ -516,12 +518,9 @@ export function findBareApprovalHookTables(contents) {
     const lines = contents.split("\n").map((line) => line.replace(/\r$/, ""));
     const tableLines = scanTomlLines(contents).tables;
     const managed = new Set();
-    const paired = pairBlocks(lines);
-    if ("blocks" in paired) {
-        for (const block of paired.blocks) {
-            for (let i = block.beginLine; i <= block.endLine; i += 1)
-                managed.add(i);
-        }
+    for (const block of pairBlocks(lines).blocks) {
+        for (let i = block.beginLine; i <= block.endLine; i += 1)
+            managed.add(i);
     }
     const ranges = [];
     for (let i = 0; i < lines.length; i += 1) {