@infinitedusky/indusk-mcp 1.1.1 → 1.1.2

package/dist/bin/commands/init.js

@@ -176,7 +176,7 @@ export async function init(projectRoot, options = {}) {
     console.info("\n[Hooks]");
     const hooksSource = join(packageRoot, "hooks");
     const hooksTarget = join(projectRoot, ".claude/hooks");
-    const hookFiles = ["check-gates.js", "gate-reminder.js", "validate-impl-structure.js"];
+    const hookFiles = ["check-gates.js", "gate-reminder.js", "validate-impl-structure.js", "check-catchup.js"];
     if (existsSync(hooksSource)) {
         mkdirSync(hooksTarget, { recursive: true });
         for (const file of hookFiles) {
@@ -202,6 +202,7 @@ export async function init(projectRoot, options = {}) {
                 hooks: [
                     { type: "command", command: "node .claude/hooks/check-gates.js" },
                     { type: "command", command: "node .claude/hooks/validate-impl-structure.js" },
+                    { type: "command", command: "node .claude/hooks/check-catchup.js" },
                 ],
             },
         ],
@@ -221,7 +222,8 @@ export async function init(projectRoot, options = {}) {
             // Check if our hook is already present
             const hasOurHook = existingEntries.some((e) => e.hooks?.some((h) => h.command?.includes("check-gates") ||
                 h.command?.includes("gate-reminder") ||
-                h.command?.includes("validate-impl")));
+                h.command?.includes("validate-impl") ||
+                h.command?.includes("check-catchup")));
             if (!hasOurHook || force) {
                 // Remove old entries if force, then add
                 if (force) {

package/hooks/check-catchup.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+/**
+ * PreToolUse hook: blocks Edit/Write on project files until /catchup is complete.
+ *
+ * Reads .claude/handoff.md and checks that all Catchup Status boxes are checked.
+ * Allows edits TO the handoff file itself (so catchup can check off boxes).
+ * Allows edits if no handoff file exists (first session, no enforcement).
+ *
+ * Exit 0 = allow
+ * Exit 2 = block (stderr sent to agent)
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+const input = JSON.parse(readFileSync("/dev/stdin", "utf-8"));
+const toolInput = input.tool_input ?? {};
+const filePath = toolInput.file_path ?? "";
+
+// Find project root by looking for .claude/ directory
+function findProjectRoot() {
+	let dir = process.cwd();
+	for (let i = 0; i < 10; i++) {
+		if (existsSync(join(dir, ".claude"))) return dir;
+		const parent = resolve(dir, "..");
+		if (parent === dir) break;
+		dir = parent;
+	}
+	return process.cwd();
+}
+
+const projectRoot = findProjectRoot();
+const handoffPath = join(projectRoot, ".claude", "handoff.md");
+
+// Allow if no handoff exists (first session or handoff not yet created)
+if (!existsSync(handoffPath)) {
+	process.exit(0);
+}
+
+// Always allow edits to the handoff file itself (catchup needs to check boxes)
+if (filePath.endsWith("handoff.md")) {
+	process.exit(0);
+}
+
+// Read the handoff and check catchup status
+const content = readFileSync(handoffPath, "utf-8");
+
+// Look for the Catchup Status section
+const statusMatch = content.match(/## Catchup Status\n([\s\S]*?)(?:\n##|\n$|$)/);
+if (!statusMatch) {
+	// No catchup status section — allow (handoff was written before this feature)
+	process.exit(0);
+}
+
+const statusSection = statusMatch[1];
+const unchecked = [];
+const checkboxes = statusSection.matchAll(/- \[( |x)\] (\w+)/g);
+
+for (const match of checkboxes) {
+	if (match[1] === " ") {
+		unchecked.push(match[2]);
+	}
+}
+
+if (unchecked.length === 0) {
+	// All boxes checked — catchup is complete
+	process.exit(0);
+}
+
+// Block the edit
+process.stderr.write(
+	`Catchup incomplete. Run /catchup before editing project files.\n` +
+		`Missing steps: ${unchecked.join(", ")}\n` +
+		`The handoff file (.claude/handoff.md) has unchecked catchup boxes. ` +
+		`Complete each /catchup step to check them off.`,
+);
+process.exit(2);

package/package.json

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

package/skills/catchup.md

@@ -16,14 +16,20 @@ Check if `.claude/handoff.md` exists. If it does, read it first — this is the
 
 If the handoff exists, present a brief summary to the user: "Last session was working on X, stopped at Y. Ready to pick up there?"
 
-If no handoff exists, skip to step 2.
+**After reading, edit the handoff to check off:** `- [x] handoff`
+
+If no handoff exists, create one with all catchup status boxes unchecked, then check off handoff.
 
 ### 2. Read Lessons
 Call `list_lessons`. Read every lesson. These are rules learned from past mistakes — not suggestions. Internalize them before touching any code.
 
+**After reading, edit the handoff to check off:** `- [x] lessons`
+
 ### 3. Check Infrastructure
 Call `check_health`. Verify FalkorDB and CGC are running. If unhealthy, tell the user what's down and how to fix it.
 
+**After checking, edit the handoff to check off:** `- [x] health`
+
 ### 4. Read Project Context
 Call `get_context` to read CLAUDE.md. This contains:
 - **Architecture** — what the project is, how it's structured
@@ -34,12 +40,16 @@ Call `get_context` to read CLAUDE.md. This contains:
 
 Read it fully. Don't skim.
 
+**After reading, edit the handoff to check off:** `- [x] context`
+
 ### 5. Check Active Plans
 Call `list_plans`. This shows every plan and its status. Pay attention to:
 - Plans with status `in-progress` — these are actively being worked on
 - The current phase of each active plan — this is where `/work` will pick up
 - Dependencies between plans — don't start a blocked plan
 
+**After checking, edit the handoff to check off:** `- [x] plans`
+
 ### 6. Review Skills and Extensions
 Call `extensions_status` to see what extensions are enabled and their capabilities.
 
@@ -51,8 +61,12 @@ Then read all installed skill files in `.claude/skills/*/SKILL.md`. These define
 
 Understand what each skill does and when to use it. You should be able to answer: "What slash commands are available and what do they do?"
 
+**After reviewing, edit the handoff to check off:** `- [x] skills` and `- [x] extensions`
+
 ### 7. Check Code Graph
-Call `get_repository_stats` to understand the codebase size and structure. This gives you a sense of what's indexed and queryable. If it fails, the CGC extension may not be enabled or FalkorDB may be down — check_health will have flagged this.
+Call `graph_stats` to understand the codebase size and structure. This gives you a sense of what's indexed and queryable. If it fails, call `graph_doctor` to diagnose. If FalkorDB is down or the repo isn't indexed, flag it.
+
+**After checking, edit the handoff to check off:** `- [x] graph`
 
 ### 8. Summarize
 

package/skills/handoff.md

@@ -32,6 +32,16 @@ Create or overwrite `.claude/handoff.md` with:
 
 ## Watch Out For
 {Gotchas the next agent should know. "The FalkorDB graph needs reindexing." "The hooks aren't published yet — version 1.0.3 has them." "Don't touch init.ts until the extension system PR is merged."}
+
+## Catchup Status
+- [ ] handoff
+- [ ] lessons
+- [ ] skills
+- [ ] health
+- [ ] context
+- [ ] plans
+- [ ] extensions
+- [ ] graph
 ```
 
 ## When to Write a Handoff
@@ -48,3 +58,4 @@ Create or overwrite `.claude/handoff.md` with:
 - **Decisions that aren't saved anywhere else MUST go here.** They'll be lost otherwise.
 - **Overwrite the previous handoff.** There's only one — the most recent session's. Old handoffs are consumed by /catchup and don't need to persist.
 - **Keep it short.** This isn't a retrospective. It's a sticky note for the next person.
+- **Always include the Catchup Status section** with all boxes unchecked. This is enforced by a hook — the next session cannot edit or write code until `/catchup` checks off every box. Each step in catchup marks its box when completed.