@infinitedusky/indusk-mcp 1.22.0 → 1.23.1

package/dist/lib/eval/evaluator-runner.js

@@ -66,6 +66,8 @@ export function runEvaluatorBackground(opts) {
         "opus",
         "--permission-mode",
         "acceptEdits",
+        "--mcp-config",
+        ".mcp.json",
         "--allowed-tools",
         allowedTools.join(","),
     ];
@@ -188,6 +190,8 @@ async function runEvaluatorSyncInner(opts, projectGroup) {
         "opus",
         "--permission-mode",
         "acceptEdits",
+        "--mcp-config",
+        ".mcp.json",
         "--allowed-tools",
         allowedTools.join(","),
     ];

package/dist/lib/eval/persistent-evaluator.js

@@ -160,6 +160,10 @@ Output ONLY the JSON scorecard as before — no commentary.`;
                             "json",
                             "--resume",
                             session.sessionId,
+                            "--mcp-config",
+                            ".mcp.json",
+                            "--permission-mode",
+                            "acceptEdits",
                             "--allowed-tools",
                             ALLOWED_TOOLS.join(","),
                         ],
@@ -175,6 +179,8 @@ Output ONLY the JSON scorecard as before — no commentary.`;
                         "opus",
                         "--permission-mode",
                         "acceptEdits",
+                        "--mcp-config",
+                        ".mcp.json",
                         "--allowed-tools",
                         ALLOWED_TOOLS.join(","),
                     ],

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

@@ -1,10 +1,20 @@
 import { type Trajectory } from "./parser.js";
 export interface ValidationError {
-    rule: "trajectory-presence" | "cross-reference-integrity" | "temporal-coherence" | "deferred-completeness";
+    rule: "trajectory-presence" | "cross-reference-integrity" | "temporal-coherence" | "deferred-completeness" | "rationale-completeness";
     message: string;
     /** The rough line number in the impl body, if known. */
     line?: number;
 }
+export interface ValidateTrajectoryOptions {
+    /**
+     * When true, also enforce `### Trajectory Rationale` completeness — every
+     * trajectory T-ID must appear as a `- **TN**` entry in the subsection,
+     * and the subsection must not contain entries for IDs missing from the
+     * trajectory table. Mirrors the JS hook's `rationale: required` frontmatter
+     * check at apps/indusk-mcp/hooks/validate-impl-structure.js.
+     */
+    rationaleRequired?: boolean;
+}
 /**
  * Rule 1: Every impl document must have a `## Test Trajectory` section.
  */
@@ -28,9 +38,30 @@ export declare function validateTemporalCoherence(trajectory: Trajectory): Valid
  */
 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.
+ * Rule 5: When the impl frontmatter sets `rationale: required`, every
+ * trajectory row whose `Writable at` is later than Phase 0 (the pre-plan
+ * baseline) must have an entry in the `### Trajectory Rationale` subsection.
+ *
+ * Phase 0 rows do NOT need a rationale — Phase 0 means "writable today
+ * against the current stack, before any plan implementation," which is
+ * the default and needs no justification. We only require rationale when
+ * a test will be authored after some plan code lands (Writable at: Phase 1+).
+ *
+ * If no row needs a rationale (every row is Phase 0), the subsection itself
+ * is optional. If any row is Phase 1+, the subsection must exist and contain
+ * an entry for every Phase 1+ row. Stale entries (entries for IDs not in the
+ * trajectory) are always flagged.
+ *
+ * Mirrors `validateRationaleCompleteness` in
+ * `.claude/hooks/validate-impl-structure.js`.
+ */
+export declare function validateRationaleCompleteness(body: string, trajectory: Trajectory): ValidationError[];
+/**
+ * Run all 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. Pass `{ rationaleRequired: true }` to additionally enforce
+ * `### Trajectory Rationale` completeness (mirrors the JS hook's check on
+ * `rationale: required` in frontmatter).
  */
-export declare function validateTrajectory(body: string): ValidationError[];
+export declare function validateTrajectory(body: string, options?: ValidateTrajectoryOptions): ValidationError[];

package/dist/lib/trajectory/validator.js

@@ -184,19 +184,101 @@ export function validateDeferredCompleteness(trajectory) {
     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.
+ * Rule 5: When the impl frontmatter sets `rationale: required`, every
+ * trajectory row whose `Writable at` is later than Phase 0 (the pre-plan
+ * baseline) must have an entry in the `### Trajectory Rationale` subsection.
+ *
+ * Phase 0 rows do NOT need a rationale — Phase 0 means "writable today
+ * against the current stack, before any plan implementation," which is
+ * the default and needs no justification. We only require rationale when
+ * a test will be authored after some plan code lands (Writable at: Phase 1+).
+ *
+ * If no row needs a rationale (every row is Phase 0), the subsection itself
+ * is optional. If any row is Phase 1+, the subsection must exist and contain
+ * an entry for every Phase 1+ row. Stale entries (entries for IDs not in the
+ * trajectory) are always flagged.
+ *
+ * Mirrors `validateRationaleCompleteness` in
+ * `.claude/hooks/validate-impl-structure.js`.
  */
-export function validateTrajectory(body) {
+export function validateRationaleCompleteness(body, trajectory) {
+    const errors = [];
+    const rowsNeedingRationale = trajectory.rows.filter((r) => Number.isFinite(r.writableAt) && r.writableAt > 0);
+    const hasSubsection = /^###\s+Trajectory Rationale\b/m.test(body);
+    const rationaleIds = hasSubsection ? parseRationaleBlock(body) : new Set();
+    if (rowsNeedingRationale.length > 0 && !hasSubsection) {
+        errors.push({
+            rule: "rationale-completeness",
+            message: `\`rationale: required\` is set and ${rowsNeedingRationale.length} trajectory row(s) have \`Writable at\` later than Phase 0, but the impl is missing the \`### Trajectory Rationale\` subsection. Phase 0 rows don't need rationale; rows where authoring waits on plan code do — add an entry for ${rowsNeedingRationale.map((r) => r.id).join(", ")}.`,
+        });
+        // Even without the subsection, fall through to also check for stale entries
+        // (there are none in this case, but the structure is symmetric).
+    }
+    const missing = [];
+    for (const row of rowsNeedingRationale) {
+        if (!rationaleIds.has(row.id))
+            missing.push(row.id);
+    }
+    if (missing.length > 0 && hasSubsection) {
+        errors.push({
+            rule: "rationale-completeness",
+            message: `Trajectory rows with \`Writable at\` later than Phase 0 missing from \`### Trajectory Rationale\`: ${missing.join(", ")}. Every row whose authoring waits on plan code needs a \`- **TN** \`Writable at: Phase N\` — {reason}\` entry. Phase 0 rows (writable today against the current stack) do not need rationale.`,
+        });
+    }
+    const knownIds = new Set(trajectory.rows.map((r) => r.id));
+    const extra = [...rationaleIds].filter((id) => !knownIds.has(id));
+    if (extra.length > 0) {
+        errors.push({
+            rule: "rationale-completeness",
+            message: `\`### Trajectory Rationale\` contains entries for IDs not present in the trajectory table: ${extra.join(", ")}. Remove the stale entries or add the missing trajectory rows.`,
+        });
+    }
+    return errors;
+}
+/**
+ * Parse the `### Trajectory Rationale` subsection and return the set of
+ * T-IDs that appear as `- **TN**` entries. Stops at the next heading of
+ * depth 1-3.
+ */
+function parseRationaleBlock(body) {
+    const lines = body.split("\n");
+    const ids = new Set();
+    let inRationale = false;
+    for (const line of lines) {
+        if (/^###\s+Trajectory Rationale\b/.test(line)) {
+            inRationale = true;
+            continue;
+        }
+        if (!inRationale)
+            continue;
+        if (/^#{1,3}\s+/.test(line) && !/^###\s+Trajectory Rationale\b/.test(line))
+            break;
+        const match = line.match(/^-\s+\*\*(T\d+)\*\*/);
+        if (match)
+            ids.add(match[1]);
+    }
+    return ids;
+}
+/**
+ * Run all 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. Pass `{ rationaleRequired: true }` to additionally enforce
+ * `### Trajectory Rationale` completeness (mirrors the JS hook's check on
+ * `rationale: required` in frontmatter).
+ */
+export function validateTrajectory(body, options = {}) {
     const presenceErrors = validateTrajectoryPresence(body);
     if (presenceErrors.length > 0)
         return presenceErrors;
     const trajectory = parseTrajectory(body);
-    return [
+    const errors = [
         ...validateCrossReferenceIntegrity(body, trajectory),
         ...validateTemporalCoherence(trajectory),
         ...validateDeferredCompleteness(trajectory),
     ];
+    if (options.rationaleRequired) {
+        errors.push(...validateRationaleCompleteness(body, trajectory));
+    }
+    return errors;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@infinitedusky/indusk-mcp",
-	"version": "1.22.0",
+	"version": "1.23.1",
 	"description": "InDusk development system — skills, MCP tools, and CLI for structured AI-assisted development",
 	"type": "module",
 	"files": [
@@ -24,7 +24,8 @@
 		"dev": "tsx watch src/server/index.ts",
 		"build": "tsc",
 		"start": "node dist/server/index.js",
-		"test": "vitest run"
+		"test": "vitest run",
+		"prepublishOnly": "pnpm build"
 	},
 	"dependencies": {
 		"@modelcontextprotocol/sdk": "^1.12.1",