@infinitedusky/indusk-mcp 1.16.0 → 1.16.1

package/dist/bin/cli.js

@@ -3,8 +3,31 @@ import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { Command } from "commander";
+import { resolveProjectRoot } from "../lib/config.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const pkg = JSON.parse(readFileSync(join(__dirname, "../../package.json"), "utf-8"));
+/**
+ * Resolve the InDusk project root for commands that operate on an existing
+ * project. Walks up from cwd looking for `.indusk/config.json`. If not
+ * found, errors out — prevents accidental writes to the wrong `.claude/`
+ * when invoked from a sub-directory like `apps/indusk-mcp/`.
+ *
+ * Commands that CREATE the project root (currently only `init`) use
+ * `process.cwd()` directly — init is responsible for creating the marker.
+ */
+function rootOrExit() {
+    const cwd = process.cwd();
+    const root = resolveProjectRoot(cwd);
+    if (root === null) {
+        console.error(`Not inside an InDusk project (no .indusk/config.json found walking up from ${cwd}).\n` +
+            "Run 'indusk init' here to initialize a new project, or cd to an existing one.");
+        process.exit(1);
+    }
+    if (root !== cwd) {
+        console.info(`[indusk] Using project root: ${root}\n`);
+    }
+    return root;
+}
 const program = new Command();
 program
     .name("dev-system")
@@ -29,7 +52,7 @@ program
     .description("Update skills from package without touching project content")
     .action(async () => {
     const { update } = await import("./commands/update.js");
-    await update(process.cwd());
+    await update(rootOrExit());
 });
 const ext = program
     .command("extensions")
@@ -39,28 +62,28 @@ ext
     .description("Show all available extensions")
     .action(async () => {
     const { extensionsList } = await import("./commands/extensions.js");
-    await extensionsList(process.cwd());
+    await extensionsList(rootOrExit());
 });
 ext
     .command("status")
     .description("Show enabled extensions with health")
     .action(async () => {
     const { extensionsStatus } = await import("./commands/extensions.js");
-    await extensionsStatus(process.cwd());
+    await extensionsStatus(rootOrExit());
 });
 ext
     .command("enable <names...>")
     .description("Enable extensions")
     .action(async (names) => {
     const { extensionsEnable } = await import("./commands/extensions.js");
-    await extensionsEnable(process.cwd(), names);
+    await extensionsEnable(rootOrExit(), names);
 });
 ext
     .command("disable <names...>")
     .description("Disable extensions")
     .action(async (names) => {
     const { extensionsDisable } = await import("./commands/extensions.js");
-    await extensionsDisable(process.cwd(), names);
+    await extensionsDisable(rootOrExit(), names);
 });
 ext
     .command("add <name>")
@@ -68,35 +91,35 @@ ext
     .requiredOption("--from <source>", "Source: npm:pkg, github:user/repo, URL, or local path")
     .action(async (name, opts) => {
     const { extensionsAdd } = await import("./commands/extensions.js");
-    await extensionsAdd(process.cwd(), name, opts.from);
+    await extensionsAdd(rootOrExit(), name, opts.from);
 });
 ext
     .command("remove <names...>")
     .description("Remove extensions")
     .action(async (names) => {
     const { extensionsRemove } = await import("./commands/extensions.js");
-    await extensionsRemove(process.cwd(), names);
+    await extensionsRemove(rootOrExit(), names);
 });
 ext
     .command("update [names...]")
     .description("Update third-party extensions from their original source")
     .action(async (names) => {
     const { extensionsUpdate } = await import("./commands/extensions.js");
-    await extensionsUpdate(process.cwd(), names);
+    await extensionsUpdate(rootOrExit(), names);
 });
 ext
     .command("suggest")
     .description("Recommend extensions based on project contents")
     .action(async () => {
     const { extensionsSuggest } = await import("./commands/extensions.js");
-    await extensionsSuggest(process.cwd());
+    await extensionsSuggest(rootOrExit());
 });
 program
     .command("init-docs")
     .description("Scaffold a VitePress documentation site with Mermaid, llms.txt, and FullscreenDiagram")
     .action(async () => {
     const { initDocs } = await import("./commands/init-docs.js");
-    await initDocs(process.cwd());
+    await initDocs(rootOrExit());
 });
 program
     .command("check-gates")
@@ -105,7 +128,7 @@ program
     .option("--phase <number>", "Check a specific phase number", Number.parseInt)
     .action(async (opts) => {
     const { checkGates } = await import("./commands/check-gates.js");
-    await checkGates(process.cwd(), { file: opts.file, phase: opts.phase });
+    await checkGates(rootOrExit(), { file: opts.file, phase: opts.phase });
 });
 const infra = program
     .command("infra")
@@ -144,7 +167,7 @@ graph
     const { getLogPath } = await import("../lib/semantic-graph/paths.js");
     const { SemanticGraphClient } = await import("../lib/semantic-graph/runtime-client.js");
     const { runSync } = await import("../lib/semantic-graph/sync-engine.js");
-    const projectRoot = process.cwd();
+    const projectRoot = rootOrExit();
     const projectName = basename(projectRoot);
     const adapter = new CgcAdapter();
     const logWriter = new LogWriter(getLogPath(projectRoot));
@@ -164,7 +187,7 @@ graph
     const { getLogPath } = await import("../lib/semantic-graph/paths.js");
     const { replay } = await import("../lib/semantic-graph/replay.js");
     const { SemanticGraphClient } = await import("../lib/semantic-graph/runtime-client.js");
-    const projectRoot = process.cwd();
+    const projectRoot = rootOrExit();
     const projectName = basename(projectRoot);
     const logPath = getLogPath(projectRoot);
     const client = new SemanticGraphClient(projectName);
@@ -188,7 +211,7 @@ graph
     const { getLogPath } = await import("../lib/semantic-graph/paths.js");
     const { readAllEvents } = await import("../lib/semantic-graph/log-reader.js");
     const { SemanticGraphClient } = await import("../lib/semantic-graph/runtime-client.js");
-    const projectRoot = process.cwd();
+    const projectRoot = rootOrExit();
     const projectName = basename(projectRoot);
     const logPath = getLogPath(projectRoot);
     console.info(`Project: ${projectName}`);
@@ -223,7 +246,7 @@ program
     .description("Strip InDusk settings overlay before a PR")
     .action(async () => {
     const { stripOverlay } = await import("../lib/settings-overlay.js");
-    stripOverlay(process.cwd());
+    stripOverlay(rootOrExit());
     console.info("Stripped InDusk overlay from .claude/settings.json");
 });
 program
@@ -231,7 +254,7 @@ program
     .description("Re-apply InDusk settings overlay after a PR")
     .action(async () => {
     const { applyOverlay } = await import("../lib/settings-overlay.js");
-    applyOverlay(process.cwd());
+    applyOverlay(rootOrExit());
     console.info("Re-applied InDusk overlay to .claude/settings.json");
 });
 program
@@ -239,13 +262,14 @@ program
     .description("Install extensions (shorthand for extensions enable / add)")
     .option("--from <source>", "Source for third-party extension (npm:pkg, github:user/repo, URL, or path)")
     .action(async (names, opts) => {
+    const root = rootOrExit();
     if (opts.from) {
         const { extensionsAdd } = await import("./commands/extensions.js");
-        await extensionsAdd(process.cwd(), names[0], opts.from);
+        await extensionsAdd(root, names[0], opts.from);
     }
     else {
         const { extensionsEnable } = await import("./commands/extensions.js");
-        await extensionsEnable(process.cwd(), names);
+        await extensionsEnable(root, names);
     }
 });
 const eval_ = program.command("eval").description("Context evaluation and quality scoring");
@@ -257,7 +281,7 @@ eval_
     .option("--json", "Output as JSON")
     .action(async (opts) => {
     const { evalSummary } = await import("./commands/eval.js");
-    await evalSummary(process.cwd(), opts);
+    await evalSummary(rootOrExit(), opts);
 });
 eval_
     .command("findings")
@@ -265,21 +289,21 @@ eval_
     .option("--all", "Show all findings including fixed/ignored")
     .action(async (opts) => {
     const { evalFindings } = await import("./commands/eval.js");
-    await evalFindings(process.cwd(), opts);
+    await evalFindings(rootOrExit(), opts);
 });
 eval_
     .command("fix <key>")
     .description("Mark an eval finding as fixed")
     .action(async (key) => {
     const { evalMark } = await import("./commands/eval.js");
-    await evalMark(process.cwd(), key, "fixed");
+    await evalMark(rootOrExit(), key, "fixed");
 });
 eval_
     .command("ignore <key>")
     .description("Mark an eval finding as ignored")
     .action(async (key) => {
     const { evalMark } = await import("./commands/eval.js");
-    await evalMark(process.cwd(), key, "ignored");
+    await evalMark(rootOrExit(), key, "ignored");
 });
 eval_
     .command("baseline")
@@ -288,7 +312,7 @@ eval_
     .option("--keep", "Keep baseline worktree after eval")
     .action(async (opts) => {
     const { evalBaseline } = await import("./commands/eval.js");
-    await evalBaseline(process.cwd(), opts);
+    await evalBaseline(rootOrExit(), opts);
 });
 program
     .command("beam <file>")
@@ -299,7 +323,7 @@ program
     const { runBeam } = await import("../lib/beam/runner.js");
     const { formatBeamMarkdown, formatBeamTrace } = await import("../lib/beam/format.js");
     const result = await runBeam({
-        projectRoot: process.cwd(),
+        projectRoot: rootOrExit(),
         targetPath: file,
         trace: opts.trace ?? false,
     });

package/dist/lib/config.d.ts

@@ -1,3 +1,20 @@
+/**
+ * Resolve the InDusk project root by walking up from the given directory
+ * until `.indusk/config.json` is found. Returns the directory containing
+ * `.indusk/config.json`, or `null` if none is found up to the filesystem
+ * root.
+ *
+ * `.indusk/config.json` is the authoritative "this is an InDusk project"
+ * marker — created by `indusk init`, never by sub-apps that happen to
+ * have their own `.claude/` scaffolding. Walking up to find it prevents
+ * bugs like `indusk update` syncing to the wrong `.claude/` when the user
+ * runs it from a sub-directory (e.g. `apps/indusk-mcp/`).
+ *
+ * For `indusk init` itself, use the raw cwd — init creates the marker, so
+ * walk-up would either find nothing or (worse) match an ancestor project
+ * the user doesn't intend to re-init.
+ */
+export declare function resolveProjectRoot(startDir: string): string | null;
 export interface VerifyToolConfig {
     tool: string;
     config: string;

package/dist/lib/config.js

@@ -1,5 +1,33 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { basename, dirname, join } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
+/**
+ * Resolve the InDusk project root by walking up from the given directory
+ * until `.indusk/config.json` is found. Returns the directory containing
+ * `.indusk/config.json`, or `null` if none is found up to the filesystem
+ * root.
+ *
+ * `.indusk/config.json` is the authoritative "this is an InDusk project"
+ * marker — created by `indusk init`, never by sub-apps that happen to
+ * have their own `.claude/` scaffolding. Walking up to find it prevents
+ * bugs like `indusk update` syncing to the wrong `.claude/` when the user
+ * runs it from a sub-directory (e.g. `apps/indusk-mcp/`).
+ *
+ * For `indusk init` itself, use the raw cwd — init creates the marker, so
+ * walk-up would either find nothing or (worse) match an ancestor project
+ * the user doesn't intend to re-init.
+ */
+export function resolveProjectRoot(startDir) {
+    let dir = startDir;
+    for (let i = 0; i < 20; i++) {
+        if (existsSync(join(dir, ".indusk/config.json")))
+            return dir;
+        const parent = resolve(dir, "..");
+        if (parent === dir)
+            return null;
+        dir = parent;
+    }
+    return null;
+}
 const CONFIG_PATH = ".indusk/config.json";
 export function getConfigPath(projectRoot) {
     return join(projectRoot, CONFIG_PATH);

package/dist/lib/falsification/log.d.ts

@@ -0,0 +1,51 @@
+export type HypothesisOutcome = "fix-in-scope" | "spawn-plan" | "accept-finding";
+export interface HypothesisEntry {
+    kind: "hypothesis";
+    hypothesis: string;
+    testPath: string | null;
+    outcome: HypothesisOutcome;
+    note?: string;
+    timestamp: string;
+}
+export interface TerminatorEntry {
+    kind: "terminator";
+    reason: string;
+    timestamp: string;
+}
+export type LogEntry = HypothesisEntry | TerminatorEntry;
+export interface MalformedLine {
+    lineNumber: number;
+    content: string;
+    reason: string;
+}
+/**
+ * Append a confirmed-hypothesis entry to the plan's falsification log.
+ * Creates the log file with a header if it doesn't yet exist. Throws if
+ * the log is already terminated (a new hypothesis after a terminator is a
+ * sign the ritual was restarted incorrectly — see `isFalsificationComplete`
+ * and start a new plan or explicitly un-terminate first).
+ */
+export declare function appendHypothesis(planRoot: string, entry: Omit<HypothesisEntry, "kind" | "timestamp">): HypothesisEntry;
+/**
+ * Append a terminator entry marking the falsification ritual complete for
+ * this plan. No further hypotheses can be appended after this. The reason
+ * is the user-confirmed rationale for termination (e.g., "investigated
+ * concurrency, race conditions, partial-write paths, and type-narrowing
+ * gaps; no in-scope failure remained").
+ */
+export declare function markTerminated(planRoot: string, reason: string): TerminatorEntry;
+/**
+ * Read the falsification log for a plan. Returns an empty array if the log
+ * file does not exist. Malformed entries are skipped (not thrown) and
+ * surfaced via the optional `onMalformed` callback, matching the semantic
+ * graph event log's resilience pattern.
+ */
+export declare function readFalsificationLog(planRoot: string, opts?: {
+    onMalformed?: (malformed: MalformedLine) => void;
+}): LogEntry[];
+/**
+ * True iff the plan's falsification log exists AND its last entry is a
+ * terminator. False for a missing log, a log with only hypotheses (ritual
+ * started but not terminated), or an empty log file.
+ */
+export declare function isFalsificationComplete(planRoot: string): boolean;

package/dist/lib/falsification/log.js

@@ -0,0 +1,207 @@
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+const VALID_OUTCOMES = new Set([
+    "fix-in-scope",
+    "spawn-plan",
+    "accept-finding",
+]);
+/**
+ * Reject multiline content at the library boundary. The log's on-disk
+ * format is markdown sections with bold-labeled single-line fields; any
+ * line-separator character in hypothesis / note / reason silently
+ * truncates during parse (the regex uses /m mode, where $ matches before
+ * LF, CR, LS, and PS). Throwing here forces callers to sanitize — either
+ * collapse to a single line or split across multiple entries.
+ *
+ * Line separators rejected: LF (\n), CR (\r), LS (U+2028), PS (U+2029).
+ */
+const LINE_SEPARATOR_RE = /[\n\r\u2028\u2029]/;
+function assertSingleLine(field, value) {
+    if (LINE_SEPARATOR_RE.test(value)) {
+        throw new Error(`Falsification log ${field} must be single-line (got a value containing a line separator). Either collapse to one line (replace '\\n' with '; '), or split the content across multiple entries. The log's parser is line-oriented; any line-separator (LF, CR, LS, PS) would silently truncate.`);
+    }
+}
+function logPath(planRoot) {
+    return join(planRoot, "falsification.md");
+}
+function headerFor(planRoot) {
+    return `# Falsification Log — ${basename(planRoot)}\n\nAppend-only record of the /falsify bounty hunt for this plan. Never edit in place; entries are appended via \`appendHypothesis\` and \`markTerminated\` from \`apps/indusk-mcp/src/lib/falsification/log.ts\`.\n\n`;
+}
+/**
+ * Append a confirmed-hypothesis entry to the plan's falsification log.
+ * Creates the log file with a header if it doesn't yet exist. Throws if
+ * the log is already terminated (a new hypothesis after a terminator is a
+ * sign the ritual was restarted incorrectly — see `isFalsificationComplete`
+ * and start a new plan or explicitly un-terminate first).
+ */
+export function appendHypothesis(planRoot, entry) {
+    assertSingleLine("hypothesis", entry.hypothesis);
+    if (entry.note !== undefined)
+        assertSingleLine("note", entry.note);
+    const path = logPath(planRoot);
+    const existing = existsSync(path) ? readFalsificationLog(planRoot) : [];
+    if (existing.length > 0 && existing[existing.length - 1].kind === "terminator") {
+        throw new Error(`Falsification log at ${path} is already terminated. Start a new plan or remove the terminator before appending.`);
+    }
+    if (!existsSync(path)) {
+        writeFileSync(path, headerFor(planRoot), "utf-8");
+    }
+    const stored = {
+        kind: "hypothesis",
+        hypothesis: entry.hypothesis,
+        testPath: entry.testPath,
+        outcome: entry.outcome,
+        note: entry.note,
+        timestamp: new Date().toISOString(),
+    };
+    appendFileSync(path, renderHypothesis(stored), "utf-8");
+    return stored;
+}
+/**
+ * Append a terminator entry marking the falsification ritual complete for
+ * this plan. No further hypotheses can be appended after this. The reason
+ * is the user-confirmed rationale for termination (e.g., "investigated
+ * concurrency, race conditions, partial-write paths, and type-narrowing
+ * gaps; no in-scope failure remained").
+ */
+export function markTerminated(planRoot, reason) {
+    if (!reason.trim()) {
+        throw new Error("markTerminated requires a non-empty reason.");
+    }
+    assertSingleLine("reason", reason);
+    const path = logPath(planRoot);
+    const existing = existsSync(path) ? readFalsificationLog(planRoot) : [];
+    if (existing.length > 0 && existing[existing.length - 1].kind === "terminator") {
+        throw new Error(`Falsification log at ${path} is already terminated.`);
+    }
+    if (!existsSync(path)) {
+        writeFileSync(path, headerFor(planRoot), "utf-8");
+    }
+    const stored = {
+        kind: "terminator",
+        reason: reason.trim(),
+        timestamp: new Date().toISOString(),
+    };
+    appendFileSync(path, renderTerminator(stored), "utf-8");
+    return stored;
+}
+/**
+ * Read the falsification log for a plan. Returns an empty array if the log
+ * file does not exist. Malformed entries are skipped (not thrown) and
+ * surfaced via the optional `onMalformed` callback, matching the semantic
+ * graph event log's resilience pattern.
+ */
+export function readFalsificationLog(planRoot, opts) {
+    const path = logPath(planRoot);
+    if (!existsSync(path))
+        return [];
+    const content = readFileSync(path, "utf-8");
+    const entries = [];
+    const sectionRegex = /^##\s+(Hypothesis|Terminated)\s+(.+?)\s*$/gm;
+    const matches = [...content.matchAll(sectionRegex)];
+    for (let i = 0; i < matches.length; i++) {
+        const match = matches[i];
+        const [, kind, timestamp] = match;
+        const start = (match.index ?? 0) + match[0].length;
+        const end = i + 1 < matches.length ? (matches[i + 1].index ?? content.length) : content.length;
+        const body = content.slice(start, end).trim();
+        if (kind === "Hypothesis") {
+            const entry = parseHypothesisBody(body, timestamp);
+            if ("lineNumber" in entry) {
+                opts?.onMalformed?.(entry);
+            }
+            else {
+                entries.push(entry);
+            }
+        }
+        else if (kind === "Terminated") {
+            const entry = parseTerminatorBody(body, timestamp);
+            if ("lineNumber" in entry) {
+                opts?.onMalformed?.(entry);
+            }
+            else {
+                entries.push(entry);
+            }
+        }
+    }
+    return entries;
+}
+/**
+ * True iff the plan's falsification log exists AND its last entry is a
+ * terminator. False for a missing log, a log with only hypotheses (ritual
+ * started but not terminated), or an empty log file.
+ */
+export function isFalsificationComplete(planRoot) {
+    const entries = readFalsificationLog(planRoot);
+    if (entries.length === 0)
+        return false;
+    return entries[entries.length - 1].kind === "terminator";
+}
+// ---------------------------------------------------------------
+// Rendering (writing entries to markdown)
+// ---------------------------------------------------------------
+function renderHypothesis(entry) {
+    const lines = [
+        `## Hypothesis ${entry.timestamp}`,
+        "",
+        `**Hypothesis:** ${entry.hypothesis}`,
+        `**Test:** ${entry.testPath ?? "(not written)"}`,
+        `**Outcome:** ${entry.outcome}`,
+    ];
+    if (entry.note) {
+        lines.push(`**Note:** ${entry.note}`);
+    }
+    lines.push("", "");
+    return lines.join("\n");
+}
+function renderTerminator(entry) {
+    return [`## Terminated ${entry.timestamp}`, "", `**Reason:** ${entry.reason}`, "", ""].join("\n");
+}
+// ---------------------------------------------------------------
+// Parsing (reading entries from markdown)
+// ---------------------------------------------------------------
+function parseHypothesisBody(body, timestamp) {
+    const hypothesisMatch = body.match(/^\*\*Hypothesis:\*\*\s+(.+)$/m);
+    const testMatch = body.match(/^\*\*Test:\*\*\s+(.+)$/m);
+    const outcomeMatch = body.match(/^\*\*Outcome:\*\*\s+([a-z-]+)$/m);
+    const noteMatch = body.match(/^\*\*Note:\*\*\s+(.+)$/m);
+    if (!hypothesisMatch || !outcomeMatch) {
+        return {
+            lineNumber: 0,
+            content: body,
+            reason: "Hypothesis entry missing required fields (hypothesis or outcome)",
+        };
+    }
+    const outcome = outcomeMatch[1];
+    if (!VALID_OUTCOMES.has(outcome)) {
+        return {
+            lineNumber: 0,
+            content: body,
+            reason: `Invalid outcome "${outcome}"; must be one of ${[...VALID_OUTCOMES].join(", ")}`,
+        };
+    }
+    const testRaw = testMatch?.[1]?.trim() ?? "(not written)";
+    return {
+        kind: "hypothesis",
+        hypothesis: hypothesisMatch[1].trim(),
+        testPath: testRaw === "(not written)" ? null : testRaw,
+        outcome,
+        note: noteMatch?.[1]?.trim(),
+        timestamp,
+    };
+}
+function parseTerminatorBody(body, timestamp) {
+    const reasonMatch = body.match(/^\*\*Reason:\*\*\s+(.+)$/m);
+    if (!reasonMatch) {
+        return {
+            lineNumber: 0,
+            content: body,
+            reason: "Terminator entry missing required Reason field",
+        };
+    }
+    return {
+        kind: "terminator",
+        reason: reasonMatch[1].trim(),
+        timestamp,
+    };
+}

package/dist/lib/falsification/skip.d.ts

@@ -0,0 +1,23 @@
+export interface SkipCheck {
+    skipped: boolean;
+    reason: string | null;
+}
+/**
+ * Parse an impl.md body (the full file content including frontmatter) and
+ * return whether the author has explicitly opted out of the falsification
+ * ritual. Opt-out requires both fields in frontmatter:
+ *
+ *   falsification: skipped
+ *   falsification_reason: "a non-empty reason"
+ *
+ * Returns `{ skipped: true, reason }` only if both fields are present and
+ * the reason is non-empty after trimming. Any other state — missing
+ * `falsification`, falsification set to anything other than `skipped`,
+ * missing or empty reason — returns `{ skipped: false, reason: null }`.
+ *
+ * The two-field shape matches the planner skill's precedent (gate_policy
+ * as a single enum value) while keeping the reason unambiguous against
+ * YAML parsers. Colons inside quoted YAML strings are fragile across
+ * parsers; two fields avoid that class of bug entirely.
+ */
+export declare function isFalsificationSkipped(implContent: string): SkipCheck;

package/dist/lib/falsification/skip.js

@@ -0,0 +1,37 @@
+import matter from "gray-matter";
+/**
+ * Parse an impl.md body (the full file content including frontmatter) and
+ * return whether the author has explicitly opted out of the falsification
+ * ritual. Opt-out requires both fields in frontmatter:
+ *
+ *   falsification: skipped
+ *   falsification_reason: "a non-empty reason"
+ *
+ * Returns `{ skipped: true, reason }` only if both fields are present and
+ * the reason is non-empty after trimming. Any other state — missing
+ * `falsification`, falsification set to anything other than `skipped`,
+ * missing or empty reason — returns `{ skipped: false, reason: null }`.
+ *
+ * The two-field shape matches the planner skill's precedent (gate_policy
+ * as a single enum value) while keeping the reason unambiguous against
+ * YAML parsers. Colons inside quoted YAML strings are fragile across
+ * parsers; two fields avoid that class of bug entirely.
+ */
+export function isFalsificationSkipped(implContent) {
+    try {
+        const { data } = matter(implContent);
+        const flag = data.falsification;
+        const reasonRaw = data.falsification_reason;
+        if (flag !== "skipped")
+            return { skipped: false, reason: null };
+        if (typeof reasonRaw !== "string")
+            return { skipped: false, reason: null };
+        const reason = reasonRaw.trim();
+        if (!reason)
+            return { skipped: false, reason: null };
+        return { skipped: true, reason };
+    }
+    catch {
+        return { skipped: false, reason: null };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@infinitedusky/indusk-mcp",
-	"version": "1.16.0",
+	"version": "1.16.1",
 	"description": "InDusk development system — skills, MCP tools, and CLI for structured AI-assisted development",
 	"type": "module",
 	"files": [