@infinitedusky/indusk-mcp 1.15.0 → 1.16.0

package/dist/bin/commands/update.js

@@ -183,21 +183,32 @@ export async function update(projectRoot) {
     console.info("\n[Hooks]\n");
     const hooksSource = join(packageRoot, "hooks");
     const hooksTarget = join(projectRoot, ".claude/hooks");
+    console.info(`  source: ${hooksSource}`);
     let hooksUpdated = 0;
     let hooksCurrent = 0;
-    if (existsSync(hooksSource) && existsSync(hooksTarget)) {
-        const hookFiles = [
-            "check-gates.js",
-            "gate-reminder.js",
-            "validate-impl-structure.js",
-            "check-catchup.js",
-            "eval-trigger.js",
-        ];
+    if (!existsSync(hooksSource)) {
+        console.info(`  source missing — the package install is broken`);
+    }
+    else if (!existsSync(hooksTarget)) {
+        // Never initialized — create the dir and copy all bundled hooks
+        mkdirSync(hooksTarget, { recursive: true });
+        console.info(`  created: ${hooksTarget}`);
+        const bundled = globSync("*.js", { cwd: hooksSource });
+        for (const file of bundled) {
+            cpSync(join(hooksSource, file), join(hooksTarget, file));
+            console.info(`  added: ${file}`);
+            hooksUpdated++;
+        }
+        console.info(`\n  ${hooksUpdated} added.`);
+    }
+    else {
+        // Both dirs exist — sync by hash compare. Discover bundled hooks from
+        // the source dir rather than hardcoding names, so new hooks added to
+        // the package get synced on update without code changes here.
+        const hookFiles = globSync("*.js", { cwd: hooksSource });
         for (const file of hookFiles) {
             const sourceFile = join(hooksSource, file);
             const targetFile = join(hooksTarget, file);
-            if (!existsSync(sourceFile))
-                continue;
             if (!existsSync(targetFile)) {
                 cpSync(sourceFile, targetFile);
                 console.info(`  added: ${file}`);
@@ -244,9 +255,6 @@ export async function update(projectRoot) {
             }
         }
     }
-    else {
-        console.info("  not installed (run init to install)");
-    }
     // 5b. Migrate stale MCP configs
     const mcpJsonPath = join(projectRoot, ".mcp.json");
     if (existsSync(mcpJsonPath)) {

package/dist/lib/trajectory/audit.d.ts

@@ -0,0 +1,51 @@
+import type { DeferredRow, Trajectory, TrajectoryRow } from "./parser.js";
+export type MitigationKind = "telemetry-alert" | "scheduled-review" | "downstream-plan" | "canary-or-staging" | "feedback-signal" | "unclassified";
+export interface MitigationClassification {
+    row: DeferredRow;
+    kind: MitigationKind;
+    /** Hints extracted from the text: plan names, file paths, metric names. */
+    hints: string[];
+    /** Non-null when the mitigation is too vague — needs a more concrete commitment. */
+    warning: string | null;
+}
+/**
+ * Retrospective audit: classify every Deferred Verification row, flag any
+ * whose mitigation text is too vague or unclassifiable. Returns findings
+ * suitable for inclusion in a retrospective's "What We Learned" section
+ * or a Graphiti audit episode.
+ */
+export declare function auditDeferredMitigations(trajectory: Trajectory): MitigationClassification[];
+export interface BlockedRowFinding {
+    row: TrajectoryRow;
+    message: string;
+}
+/**
+ * Retrospective audit: surface trajectory rows that ended the plan in
+ * `blocked` state. Blocked means "was writable/written but regressed or
+ * changed" — if the plan closes with blocked rows, they should be
+ * explicitly resolved (fix, move passesAt, or move to Deferred Verification).
+ */
+export declare function findBlockedRows(trajectory: Trajectory): BlockedRowFinding[];
+export interface TestIdResolution {
+    id: string;
+    asserts: string;
+    /** Best-effort test file name glob (e.g. "**\/*reconciler*.test.ts") or null. */
+    fileGlob: string | null;
+    /** Vitest command with a filter, if one can be derived from the asserts text. */
+    suggestedCommand: string;
+}
+/**
+ * Derive a concrete test file glob + runnable command from a trajectory
+ * row's asserts text. Heuristic: extract identifiers (camelCase, kebab-case,
+ * backtick-quoted code) and use the longest as a filename hint. Returns a
+ * fallback `pnpm test` with a `-t` name filter if no filename hint found.
+ *
+ * The verify skill uses this to resolve phase-Verification items that say
+ * "T3 passes (...)" into a real invocation. Best-effort — human can override.
+ */
+export declare function resolveTestIdCommand(trajectory: Trajectory, id: string): TestIdResolution | null;
+/** Convenience — parse + audit + resolve in one call for the retrospective skill. */
+export declare function auditPlanAtClose(body: string): {
+    deferred: MitigationClassification[];
+    blocked: BlockedRowFinding[];
+};

package/dist/lib/trajectory/audit.js

@@ -0,0 +1,96 @@
+import { parseTrajectory } from "./parser.js";
+const TELEMETRY_KEYWORDS = ["alert", "metric", "otel", "dash0", "grafana", "threshold"];
+const REVIEW_KEYWORDS = [
+    "weekly",
+    "monthly",
+    "quarterly",
+    "daily",
+    "review",
+    "spot-check",
+    "audit",
+];
+const PLAN_REF = /\b[a-z][a-z0-9-]*-[a-z][a-z0-9-]*\b/g; // kebab-case identifiers that look like plan slugs
+const CANARY_KEYWORDS = ["staging", "canary", "smoke", "preflight", "pre-release"];
+const FEEDBACK_KEYWORDS = ["feedback", "ticket", "support", "channel", "signal"];
+function classifyMitigation(row) {
+    const text = row.mitigation.toLowerCase();
+    const hints = [];
+    const hasAny = (words) => words.some((w) => text.includes(w));
+    let kind = "unclassified";
+    if (hasAny(TELEMETRY_KEYWORDS))
+        kind = "telemetry-alert";
+    else if (hasAny(CANARY_KEYWORDS))
+        kind = "canary-or-staging";
+    else if (hasAny(FEEDBACK_KEYWORDS))
+        kind = "feedback-signal";
+    else if (hasAny(REVIEW_KEYWORDS))
+        kind = "scheduled-review";
+    const planRefs = [...row.mitigation.matchAll(PLAN_REF)].map((m) => m[0]);
+    if (planRefs.length > 0) {
+        hints.push(...planRefs);
+        if (kind === "unclassified")
+            kind = "downstream-plan";
+    }
+    let warning = null;
+    if (kind === "unclassified" || row.mitigation.trim().length < 20) {
+        warning = `Mitigation for "${row.name}" is vague — expected a specific alert, review cadence, plan reference, or procedure. Got: "${row.mitigation}"`;
+    }
+    return { row, kind, hints, warning };
+}
+/**
+ * Retrospective audit: classify every Deferred Verification row, flag any
+ * whose mitigation text is too vague or unclassifiable. Returns findings
+ * suitable for inclusion in a retrospective's "What We Learned" section
+ * or a Graphiti audit episode.
+ */
+export function auditDeferredMitigations(trajectory) {
+    return trajectory.deferred.map(classifyMitigation);
+}
+/**
+ * Retrospective audit: surface trajectory rows that ended the plan in
+ * `blocked` state. Blocked means "was writable/written but regressed or
+ * changed" — if the plan closes with blocked rows, they should be
+ * explicitly resolved (fix, move passesAt, or move to Deferred Verification).
+ */
+export function findBlockedRows(trajectory) {
+    return trajectory.rows
+        .filter((row) => row.state === "blocked")
+        .map((row) => ({
+        row,
+        message: `Row ${row.id} ended plan in 'blocked' state — needs resolution (fix, reschedule, or move to Deferred Verification)`,
+    }));
+}
+/**
+ * Derive a concrete test file glob + runnable command from a trajectory
+ * row's asserts text. Heuristic: extract identifiers (camelCase, kebab-case,
+ * backtick-quoted code) and use the longest as a filename hint. Returns a
+ * fallback `pnpm test` with a `-t` name filter if no filename hint found.
+ *
+ * The verify skill uses this to resolve phase-Verification items that say
+ * "T3 passes (...)" into a real invocation. Best-effort — human can override.
+ */
+export function resolveTestIdCommand(trajectory, id) {
+    const row = trajectory.rows.find((r) => r.id === id);
+    if (!row)
+        return null;
+    const backtickMatches = [...row.asserts.matchAll(/`([^`]+)`/g)].map((m) => m[1]);
+    const identifiers = [...row.asserts.matchAll(/\b[a-zA-Z][a-zA-Z0-9_]{3,}\b/g)].map((m) => m[0]);
+    const keyword = backtickMatches
+        .filter((s) => /[a-zA-Z]/.test(s))
+        .sort((a, b) => b.length - a.length)[0] ??
+        identifiers.sort((a, b) => b.length - a.length)[0] ??
+        null;
+    const fileGlob = keyword ? `**/*${keyword.toLowerCase().replace(/[^a-z0-9]/g, "")}*.test.ts` : null;
+    const suggestedCommand = keyword
+        ? `pnpm test -t "${keyword}"`
+        : `pnpm test -t "${row.asserts.slice(0, 40)}"`;
+    return { id, asserts: row.asserts, fileGlob, suggestedCommand };
+}
+/** Convenience — parse + audit + resolve in one call for the retrospective skill. */
+export function auditPlanAtClose(body) {
+    const trajectory = parseTrajectory(body);
+    return {
+        deferred: auditDeferredMitigations(trajectory),
+        blocked: findBlockedRows(trajectory),
+    };
+}

package/dist/lib/trajectory/parser.d.ts

@@ -0,0 +1,30 @@
+export type TrajectoryState = "planned" | "writable" | "written" | "passing" | "blocked" | "skipped" | "unknown";
+export type TrajectoryKind = "example" | "property" | "contract" | "approval" | "formal";
+export type TrajectoryScope = "unit" | "integration" | "e2e";
+export interface TrajectoryRow {
+    id: string;
+    asserts: string;
+    writableAt: number;
+    passesAt: number;
+    state: TrajectoryState;
+    kind?: TrajectoryKind;
+    scope?: TrajectoryScope;
+}
+export interface DeferredRow {
+    name: string;
+    reason: string;
+    wouldRequire: string;
+    mitigation: string;
+}
+export interface Trajectory {
+    rows: TrajectoryRow[];
+    deferred: DeferredRow[];
+    present: boolean;
+}
+/**
+ * Parse a Test Trajectory from an impl.md body (the content after the
+ * frontmatter). Returns an empty trajectory with `present: false` when the
+ * `## Test Trajectory` section is absent. Never throws — errors are surfaced
+ * by the validator, not the parser.
+ */
+export declare function parseTrajectory(body: string): Trajectory;

package/dist/lib/trajectory/parser.js

@@ -0,0 +1,251 @@
+const TRAJECTORY_HEADING = /^##\s+Test Trajectory\b/;
+const DEFERRED_HEADING = /^###\s+Deferred Verification\b/;
+const NEXT_SECTION_HEADING = /^#{1,3}\s+/;
+const PHASE_REFERENCE = /^\s*Phase\s+(\d+)\s*$/i;
+const VALID_STATES = new Set([
+    "planned",
+    "writable",
+    "written",
+    "passing",
+    "blocked",
+    "skipped",
+    "unknown",
+]);
+const VALID_KINDS = new Set([
+    "example",
+    "property",
+    "contract",
+    "approval",
+    "formal",
+]);
+const VALID_SCOPES = new Set(["unit", "integration", "e2e"]);
+/**
+ * Parse a markdown table row into cells. Strips the leading/trailing pipe and
+ * splits on unescaped pipes. Does NOT handle escaped pipes inside cell content
+ * — the trajectory asserts column does not contain pipes in practice.
+ */
+function parseTableRow(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|") || !trimmed.endsWith("|"))
+        return [];
+    return trimmed
+        .slice(1, -1)
+        .split("|")
+        .map((cell) => cell.trim());
+}
+/**
+ * Normalize a header cell to a canonical key. Case-insensitive, trims
+ * whitespace, maps variant spellings to canonical names.
+ */
+function normalizeHeader(header) {
+    const normalized = header.toLowerCase().replace(/\s+/g, " ").trim();
+    const aliases = {
+        id: "id",
+        asserts: "asserts",
+        "writable at": "writableAt",
+        "passes at": "passesAt",
+        state: "state",
+        kind: "kind",
+        scope: "scope",
+    };
+    return aliases[normalized] ?? normalized;
+}
+/**
+ * Parse a "Phase N" cell into a number. Returns NaN if the cell is not a
+ * valid phase reference. The validator catches NaN and emits a specific error.
+ */
+function parsePhaseReference(cell) {
+    const match = cell.match(PHASE_REFERENCE);
+    if (!match)
+        return Number.NaN;
+    return Number.parseInt(match[1], 10);
+}
+function parseState(cell) {
+    const normalized = cell.toLowerCase().trim();
+    if (VALID_STATES.has(normalized)) {
+        return normalized;
+    }
+    return "unknown";
+}
+function parseOptionalKind(cell) {
+    const normalized = cell.toLowerCase().trim();
+    if (!normalized)
+        return undefined;
+    if (VALID_KINDS.has(normalized)) {
+        return normalized;
+    }
+    return undefined;
+}
+function parseOptionalScope(cell) {
+    const normalized = cell.toLowerCase().trim();
+    if (!normalized)
+        return undefined;
+    if (VALID_SCOPES.has(normalized)) {
+        return normalized;
+    }
+    return undefined;
+}
+/**
+ * Extract the block of lines under `## Test Trajectory` up to the next
+ * heading of equal or lesser depth. The trajectory block includes the
+ * main table; the `### Deferred Verification` subsection is extracted
+ * separately.
+ */
+function extractTrajectoryBlock(lines) {
+    let inTrajectory = false;
+    let inDeferred = false;
+    const tableLines = [];
+    const deferredLines = [];
+    for (const line of lines) {
+        if (TRAJECTORY_HEADING.test(line)) {
+            inTrajectory = true;
+            inDeferred = false;
+            continue;
+        }
+        if (!inTrajectory)
+            continue;
+        if (DEFERRED_HEADING.test(line)) {
+            inDeferred = true;
+            continue;
+        }
+        // A new top-level or second-level heading ends the trajectory block.
+        // A third-level heading other than Deferred Verification also ends it.
+        if (NEXT_SECTION_HEADING.test(line) && !DEFERRED_HEADING.test(line)) {
+            const depth = line.match(/^(#{1,6})/)?.[1].length ?? 0;
+            if (depth <= 2)
+                break;
+            // A ### heading that isn't Deferred Verification ends the trajectory
+            if (depth === 3)
+                break;
+        }
+        if (inDeferred) {
+            deferredLines.push(line);
+        }
+        else {
+            tableLines.push(line);
+        }
+    }
+    return { tableLines, deferredLines };
+}
+/**
+ * Parse a Deferred Verification block. Each deferred item is a top-level
+ * bullet with three sub-bullets:
+ *
+ * - **{name}**
+ *   - reason: {text}
+ *   - would require: {text}
+ *   - mitigation: {text}
+ */
+function parseDeferredBlock(lines) {
+    const rows = [];
+    let current = null;
+    const flush = () => {
+        if (current && current.name !== undefined) {
+            rows.push({
+                name: current.name,
+                reason: current.reason ?? "",
+                wouldRequire: current.wouldRequire ?? "",
+                mitigation: current.mitigation ?? "",
+            });
+        }
+        current = null;
+    };
+    for (const rawLine of lines) {
+        const line = rawLine.replace(/\s+$/, "");
+        // Top-level bullet with bolded name: - **{name}**
+        const nameMatch = line.match(/^-\s+\*\*(.+?)\*\*\s*(?:—\s*(.*))?$/);
+        if (nameMatch) {
+            flush();
+            current = { name: nameMatch[1].trim() };
+            // Handle inline one-line form: - **Name** — reason: X — would require: Y — mitigation: Z
+            const rest = nameMatch[2];
+            if (rest) {
+                const reasonMatch = rest.match(/reason:\s*([^—]+?)(?:\s*—|$)/i);
+                const wrMatch = rest.match(/would require:\s*([^—]+?)(?:\s*—|$)/i);
+                const mitMatch = rest.match(/mitigation:\s*(.+)$/i);
+                if (reasonMatch)
+                    current.reason = reasonMatch[1].trim();
+                if (wrMatch)
+                    current.wouldRequire = wrMatch[1].trim();
+                if (mitMatch)
+                    current.mitigation = mitMatch[1].trim();
+            }
+            continue;
+        }
+        if (!current)
+            continue;
+        // Sub-bullet: - reason: / - would require: / - mitigation:
+        const subMatch = line.match(/^\s+-\s+(reason|would require|mitigation):\s*(.*)$/i);
+        if (subMatch) {
+            const key = subMatch[1].toLowerCase();
+            const value = subMatch[2].trim();
+            if (key === "reason")
+                current.reason = value;
+            else if (key === "would require")
+                current.wouldRequire = value;
+            else if (key === "mitigation")
+                current.mitigation = value;
+        }
+    }
+    flush();
+    return rows;
+}
+/**
+ * Parse the trajectory table. Returns rows parsed from the GFM table under
+ * `## Test Trajectory`. Unknown column headers are ignored. Rows with
+ * missing required columns are skipped — the validator catches structural
+ * problems and surfaces them.
+ */
+function parseTrajectoryTable(lines) {
+    const tableLines = lines.filter((line) => line.trim().startsWith("|"));
+    if (tableLines.length < 2)
+        return [];
+    const headerCells = parseTableRow(tableLines[0]);
+    const separator = parseTableRow(tableLines[1]);
+    // Separator row looks like |----|----|... — every cell is dashes/colons
+    const isSeparator = separator.every((cell) => /^:?-+:?$/.test(cell));
+    if (!isSeparator)
+        return [];
+    const columnKeys = headerCells.map(normalizeHeader);
+    const rows = [];
+    for (let i = 2; i < tableLines.length; i++) {
+        const cells = parseTableRow(tableLines[i]);
+        if (cells.length !== columnKeys.length)
+            continue;
+        const record = {};
+        for (let j = 0; j < columnKeys.length; j++) {
+            record[columnKeys[j]] = cells[j];
+        }
+        const id = record.id?.trim();
+        const asserts = record.asserts?.trim();
+        if (!id || !asserts)
+            continue;
+        rows.push({
+            id,
+            asserts,
+            writableAt: parsePhaseReference(record.writableAt ?? ""),
+            passesAt: parsePhaseReference(record.passesAt ?? ""),
+            state: parseState(record.state ?? ""),
+            kind: parseOptionalKind(record.kind ?? ""),
+            scope: parseOptionalScope(record.scope ?? ""),
+        });
+    }
+    return rows;
+}
+/**
+ * Parse a Test Trajectory from an impl.md body (the content after the
+ * frontmatter). Returns an empty trajectory with `present: false` when the
+ * `## Test Trajectory` section is absent. Never throws — errors are surfaced
+ * by the validator, not the parser.
+ */
+export function parseTrajectory(body) {
+    const lines = body.split("\n");
+    const hasTrajectory = lines.some((line) => TRAJECTORY_HEADING.test(line));
+    if (!hasTrajectory) {
+        return { rows: [], deferred: [], present: false };
+    }
+    const { tableLines, deferredLines } = extractTrajectoryBlock(lines);
+    const rows = parseTrajectoryTable(tableLines);
+    const deferred = parseDeferredBlock(deferredLines);
+    return { rows, deferred, present: true };
+}

package/dist/lib/trajectory/state-ops.d.ts

@@ -0,0 +1,49 @@
+import type { Trajectory, TrajectoryRow, TrajectoryState } from "./parser.js";
+/**
+ * Rows whose `Writable at` equals the given phase and whose state is not
+ * yet `written` or beyond. These are tests the author should commit as
+ * failing at phase start (before implementation work).
+ */
+export declare function getRowsWritableAt(trajectory: Trajectory, phase: number): TrajectoryRow[];
+/**
+ * Rows whose `Passes at` equals the given phase, regardless of current state.
+ * These are the tests that must be in `passing` (or `skipped` with reason)
+ * before the phase can close.
+ */
+export declare function getRowsPassingAt(trajectory: Trajectory, phase: number): TrajectoryRow[];
+/**
+ * Rows that block phase-close for the given phase. A row blocks if its
+ * `Passes at` equals the phase AND its state is not one of the terminal
+ * states (`passing`, `skipped`, `blocked` — blocked implies a tracked
+ * investigation, not a silent fail).
+ */
+export declare function getRowsBlockingPhaseClose(trajectory: Trajectory, phase: number): TrajectoryRow[];
+/**
+ * Update the `State` column for a specific row ID in an impl.md body.
+ * Returns the new body. The input must be the full impl body (after
+ * frontmatter); the output is body markdown with exactly one cell changed.
+ *
+ * If the row ID is not found, returns the body unchanged.
+ */
+export declare function updateRowState(body: string, id: string, newState: TrajectoryState): string;
+/**
+ * Convenience: parse the body, compute blocking rows, and return error
+ * messages suitable for a hook's stderr. Returns empty array if phase can
+ * close cleanly.
+ */
+export declare function computePhaseCloseBlockers(body: string, phase: number): {
+    row: TrajectoryRow;
+    message: string;
+}[];
+/**
+ * Convenience: nudge text for phase start. Returns a string listing rows
+ * whose `Writable at` equals the phase and are not yet written, or null
+ * if nothing needs authoring.
+ */
+export declare function getPhaseStartNudge(body: string, phase: number): string | null;
+/**
+ * Convenience: nudge text for near-phase-close. Returns a string listing
+ * rows whose `Passes at` equals the phase but state is not yet `passing`
+ * or `skipped`, or null if the trajectory for this phase is green.
+ */
+export declare function getPhaseCloseNudge(body: string, phase: number): string | null;

package/dist/lib/trajectory/state-ops.js

@@ -0,0 +1,132 @@
+import { parseTrajectory } from "./parser.js";
+/**
+ * Rows whose `Writable at` equals the given phase and whose state is not
+ * yet `written` or beyond. These are tests the author should commit as
+ * failing at phase start (before implementation work).
+ */
+export function getRowsWritableAt(trajectory, phase) {
+    return trajectory.rows.filter((row) => row.writableAt === phase &&
+        (row.state === "planned" || row.state === "writable" || row.state === "unknown"));
+}
+/**
+ * Rows whose `Passes at` equals the given phase, regardless of current state.
+ * These are the tests that must be in `passing` (or `skipped` with reason)
+ * before the phase can close.
+ */
+export function getRowsPassingAt(trajectory, phase) {
+    return trajectory.rows.filter((row) => row.passesAt === phase);
+}
+/**
+ * Rows that block phase-close for the given phase. A row blocks if its
+ * `Passes at` equals the phase AND its state is not one of the terminal
+ * states (`passing`, `skipped`, `blocked` — blocked implies a tracked
+ * investigation, not a silent fail).
+ */
+export function getRowsBlockingPhaseClose(trajectory, phase) {
+    return trajectory.rows.filter((row) => row.passesAt === phase &&
+        row.state !== "passing" &&
+        row.state !== "skipped" &&
+        row.state !== "blocked");
+}
+/**
+ * Update the `State` column for a specific row ID in an impl.md body.
+ * Returns the new body. The input must be the full impl body (after
+ * frontmatter); the output is body markdown with exactly one cell changed.
+ *
+ * If the row ID is not found, returns the body unchanged.
+ */
+export function updateRowState(body, id, newState) {
+    const lines = body.split("\n");
+    let inTrajectoryTable = false;
+    let headerCells = null;
+    let stateIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^##\s+Test Trajectory\b/.test(line)) {
+            inTrajectoryTable = true;
+            headerCells = null;
+            stateIndex = -1;
+            continue;
+        }
+        if (!inTrajectoryTable)
+            continue;
+        // A new heading ends the trajectory block
+        if (/^#{1,3}\s+/.test(line) && !/^##\s+Test Trajectory\b/.test(line)) {
+            inTrajectoryTable = false;
+            continue;
+        }
+        const trimmed = line.trim();
+        if (!trimmed.startsWith("|") || !trimmed.endsWith("|"))
+            continue;
+        const cells = trimmed
+            .slice(1, -1)
+            .split("|")
+            .map((c) => c.trim());
+        // Header row: find the State column index
+        if (!headerCells) {
+            headerCells = cells;
+            stateIndex = cells.findIndex((c) => c.toLowerCase() === "state");
+            continue;
+        }
+        // Separator row: skip
+        if (cells.every((c) => /^:?-+:?$/.test(c)))
+            continue;
+        // Data row: check ID and update State
+        if (cells[0] !== id || stateIndex === -1)
+            continue;
+        if (cells[stateIndex] === newState)
+            return body;
+        const newCells = [...cells];
+        newCells[stateIndex] = newState;
+        // Preserve the leading/trailing pipe and surrounding whitespace
+        const leadingWs = line.match(/^\s*/)?.[0] ?? "";
+        lines[i] = `${leadingWs}| ${newCells.join(" | ")} |`;
+        return lines.join("\n");
+    }
+    return body;
+}
+/**
+ * Convenience: parse the body, compute blocking rows, and return error
+ * messages suitable for a hook's stderr. Returns empty array if phase can
+ * close cleanly.
+ */
+export function computePhaseCloseBlockers(body, phase) {
+    const trajectory = parseTrajectory(body);
+    if (!trajectory.present)
+        return [];
+    const blocking = getRowsBlockingPhaseClose(trajectory, phase);
+    return blocking.map((row) => ({
+        row,
+        message: `  [${row.id}] ${row.asserts} — state: ${row.state} (must be 'passing' or 'skipped' to close Phase ${phase})`,
+    }));
+}
+/**
+ * Convenience: nudge text for phase start. Returns a string listing rows
+ * whose `Writable at` equals the phase and are not yet written, or null
+ * if nothing needs authoring.
+ */
+export function getPhaseStartNudge(body, phase) {
+    const trajectory = parseTrajectory(body);
+    if (!trajectory.present)
+        return null;
+    const rows = getRowsWritableAt(trajectory, phase);
+    if (rows.length === 0)
+        return null;
+    const lines = rows.map((r) => `  [${r.id}] ${r.asserts}`);
+    return `Phase ${phase} opens with these tests to author (commit as failing before implementation work):\n${lines.join("\n")}`;
+}
+/**
+ * Convenience: nudge text for near-phase-close. Returns a string listing
+ * rows whose `Passes at` equals the phase but state is not yet `passing`
+ * or `skipped`, or null if the trajectory for this phase is green.
+ */
+export function getPhaseCloseNudge(body, phase) {
+    const trajectory = parseTrajectory(body);
+    if (!trajectory.present)
+        return null;
+    const blocking = getRowsBlockingPhaseClose(trajectory, phase);
+    if (blocking.length === 0)
+        return null;
+    const lines = blocking.map((r) => `  [${r.id}] ${r.asserts} — state: ${r.state}`);
+    return `Phase ${phase} cannot close until these trajectory rows are 'passing' or 'skipped':\n${lines.join("\n")}`;
+}

package/dist/lib/trajectory/validator.d.ts

@@ -0,0 +1,36 @@
+import { type Trajectory } from "./parser.js";
+export interface ValidationError {
+    rule: "trajectory-presence" | "cross-reference-integrity" | "temporal-coherence" | "deferred-completeness";
+    message: string;
+    /** The rough line number in the impl body, if known. */
+    line?: number;
+}
+/**
+ * Rule 1: Every impl document must have a `## Test Trajectory` section.
+ */
+export declare function validateTrajectoryPresence(body: string): ValidationError[];
+/**
+ * Rule 2: Every test ID referenced in a phase Verification block must exist
+ * in the Trajectory table. Phases with no test-ID references must declare
+ * `(no tests flip at this phase — reason: {allowed-reason})`.
+ */
+export declare function validateCrossReferenceIntegrity(body: string, trajectory: Trajectory): ValidationError[];
+/**
+ * Rule 3: For every Trajectory row, the phase number in `Writable at` must
+ * be ≤ the phase number in `Passes at`. A test cannot pass before its
+ * dependencies exist. Also catches NaN from malformed `Phase N` references.
+ */
+export declare function validateTemporalCoherence(trajectory: Trajectory): ValidationError[];
+/**
+ * Rule 4: Every Deferred Verification row must have non-empty `reason:`,
+ * `would require:`, and `mitigation:` fields. The mitigation field is the
+ * compensating control — without it, deferring a test means flying blind.
+ */
+export declare function validateDeferredCompleteness(trajectory: Trajectory): ValidationError[];
+/**
+ * Run all four trajectory validation rules against an impl body. The body
+ * is the markdown content after the frontmatter — pass the output of
+ * `gray-matter` or equivalent. Returns combined errors; empty array means
+ * the trajectory is valid.
+ */
+export declare function validateTrajectory(body: string): ValidationError[];

package/dist/lib/trajectory/validator.js

@@ -0,0 +1,202 @@
+import { parseTrajectory } from "./parser.js";
+const TRAJECTORY_HEADING = /^##\s+Test Trajectory\b/;
+const PHASE_HEADING = /^###\s+Phase\s+(\d+)\b/;
+const VERIFICATION_HEADING = /^####\s+Phase\s+(\d+)\s+Verification\b/;
+const NEXT_GATE_HEADING = /^####\s+Phase\s+\d+\s+(OTel|Context|Document|Forward Intelligence)\b/;
+const CHECKLIST_ITEM = /^-\s+\[[ xX]\]\s+(.*)/;
+const TEST_ID_PATTERN = /\bT\d+\b/g;
+const ALLOWED_NO_TESTS_REASONS = new Set([
+    "schema-only",
+    "delete",
+    "refactor",
+    "infra",
+]);
+// Match both em-dash and hyphen with flexible whitespace around the separator
+const NO_TESTS_DECLARATION = /\(no tests flip at this phase\s*[—–-]+\s*reason:\s*([a-z-]+)\s*\)/i;
+/**
+ * Rule 1: Every impl document must have a `## Test Trajectory` section.
+ */
+export function validateTrajectoryPresence(body) {
+    const lines = body.split("\n");
+    const hasTrajectory = lines.some((line) => TRAJECTORY_HEADING.test(line));
+    if (hasTrajectory)
+        return [];
+    return [
+        {
+            rule: "trajectory-presence",
+            message: "Impl is missing the `## Test Trajectory` section. Every impl must declare its tests at the top as a table with columns: ID | Asserts | Writable at | Passes at | State. See `.indusk/planning/tests-first-planning/adr.md` Section 3.",
+        },
+    ];
+}
+/**
+ * Extract each phase's Verification block as a list of checklist items.
+ */
+function extractPhaseVerifications(body) {
+    const lines = body.split("\n");
+    const result = [];
+    let currentPhase = null;
+    let currentVerification = null;
+    let inVerification = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const phaseMatch = line.match(PHASE_HEADING);
+        if (phaseMatch) {
+            if (currentVerification)
+                result.push(currentVerification);
+            currentPhase = Number.parseInt(phaseMatch[1], 10);
+            currentVerification = null;
+            inVerification = false;
+            continue;
+        }
+        const verMatch = line.match(VERIFICATION_HEADING);
+        if (verMatch && currentPhase !== null) {
+            if (currentVerification)
+                result.push(currentVerification);
+            currentVerification = {
+                phase: currentPhase,
+                items: [],
+                headingLine: i + 1,
+            };
+            inVerification = true;
+            continue;
+        }
+        if (inVerification && NEXT_GATE_HEADING.test(line)) {
+            if (currentVerification)
+                result.push(currentVerification);
+            currentVerification = null;
+            inVerification = false;
+            continue;
+        }
+        if (inVerification && currentVerification) {
+            const itemMatch = line.match(CHECKLIST_ITEM);
+            if (itemMatch) {
+                currentVerification.items.push({ text: itemMatch[1].trim(), line: i + 1 });
+            }
+        }
+    }
+    if (currentVerification)
+        result.push(currentVerification);
+    return result;
+}
+/**
+ * Rule 2: Every test ID referenced in a phase Verification block must exist
+ * in the Trajectory table. Phases with no test-ID references must declare
+ * `(no tests flip at this phase — reason: {allowed-reason})`.
+ */
+export function validateCrossReferenceIntegrity(body, trajectory) {
+    const errors = [];
+    const knownIds = new Set(trajectory.rows.map((row) => row.id));
+    const verifications = extractPhaseVerifications(body);
+    for (const ver of verifications) {
+        let foundTestReference = false;
+        let foundNoTestsDeclaration = false;
+        for (const item of ver.items) {
+            const noTestsMatch = item.text.match(NO_TESTS_DECLARATION);
+            if (noTestsMatch) {
+                foundNoTestsDeclaration = true;
+                const reason = noTestsMatch[1].toLowerCase();
+                if (!ALLOWED_NO_TESTS_REASONS.has(reason)) {
+                    errors.push({
+                        rule: "cross-reference-integrity",
+                        line: item.line,
+                        message: `Phase ${ver.phase} Verification: "(no tests flip at this phase — reason: ${reason})" uses disallowed reason. Allowed: ${[...ALLOWED_NO_TESTS_REASONS].join(", ")}.`,
+                    });
+                }
+                continue;
+            }
+            const idMatches = item.text.match(TEST_ID_PATTERN);
+            if (idMatches) {
+                foundTestReference = true;
+                for (const id of idMatches) {
+                    if (!knownIds.has(id)) {
+                        errors.push({
+                            rule: "cross-reference-integrity",
+                            line: item.line,
+                            message: `Phase ${ver.phase} Verification references test ID \`${id}\` but no such row exists in the Test Trajectory table.`,
+                        });
+                    }
+                }
+            }
+        }
+        if (!foundTestReference && !foundNoTestsDeclaration && ver.items.length > 0) {
+            errors.push({
+                rule: "cross-reference-integrity",
+                line: ver.headingLine,
+                message: `Phase ${ver.phase} Verification has no test ID references and no "(no tests flip at this phase — reason: {schema-only|delete|refactor|infra})" declaration. Every phase's Verification must either flip named tests from the trajectory or explicitly declare no tests flip with an allowed reason.`,
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Rule 3: For every Trajectory row, the phase number in `Writable at` must
+ * be ≤ the phase number in `Passes at`. A test cannot pass before its
+ * dependencies exist. Also catches NaN from malformed `Phase N` references.
+ */
+export function validateTemporalCoherence(trajectory) {
+    const errors = [];
+    for (const row of trajectory.rows) {
+        if (!Number.isFinite(row.writableAt)) {
+            errors.push({
+                rule: "temporal-coherence",
+                message: `Trajectory row \`${row.id}\` has invalid "Writable at" — expected "Phase N" where N is a number.`,
+            });
+            continue;
+        }
+        if (!Number.isFinite(row.passesAt)) {
+            errors.push({
+                rule: "temporal-coherence",
+                message: `Trajectory row \`${row.id}\` has invalid "Passes at" — expected "Phase N" where N is a number.`,
+            });
+            continue;
+        }
+        if (row.writableAt > row.passesAt) {
+            errors.push({
+                rule: "temporal-coherence",
+                message: `Trajectory row \`${row.id}\` has "Writable at" Phase ${row.writableAt} > "Passes at" Phase ${row.passesAt}. A test cannot pass before its dependencies exist. If phases were reordered, update the trajectory to reflect the new dependency order.`,
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Rule 4: Every Deferred Verification row must have non-empty `reason:`,
+ * `would require:`, and `mitigation:` fields. The mitigation field is the
+ * compensating control — without it, deferring a test means flying blind.
+ */
+export function validateDeferredCompleteness(trajectory) {
+    const errors = [];
+    for (const row of trajectory.deferred) {
+        const missing = [];
+        if (!row.reason)
+            missing.push("reason");
+        if (!row.wouldRequire)
+            missing.push("would require");
+        if (!row.mitigation)
+            missing.push("mitigation");
+        if (missing.length > 0) {
+            errors.push({
+                rule: "deferred-completeness",
+                message: `Deferred Verification row "${row.name}" is missing: ${missing.join(", ")}. Every deferred row requires all three fields — reason (why not testable here), would require (what would unlock a proper test), and mitigation (compensating control that keeps us from flying blind).`,
+            });
+        }
+    }
+    return errors;
+}
+/**
+ * Run all four trajectory validation rules against an impl body. The body
+ * is the markdown content after the frontmatter — pass the output of
+ * `gray-matter` or equivalent. Returns combined errors; empty array means
+ * the trajectory is valid.
+ */
+export function validateTrajectory(body) {
+    const presenceErrors = validateTrajectoryPresence(body);
+    if (presenceErrors.length > 0)
+        return presenceErrors;
+    const trajectory = parseTrajectory(body);
+    return [
+        ...validateCrossReferenceIntegrity(body, trajectory),
+        ...validateTemporalCoherence(trajectory),
+        ...validateDeferredCompleteness(trajectory),
+    ];
+}

package/package.json

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

package/skills/falsify.md

@@ -0,0 +1,87 @@
+---
+name: falsify
+description: Run the falsification ritual against a completed plan. Goal-flip from "prove it works" to "find a failing test" — investigate the code, form a specific hypothesis about what should be broken, write the test that confirms it, run it. Required between /work completion and /retrospective.
+argument-hint: "{plan-name}"
+---
+
+You are about to run the **falsification ritual** against a plan whose `/work` has completed. The plan has an attested state — the goal, the Trajectory rows (all in terminal state), the claims it makes about what is now true. Your job is **not** to confirm those claims. Your job is to **falsify them**.
+
+This is a goal-flip, not a persona switch. Same agent, different question. Instead of "does this work?" — "what specific thing, with what specific inputs, makes this fail?"
+
+## How to hunt
+
+This is bounty hunting, not candidate generation. **Do not write hopeful tests and see what fails.** Each iteration hunts a specific target:
+
+1. **Read the attested state.** Open the plan's `impl.md`. Read the Goal. Read every Trajectory row — what does each claim? Read the ADR if one exists — what invariants does the plan promise?
+2. **Investigate the code.** Read the actual implementation. Compare what the code does against what the attestation claims. Look for gaps.
+3. **Form a specific hypothesis.** Not "what could go wrong?" — "*this specific condition, with these specific inputs, will violate this specific invariant.*" Name the failure before writing any test.
+4. **Write the test that confirms the hypothesis.** If the hypothesis is right, the test fails. If the hypothesis is wrong, the test passes.
+5. **Run the test.**
+
+Prompts to ask yourself while investigating (use these as starting points, not a checklist):
+
+- **What's an edge case not covered by T1–Tn?** List every row. For each: what inputs did the author think of? What inputs did they miss?
+- **What's an implicit invariant the attestation makes that the Trajectory doesn't test?** "Recoverable from crash" implies "recoverable from partial write." Is there a test for partial writes?
+- **What about concurrent, partial, or malformed inputs?** Two callers at once. A half-written file. A valid-shape but semantically-wrong input.
+- **What would a malicious user try?** If this accepts input, what input breaks the parser, or traverses paths, or exhausts memory?
+- **What does the attestation assume about the environment?** Time monotonicity. Disk not full. Network present. Clock skew. Is any assumption documented vs. silently-assumed?
+- **What's the first thing someone would try if they were paid $100 to find one failure here?** Specifically. Concretely.
+- **What invariants are only enforced in one direction?** (E.g., "create calls validate, but update bypasses validation.")
+- **What claim does the Goal make that's not expressed as a Trajectory row?** That's often the unguarded surface.
+
+**Anti-pattern — do NOT do this:** "I'll write several tests and see which ones fail." That's candidate generation. It's cheap and useless. Every candidate you write without a specific hypothesis is noise. Investigate first, hypothesize specifically, write the test that targets *that* hypothesis.
+
+## Three outcomes per failing test
+
+When a test fails (your hypothesis is confirmed), pick one outcome — recommend one, but the user decides:
+
+1. **Fix in scope** — the gap is small and clearly in-scope for the plan's original goal. Add a new phase to the current `impl.md`, flip the impl status back to `in-progress`, return to `/work`. This is "build the plane while flying" — the plan grows during its own closure.
+2. **Spawn a new plan** — the gap is large, touches unrelated areas, or deserves its own planning lifecycle. Create `.indusk/planning/{new-slug}/brief.md` with the failing test as its core motivation. Link via `blocks:` in the current plan's brief.
+3. **Accept as finding** — rare. The gap is small, unambiguously out-of-scope, and the cost of a new plan isn't justified. Record in the falsification log and note in retrospective. Use only when the other two genuinely don't fit.
+
+After choosing the outcome, record the hypothesis via `appendHypothesis(planRoot, { hypothesis, testPath, outcome, note? })` from `apps/indusk-mcp/src/lib/falsification/log.ts`. The log file at `.indusk/planning/{plan}/falsification.md` captures the session's history.
+
+## Loop exit (hybrid)
+
+Continue hunting until you genuinely **cannot form a specific in-scope hypothesis** about what should be broken. Not "I've tried enough tests" — "I have investigated the code and cannot name a concrete attack vector remaining."
+
+When you reach that point, present the user with a summary:
+
+- Hypotheses investigated and their outcomes (confirmed → fix/spawn/accept; wrong → the hypothesis was rejected, note what held up)
+- Regions of code you searched without finding an attack vector
+- Any areas you did NOT investigate and why (e.g., "didn't investigate serialization because no serialization code was changed")
+
+The user confirms termination — or points at an area you didn't investigate. Not "write another test" — they should point at a *region* you missed. If that produces a new hypothesis, the loop continues. If nothing new surfaces, call `markTerminated(planRoot, reason)` to close the log and hand off to `/retrospective`.
+
+## When to skip the ritual entirely
+
+For genuinely trivial plans (two-line typo fix, changelog entry, variable rename with no behavioral change), the ritual's cost may exceed its discipline value. To skip, the plan's `impl.md` frontmatter must contain BOTH:
+
+```yaml
+falsification: skipped
+falsification_reason: "a non-empty reason, quoted as a YAML string"
+```
+
+The retrospective skill's Step 0 gate accepts either a completed falsification log OR the two-field skip frontmatter. Skipping is a confession, not a bypass — use sparingly.
+
+## Output
+
+By the time you hand off to `/retrospective`, one of these must be true:
+
+- `.indusk/planning/{plan}/falsification.md` exists with a terminator entry (log is closed cleanly), OR
+- The plan reopened (`impl` status flipped to `in-progress`) via a "fix in scope" outcome and `/work` is active again (deferring falsification until the fix lands)
+
+The `/retrospective` skill's Step 0 hard-blocks without this. Don't bypass.
+
+## Why this exists
+
+See the [Falsification Ritual guide](apps/indusk-docs/src/guide/falsification-ritual.md) for the full motivation. Short version: the Test Trajectory made universal deferral structurally impossible, but authors only write tests they can think of — and the author is the last person likely to notice the gaps in their own thinking. The ritual is a bullshit detector. Its purpose is rigor through self-examination.
+
+## Important
+
+- Same agent, flipped goal. No persona, no separate session. The same you that built the plan, asked a different question.
+- Bounty hunting, not candidate generation. Investigate first, hypothesize specifically, write the test that targets *that*.
+- Exit criterion is "can't form a specific in-scope hypothesis" — not "ran out of candidates" or "tried N things."
+- The log is append-only. Never edit `falsification.md` by hand. Write via `appendHypothesis` / `markTerminated` from the library.
+- If you find a gap, pick an outcome. Do not log a failing test and then continue looking for more failing tests as if the first didn't matter — each failure demands a decision before moving on.
+- The user's input is: $ARGUMENTS

package/skills/planner.md

@@ -92,7 +92,7 @@ Workflow templates are in `templates/workflows/` in the package. They describe w
    ```
    mcp__graphiti__add_memory({
      name: "adr-{plan-name}",
-     episode_body: "In the context of {use case}, facing {constraint}, we decided for {chosen option} and against {rejected alternatives}, to achieve {desired outcome}, accepting {tradeoff}, because {rationale}.",
+     episode_body: "In context facing: {use case AND constraint}. We decided for: {chosen option}. And against: {rejected alternatives}. To achieve: {desired outcome}. Accepting: {tradeoff}. Because: {rationale}.",
      group_id: "{project-group}",
      source: "text",
      source_description: "ADR acceptance"
@@ -207,13 +207,34 @@ status: proposed | accepted | deprecated | superseded | abandoned
 # {Title}
 
 ## Y-Statement
-In the context of **{use case}**,
-facing **{constraint}**,
-we decided for **{chosen option}**
-and against **{rejected alternatives}**,
-to achieve **{desired outcome}**,
-accepting **{tradeoff}**,
-because **{rationale}**.
+
+**In the context of:**
+{the use case — one paragraph, plain text, not bold}
+
+**Facing:**
+{the constraint or problem the use case presents — one paragraph}
+
+**We decided for:**
+{the chosen option — one paragraph}
+
+**And against:**
+{the rejected alternatives — one paragraph}
+
+**To achieve:**
+{the desired outcome — one paragraph}
+
+**Accepting:**
+{the tradeoff — one paragraph}
+
+**Because:**
+{the rationale — one paragraph}
+
+Format rules (the standard Y-statement format for every ADR in every project going forward):
+- Use all seven canonical clauses: In the context of, Facing, We decided for, And against, To achieve, Accepting, Because. These are the standard Y-statement fields — do not collapse, rename, or omit them.
+- Each clause is its own section. The clause label is bold and ends with a colon.
+- The paragraph body begins on the next line immediately after the bold label — no blank line between the label and the paragraph.
+- The paragraph body is plain text — not bold, no inline label.
+- A blank line separates each clause (between the end of one paragraph and the next bold label).
 
 ## Context
 {Situation and background. Reference research and brief.}

package/skills/retrospective.md

@@ -28,6 +28,34 @@ The retrospective skill replaces the freeform "write a retrospective" step with
 
 Work through these steps in order. Each step is blocking — do not skip ahead.
 
+### Step 0: Falsification Gate
+
+**This gate blocks everything below. Do not proceed to Step 1 until it passes.**
+
+Before writing a single word of the retrospective, confirm that the plan has completed the falsification ritual or has an explicit, recorded skip-reason.
+
+Check the gate by reading two sources:
+
+1. **Completion:** Does `.indusk/planning/{plan-name}/falsification.md` exist with a terminator entry? Use `isFalsificationComplete(planRoot)` from `apps/indusk-mcp/src/lib/falsification/log.js` (invoke via `tsx` or an MCP tool wrapper).
+2. **Skip:** Does the impl's frontmatter contain BOTH `falsification: skipped` AND `falsification_reason: "{non-empty text}"`? Use `isFalsificationSkipped(implContent)` from `apps/indusk-mcp/src/lib/falsification/skip.js`.
+
+The gate passes if either condition holds. If neither holds, refuse to run the retrospective and surface this message to the user:
+
+> **Retrospective blocked: falsification gate not satisfied for `{plan-name}`.**
+>
+> Before closing out a plan, run `/falsify {plan-name}` to exercise the bounty-hunting ritual — investigate the code, form a specific hypothesis about what should be broken, write the test that confirms it. The ritual may surface gaps worth addressing before archival (fix in scope, spawn a new plan, or accept as finding).
+>
+> To skip the ritual intentionally, add these two fields to the impl's frontmatter:
+>
+> ```yaml
+> falsification: skipped
+> falsification_reason: "why skipping is acceptable for this specific plan"
+> ```
+>
+> The skip-reason is recorded in the archive and surfaced in retrospectives. Use sparingly — typically only for trivial typo-fix plans where the ritual cost exceeds the discipline value.
+
+Do not proceed to Step 1 until the gate passes. This is structural enforcement of the discipline documented in the [Falsification Ritual guide](apps/indusk-docs/src/guide/falsification-ritual.md) — happy-path authoring produces happy-path tests, and the ritual is the mechanism for surfacing the gaps the author couldn't think of.
+
 ### Step 1: Write the Retrospective Document
 
 Create `.indusk/planning/{plan-name}/retrospective.md` using the template from the plan skill. This is the reflective writing — what we set out to do, what actually happened, what we learned.

package/skills/work.md

@@ -204,7 +204,8 @@ The hook validates that both `asked:` and `user:` are present with non-empty quo
     - Update impl status to `completed`
     - Summarize what was done
     - If this plan included an ADR, confirm CLAUDE.md's Key Decisions was updated
-    - Let the user know the plan is ready for a retrospective if they want one (`/planner {name}` will pick up at the retrospective stage)
+    - **Run `/falsify {plan}` next, before `/retrospective`.** The falsification ritual is the bridge between "impl done" and "plan archived." It drives the same working agent through a goal-flipped bounty hunt — investigate the code, form a specific hypothesis about what should be broken, write the test that confirms it. The ritual may surface gaps worth addressing, which can reopen the impl (status flips back to `in-progress`) for a fix-in-scope phase, or spawn a new plan, or be recorded as a finding. Only after `/falsify` terminates cleanly — or has been explicitly skipped via `falsification: skipped` + `falsification_reason: "..."` in the impl frontmatter — is the plan ready for `/retrospective`. See the [Falsification Ritual guide](apps/indusk-docs/src/guide/falsification-ritual.md) and `.indusk/planning/archive/falsification-ritual/adr.md`.
+    - Let the user know: "Impl complete. Run `/falsify {plan}` next. If it terminates cleanly, then `/retrospective {plan}` will close out the plan."
 
 ## Teach Mode