@directive-run/cli 0.2.0

package/dist/cli.js

@@ -0,0 +1,2992 @@
+#!/usr/bin/env node
+import * as p from '@clack/prompts';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from 'fs';
+import { join, relative, dirname, resolve } from 'path';
+import pc5 from 'picocolors';
+import { getAllExamples, getExample, getKnowledge } from '@directive-run/knowledge';
+
+// src/lib/constants.ts
+var CLI_NAME = "directive";
+var SECTION_START = "<!-- directive:start -->";
+var SECTION_END = "<!-- directive:end -->";
+var TOOL_SIGNALS = [
+  {
+    id: "cursor",
+    name: "Cursor",
+    signals: [".cursor", ".cursorrules"],
+    outputPath: ".cursorrules"
+  },
+  {
+    id: "claude",
+    name: "Claude Code",
+    signals: [".claude"],
+    outputPath: ".claude/CLAUDE.md"
+  },
+  {
+    id: "copilot",
+    name: "GitHub Copilot",
+    signals: [".github"],
+    outputPath: ".github/copilot-instructions.md"
+  },
+  {
+    id: "windsurf",
+    name: "Windsurf",
+    signals: [".windsurfrules"],
+    outputPath: ".windsurfrules"
+  },
+  {
+    id: "cline",
+    name: "Cline",
+    signals: [".clinerules"],
+    outputPath: ".clinerules"
+  }
+];
+function detectTools(rootDir) {
+  const detected = [];
+  for (const tool of TOOL_SIGNALS) {
+    const hasSignal = tool.signals.some(
+      (signal) => existsSync(join(rootDir, signal))
+    );
+    if (hasSignal) {
+      detected.push({
+        name: tool.name,
+        id: tool.id,
+        outputPath: join(rootDir, tool.outputPath)
+      });
+    }
+  }
+  return detected;
+}
+function getToolConfig(id) {
+  const tool = TOOL_SIGNALS.find((t) => t.id === id);
+  if (!tool) {
+    throw new Error(`Unknown tool: ${id}`);
+  }
+  return tool;
+}
+function getAllToolIds() {
+  return TOOL_SIGNALS.map((t) => t.id);
+}
+
+// src/lib/merge.ts
+function mergeSection(existingContent, newSection) {
+  const startIdx = existingContent.indexOf(SECTION_START);
+  const endIdx = existingContent.indexOf(SECTION_END);
+  const wrapped = `${SECTION_START}
+${newSection}
+${SECTION_END}`;
+  if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) {
+    return existingContent.slice(0, startIdx) + wrapped + existingContent.slice(endIdx + SECTION_END.length);
+  }
+  const separator = existingContent.endsWith("\n") ? "\n" : "\n\n";
+  return existingContent + separator + wrapped + "\n";
+}
+function hasDirectiveSection(content) {
+  return content.includes(SECTION_START) && content.includes(SECTION_END);
+}
+var MONOREPO_SIGNALS = [
+  { file: "pnpm-workspace.yaml", tool: "pnpm" },
+  { file: "turbo.json", tool: "turbo" }
+];
+function detectMonorepo(startDir) {
+  let dir = resolve(startDir);
+  while (dir !== dirname(dir)) {
+    for (const signal of MONOREPO_SIGNALS) {
+      if (existsSync(join(dir, signal.file))) {
+        return { isMonorepo: true, rootDir: dir, tool: signal.tool };
+      }
+    }
+    const pkgPath = join(dir, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        if (pkg.workspaces) {
+          const tool = existsSync(join(dir, "yarn.lock")) ? "yarn" : "npm";
+          return { isMonorepo: true, rootDir: dir, tool };
+        }
+      } catch {
+      }
+    }
+    dir = dirname(dir);
+  }
+  return { isMonorepo: false, rootDir: startDir };
+}
+
+// src/templates/claude.ts
+function generateClaudeRules() {
+  const corePatterns = getKnowledge("core-patterns");
+  const antiPatterns = getKnowledge("anti-patterns");
+  const naming = getKnowledge("naming");
+  const schemaTypes = getKnowledge("schema-types");
+  return `# Directive \u2014 Complete AI Coding Rules
+
+> Constraint-driven runtime for TypeScript. Declare requirements, let the runtime resolve them.
+> https://directive.run | \`npm install @directive-run/core\`
+> Full reference with examples: https://directive.run/llms.txt
+
+## Core Patterns
+
+${corePatterns}
+
+---
+
+## Anti-Patterns (All 36)
+
+${antiPatterns}
+
+### AI Package Anti-Patterns (21-36)
+
+| # | WRONG | CORRECT |
+|---|-------|---------|
+| 21 | TS types for factsSchema: \`{ confidence: number }\` | Use \`{ confidence: t.number() }\` |
+| 22 | \`facts.cache.push(item)\` in orchestrator | \`facts.cache = [...facts.cache, item]\` |
+| 23 | Returning data from orchestrator \`resolve\` | Resolvers return \`void\` \u2014 mutate \`context.facts\` |
+| 24 | Forgetting \`orchestrator.start()\` multi-agent | Single: implicit. Multi: must call \`start()\` |
+| 25 | Catching \`Error\` not \`GuardrailError\` | \`GuardrailError\` has \`.guardrailName\`, \`.errorCode\` |
+| 26 | \`from '@directive-run/ai'\` for adapters | Subpath: \`from '@directive-run/ai/openai'\` |
+| 27 | Assuming \`{ input_tokens }\` structure | Normalized: \`{ inputTokens, outputTokens }\` |
+| 28 | Same CircuitBreaker across agents | Create separate instances per dependency |
+| 29 | \`budgetWarningThreshold: 1.5\` | Must be 0-1 (percentage) |
+| 30 | \`race\` minSuccess > agents.length | Must be \`1 \u2264 minSuccess \u2264 agents.length\` |
+| 31 | Async summarizer with autoManage: true | Use \`autoManage: false\` for sync control |
+| 32 | Side effects in reflect \`evaluator\` | Evaluator must be pure |
+| 33 | Task calling \`runSingleAgent\` | Tasks can't call agents \u2014 separate node |
+| 34 | Task expecting object input | Input is always \`string\` \u2014 \`JSON.parse(input)\` |
+| 35 | Task ID same as agent ID | IDs share namespace \u2014 distinct names |
+| 36 | \`from '@directive-run/ai/mcp'\` | \`from '@directive-run/ai'\` (main export) |
+
+---
+
+## Naming Conventions
+
+${naming}
+
+---
+
+## Schema Type Builders
+
+${schemaTypes}
+
+---
+
+## Multi-Module Quick Reference
+
+\`\`\`typescript
+// Two modules with cross-module dependency
+const authSchema = { facts: { token: t.string(), isAuth: t.boolean() } };
+const authModule = createModule("auth", { schema: authSchema, /* ... */ });
+
+const cartModule = createModule("cart", {
+  schema: { facts: { items: t.array<CartItem>() } },
+  crossModuleDeps: { auth: authSchema },  // Declare dependency
+  constraints: {
+    checkout: {
+      when: (facts) => facts.self.items.length > 0 && facts.auth.isAuth,  // facts.self.* for own, facts.auth.* for cross
+      require: () => ({ type: "CHECKOUT" }),
+    },
+  },
+  // ...
+});
+
+const system = createSystem({ modules: { auth: authModule, cart: cartModule } });
+// Access: system.facts.auth.token, system.events.cart.addItem({...})
+\`\`\`
+
+Key rules:
+- \`facts.self.*\` for own module facts in constraints/resolvers
+- \`facts.otherModule.*\` for cross-module reads
+- \`crossModuleDeps\` must declare consumed schemas
+- \`system.events.moduleName.eventName(payload)\` for namespaced events
+- The \`::\` separator is internal \u2014 always use dot notation
+
+---
+
+## Constraints
+
+- \`when(facts)\` \u2192 boolean. When true, requirement is emitted.
+- \`require(facts)\` \u2192 \`{ type: "TYPE", ...data }\` object (never string literal)
+- \`priority: number\` \u2014 higher evaluated first
+- \`after: ["constraintName"]\` \u2014 ordering within same priority
+- Async: \`async: true\` + \`deps: ['factName']\` (deps REQUIRED for async)
+- Constraints DECLARE needs, resolvers FULFILL them \u2014 decoupled.
+
+---
+
+## Resolvers
+
+- \`resolve(req, context)\` \u2014 async, returns \`void\`. Mutate \`context.facts.*\`.
+- \`requirement: "TYPE"\` \u2014 which type this handles
+- \`key: (req) => string\` \u2014 deduplication key
+- \`retry: { attempts: 3, backoff: "exponential", initialDelay: 100 }\`
+- \`batch: { maxSize: 10, windowMs: 50 }\` for N+1 prevention
+- Always \`await system.settle()\` after start to wait for resolution
+
+---
+
+## System API
+
+- \`system.facts.fieldName\` \u2014 read/write facts
+- \`system.derive.derivationName\` \u2014 read derived values
+- \`system.events.eventName(payload)\` \u2014 dispatch events
+- \`system.subscribe(listener)\` \u2014 subscribe to all changes
+- \`system.read(key)\` \u2014 read fact or derivation by string key
+- \`system.inspect()\` \u2014 full state snapshot
+- \`system.settle()\` \u2014 wait for async operations
+- \`system.start()\` / \`system.stop()\` / \`system.destroy()\`
+
+---
+
+## React (\`@directive-run/react\`)
+
+\`\`\`typescript
+import { useSelector, useEvent } from "@directive-run/react";
+
+const count = useSelector(system, (s) => s.facts.count);
+const events = useEvent(system);
+// onClick={() => events.increment()}
+\`\`\`
+
+**NO** \`useDirective()\` hook. Use \`useSelector\` + \`useEvent\`.
+
+---
+
+## Plugins (\`@directive-run/core/plugins\`)
+
+\`devtoolsPlugin()\`, \`loggingPlugin()\`, \`persistencePlugin(config)\`,
+\`createCircuitBreaker(config)\`, \`createObservability(config)\`
+
+---
+
+## AI Package (\`@directive-run/ai\`)
+
+### Single-Agent Orchestrator
+
+\`\`\`typescript
+import { createAgentOrchestrator, t } from '@directive-run/ai';
+import { createAnthropicRunner } from '@directive-run/ai/anthropic';
+
+const orchestrator = createAgentOrchestrator({
+  runner: createAnthropicRunner({ apiKey }),
+  factsSchema: { result: t.string(), confidence: t.number() },
+  init: (facts) => { facts.result = ""; facts.confidence = 0; },
+  maxTokenBudget: 100000,
+  budgetWarningThreshold: 0.8,
+  guardrails: { input: [...], output: [...] },
+  memory: createAgentMemory({ strategy: createSlidingWindowStrategy({ maxMessages: 30 }) }),
+  debug: true,
+});
+
+const result = await orchestrator.run(agent, "analyze this");
+\`\`\`
+
+### Multi-Agent
+
+\`\`\`typescript
+import { createMultiAgentOrchestrator, parallel, sequential, dag } from '@directive-run/ai';
+
+const orch = createMultiAgentOrchestrator({
+  agents: { researcher: agentA, writer: agentB },
+  patterns: {
+    pipeline: sequential(["researcher", "writer"]),
+    brainstorm: parallel(["researcher", "writer"], mergeResults),
+    workflow: dag([
+      { id: "research", handler: "researcher" },
+      { id: "write", handler: "writer", dependencies: ["research"] },
+    ]),
+  },
+  runner,
+});
+orch.start();  // Required for multi-agent!
+\`\`\`
+
+8 patterns: \`parallel\`, \`sequential\`, \`supervisor\`, \`dag\`, \`reflect\`, \`race\`, \`debate\`, \`goal\`
+
+### Adapter Imports (Subpath!)
+
+\`\`\`typescript
+import { createAnthropicRunner } from '@directive-run/ai/anthropic';
+import { createOpenAIRunner } from '@directive-run/ai/openai';
+import { createOllamaRunner } from '@directive-run/ai/ollama';
+import { createGeminiRunner } from '@directive-run/ai/gemini';
+\`\`\`
+
+### Guardrails
+
+\`createPIIGuardrail\`, \`createModerationGuardrail\`, \`createRateLimitGuardrail\`,
+\`createToolGuardrail\`, \`createOutputSchemaGuardrail\`, \`createLengthGuardrail\`,
+\`createContentFilterGuardrail\`
+
+\`GuardrailResult: { passed: boolean, reason?: string, transformed?: unknown }\`
+
+### Memory
+
+\`createAgentMemory({ strategy, summarizer?, autoManage? })\`
+Strategies: \`createSlidingWindowStrategy\`, \`createTokenBasedStrategy\`, \`createHybridStrategy\`
+Summarizers: \`createTruncationSummarizer\`, \`createKeyPointsSummarizer\`, \`createLLMSummarizer(runner)\`
+
+### Streaming
+
+\`\`\`typescript
+const streamResult = orchestrator.runStream(agent, "analyze");
+for await (const chunk of streamResult.stream) {
+  switch (chunk.type) {
+    case "token": process.stdout.write(chunk.data); break;
+    case "done": console.log("Tokens:", chunk.totalTokens); break;
+    case "error": console.error(chunk.error); break;
+  }
+}
+\`\`\`
+
+Backpressure: \`"buffer"\` (default), \`"block"\`, \`"drop"\`
+`;
+}
+
+// src/templates/cursor.ts
+function generateCursorRules() {
+  return `# Directive \u2014 AI Coding Rules
+
+> Constraint-driven runtime for TypeScript. \`npm install @directive-run/core\`
+> Full reference: https://directive.run/llms.txt
+
+## Schema Shape (CRITICAL)
+
+\`\`\`typescript
+import { createModule, createSystem, t } from "@directive-run/core";
+
+const myModule = createModule("name", {
+  schema: {
+    facts: { count: t.number(), items: t.array<string>() },
+    derivations: { total: "number" },
+    events: { increment: "void", addItem: "string" },
+    requirements: { FETCH_DATA: { url: "string" } },
+  },
+  init: (facts) => { facts.count = 0; facts.items = []; },
+  derive: {
+    total: (facts) => facts.items.length + facts.count,
+  },
+  events: {
+    increment: (facts) => { facts.count += 1; },
+    addItem: (facts, item) => { facts.items = [...facts.items, item]; },
+  },
+  constraints: {
+    fetchWhenReady: {
+      when: (facts) => facts.count > 0 && facts.items.length === 0,
+      require: (facts) => ({ type: "FETCH_DATA", url: "/api/items" }),
+    },
+  },
+  resolvers: {
+    fetchData: {
+      requirement: "FETCH_DATA",
+      resolve: async (req, context) => {
+        const data = await fetch(req.url).then(r => r.json());
+        context.facts.items = data;
+      },
+    },
+  },
+});
+
+const system = createSystem({ module: myModule });
+await system.settle();
+\`\`\`
+
+## Top 10 Anti-Patterns
+
+| # | WRONG | CORRECT |
+|---|-------|---------|
+| 1 | \`facts.profile as ResourceState<Profile>\` | Remove cast \u2014 schema provides types |
+| 2 | \`{ phase: t.string() }\` flat schema | \`schema: { facts: { phase: t.string() } }\` |
+| 3 | \`facts.items\` in multi-module | \`facts.self.items\` |
+| 4 | \`t.map()\`, \`t.set()\`, \`t.promise()\` | Don't exist. Use \`t.object<Map<K,V>>()\` |
+| 5 | \`(req, ctx)\` in resolver | \`(req, context)\` \u2014 never abbreviate |
+| 6 | \`createModule("n", { phase: t.string() })\` | Must wrap: \`schema: { facts: { ... } }\` |
+| 7 | \`system.dispatch('login', {...})\` | \`system.events.login({...})\` |
+| 8 | \`facts.items.push(item)\` | \`facts.items = [...facts.items, item]\` |
+| 9 | \`useDirective(system)\` | \`useSelector(system, s => s.facts.count)\` |
+| 10 | \`facts['auth::status']\` | \`facts.auth.status\` dot notation |
+
+## Naming
+
+- \`req\` = requirement (not request). Parameter: \`(req, context)\`
+- \`derive\` / derivations \u2014 never "computed" or "selectors"
+- Resolvers return \`void\` \u2014 mutate \`context.facts\` instead
+- Always use braces for returns: \`if (x) { return y; }\`
+- Multi-module: \`facts.self.fieldName\` for own module facts
+- Events: \`system.events.eventName(payload)\` \u2014 not \`system.dispatch()\`
+- Import from main: \`import { createModule } from '@directive-run/core'\`
+
+## Schema Types That Exist
+
+\`t.string<T>()\`, \`t.number()\`, \`t.boolean()\`, \`t.array<T>()\`, \`t.object<T>()\`,
+\`t.enum("a","b")\`, \`t.literal(value)\`, \`t.nullable(inner)\`, \`t.optional(inner)\`, \`t.union(...)\`
+
+Chainable: \`.default()\`, \`.validate()\`, \`.transform()\`, \`.brand<>()\`, \`.refine()\`
+
+**DO NOT USE** (hallucinations): \`t.map()\`, \`t.set()\`, \`t.date()\`, \`t.tuple()\`, \`t.record()\`, \`t.promise()\`, \`t.any()\`
+
+## Key Pattern: Constraint \u2192 Requirement \u2192 Resolver
+
+When the user wants "do X when Y": create THREE things:
+1. **Constraint**: \`when: (facts) => Y_condition\` \u2192 \`require: { type: "DO_X" }\`
+2. **Resolver**: handles "DO_X", calls API, sets \`context.facts\`
+3. They are **decoupled**. Constraint declares need, resolver fulfills it.
+`;
+}
+
+// src/templates/copilot.ts
+function generateCopilotRules() {
+  const base = generateCursorRules();
+  const extraAntiPatterns = `
+## Anti-Patterns 11-20
+
+| # | WRONG | CORRECT |
+|---|-------|---------|
+| 11 | \`module("name").schema({...}).build()\` | Prefer \`createModule("name", {...})\` object syntax |
+| 12 | Returning data from \`resolve\` | Resolvers return \`void\` \u2014 mutate \`context.facts\` |
+| 13 | Async logic in \`init\` | \`init\` is synchronous, facts assignment only |
+| 14 | \`await system.start()\` without settle | Add \`await system.settle()\` after start |
+| 15 | Missing \`crossModuleDeps\` | Declare \`crossModuleDeps: { auth: authSchema }\` |
+| 16 | \`require: "TYPE"\` string literal | \`require: { type: "TYPE" }\` object form |
+| 17 | Passthrough derivation \`(f) => f.count\` | Remove \u2014 read fact directly |
+| 18 | \`from '@directive-run/core/module'\` | \`from '@directive-run/core'\` (main export) |
+| 19 | \`async when()\` without \`deps\` | Add \`deps: ['factName']\` for async constraints |
+| 20 | No error boundary on resolver | Use try-catch or module error boundary config |
+`;
+  const multiModule = `
+## Multi-Module
+
+\`\`\`typescript
+const system = createSystem({
+  modules: { auth: authModule, cart: cartModule },
+});
+
+// Access: system.facts.auth.token, system.events.cart.addItem({...})
+// In constraints/resolvers: use facts.self.* for own module
+// Declare deps: crossModuleDeps: { auth: authSchema }
+\`\`\`
+`;
+  const aiBasics = `
+## AI Package Basics (\`@directive-run/ai\`)
+
+\`\`\`typescript
+import { createAgentOrchestrator, t } from '@directive-run/ai';
+import { createAnthropicRunner } from '@directive-run/ai/anthropic'; // Subpath import!
+
+const orchestrator = createAgentOrchestrator({
+  runner: createAnthropicRunner({ apiKey: process.env.ANTHROPIC_API_KEY }),
+  factsSchema: { result: t.string(), confidence: t.number() }, // Use t.*() !
+  init: (facts) => { facts.result = ""; facts.confidence = 0; },
+});
+
+const result = await orchestrator.run(agent, "analyze this");
+\`\`\`
+
+**AI Anti-Patterns:**
+- Use \`t.number()\` not \`number\` for factsSchema
+- Subpath imports: \`from '@directive-run/ai/anthropic'\` not \`from '@directive-run/ai'\`
+- Token usage normalized: \`{ inputTokens, outputTokens }\` (not provider-specific)
+- \`facts.cache = [...facts.cache, item]\` not \`facts.cache.push(item)\`
+`;
+  return base + extraAntiPatterns + multiModule + aiBasics;
+}
+
+// src/templates/cline.ts
+function generateClineRules() {
+  return generateCopilotRules();
+}
+
+// src/templates/windsurf.ts
+function generateWindsurfRules() {
+  return generateCopilotRules();
+}
+
+// src/templates/index.ts
+var generators = {
+  cursor: generateCursorRules,
+  claude: generateClaudeRules,
+  copilot: generateCopilotRules,
+  windsurf: generateWindsurfRules,
+  cline: generateClineRules
+};
+function getTemplate(toolId) {
+  const generator = generators[toolId];
+  if (!generator) {
+    throw new Error(`No template for tool: ${toolId}`);
+  }
+  return generator();
+}
+
+// src/commands/ai-rules.ts
+function parseArgs(args) {
+  const opts = {
+    force: false,
+    merge: false,
+    tools: [],
+    dir: process.cwd()
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--force":
+        opts.force = true;
+        break;
+      case "--merge":
+        opts.merge = true;
+        break;
+      case "--tool": {
+        const val = args[++i];
+        if (val) {
+          opts.tools.push(val);
+        }
+        break;
+      }
+      case "--dir": {
+        const val = args[++i];
+        if (val) {
+          opts.dir = val;
+        }
+        break;
+      }
+    }
+  }
+  return opts;
+}
+async function aiRulesCommand(args) {
+  const opts = parseArgs(args);
+  p.intro(pc5.bgCyan(pc5.black(" directive ai-rules ")));
+  const mono = detectMonorepo(opts.dir);
+  let targetDir = opts.dir;
+  if (mono.isMonorepo && mono.rootDir !== opts.dir) {
+    const placement = await p.select({
+      message: "Monorepo detected. Where should AI rules be installed?",
+      options: [
+        {
+          value: "root",
+          label: `Monorepo root (${relative(opts.dir, mono.rootDir) || "."})`,
+          hint: "recommended"
+        },
+        {
+          value: "workspace",
+          label: `Current workspace (${relative(mono.rootDir, opts.dir)})`
+        }
+      ]
+    });
+    if (p.isCancel(placement)) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+    if (placement === "root") {
+      targetDir = mono.rootDir;
+    }
+  }
+  let selectedTools;
+  if (opts.tools.length > 0) {
+    selectedTools = opts.tools.map((id) => {
+      const config = getToolConfig(id);
+      return {
+        name: config.name,
+        id: config.id,
+        outputPath: join(targetDir, config.outputPath)
+      };
+    });
+  } else {
+    const detected = detectTools(targetDir);
+    if (detected.length > 0) {
+      const choices = await p.multiselect({
+        message: `Detected ${detected.length} AI tool(s). Which should get Directive rules?`,
+        options: detected.map((t) => ({
+          value: t.id,
+          label: t.name,
+          hint: relative(targetDir, t.outputPath)
+        })),
+        initialValues: detected.map((t) => t.id),
+        required: true
+      });
+      if (p.isCancel(choices)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+      }
+      selectedTools = choices.map((id) => {
+        const config = getToolConfig(id);
+        return {
+          name: config.name,
+          id: config.id,
+          outputPath: join(targetDir, config.outputPath)
+        };
+      });
+    } else {
+      const choices = await p.multiselect({
+        message: "No AI tools detected. Which tools do you use?",
+        options: getAllToolIds().map((id) => {
+          const config = getToolConfig(id);
+          return { value: id, label: config.name };
+        }),
+        required: true
+      });
+      if (p.isCancel(choices)) {
+        p.cancel("Cancelled.");
+        process.exit(0);
+      }
+      selectedTools = choices.map((id) => {
+        const config = getToolConfig(id);
+        return {
+          name: config.name,
+          id: config.id,
+          outputPath: join(targetDir, config.outputPath)
+        };
+      });
+    }
+  }
+  if (selectedTools.length === 0) {
+    p.cancel("No tools selected.");
+    process.exit(0);
+  }
+  const s = p.spinner();
+  for (const tool of selectedTools) {
+    s.start(`Generating ${tool.name} rules...`);
+    const content = getTemplate(tool.id);
+    const filePath = tool.outputPath;
+    const fileExists = existsSync(filePath);
+    s.stop(`Generated ${tool.name} rules.`);
+    if (fileExists && !opts.force) {
+      const existingContent = readFileSync(filePath, "utf-8");
+      if (opts.merge) {
+        writeFile(filePath, mergeSection(existingContent, content));
+        p.log.success(
+          `${pc5.green("Merged")} Directive section into ${pc5.dim(relative(targetDir, filePath))}`
+        );
+        continue;
+      }
+      if (hasDirectiveSection(existingContent)) {
+        const action = await p.select({
+          message: `${relative(targetDir, filePath)} already has a Directive section. What should we do?`,
+          options: [
+            {
+              value: "merge",
+              label: "Update Directive section only",
+              hint: "recommended"
+            },
+            { value: "overwrite", label: "Overwrite entire file" },
+            { value: "skip", label: "Skip this file" }
+          ]
+        });
+        if (p.isCancel(action)) {
+          p.cancel("Cancelled.");
+          process.exit(0);
+        }
+        if (action === "merge") {
+          writeFile(filePath, mergeSection(existingContent, content));
+          p.log.success(
+            `${pc5.green("Updated")} ${pc5.dim(relative(targetDir, filePath))}`
+          );
+        } else if (action === "overwrite") {
+          writeFile(filePath, content);
+          p.log.success(
+            `${pc5.green("Wrote")} ${pc5.dim(relative(targetDir, filePath))}`
+          );
+        } else {
+          p.log.info(`Skipped ${pc5.dim(relative(targetDir, filePath))}`);
+        }
+      } else {
+        const action = await p.select({
+          message: `${relative(targetDir, filePath)} already exists. What should we do?`,
+          options: [
+            {
+              value: "append",
+              label: "Append Directive section",
+              hint: "preserves existing content"
+            },
+            { value: "overwrite", label: "Overwrite entire file" },
+            { value: "skip", label: "Skip this file" }
+          ]
+        });
+        if (p.isCancel(action)) {
+          p.cancel("Cancelled.");
+          process.exit(0);
+        }
+        if (action === "append") {
+          writeFile(filePath, mergeSection(existingContent, content));
+          p.log.success(
+            `${pc5.green("Appended")} to ${pc5.dim(relative(targetDir, filePath))}`
+          );
+        } else if (action === "overwrite") {
+          writeFile(filePath, content);
+          p.log.success(
+            `${pc5.green("Wrote")} ${pc5.dim(relative(targetDir, filePath))}`
+          );
+        } else {
+          p.log.info(`Skipped ${pc5.dim(relative(targetDir, filePath))}`);
+        }
+      }
+    } else {
+      writeFile(filePath, content);
+      p.log.success(
+        `${pc5.green("Created")} ${pc5.dim(relative(targetDir, filePath))}`
+      );
+    }
+  }
+  p.outro(
+    `Done! Run ${pc5.cyan(`${CLI_NAME} ai-rules init --merge`)} anytime to update.`
+  );
+}
+function writeFile(filePath, content) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, content, "utf-8");
+}
+async function aiRulesUpdateCommand(args) {
+  const opts = parseArgs(args);
+  const targetDir = opts.dir;
+  const ruleFiles = [
+    { id: "cursor", path: join(targetDir, ".cursorrules") },
+    { id: "claude", path: join(targetDir, ".claude/CLAUDE.md") },
+    { id: "copilot", path: join(targetDir, ".github/copilot-instructions.md") },
+    { id: "windsurf", path: join(targetDir, ".windsurfrules") },
+    { id: "cline", path: join(targetDir, ".clinerules") }
+  ];
+  let updated = 0;
+  for (const file of ruleFiles) {
+    if (!existsSync(file.path)) {
+      continue;
+    }
+    const existing = readFileSync(file.path, "utf-8");
+    if (!hasDirectiveSection(existing)) {
+      continue;
+    }
+    const newContent = getTemplate(file.id);
+    const merged = mergeSection(existing, newContent);
+    writeFile(file.path, merged);
+    console.log(
+      `${pc5.green("Updated")} ${pc5.dim(relative(targetDir, file.path))}`
+    );
+    updated++;
+  }
+  if (updated === 0) {
+    console.log(
+      pc5.dim(
+        `No existing rule files found. Run ${pc5.cyan(`${CLI_NAME} ai-rules init`)} first.`
+      )
+    );
+  } else {
+    console.log(
+      pc5.green(`
+Updated ${updated} file(s) to latest knowledge version.`)
+    );
+  }
+}
+async function aiRulesCheckCommand(args) {
+  const opts = parseArgs(args);
+  const targetDir = opts.dir;
+  const ruleFiles = [
+    { id: "cursor", path: join(targetDir, ".cursorrules"), name: "Cursor" },
+    { id: "claude", path: join(targetDir, ".claude/CLAUDE.md"), name: "Claude Code" },
+    { id: "copilot", path: join(targetDir, ".github/copilot-instructions.md"), name: "GitHub Copilot" },
+    { id: "windsurf", path: join(targetDir, ".windsurfrules"), name: "Windsurf" },
+    { id: "cline", path: join(targetDir, ".clinerules"), name: "Cline" }
+  ];
+  let checked = 0;
+  let stale = 0;
+  for (const file of ruleFiles) {
+    if (!existsSync(file.path)) {
+      continue;
+    }
+    const existing = readFileSync(file.path, "utf-8");
+    if (!hasDirectiveSection(existing)) {
+      continue;
+    }
+    checked++;
+    const freshContent = getTemplate(file.id);
+    const merged = mergeSection(existing, freshContent);
+    if (merged !== existing) {
+      console.log(`${pc5.red("\u2717")} ${file.name} rules are ${pc5.yellow("stale")}`);
+      stale++;
+    } else {
+      console.log(`${pc5.green("\u2713")} ${file.name} rules are ${pc5.green("current")}`);
+    }
+  }
+  if (checked === 0) {
+    console.log(pc5.dim("No rule files found to check."));
+    return;
+  }
+  if (stale > 0) {
+    console.log(
+      `
+${pc5.yellow(`${stale} file(s) are stale.`)} Run ${pc5.cyan(`${CLI_NAME} ai-rules update`)} to refresh.`
+    );
+    process.exit(1);
+  } else {
+    console.log(pc5.green("\nAll rule files are current."));
+  }
+}
+function parseArgs2(args) {
+  const opts = {
+    dir: process.cwd(),
+    noInteractive: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--template": {
+        const val = args[++i];
+        if (val) {
+          opts.template = val;
+        }
+        break;
+      }
+      case "--dir": {
+        const val = args[++i];
+        if (val) {
+          opts.dir = val;
+        }
+        break;
+      }
+      case "--no-interactive":
+        opts.noInteractive = true;
+        break;
+    }
+  }
+  return opts;
+}
+function detectPackageManager(dir) {
+  if (existsSync(join(dir, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (existsSync(join(dir, "bun.lockb")) || existsSync(join(dir, "bun.lock"))) {
+    return "bun";
+  }
+  if (existsSync(join(dir, "yarn.lock"))) {
+    return "yarn";
+  }
+  return "npm";
+}
+function installCmd(pm, pkg) {
+  switch (pm) {
+    case "pnpm":
+      return `pnpm add ${pkg}`;
+    case "yarn":
+      return `yarn add ${pkg}`;
+    case "bun":
+      return `bun add ${pkg}`;
+    default:
+      return `npm install ${pkg}`;
+  }
+}
+function getTemplates(moduleName) {
+  return {
+    counter: {
+      id: "counter",
+      label: "Counter (minimal)",
+      hint: "schema + init + derive + events \u2014 simplest starting point",
+      files: [
+        {
+          path: `src/${moduleName}.ts`,
+          content: generateCounterModule(moduleName)
+        },
+        {
+          path: "src/main.ts",
+          content: generateCounterMain(moduleName)
+        }
+      ],
+      deps: ["@directive-run/core"]
+    },
+    "auth-flow": {
+      id: "auth-flow",
+      label: "Auth flow (constraints + resolvers)",
+      hint: "login flow with constraints, resolvers, retry, and effects",
+      files: [
+        {
+          path: `src/${moduleName}.ts`,
+          content: generateAuthModule(moduleName)
+        },
+        {
+          path: "src/main.ts",
+          content: generateAuthMain(moduleName)
+        }
+      ],
+      deps: ["@directive-run/core"]
+    },
+    "ai-orchestrator": {
+      id: "ai-orchestrator",
+      label: "AI orchestrator",
+      hint: "agent orchestrator with guardrails and streaming",
+      files: [
+        {
+          path: `src/${moduleName}.ts`,
+          content: generateAIModule(moduleName)
+        },
+        {
+          path: "src/main.ts",
+          content: generateAIMain(moduleName)
+        }
+      ],
+      deps: ["@directive-run/core", "@directive-run/ai"]
+    }
+  };
+}
+function generateCounterModule(name) {
+  const camelName = toCamelCase(name);
+  return `import { type ModuleSchema, createModule, t } from "@directive-run/core";
+
+const schema = {
+  facts: {
+    count: t.number(),
+    label: t.string(),
+  },
+  derivations: {
+    isEven: t.boolean(),
+    display: t.string(),
+  },
+  events: {
+    increment: {},
+    decrement: {},
+    reset: {},
+    setLabel: { value: t.string() },
+  },
+} satisfies ModuleSchema;
+
+export const ${camelName} = createModule("${name}", {
+  schema,
+
+  init: (facts) => {
+    facts.count = 0;
+    facts.label = "${name}";
+  },
+
+  derive: {
+    isEven: (facts) => facts.count % 2 === 0,
+    display: (facts) => \`\${facts.label}: \${facts.count}\`,
+  },
+
+  events: {
+    increment: (facts) => {
+      facts.count++;
+    },
+    decrement: (facts) => {
+      facts.count--;
+    },
+    reset: (facts) => {
+      facts.count = 0;
+    },
+    setLabel: (facts, { value }) => {
+      facts.label = value;
+    },
+  },
+});
+`;
+}
+function generateCounterMain(name) {
+  const camelName = toCamelCase(name);
+  return `import { createSystem } from "@directive-run/core";
+import { ${camelName} } from "./${name}.js";
+
+const system = createSystem({
+  module: ${camelName},
+});
+
+system.start();
+
+// Read facts and derivations
+console.log("count:", system.facts.count);
+console.log("display:", system.read("display"));
+
+// Dispatch events
+system.events.increment();
+console.log("after increment:", system.facts.count);
+
+// Subscribe to changes
+system.subscribe(["count"], () => {
+  console.log("count changed:", system.facts.count);
+});
+
+system.events.increment();
+system.events.increment();
+
+export default system;
+`;
+}
+function generateAuthModule(name) {
+  const camelName = toCamelCase(name);
+  return `import { type ModuleSchema, createModule, t } from "@directive-run/core";
+
+type AuthStatus = "idle" | "authenticating" | "authenticated" | "expired";
+
+const schema = {
+  facts: {
+    email: t.string(),
+    password: t.string(),
+    token: t.string(),
+    status: t.string<AuthStatus>(),
+    error: t.string(),
+  },
+  derivations: {
+    isAuthenticated: t.boolean(),
+    canLogin: t.boolean(),
+  },
+  events: {
+    setEmail: { value: t.string() },
+    setPassword: { value: t.string() },
+    requestLogin: {},
+    logout: {},
+  },
+  requirements: {
+    LOGIN: { email: t.string(), password: t.string() },
+  },
+} satisfies ModuleSchema;
+
+export const ${camelName} = createModule("${name}", {
+  schema,
+
+  init: (facts) => {
+    facts.email = "";
+    facts.password = "";
+    facts.token = "";
+    facts.status = "idle";
+    facts.error = "";
+  },
+
+  derive: {
+    isAuthenticated: (facts) => facts.status === "authenticated",
+    canLogin: (facts) => {
+      return (
+        facts.email.trim() !== "" &&
+        facts.password.trim() !== "" &&
+        (facts.status === "idle" || facts.status === "expired")
+      );
+    },
+  },
+
+  events: {
+    setEmail: (facts, { value }) => {
+      facts.email = value;
+    },
+    setPassword: (facts, { value }) => {
+      facts.password = value;
+    },
+    requestLogin: (facts) => {
+      facts.status = "authenticating";
+      facts.error = "";
+    },
+    logout: (facts) => {
+      facts.token = "";
+      facts.status = "idle";
+    },
+  },
+
+  constraints: {
+    needsLogin: {
+      priority: 100,
+      when: (facts) => facts.status === "authenticating",
+      require: (facts) => ({
+        type: "LOGIN",
+        email: facts.email,
+        password: facts.password,
+      }),
+    },
+  },
+
+  resolvers: {
+    login: {
+      requirement: "LOGIN",
+      retry: { attempts: 2, backoff: "exponential" },
+      resolve: async (req, context) => {
+        // Replace with real auth API call
+        await new Promise((resolve) => setTimeout(resolve, 500));
+
+        const token = \`token_\${Date.now()}\`;
+        context.facts.token = token;
+        context.facts.status = "authenticated";
+      },
+    },
+  },
+
+  effects: {
+    logStatusChange: {
+      deps: ["status"],
+      run: (facts, prev) => {
+        if (prev && prev.status !== facts.status) {
+          console.log(\`Auth status: \${prev.status} \u2192 \${facts.status}\`);
+        }
+      },
+    },
+  },
+});
+`;
+}
+function generateAuthMain(name) {
+  const camelName = toCamelCase(name);
+  return `import { createSystem } from "@directive-run/core";
+import { ${camelName} } from "./${name}.js";
+
+const system = createSystem({
+  module: ${camelName},
+});
+
+system.start();
+
+// Set credentials and login
+system.events.setEmail({ value: "user@example.com" });
+system.events.setPassword({ value: "password123" });
+system.events.requestLogin();
+
+// Wait for auth to complete
+await system.settle();
+
+console.log("authenticated:", system.read("isAuthenticated"));
+console.log("token:", system.facts.token);
+
+export default system;
+`;
+}
+function generateAIModule(name) {
+  const camelName = toCamelCase(name);
+  return `import { type ModuleSchema, createModule, t } from "@directive-run/core";
+import {
+  createAgentOrchestrator,
+  createAgentMemory,
+  createSlidingWindowStrategy,
+} from "@directive-run/ai";
+
+// ============================================================================
+// Module \u2014 state management
+// ============================================================================
+
+type AgentStatus = "idle" | "thinking" | "done" | "error";
+
+const schema = {
+  facts: {
+    input: t.string(),
+    output: t.string(),
+    status: t.string<AgentStatus>(),
+    error: t.string(),
+  },
+  derivations: {
+    isThinking: t.boolean(),
+    hasOutput: t.boolean(),
+  },
+  events: {
+    setInput: { value: t.string() },
+    requestRun: {},
+    reset: {},
+  },
+  requirements: {
+    RUN_AGENT: { input: t.string() },
+  },
+} satisfies ModuleSchema;
+
+export const ${camelName} = createModule("${name}", {
+  schema,
+
+  init: (facts) => {
+    facts.input = "";
+    facts.output = "";
+    facts.status = "idle";
+    facts.error = "";
+  },
+
+  derive: {
+    isThinking: (facts) => facts.status === "thinking",
+    hasOutput: (facts) => facts.output !== "",
+  },
+
+  events: {
+    setInput: (facts, { value }) => {
+      facts.input = value;
+    },
+    requestRun: (facts) => {
+      facts.status = "thinking";
+      facts.output = "";
+      facts.error = "";
+    },
+    reset: (facts) => {
+      facts.input = "";
+      facts.output = "";
+      facts.status = "idle";
+      facts.error = "";
+    },
+  },
+
+  constraints: {
+    needsRun: {
+      priority: 100,
+      when: (facts) => facts.status === "thinking",
+      require: (facts) => ({
+        type: "RUN_AGENT",
+        input: facts.input,
+      }),
+    },
+  },
+
+  resolvers: {
+    runAgent: {
+      requirement: "RUN_AGENT",
+      timeout: 30000,
+      resolve: async (req, context) => {
+        // Replace with your agent runner (e.g., Anthropic, OpenAI)
+        const result = \`Echo: \${req.input}\`;
+
+        context.facts.output = result;
+        context.facts.status = "done";
+      },
+    },
+  },
+});
+
+// ============================================================================
+// Orchestrator \u2014 optional AI features
+// ============================================================================
+
+export const memory = createAgentMemory({
+  strategy: createSlidingWindowStrategy(),
+  strategyConfig: { maxMessages: 30, preserveRecentCount: 6 },
+  autoManage: true,
+});
+
+// Uncomment to add orchestrator features:
+// export const orchestrator = createAgentOrchestrator({
+//   runner: yourAgentRunner,
+//   maxTokenBudget: 50000,
+//   memory,
+// });
+`;
+}
+function generateAIMain(name) {
+  const camelName = toCamelCase(name);
+  return `import { createSystem } from "@directive-run/core";
+import { ${camelName} } from "./${name}.js";
+
+const system = createSystem({
+  module: ${camelName},
+});
+
+system.start();
+
+// Set input and run
+system.events.setInput({ value: "Hello, world!" });
+system.events.requestRun();
+
+// Wait for completion
+await system.settle();
+
+console.log("output:", system.facts.output);
+
+export default system;
+`;
+}
+function toCamelCase(name) {
+  return name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function writeFile2(filePath, content) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, content, "utf-8");
+}
+async function initCommand(args) {
+  const opts = parseArgs2(args);
+  p.intro(pc5.bgCyan(pc5.black(" directive init ")));
+  let moduleName;
+  if (opts.noInteractive) {
+    moduleName = "my-module";
+  } else {
+    const nameResult = await p.text({
+      message: "Module name:",
+      placeholder: "my-module",
+      defaultValue: "my-module",
+      validate: (val) => {
+        if (!/^[a-z][a-z0-9-]*$/.test(val)) {
+          return "Must start with a letter, use lowercase letters, numbers, and hyphens";
+        }
+      }
+    });
+    if (p.isCancel(nameResult)) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+    moduleName = nameResult;
+  }
+  let templateId;
+  if (opts.template) {
+    const templates2 = getTemplates(moduleName);
+    if (!(opts.template in templates2)) {
+      p.log.error(
+        `Unknown template: ${opts.template}. Available: ${Object.keys(templates2).join(", ")}`
+      );
+      process.exit(1);
+    }
+    templateId = opts.template;
+  } else if (opts.noInteractive) {
+    templateId = "counter";
+  } else {
+    const templates2 = getTemplates(moduleName);
+    const choice = await p.select({
+      message: "Project template:",
+      options: Object.values(templates2).map((t) => ({
+        value: t.id,
+        label: t.label,
+        hint: t.hint
+      }))
+    });
+    if (p.isCancel(choice)) {
+      p.cancel("Cancelled.");
+      process.exit(0);
+    }
+    templateId = choice;
+  }
+  const templates = getTemplates(moduleName);
+  const template = templates[templateId];
+  const pm = detectPackageManager(opts.dir);
+  p.log.info(`Package manager: ${pc5.cyan(pm)}`);
+  const s = p.spinner();
+  s.start("Creating project files...");
+  let skipped = 0;
+  for (const file of template.files) {
+    const filePath = join(opts.dir, file.path);
+    if (existsSync(filePath)) {
+      skipped++;
+      continue;
+    }
+    writeFile2(filePath, file.content);
+  }
+  s.stop("Project files created.");
+  for (const file of template.files) {
+    const filePath = join(opts.dir, file.path);
+    const rel = relative(opts.dir, filePath);
+    if (existsSync(filePath)) {
+      p.log.success(`${pc5.green("Created")} ${pc5.dim(rel)}`);
+    }
+  }
+  if (skipped > 0) {
+    p.log.warn(`Skipped ${skipped} file(s) that already exist.`);
+  }
+  const depsCmd = installCmd(pm, template.deps.join(" "));
+  p.outro(
+    `Next steps:
+  ${pc5.cyan(depsCmd)}
+  ${pc5.cyan(`${CLI_NAME} ai-rules init`)}
+  ${pc5.dim("Start building!")}`
+  );
+}
+function parseArgs3(args) {
+  const opts = {
+    with: [],
+    minimal: false,
+    dir: process.cwd()
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--with": {
+        const val = args[++i];
+        if (val) {
+          opts.with = val.split(",").map((s) => s.trim());
+        }
+        break;
+      }
+      case "--minimal":
+        opts.minimal = true;
+        break;
+      case "--dir": {
+        const val = args[++i];
+        if (val) {
+          opts.dir = val;
+        }
+        break;
+      }
+    }
+  }
+  return opts;
+}
+var ALL_SECTIONS = [
+  "derive",
+  "events",
+  "constraints",
+  "resolvers",
+  "effects"
+];
+function generateModule(name, sections) {
+  const camelName = toCamelCase2(name);
+  const hasConstraints = sections.includes("constraints");
+  const hasResolvers = sections.includes("resolvers");
+  const imports = ["type ModuleSchema", "createModule", "t"];
+  let code = `import { ${imports.join(", ")} } from "@directive-run/core";
+
+`;
+  code += `const schema = {
+`;
+  code += `  facts: {
+`;
+  code += `    // Add your facts here
+`;
+  code += `    status: t.string(),
+`;
+  code += `  },
+`;
+  if (sections.includes("derive")) {
+    code += `  derivations: {
+`;
+    code += `    // Add derivation types here
+`;
+    code += `    isReady: t.boolean(),
+`;
+    code += `  },
+`;
+  }
+  if (sections.includes("events")) {
+    code += `  events: {
+`;
+    code += `    // Add event shapes here
+`;
+    code += `    setStatus: { value: t.string() },
+`;
+    code += `  },
+`;
+  }
+  if (hasConstraints || hasResolvers) {
+    code += `  requirements: {
+`;
+    code += `    // Add requirement shapes here
+`;
+    code += `    PROCESS: { input: t.string() },
+`;
+    code += `  },
+`;
+  }
+  code += `} satisfies ModuleSchema;
+
+`;
+  code += `export const ${camelName} = createModule("${name}", {
+`;
+  code += `  schema,
+
+`;
+  code += `  init: (facts) => {
+`;
+  code += `    facts.status = "idle";
+`;
+  code += `  },
+`;
+  if (sections.includes("derive")) {
+    code += `
+  derive: {
+`;
+    code += `    isReady: (facts) => facts.status === "ready",
+`;
+    code += `  },
+`;
+  }
+  if (sections.includes("events")) {
+    code += `
+  events: {
+`;
+    code += `    setStatus: (facts, { value }) => {
+`;
+    code += `      facts.status = value;
+`;
+    code += `    },
+`;
+    code += `  },
+`;
+  }
+  if (hasConstraints) {
+    code += `
+  constraints: {
+`;
+    code += `    needsProcessing: {
+`;
+    code += `      priority: 100,
+`;
+    code += `      when: (facts) => facts.status === "pending",
+`;
+    code += `      require: (facts) => ({
+`;
+    code += `        type: "PROCESS",
+`;
+    code += `        input: facts.status,
+`;
+    code += `      }),
+`;
+    code += `    },
+`;
+    code += `  },
+`;
+  }
+  if (hasResolvers) {
+    code += `
+  resolvers: {
+`;
+    code += `    process: {
+`;
+    code += `      requirement: "PROCESS",
+`;
+    code += `      resolve: async (req, context) => {
+`;
+    code += `        // Implement resolution logic here
+`;
+    code += `        context.facts.status = "done";
+`;
+    code += `      },
+`;
+    code += `    },
+`;
+    code += `  },
+`;
+  }
+  if (sections.includes("effects")) {
+    code += `
+  effects: {
+`;
+    code += `    logChange: {
+`;
+    code += `      deps: ["status"],
+`;
+    code += `      run: (facts, prev) => {
+`;
+    code += `        if (prev && prev.status !== facts.status) {
+`;
+    code += `          console.log(\`Status: \${prev.status} \u2192 \${facts.status}\`);
+`;
+    code += `        }
+`;
+    code += `      },
+`;
+    code += `    },
+`;
+    code += `  },
+`;
+  }
+  code += `});
+`;
+  return code;
+}
+function generateOrchestrator(name) {
+  const camelName = toCamelCase2(name);
+  return `import { type ModuleSchema, createModule, createSystem, t } from "@directive-run/core";
+import {
+  createAgentOrchestrator,
+  createAgentMemory,
+  createSlidingWindowStrategy,
+} from "@directive-run/ai";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+type AgentStatus = "idle" | "thinking" | "done" | "error";
+
+// ============================================================================
+// Schema
+// ============================================================================
+
+const schema = {
+  facts: {
+    input: t.string(),
+    output: t.string(),
+    status: t.string<AgentStatus>(),
+    error: t.string(),
+    totalTokens: t.number(),
+  },
+  derivations: {
+    isThinking: t.boolean(),
+    hasOutput: t.boolean(),
+  },
+  events: {
+    setInput: { value: t.string() },
+    requestRun: {},
+    reset: {},
+  },
+  requirements: {
+    RUN_AGENT: { input: t.string() },
+  },
+} satisfies ModuleSchema;
+
+// ============================================================================
+// Module
+// ============================================================================
+
+export const ${camelName} = createModule("${name}", {
+  schema,
+
+  init: (facts) => {
+    facts.input = "";
+    facts.output = "";
+    facts.status = "idle";
+    facts.error = "";
+    facts.totalTokens = 0;
+  },
+
+  derive: {
+    isThinking: (facts) => facts.status === "thinking",
+    hasOutput: (facts) => facts.output !== "",
+  },
+
+  events: {
+    setInput: (facts, { value }) => {
+      facts.input = value;
+    },
+    requestRun: (facts) => {
+      facts.status = "thinking";
+      facts.output = "";
+      facts.error = "";
+    },
+    reset: (facts) => {
+      facts.input = "";
+      facts.output = "";
+      facts.status = "idle";
+      facts.error = "";
+      facts.totalTokens = 0;
+    },
+  },
+
+  constraints: {
+    needsRun: {
+      priority: 100,
+      when: (facts) => facts.status === "thinking",
+      require: (facts) => ({
+        type: "RUN_AGENT",
+        input: facts.input,
+      }),
+    },
+  },
+
+  resolvers: {
+    runAgent: {
+      requirement: "RUN_AGENT",
+      timeout: 30000,
+      resolve: async (req, context) => {
+        // TODO: Replace with your agent runner
+        const result = \`Echo: \${req.input}\`;
+
+        context.facts.output = result;
+        context.facts.status = "done";
+      },
+    },
+  },
+});
+
+// ============================================================================
+// AI Features
+// ============================================================================
+
+export const memory = createAgentMemory({
+  strategy: createSlidingWindowStrategy(),
+  strategyConfig: { maxMessages: 30, preserveRecentCount: 6 },
+  autoManage: true,
+});
+
+// TODO: Add your agent runner and configure the orchestrator
+// export const orchestrator = createAgentOrchestrator({
+//   runner: yourAgentRunner,
+//   maxTokenBudget: 50000,
+//   memory,
+//   guardrails: {
+//     input: [],
+//     output: [],
+//   },
+// });
+
+// ============================================================================
+// System
+// ============================================================================
+
+export const system = createSystem({
+  module: ${camelName},
+});
+`;
+}
+function toCamelCase2(name) {
+  return name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function writeFile3(filePath, content) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, content, "utf-8");
+}
+function findModulesDir(dir) {
+  if (existsSync(join(dir, "src"))) {
+    return join(dir, "src");
+  }
+  return join(dir, "src");
+}
+async function newModuleCommand(name, args) {
+  const opts = parseArgs3(args);
+  if (!name || !/^[a-z][a-z0-9-]*$/.test(name)) {
+    console.error(
+      `Invalid module name: ${name || "(none)"}
+Must start with a letter, use lowercase letters, numbers, and hyphens.`
+    );
+    process.exit(1);
+  }
+  let sections;
+  if (opts.minimal) {
+    sections = [];
+  } else if (opts.with.length > 0) {
+    sections = opts.with.filter(
+      (s) => ALL_SECTIONS.includes(s)
+    );
+  } else {
+    sections = ALL_SECTIONS;
+  }
+  const targetDir = findModulesDir(opts.dir);
+  const filePath = join(targetDir, `${name}.ts`);
+  if (existsSync(filePath)) {
+    console.error(`File already exists: ${relative(opts.dir, filePath)}`);
+    process.exit(1);
+  }
+  const content = generateModule(name, sections);
+  writeFile3(filePath, content);
+  const rel = relative(opts.dir, filePath);
+  console.log(`${pc5.green("Created")} ${pc5.dim(rel)}`);
+  if (sections.length === 0) {
+    console.log(pc5.dim("  Minimal module (schema + init only)"));
+  } else {
+    console.log(pc5.dim(`  Sections: ${sections.join(", ")}`));
+  }
+}
+async function newOrchestratorCommand(name, args) {
+  const opts = parseArgs3(args);
+  if (!name || !/^[a-z][a-z0-9-]*$/.test(name)) {
+    console.error(
+      `Invalid orchestrator name: ${name || "(none)"}
+Must start with a letter, use lowercase letters, numbers, and hyphens.`
+    );
+    process.exit(1);
+  }
+  const targetDir = findModulesDir(opts.dir);
+  const filePath = join(targetDir, `${name}.ts`);
+  if (existsSync(filePath)) {
+    console.error(`File already exists: ${relative(opts.dir, filePath)}`);
+    process.exit(1);
+  }
+  const content = generateOrchestrator(name);
+  writeFile3(filePath, content);
+  const rel = relative(opts.dir, filePath);
+  console.log(`${pc5.green("Created")} ${pc5.dim(rel)}`);
+  console.log(pc5.dim("  AI orchestrator with memory, guardrails, and streaming"));
+}
+async function loadSystem(filePath) {
+  const resolved = resolve(filePath);
+  if (!existsSync(resolved)) {
+    throw new Error(`File not found: ${resolved}`);
+  }
+  try {
+    const mod = await import(resolved);
+    if (mod.default && isSystem(mod.default)) {
+      return mod.default;
+    }
+    if (mod.system && isSystem(mod.system)) {
+      return mod.system;
+    }
+    for (const key of Object.keys(mod)) {
+      if (isSystem(mod[key])) {
+        return mod[key];
+      }
+    }
+    throw new Error(
+      `No Directive system found in ${pc5.dim(filePath)}
+Export a system as default or named "system":
+
+  ${pc5.cyan("export default")} createSystem({ module: myModule });
+  ${pc5.cyan("export const system")} = createSystem({ module: myModule });`
+    );
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("No Directive system")) {
+      throw err;
+    }
+    throw new Error(
+      `Failed to load ${pc5.dim(filePath)}: ${err instanceof Error ? err.message : String(err)}
+
+Make sure the file is valid TypeScript and tsx is installed:
+  ${pc5.cyan("npm install -D tsx")}`
+    );
+  }
+}
+function isSystem(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  const sys = obj;
+  return typeof sys.inspect === "function" && typeof sys.start === "function" && typeof sys.stop === "function" && "facts" in sys;
+}
+
+// src/commands/inspect.ts
+function parseArgs4(args) {
+  const opts = { json: false };
+  let filePath = "";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--json":
+        opts.json = true;
+        break;
+      case "--module": {
+        const val = args[++i];
+        if (val) {
+          opts.module = val;
+        }
+        break;
+      }
+      default:
+        if (arg && !arg.startsWith("-") && !filePath) {
+          filePath = arg;
+        }
+    }
+  }
+  return { filePath, opts };
+}
+function formatFacts(facts) {
+  const lines = [];
+  lines.push(pc5.bold("Facts:"));
+  const entries = Object.entries(facts);
+  if (entries.length === 0) {
+    lines.push("  (none)");
+    return lines.join("\n");
+  }
+  for (const [key, value] of entries) {
+    const formatted = formatValue(value);
+    lines.push(`  ${pc5.cyan(key)} = ${formatted}`);
+  }
+  return lines.join("\n");
+}
+function formatConstraints(constraints) {
+  const lines = [];
+  lines.push(pc5.bold("Constraints:"));
+  if (constraints.length === 0) {
+    lines.push("  (none)");
+    return lines.join("\n");
+  }
+  for (const c of constraints) {
+    const status = c.disabled ? pc5.dim("disabled") : c.active ? pc5.green("active") : pc5.dim("inactive");
+    const hits = c.hitCount > 0 ? pc5.yellow(` (${c.hitCount} hits)`) : "";
+    lines.push(
+      `  ${pc5.cyan(c.id)}  ${status}  priority=${c.priority}${hits}`
+    );
+  }
+  return lines.join("\n");
+}
+function formatResolverDefs(resolverDefs, resolvers) {
+  const lines = [];
+  lines.push(pc5.bold("Resolvers:"));
+  if (resolverDefs.length === 0) {
+    lines.push("  (none)");
+    return lines.join("\n");
+  }
+  for (const def of resolverDefs) {
+    const status = resolvers[def.id];
+    const stateStr = status ? formatResolverState(status.state, status.error, status.duration) : pc5.dim("idle");
+    lines.push(
+      `  ${pc5.cyan(def.id)} \u2192 ${def.requirement}  ${stateStr}`
+    );
+  }
+  return lines.join("\n");
+}
+function formatUnmet(unmet) {
+  const lines = [];
+  lines.push(pc5.bold("Unmet Requirements:"));
+  if (unmet.length === 0) {
+    lines.push(`  ${pc5.green("(all requirements met)")}`);
+    return lines.join("\n");
+  }
+  for (const u of unmet) {
+    lines.push(
+      `  ${pc5.yellow(u.requirement.type)} (id: ${pc5.dim(u.id)})  from ${pc5.dim(u.fromConstraint)}`
+    );
+  }
+  return lines.join("\n");
+}
+function formatInflight(inflight) {
+  const lines = [];
+  lines.push(pc5.bold("Inflight:"));
+  if (inflight.length === 0) {
+    lines.push(`  ${pc5.green("(none)")}`);
+    return lines.join("\n");
+  }
+  const now = Date.now();
+  for (const inf of inflight) {
+    const elapsed = now - inf.startedAt;
+    lines.push(
+      `  ${pc5.cyan(inf.resolverId)} \u2192 req ${pc5.dim(inf.id)}  ${pc5.yellow(`${elapsed}ms`)}`
+    );
+  }
+  return lines.join("\n");
+}
+function formatResolverState(state, error, duration) {
+  const dur = duration !== void 0 ? ` ${duration}ms` : "";
+  switch (state) {
+    case "resolved":
+      return pc5.green(`resolved${dur}`);
+    case "errored":
+      return pc5.red(`errored${dur}${error ? ` \u2014 ${error}` : ""}`);
+    case "inflight":
+      return pc5.yellow("inflight");
+    case "cancelled":
+      return pc5.dim("cancelled");
+    default:
+      return pc5.dim(state);
+  }
+}
+function formatValue(value) {
+  if (value === null) {
+    return pc5.dim("null");
+  }
+  if (value === void 0) {
+    return pc5.dim("undefined");
+  }
+  if (typeof value === "string") {
+    return value.length > 60 ? `"${value.slice(0, 57)}..."` : `"${value}"`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.length} items]`;
+  }
+  return JSON.stringify(value).slice(0, 60);
+}
+function findWarnings(inspection) {
+  const warnings = [];
+  new Set(inspection.unmet.map((u) => u.requirement.type));
+  new Set(
+    inspection.resolverDefs.map((r) => r.requirement)
+  );
+  for (const def of inspection.resolverDefs) {
+    if (def.requirement === "(predicate)") {
+      continue;
+    }
+  }
+  for (const u of inspection.unmet) {
+    const hasResolver = inspection.resolverDefs.some(
+      (r) => r.requirement === u.requirement.type || r.requirement === "(predicate)"
+    );
+    if (!hasResolver) {
+      warnings.push(
+        `No resolver for requirement type "${u.requirement.type}"`
+      );
+    }
+  }
+  return warnings;
+}
+async function inspectCommand(args) {
+  const { filePath, opts } = parseArgs4(args);
+  if (!filePath) {
+    console.error(
+      "Usage: directive inspect <file> [--json] [--module <name>]"
+    );
+    process.exit(1);
+  }
+  const system = await loadSystem(filePath);
+  if (!system.isRunning) {
+    system.start();
+  }
+  const inspection = system.inspect();
+  if (opts.json) {
+    const factsObj2 = {};
+    if (system.facts) {
+      for (const key of Object.keys(system.facts)) {
+        try {
+          factsObj2[key] = system.facts[key];
+        } catch {
+          factsObj2[key] = "(error reading)";
+        }
+      }
+    }
+    console.log(
+      JSON.stringify(
+        {
+          facts: factsObj2,
+          ...inspection
+        },
+        null,
+        2
+      )
+    );
+    system.stop();
+    return;
+  }
+  console.log();
+  console.log(pc5.bold(pc5.cyan("Directive System Inspection")));
+  console.log(pc5.dim("\u2500".repeat(40)));
+  console.log();
+  const factsObj = {};
+  if (system.facts) {
+    for (const key of Object.keys(system.facts)) {
+      try {
+        factsObj[key] = system.facts[key];
+      } catch {
+        factsObj[key] = "(error reading)";
+      }
+    }
+  }
+  console.log(formatFacts(factsObj));
+  console.log();
+  console.log(formatConstraints(inspection.constraints));
+  console.log();
+  console.log(formatResolverDefs(inspection.resolverDefs, inspection.resolvers));
+  console.log();
+  console.log(formatUnmet(inspection.unmet));
+  console.log();
+  if (inspection.inflight.length > 0) {
+    console.log(formatInflight(inspection.inflight));
+    console.log();
+  }
+  const warnings = findWarnings(inspection);
+  if (warnings.length > 0) {
+    console.log(pc5.bold(pc5.yellow("Warnings:")));
+    for (const w of warnings) {
+      console.log(`  ${pc5.yellow("\u26A0")} ${w}`);
+    }
+    console.log();
+  }
+  system.stop();
+}
+function parseArgs5(args) {
+  const opts = {};
+  let filePath = "";
+  let requirementId;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--module": {
+        const val = args[++i];
+        if (val) {
+          opts.module = val;
+        }
+        break;
+      }
+      default:
+        if (arg && !arg.startsWith("-")) {
+          if (!filePath) {
+            filePath = arg;
+          } else if (!requirementId) {
+            requirementId = arg;
+          }
+        }
+    }
+  }
+  return { filePath, requirementId, opts };
+}
+async function explainCommand(args) {
+  const { filePath, requirementId } = parseArgs5(args);
+  if (!filePath) {
+    console.error(
+      "Usage: directive explain <file> [requirement-id]"
+    );
+    process.exit(1);
+  }
+  const system = await loadSystem(filePath);
+  if (!system.isRunning) {
+    system.start();
+  }
+  const inspection = system.inspect();
+  if (requirementId) {
+    const explanation = system.explain(requirementId);
+    if (!explanation) {
+      console.error(
+        `Requirement "${requirementId}" not found.
+
+Current requirements:`
+      );
+      if (inspection.unmet.length === 0) {
+        console.log(pc5.dim("  (no unmet requirements)"));
+      } else {
+        for (const u of inspection.unmet) {
+          console.log(
+            `  ${pc5.cyan(u.id)} \u2014 ${u.requirement.type} (from ${u.fromConstraint})`
+          );
+        }
+      }
+      system.stop();
+      process.exit(1);
+    }
+    console.log();
+    console.log(pc5.bold(pc5.cyan("Requirement Explanation")));
+    console.log(pc5.dim("\u2500".repeat(40)));
+    console.log();
+    console.log(explanation);
+    console.log();
+  } else {
+    console.log();
+    console.log(pc5.bold(pc5.cyan("All Requirements")));
+    console.log(pc5.dim("\u2500".repeat(40)));
+    console.log();
+    if (inspection.unmet.length === 0) {
+      console.log(pc5.green("All requirements are met."));
+      console.log();
+      const resolverEntries = Object.entries(
+        inspection.resolvers
+      );
+      if (resolverEntries.length > 0) {
+        console.log(pc5.bold("Recent Resolver Activity:"));
+        for (const [key, status] of resolverEntries) {
+          const state = formatState(status.state);
+          const dur = status.duration !== void 0 ? ` (${status.duration}ms)` : "";
+          console.log(`  ${pc5.cyan(key)}  ${state}${dur}`);
+        }
+        console.log();
+      }
+    } else {
+      console.log(
+        `${pc5.yellow(String(inspection.unmet.length))} unmet requirement(s):
+`
+      );
+      for (const u of inspection.unmet) {
+        console.log(
+          `${pc5.yellow("\u25CF")} ${pc5.bold(u.requirement.type)} (id: ${pc5.dim(u.id)})`
+        );
+        console.log(`  From constraint: ${pc5.cyan(u.fromConstraint)}`);
+        const payload = { ...u.requirement };
+        delete payload.type;
+        const payloadKeys = Object.keys(payload);
+        if (payloadKeys.length > 0) {
+          console.log(`  Payload: ${JSON.stringify(payload)}`);
+        }
+        const resolverStatus = inspection.resolvers[u.id];
+        if (resolverStatus) {
+          console.log(
+            `  Resolver: ${formatState(resolverStatus.state)}${resolverStatus.error ? ` \u2014 ${resolverStatus.error}` : ""}`
+          );
+        } else {
+          const hasResolver = inspection.resolverDefs.some(
+            (r) => r.requirement === u.requirement.type || r.requirement === "(predicate)"
+          );
+          if (!hasResolver) {
+            console.log(`  ${pc5.red("No resolver registered for this type")}`);
+          }
+        }
+        console.log();
+      }
+      console.log(
+        pc5.dim(
+          `Run ${pc5.cyan(`directive explain <file> <requirement-id>`)} for detailed explanation.`
+        )
+      );
+    }
+  }
+  system.stop();
+}
+function formatState(state) {
+  switch (state) {
+    case "resolved":
+      return pc5.green("resolved");
+    case "errored":
+      return pc5.red("errored");
+    case "inflight":
+      return pc5.yellow("inflight");
+    case "pending":
+      return pc5.yellow("pending");
+    case "cancelled":
+      return pc5.dim("cancelled");
+    default:
+      return pc5.dim(state);
+  }
+}
+function parseArgs6(args) {
+  const opts = { ascii: false, open: true };
+  let filePath = "";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    switch (arg) {
+      case "--ascii":
+        opts.ascii = true;
+        break;
+      case "--no-open":
+        opts.open = false;
+        break;
+      case "--output": {
+        const val = args[++i];
+        if (val) {
+          opts.output = val;
+        }
+        break;
+      }
+      default:
+        if (arg && !arg.startsWith("-") && !filePath) {
+          filePath = arg;
+        }
+    }
+  }
+  return { filePath, opts };
+}
+function renderAsciiGraph(inspection) {
+  const lines = [];
+  lines.push(pc5.bold("Dependency Graph"));
+  lines.push(pc5.dim("\u2550".repeat(50)));
+  lines.push("");
+  const constraintMap = /* @__PURE__ */ new Map();
+  for (const c of inspection.constraints) {
+    constraintMap.set(c.id, {
+      reqTypes: /* @__PURE__ */ new Set(),
+      active: c.active,
+      priority: c.priority
+    });
+  }
+  for (const u of inspection.unmet) {
+    const entry = constraintMap.get(u.fromConstraint);
+    if (entry) {
+      entry.reqTypes.add(u.requirement.type);
+    }
+  }
+  const resolversByType = /* @__PURE__ */ new Map();
+  for (const r of inspection.resolverDefs) {
+    if (!resolversByType.has(r.requirement)) {
+      resolversByType.set(r.requirement, []);
+    }
+    resolversByType.get(r.requirement).push(r.id);
+  }
+  lines.push(pc5.bold("Constraints \u2192 Requirements \u2192 Resolvers"));
+  lines.push("");
+  for (const [id, info] of constraintMap) {
+    const status = info.active ? pc5.green("\u25CF") : pc5.dim("\u25CB");
+    lines.push(`${status} ${pc5.cyan(id)} (priority: ${info.priority})`);
+    if (info.reqTypes.size > 0) {
+      for (const reqType of info.reqTypes) {
+        lines.push(`  \u2514\u2500\u25B6 ${pc5.yellow(reqType)}`);
+        const resolvers = resolversByType.get(reqType) || [];
+        if (resolvers.length > 0) {
+          for (const r of resolvers) {
+            lines.push(`      \u2514\u2500\u25B6 ${pc5.magenta(r)}`);
+          }
+        } else {
+          lines.push(`      \u2514\u2500\u25B6 ${pc5.red("(no resolver)")}`);
+        }
+      }
+    } else {
+      lines.push(`  \u2514\u2500\u25B6 ${pc5.dim("(no active requirements)")}`);
+    }
+    lines.push("");
+  }
+  const usedResolvers = /* @__PURE__ */ new Set();
+  for (const resolvers of resolversByType.values()) {
+    for (const r of resolvers) {
+      usedResolvers.add(r);
+    }
+  }
+  const allResolverIds = inspection.resolverDefs.map((r) => r.id);
+  const orphanedCount = allResolverIds.filter(
+    (r) => !usedResolvers.has(r)
+  ).length;
+  if (orphanedCount > 0) {
+    lines.push(pc5.bold("Standalone Resolvers:"));
+    for (const r of inspection.resolverDefs) {
+      if (!usedResolvers.has(r.id)) {
+        lines.push(
+          `  ${pc5.magenta(r.id)} handles ${pc5.yellow(r.requirement)}`
+        );
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function renderHtmlGraph(inspection, facts) {
+  const nodes = [];
+  const edges = [];
+  const colWidth = 220;
+  const rowHeight = 50;
+  const startX = 40;
+  const startY = 60;
+  const factKeys = Object.keys(facts);
+  for (let i = 0; i < factKeys.length; i++) {
+    const key = factKeys[i];
+    nodes.push({
+      id: `fact-${key}`,
+      label: key,
+      type: "fact",
+      x: startX,
+      y: startY + i * rowHeight,
+      color: "#3b82f6"
+    });
+  }
+  for (let i = 0; i < inspection.constraints.length; i++) {
+    const c = inspection.constraints[i];
+    nodes.push({
+      id: `constraint-${c.id}`,
+      label: c.id,
+      type: "constraint",
+      x: startX + colWidth,
+      y: startY + i * rowHeight,
+      color: c.active ? "#22c55e" : "#6b7280"
+    });
+  }
+  const reqTypes = /* @__PURE__ */ new Set();
+  for (const u of inspection.unmet) {
+    reqTypes.add(u.requirement.type);
+  }
+  let reqIdx = 0;
+  for (const reqType of reqTypes) {
+    nodes.push({
+      id: `req-${reqType}`,
+      label: reqType,
+      type: "requirement",
+      x: startX + colWidth * 2,
+      y: startY + reqIdx * rowHeight,
+      color: "#eab308"
+    });
+    reqIdx++;
+  }
+  for (let i = 0; i < inspection.resolverDefs.length; i++) {
+    const r = inspection.resolverDefs[i];
+    nodes.push({
+      id: `resolver-${r.id}`,
+      label: r.id,
+      type: "resolver",
+      x: startX + colWidth * 3,
+      y: startY + i * rowHeight,
+      color: "#a855f7"
+    });
+  }
+  for (const u of inspection.unmet) {
+    edges.push({
+      from: `constraint-${u.fromConstraint}`,
+      to: `req-${u.requirement.type}`
+    });
+  }
+  for (const r of inspection.resolverDefs) {
+    if (reqTypes.has(r.requirement)) {
+      edges.push({
+        from: `req-${r.requirement}`,
+        to: `resolver-${r.id}`
+      });
+    }
+  }
+  const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+  const svgWidth = startX + colWidth * 4 + 40;
+  const maxY = Math.max(...nodes.map((n) => n.y)) + rowHeight + 20;
+  const edgeSvg = edges.map((e) => {
+    const from = nodeMap.get(e.from);
+    const to = nodeMap.get(e.to);
+    if (!from || !to) {
+      return "";
+    }
+    return `<line x1="${from.x + 90}" y1="${from.y + 15}" x2="${to.x}" y2="${to.y + 15}" stroke="#94a3b8" stroke-width="1.5" marker-end="url(#arrow)"/>`;
+  }).join("\n    ");
+  const nodeSvg = nodes.map(
+    (n) => `<g>
+      <rect x="${n.x}" y="${n.y}" width="180" height="30" rx="6" fill="${n.color}" opacity="0.15" stroke="${n.color}" stroke-width="1.5"/>
+      <text x="${n.x + 90}" y="${n.y + 19}" text-anchor="middle" font-size="12" font-family="monospace" fill="${n.color}">${escapeHtml(n.label)}</text>
+    </g>`
+  ).join("\n    ");
+  const headers = ["Facts", "Constraints", "Requirements", "Resolvers"];
+  const headerSvg = headers.map(
+    (h, i) => `<text x="${startX + i * colWidth + 90}" y="35" text-anchor="middle" font-size="14" font-weight="bold" font-family="system-ui" fill="#e2e8f0">${h}</text>`
+  ).join("\n    ");
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <title>Directive System Graph</title>
+  <style>
+    body { margin: 0; background: #0f172a; display: flex; justify-content: center; padding: 20px; }
+    svg { max-width: 100%; }
+  </style>
+</head>
+<body>
+  <svg width="${svgWidth}" height="${maxY}" xmlns="http://www.w3.org/2000/svg">
+    <defs>
+      <marker id="arrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse">
+        <path d="M 0 0 L 10 5 L 0 10 z" fill="#94a3b8"/>
+      </marker>
+    </defs>
+    ${headerSvg}
+    ${edgeSvg}
+    ${nodeSvg}
+  </svg>
+</body>
+</html>`;
+}
+function escapeHtml(text2) {
+  return text2.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+async function graphCommand(args) {
+  const { filePath, opts } = parseArgs6(args);
+  if (!filePath) {
+    console.error("Usage: directive graph <file> [--ascii] [--no-open] [--output <path>]");
+    process.exit(1);
+  }
+  const system = await loadSystem(filePath);
+  if (!system.isRunning) {
+    system.start();
+  }
+  const inspection = system.inspect();
+  if (opts.ascii) {
+    console.log(renderAsciiGraph(inspection));
+    system.stop();
+    return;
+  }
+  const factsObj = {};
+  if (system.facts) {
+    for (const key of Object.keys(system.facts)) {
+      try {
+        factsObj[key] = system.facts[key];
+      } catch {
+        factsObj[key] = null;
+      }
+    }
+  }
+  const html = renderHtmlGraph(inspection, factsObj);
+  const outputPath = opts.output || join(process.cwd(), ".directive-graph.html");
+  writeFileSync(outputPath, html, "utf-8");
+  console.log(`${pc5.green("Generated")} ${pc5.dim(outputPath)}`);
+  if (opts.open) {
+    try {
+      const { exec } = await import('child_process');
+      const openCmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open";
+      exec(`${openCmd} "${outputPath}"`);
+      console.log(pc5.dim("Opened in browser."));
+    } catch {
+      console.log(
+        pc5.dim(`Open ${outputPath} in your browser to view the graph.`)
+      );
+    }
+  }
+  system.stop();
+}
+function parseArgs7(args) {
+  const opts = { dir: process.cwd() };
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--dir") {
+      const val = args[++i];
+      if (val) {
+        opts.dir = val;
+      }
+    }
+  }
+  return opts;
+}
+function checkCoreInstalled(dir) {
+  const pkgPath = join(dir, "package.json");
+  if (!existsSync(pkgPath)) {
+    return {
+      label: "@directive-run/core installed",
+      passed: false,
+      message: "No package.json found",
+      fix: "Run `npm init` to create a package.json"
+    };
+  }
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  if (!deps["@directive-run/core"]) {
+    return {
+      label: "@directive-run/core installed",
+      passed: false,
+      message: "Not found in dependencies",
+      fix: "Run `npm install @directive-run/core`"
+    };
+  }
+  return {
+    label: "@directive-run/core installed",
+    passed: true,
+    message: `v${deps["@directive-run/core"]}`
+  };
+}
+function checkVersionCompatibility(dir) {
+  const pkgPath = join(dir, "package.json");
+  if (!existsSync(pkgPath)) {
+    return {
+      label: "Package version compatibility",
+      passed: true,
+      message: "Skipped (no package.json)"
+    };
+  }
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const directivePackages = Object.keys(deps).filter(
+    (k) => k.startsWith("@directive-run/")
+  );
+  if (directivePackages.length <= 1) {
+    return {
+      label: "Package version compatibility",
+      passed: true,
+      message: directivePackages.length === 0 ? "No packages found" : "Single package"
+    };
+  }
+  return {
+    label: "Package version compatibility",
+    passed: true,
+    message: `${directivePackages.length} packages: ${directivePackages.join(", ")}`
+  };
+}
+function checkTypeScript(dir) {
+  const tsconfigPath = join(dir, "tsconfig.json");
+  if (!existsSync(tsconfigPath)) {
+    return {
+      label: "TypeScript configuration",
+      passed: false,
+      message: "No tsconfig.json found",
+      fix: "Run `tsc --init` to create a TypeScript configuration"
+    };
+  }
+  try {
+    const raw = readFileSync(tsconfigPath, "utf-8");
+    const stripped = raw.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "");
+    const config = JSON.parse(stripped);
+    const co = config.compilerOptions || {};
+    const issues = [];
+    if (co.strict !== true) {
+      issues.push("strict mode not enabled");
+    }
+    if (co.moduleResolution && !["bundler", "nodenext", "node16"].includes(
+      co.moduleResolution.toLowerCase()
+    )) {
+      issues.push(`moduleResolution is "${co.moduleResolution}"`);
+    }
+    if (issues.length > 0) {
+      return {
+        label: "TypeScript configuration",
+        passed: false,
+        message: issues.join(", "),
+        fix: 'Set "strict": true and "moduleResolution": "bundler" in tsconfig.json'
+      };
+    }
+    return {
+      label: "TypeScript configuration",
+      passed: true,
+      message: "strict mode, correct module resolution"
+    };
+  } catch {
+    return {
+      label: "TypeScript configuration",
+      passed: true,
+      message: "Found (could not parse for detailed checks)"
+    };
+  }
+}
+function checkDuplicateInstances(dir) {
+  const nodeModules = join(dir, "node_modules");
+  if (!existsSync(nodeModules)) {
+    return {
+      label: "No duplicate Directive instances",
+      passed: true,
+      message: "No node_modules found"
+    };
+  }
+  const duplicates = [];
+  try {
+    const scopeDir = join(nodeModules, "@directive-run");
+    if (existsSync(scopeDir)) {
+      const packages = readdirSync(scopeDir);
+      for (const pkg of packages) {
+        const nestedCore = join(
+          scopeDir,
+          pkg,
+          "node_modules",
+          "@directive-run",
+          "core"
+        );
+        if (existsSync(nestedCore)) {
+          duplicates.push(`@directive-run/${pkg}/node_modules/@directive-run/core`);
+        }
+      }
+    }
+  } catch {
+  }
+  if (duplicates.length > 0) {
+    return {
+      label: "No duplicate Directive instances",
+      passed: false,
+      message: `Found ${duplicates.length} duplicate(s): ${duplicates.join(", ")}`,
+      fix: "Run `npm dedupe` or check for version mismatches"
+    };
+  }
+  return {
+    label: "No duplicate Directive instances",
+    passed: true,
+    message: "No duplicates detected"
+  };
+}
+function checkAIRulesFreshness(dir) {
+  const ruleFiles = [
+    ".cursorrules",
+    ".claude/CLAUDE.md",
+    ".github/copilot-instructions.md",
+    ".windsurfrules",
+    ".clinerules"
+  ];
+  const found = [];
+  for (const file of ruleFiles) {
+    const filePath = join(dir, file);
+    if (existsSync(filePath)) {
+      const content = readFileSync(filePath, "utf-8");
+      if (hasDirectiveSection(content)) {
+        found.push(file);
+      }
+    }
+  }
+  if (found.length === 0) {
+    return {
+      label: "AI coding rules",
+      passed: true,
+      message: "Not installed (optional)"
+    };
+  }
+  return {
+    label: "AI coding rules",
+    passed: true,
+    message: `Installed for: ${found.join(", ")}`
+  };
+}
+async function doctorCommand(args) {
+  const opts = parseArgs7(args);
+  console.log();
+  console.log(pc5.bold(pc5.cyan("Directive Doctor")));
+  console.log(pc5.dim("\u2500".repeat(40)));
+  console.log();
+  const checks = [
+    checkCoreInstalled(opts.dir),
+    checkVersionCompatibility(opts.dir),
+    checkTypeScript(opts.dir),
+    checkDuplicateInstances(opts.dir),
+    checkAIRulesFreshness(opts.dir)
+  ];
+  let failures = 0;
+  for (const check of checks) {
+    const icon = check.passed ? pc5.green("\u2713") : pc5.red("\u2717");
+    console.log(`${icon} ${pc5.bold(check.label)}`);
+    console.log(`  ${pc5.dim(check.message)}`);
+    if (!check.passed && check.fix) {
+      console.log(`  ${pc5.yellow("Fix:")} ${check.fix}`);
+      failures++;
+    }
+    console.log();
+  }
+  if (failures > 0) {
+    console.log(
+      pc5.yellow(`${failures} issue(s) found. See suggested fixes above.`)
+    );
+    process.exit(1);
+  } else {
+    console.log(pc5.green("All checks passed!"));
+  }
+}
+var CATEGORIES = {
+  "Getting Started": ["counter", "contact-form", "auth-flow"],
+  "Core Patterns": [
+    "async-chains",
+    "batch-resolver",
+    "debounce-constraints",
+    "error-boundaries",
+    "feature-flags",
+    "multi-module",
+    "optimistic-updates",
+    "pagination",
+    "permissions"
+  ],
+  "Real-World": [
+    "dashboard-loader",
+    "form-wizard",
+    "newsletter",
+    "notifications",
+    "shopping-cart",
+    "theme-locale",
+    "url-sync",
+    "websocket",
+    "server"
+  ],
+  Games: ["checkers", "sudoku", "goal-heist", "ab-testing"],
+  AI: [
+    "ai-orchestrator",
+    "ai-checkpoint",
+    "ai-guardrails",
+    "fraud-analysis",
+    "provider-routing",
+    "topic-guard",
+    "dynamic-modules",
+    "time-machine"
+  ]
+};
+function getCategory(name) {
+  for (const [cat, names] of Object.entries(CATEGORIES)) {
+    if (names.includes(name)) {
+      return cat;
+    }
+  }
+  return "Other";
+}
+function getDescription(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("// Example:")) {
+      continue;
+    }
+    if (trimmed.startsWith("// Source:")) {
+      continue;
+    }
+    if (trimmed.startsWith("// Extracted")) {
+      continue;
+    }
+    const jsdocMatch = trimmed.match(/^\*\s+(.+?)(?:\s*\*\/)?$/);
+    if (jsdocMatch?.[1] && !jsdocMatch[1].startsWith("@")) {
+      return jsdocMatch[1];
+    }
+    if (trimmed.startsWith("//") && trimmed.length > 3) {
+      return trimmed.slice(2).trim();
+    }
+    if (trimmed !== "" && !trimmed.startsWith("//") && !trimmed.startsWith("/*") && !trimmed.startsWith("*")) {
+      break;
+    }
+  }
+  return "";
+}
+async function examplesListCommand(args) {
+  let filter;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--filter") {
+      filter = args[++i]?.toLowerCase();
+    }
+  }
+  const examples = getAllExamples();
+  console.log();
+  console.log(pc5.bold(pc5.cyan("Directive Examples")));
+  console.log(pc5.dim("\u2500".repeat(50)));
+  console.log();
+  const byCategory = /* @__PURE__ */ new Map();
+  for (const [name, content] of examples) {
+    const cat = getCategory(name);
+    if (filter && !cat.toLowerCase().includes(filter) && !name.includes(filter)) {
+      continue;
+    }
+    if (!byCategory.has(cat)) {
+      byCategory.set(cat, []);
+    }
+    byCategory.get(cat).push({ name, desc: getDescription(content) });
+  }
+  if (byCategory.size === 0) {
+    console.log(pc5.dim("No examples match the filter."));
+    return;
+  }
+  const categoryOrder = Object.keys(CATEGORIES);
+  const sortedCategories = [...byCategory.keys()].sort(
+    (a, b) => (categoryOrder.indexOf(a) ?? 99) - (categoryOrder.indexOf(b) ?? 99)
+  );
+  for (const cat of sortedCategories) {
+    const items = byCategory.get(cat);
+    console.log(pc5.bold(cat));
+    for (const item of items) {
+      const desc = item.desc ? pc5.dim(` \u2014 ${item.desc}`) : "";
+      console.log(`  ${pc5.cyan(item.name)}${desc}`);
+    }
+    console.log();
+  }
+  console.log(
+    pc5.dim(`${examples.size} examples available. Run ${pc5.cyan("directive examples copy <name>")} to extract one.`)
+  );
+}
+async function examplesCopyCommand(name, args) {
+  let dest = process.cwd();
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--dest") {
+      const val = args[++i];
+      if (val) {
+        dest = val;
+      }
+    }
+  }
+  if (!name) {
+    console.error("Usage: directive examples copy <name> [--dest <dir>]");
+    process.exit(1);
+  }
+  const content = getExample(name);
+  if (!content) {
+    console.error(`Example "${name}" not found.`);
+    console.error(
+      `Run ${pc5.cyan("directive examples list")} to see available examples.`
+    );
+    process.exit(1);
+  }
+  const rewritten = content.replace(
+    /from\s+["']@directive-run\/core\/plugins["']/g,
+    'from "@directive-run/core/plugins"'
+  ).replace(
+    /from\s+["']@directive-run\/core["']/g,
+    'from "@directive-run/core"'
+  ).replace(
+    /from\s+["']@directive-run\/ai["']/g,
+    'from "@directive-run/ai"'
+  );
+  const filePath = join(dest, `${name}.ts`);
+  if (existsSync(filePath)) {
+    console.error(`File already exists: ${relative(process.cwd(), filePath)}`);
+    process.exit(1);
+  }
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(filePath, rewritten, "utf-8");
+  const rel = relative(process.cwd(), filePath);
+  console.log(`${pc5.green("Copied")} ${pc5.cyan(name)} \u2192 ${pc5.dim(rel)}`);
+}
+
+// src/cli.ts
+var HELP = `
+${CLI_NAME} \u2014 CLI tools for Directive
+
+Usage: ${CLI_NAME} <command> [options]
+
+Commands:
+  init                          Project scaffolding wizard
+  new module <name>             Generate a module file
+  new orchestrator <name>       Generate an AI orchestrator
+  inspect <file>                Runtime system introspection
+  explain <file> [req-id]       Explain why a requirement exists
+  graph <file>                  Visual dependency graph
+  doctor                        Health check for project setup
+  ai-rules init                 Install AI coding rules
+  ai-rules update               Refresh rules to latest version
+  ai-rules check                Validate rules are current (CI)
+  examples list                 Browse available examples
+  examples copy <name>          Extract example to project
+
+Options:
+  --help, -h                    Show this help message
+  --version, -v                 Show version
+
+init options:
+  --template <name>             Template: counter, auth-flow, ai-orchestrator
+  --dir <path>                  Target directory (default: cwd)
+  --no-interactive              Skip prompts, use defaults
+
+new module options:
+  --with <sections>             Sections: derive,events,constraints,resolvers,effects
+  --minimal                     Schema + init only
+  --dir <path>                  Target directory (default: cwd)
+
+inspect options:
+  --json                        Output as JSON
+  --module <name>               Inspect specific module
+
+graph options:
+  --ascii                       Terminal-only output
+  --no-open                     Don't open in browser
+  --output <path>               Output file path
+
+ai-rules init options:
+  --force                       Overwrite existing files without asking
+  --merge                       Use section markers to update only the Directive section
+  --tool <name>                 Skip detection, install for specific tool(s)
+  --dir <path>                  Target directory (default: cwd)
+
+examples options:
+  --filter <category>           Filter by category or name
+  --dest <dir>                  Destination directory for copy
+`.trim();
+async function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+    console.log(HELP);
+    process.exit(0);
+  }
+  if (args.includes("--version") || args.includes("-v")) {
+    const { readFileSync: readFileSync4 } = await import('fs');
+    const { fileURLToPath } = await import('url');
+    const { dirname: dirname6, join: join9 } = await import('path');
+    const __dirname = dirname6(fileURLToPath(import.meta.url));
+    const pkg = JSON.parse(
+      readFileSync4(join9(__dirname, "..", "package.json"), "utf-8")
+    );
+    console.log(pkg.version);
+    process.exit(0);
+  }
+  const command = args[0];
+  switch (command) {
+    case "init": {
+      await initCommand(args.slice(1));
+      break;
+    }
+    case "new": {
+      const subcommand = args[1];
+      const name = args[2];
+      if (subcommand === "module") {
+        if (!name) {
+          console.error("Usage: directive new module <name>");
+          process.exit(1);
+        }
+        await newModuleCommand(name, args.slice(3));
+      } else if (subcommand === "orchestrator") {
+        if (!name) {
+          console.error("Usage: directive new orchestrator <name>");
+          process.exit(1);
+        }
+        await newOrchestratorCommand(name, args.slice(3));
+      } else {
+        console.error(
+          `Unknown subcommand: ${subcommand ?? "(none)"}
+Usage: ${CLI_NAME} new module <name>
+       ${CLI_NAME} new orchestrator <name>`
+        );
+        process.exit(1);
+      }
+      break;
+    }
+    case "inspect": {
+      await inspectCommand(args.slice(1));
+      break;
+    }
+    case "explain": {
+      await explainCommand(args.slice(1));
+      break;
+    }
+    case "graph": {
+      await graphCommand(args.slice(1));
+      break;
+    }
+    case "doctor": {
+      await doctorCommand(args.slice(1));
+      break;
+    }
+    case "ai-rules": {
+      const subcommand = args[1];
+      if (subcommand === "init") {
+        await aiRulesCommand(args.slice(2));
+      } else if (subcommand === "update") {
+        await aiRulesUpdateCommand(args.slice(2));
+      } else if (subcommand === "check") {
+        await aiRulesCheckCommand(args.slice(2));
+      } else {
+        console.error(
+          `Unknown subcommand: ${subcommand ?? "(none)"}
+Usage: ${CLI_NAME} ai-rules init
+       ${CLI_NAME} ai-rules update
+       ${CLI_NAME} ai-rules check`
+        );
+        process.exit(1);
+      }
+      break;
+    }
+    case "examples": {
+      const subcommand = args[1];
+      if (subcommand === "list") {
+        await examplesListCommand(args.slice(2));
+      } else if (subcommand === "copy") {
+        const name = args[2];
+        if (!name) {
+          console.error("Usage: directive examples copy <name>");
+          process.exit(1);
+        }
+        await examplesCopyCommand(name, args.slice(3));
+      } else {
+        console.error(
+          `Unknown subcommand: ${subcommand ?? "(none)"}
+Usage: ${CLI_NAME} examples list [--filter <category>]
+       ${CLI_NAME} examples copy <name> [--dest <dir>]`
+        );
+        process.exit(1);
+      }
+      break;
+    }
+    default:
+      console.error(
+        `Unknown command: ${command}
+Run '${CLI_NAME} --help' for usage.`
+      );
+      process.exit(1);
+  }
+}
+main().catch((err) => {
+  console.error(err.message || err);
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map