@benzotti/jedi 0.1.2 → 0.1.4

package/dist/index.js

@@ -1,6 +1,35 @@
 #!/usr/bin/env bun
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __returnValue = (v) => v;
 function __exportSetter(name, newValue) {
@@ -7676,6 +7705,118 @@ var require_public_api = __commonJS((exports) => {
   exports.stringify = stringify;
 });
 
+// node_modules/yaml/dist/index.js
+var require_dist = __commonJS((exports) => {
+  var composer = require_composer();
+  var Document = require_Document();
+  var Schema = require_Schema();
+  var errors = require_errors();
+  var Alias = require_Alias();
+  var identity = require_identity();
+  var Pair = require_Pair();
+  var Scalar = require_Scalar();
+  var YAMLMap = require_YAMLMap();
+  var YAMLSeq = require_YAMLSeq();
+  var cst = require_cst();
+  var lexer = require_lexer();
+  var lineCounter = require_line_counter();
+  var parser = require_parser();
+  var publicApi = require_public_api();
+  var visit = require_visit();
+  exports.Composer = composer.Composer;
+  exports.Document = Document.Document;
+  exports.Schema = Schema.Schema;
+  exports.YAMLError = errors.YAMLError;
+  exports.YAMLParseError = errors.YAMLParseError;
+  exports.YAMLWarning = errors.YAMLWarning;
+  exports.Alias = Alias.Alias;
+  exports.isAlias = identity.isAlias;
+  exports.isCollection = identity.isCollection;
+  exports.isDocument = identity.isDocument;
+  exports.isMap = identity.isMap;
+  exports.isNode = identity.isNode;
+  exports.isPair = identity.isPair;
+  exports.isScalar = identity.isScalar;
+  exports.isSeq = identity.isSeq;
+  exports.Pair = Pair.Pair;
+  exports.Scalar = Scalar.Scalar;
+  exports.YAMLMap = YAMLMap.YAMLMap;
+  exports.YAMLSeq = YAMLSeq.YAMLSeq;
+  exports.CST = cst;
+  exports.Lexer = lexer.Lexer;
+  exports.LineCounter = lineCounter.LineCounter;
+  exports.Parser = parser.Parser;
+  exports.parse = publicApi.parse;
+  exports.parseAllDocuments = publicApi.parseAllDocuments;
+  exports.parseDocument = publicApi.parseDocument;
+  exports.stringify = publicApi.stringify;
+  exports.visit = visit.visit;
+  exports.visitAsync = visit.visitAsync;
+});
+
+// src/utils/git.ts
+var exports_git = {};
+__export(exports_git, {
+  gitStatus: () => gitStatus,
+  gitRoot: () => gitRoot,
+  gitMergeBase: () => gitMergeBase,
+  gitLog: () => gitLog,
+  gitDiffNames: () => gitDiffNames,
+  gitDiff: () => gitDiff,
+  gitBranch: () => gitBranch,
+  exec: () => exec
+});
+async function exec(cmd, cwd) {
+  const proc = Bun.spawn(cmd, {
+    cwd: cwd ?? process.cwd(),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  const stdout2 = await new Response(proc.stdout).text();
+  const exitCode = await proc.exited;
+  return { stdout: stdout2.trim(), exitCode };
+}
+async function gitDiff(staged) {
+  const args = ["git", "diff"];
+  if (staged)
+    args.push("--cached");
+  const { stdout: stdout2 } = await exec(args);
+  return stdout2;
+}
+async function gitDiffNames(staged) {
+  const args = ["git", "diff", "--name-only"];
+  if (staged)
+    args.push("--cached");
+  const { stdout: stdout2 } = await exec(args);
+  return stdout2 ? stdout2.split(`
+`) : [];
+}
+async function gitLog(range) {
+  const args = ["git", "log", "--oneline"];
+  if (range)
+    args.push(range);
+  else
+    args.push("-20");
+  const { stdout: stdout2 } = await exec(args);
+  return stdout2;
+}
+async function gitBranch() {
+  const { stdout: stdout2 } = await exec(["git", "rev-parse", "--abbrev-ref", "HEAD"]);
+  return stdout2;
+}
+async function gitRoot() {
+  const { stdout: stdout2 } = await exec(["git", "rev-parse", "--show-toplevel"]);
+  return stdout2;
+}
+async function gitStatus() {
+  const { stdout: stdout2 } = await exec(["git", "status", "--porcelain"]);
+  return stdout2;
+}
+async function gitMergeBase(branch) {
+  const { stdout: stdout2 } = await exec(["git", "merge-base", "HEAD", branch]);
+  return stdout2;
+}
+
 // node_modules/consola/dist/core.mjs
 var LogLevels = {
   silent: Number.NEGATIVE_INFINITY,
@@ -9203,30 +9344,73 @@ var initCommand = defineCommand({
       type: "boolean",
       description: "Overwrite existing files",
       default: false
+    },
+    ci: {
+      type: "boolean",
+      description: "Headless CI mode (no prompts, JSON output)",
+      default: false
+    },
+    storage: {
+      type: "string",
+      description: "Storage adapter to configure (default: fs)"
+    },
+    "storage-path": {
+      type: "string",
+      description: "Storage base path (default: .jdi/persistence/)"
     }
   },
   async run({ args }) {
     const cwd = process.cwd();
     const projectType = await detectProjectType(cwd);
-    consola.info(`Detected project type: ${projectType}`);
-    consola.start("Initialising JDI...");
+    if (!args.ci) {
+      consola.info(`Detected project type: ${projectType}`);
+      consola.start("Initialising JDI...");
+    }
     const dirs = [
       ".claude/commands/jdi",
       ".jdi/plans",
       ".jdi/research",
       ".jdi/codebase",
       ".jdi/reviews",
-      ".jdi/config"
+      ".jdi/config",
+      ".jdi/persistence"
     ];
     for (const dir of dirs) {
       await Bun.write(join3(cwd, dir, ".gitkeep"), "");
     }
     await copyFrameworkFiles(cwd, projectType, args.force);
-    consola.success("JDI initialised successfully!");
-    consola.info("");
-    consola.info("Get started:");
-    consola.info('  /jdi:create-plan "your feature"');
-    consola.info('  /jdi:quick "small fix"');
+    if (args.storage || args["storage-path"]) {
+      const { parse, stringify } = await Promise.resolve().then(() => __toESM(require_dist(), 1));
+      const configPath = join3(cwd, ".jdi", "config", "jdi-config.yaml");
+      let config = {};
+      try {
+        const existing = await Bun.file(configPath).text();
+        config = parse(existing) ?? {};
+      } catch {}
+      config.storage = {
+        adapter: args.storage ?? "fs",
+        base_path: args["storage-path"] ?? ".jdi/persistence/"
+      };
+      await Bun.write(configPath, stringify(config));
+    }
+    if (args.ci) {
+      const result = {
+        status: "initialised",
+        project_type: projectType,
+        cwd,
+        storage: {
+          adapter: args.storage ?? "fs",
+          base_path: args["storage-path"] ?? ".jdi/persistence/"
+        }
+      };
+      console.log(JSON.stringify(result));
+    } else {
+      consola.success("JDI initialised successfully!");
+      consola.info("");
+      consola.info("Get started:");
+      consola.info('  /jdi:create-plan "your feature"');
+      consola.info('  /jdi:quick "small fix"');
+    }
   }
 });
 
@@ -9234,69 +9418,292 @@ var initCommand = defineCommand({
 import { resolve as resolve2 } from "path";
 
 // src/utils/adapter.ts
+var import_yaml = __toESM(require_dist(), 1);
 import { join as join4 } from "path";
 import { existsSync as existsSync3 } from "fs";
-
-// node_modules/yaml/dist/index.js
-var composer = require_composer();
-var Document = require_Document();
-var Schema = require_Schema();
-var errors = require_errors();
-var Alias = require_Alias();
-var identity = require_identity();
-var Pair = require_Pair();
-var Scalar = require_Scalar();
-var YAMLMap = require_YAMLMap();
-var YAMLSeq = require_YAMLSeq();
-var cst = require_cst();
-var lexer = require_lexer();
-var lineCounter = require_line_counter();
-var parser = require_parser();
-var publicApi = require_public_api();
-var visit = require_visit();
-var $Composer = composer.Composer;
-var $Document = Document.Document;
-var $Schema = Schema.Schema;
-var $YAMLError = errors.YAMLError;
-var $YAMLParseError = errors.YAMLParseError;
-var $YAMLWarning = errors.YAMLWarning;
-var $Alias = Alias.Alias;
-var $isAlias = identity.isAlias;
-var $isCollection = identity.isCollection;
-var $isDocument = identity.isDocument;
-var $isMap = identity.isMap;
-var $isNode = identity.isNode;
-var $isPair = identity.isPair;
-var $isScalar = identity.isScalar;
-var $isSeq = identity.isSeq;
-var $Pair = Pair.Pair;
-var $Scalar = Scalar.Scalar;
-var $YAMLMap = YAMLMap.YAMLMap;
-var $YAMLSeq = YAMLSeq.YAMLSeq;
-var $Lexer = lexer.Lexer;
-var $LineCounter = lineCounter.LineCounter;
-var $Parser = parser.Parser;
-var $parse = publicApi.parse;
-var $parseAllDocuments = publicApi.parseAllDocuments;
-var $parseDocument = publicApi.parseDocument;
-var $stringify = publicApi.stringify;
-var $visit = visit.visit;
-var $visitAsync = visit.visitAsync;
-
-// src/utils/adapter.ts
 async function readAdapter(cwd) {
   const adapterPath = join4(cwd, ".jdi", "config", "adapter.yaml");
   if (!existsSync3(adapterPath))
     return null;
   const content = await Bun.file(adapterPath).text();
-  return $parse(content);
+  return import_yaml.parse(content);
+}
+
+// src/utils/claude.ts
+var PROMPT_LENGTH_THRESHOLD = 1e5;
+async function findClaude() {
+  const path = Bun.which("claude");
+  if (path)
+    return path;
+  const { exec: exec2 } = await Promise.resolve().then(() => exports_git);
+  const { stdout: stdout2, exitCode } = await exec2(["which", "claude"]);
+  if (exitCode === 0 && stdout2)
+    return stdout2;
+  throw new Error("Claude CLI not found. Install it from https://docs.anthropic.com/en/docs/claude-code");
+}
+var lastEventType = "";
+function formatStreamEvent(event) {
+  if (event.type === "assistant" && event.message?.content) {
+    const parts = [];
+    for (const block of event.message.content) {
+      if (block.type === "text" && block.text) {
+        const prefix = lastEventType === "tool" ? `
+` : "";
+        parts.push(prefix + block.text.trim());
+        lastEventType = "text";
+      } else if (block.type === "tool_use") {
+        const name = block.name ?? "tool";
+        const input = block.input;
+        let detail = "";
+        if (input?.file_path) {
+          const segments = input.file_path.split("/");
+          detail = ` \u2192 ${segments.slice(-3).join("/")}`;
+        } else if (name === "Bash" && input?.command) {
+          detail = ` \u2192 ${input.command.slice(0, 60)}`;
+        } else if (input?.pattern) {
+          detail = ` \u2192 ${input.pattern}`;
+        }
+        parts.push(`  \u26A1 ${name}${detail}`);
+        lastEventType = "tool";
+      }
+    }
+    if (parts.length > 0)
+      return parts.join(`
+`) + `
+`;
+  }
+  if (event.type === "result" && event.subtype === "error_tool_result") {
+    lastEventType = "error";
+    return `  \u274C Tool error
+`;
+  }
+  return null;
+}
+async function spawnClaude(prompt2, opts) {
+  const claudePath = await findClaude();
+  const args = [
+    claudePath,
+    "-p",
+    "--verbose",
+    "--output-format",
+    "stream-json",
+    "--permission-mode",
+    opts?.permissionMode ?? "acceptEdits"
+  ];
+  if (opts?.allowedTools) {
+    for (const tool of opts.allowedTools) {
+      args.push("--allowedTools", tool);
+    }
+  }
+  if (opts?.model) {
+    args.push("--model", opts.model);
+  }
+  const useStdin = prompt2.length >= PROMPT_LENGTH_THRESHOLD;
+  if (!useStdin) {
+    args.push(prompt2);
+  }
+  consola.start(`Launching Claude Code...
+`);
+  const proc = Bun.spawn(args, {
+    cwd: opts?.cwd ?? process.cwd(),
+    stdout: "pipe",
+    stderr: "inherit",
+    stdin: useStdin ? "pipe" : "ignore"
+  });
+  if (useStdin) {
+    proc.stdin.write(prompt2);
+    proc.stdin.end();
+  }
+  const reader = proc.stdout.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed)
+          continue;
+        try {
+          const event = JSON.parse(trimmed);
+          const output = formatStreamEvent(event);
+          if (output)
+            process.stdout.write(output);
+        } catch {}
+      }
+    }
+    if (buffer.trim()) {
+      try {
+        const event = JSON.parse(buffer.trim());
+        const output = formatStreamEvent(event);
+        if (output)
+          process.stdout.write(output);
+      } catch {}
+    }
+  } catch {}
+  const exitCode = await proc.exited;
+  process.stdout.write(`
+`);
+  return { exitCode };
+}
+
+// src/storage/index.ts
+var import_yaml2 = __toESM(require_dist(), 1);
+import { join as join6 } from "path";
+import { existsSync as existsSync5 } from "fs";
+
+// src/storage/fs-storage.ts
+import { join as join5 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+
+class FsStorage {
+  basePath;
+  constructor(basePath = ".jdi/persistence") {
+    this.basePath = basePath;
+  }
+  async load(key) {
+    const filePath = join5(this.basePath, `${key}.md`);
+    if (!existsSync4(filePath))
+      return null;
+    return Bun.file(filePath).text();
+  }
+  async save(key, content) {
+    if (!existsSync4(this.basePath)) {
+      mkdirSync2(this.basePath, { recursive: true });
+    }
+    const filePath = join5(this.basePath, `${key}.md`);
+    await Bun.write(filePath, content);
+  }
+}
+
+// src/storage/index.ts
+async function createStorage(cwd, config) {
+  let adapter = config?.adapter ?? "fs";
+  let basePath = config?.basePath;
+  if (!config?.adapter && !config?.basePath) {
+    const configPath = join6(cwd, ".jdi", "config", "jdi-config.yaml");
+    if (existsSync5(configPath)) {
+      const content = await Bun.file(configPath).text();
+      const parsed = import_yaml2.parse(content);
+      if (parsed?.storage?.adapter)
+        adapter = parsed.storage.adapter;
+      if (parsed?.storage?.base_path)
+        basePath = parsed.storage.base_path;
+    }
+  }
+  if (adapter === "fs") {
+    const resolvedPath = basePath ? join6(cwd, basePath) : join6(cwd, ".jdi", "persistence");
+    return new FsStorage(resolvedPath);
+  }
+  const adapterPath = join6(cwd, adapter);
+  if (!existsSync5(adapterPath)) {
+    throw new Error(`Storage adapter not found: ${adapterPath}
+` + `Set storage.adapter in .jdi/config/jdi-config.yaml to "fs" or a path to a custom adapter module.`);
+  }
+  try {
+    const mod = await import(adapterPath);
+    const AdapterClass = mod.default ?? mod.Storage ?? mod[Object.keys(mod)[0]];
+    if (!AdapterClass || typeof AdapterClass !== "function") {
+      throw new Error(`Storage adapter at ${adapterPath} must export a class as default export.`);
+    }
+    const instance = new AdapterClass({ basePath, cwd });
+    if (typeof instance.load !== "function" || typeof instance.save !== "function") {
+      throw new Error(`Storage adapter at ${adapterPath} must implement JediStorage (load and save methods).`);
+    }
+    return instance;
+  } catch (err) {
+    if (err.message?.includes("Storage adapter"))
+      throw err;
+    throw new Error(`Failed to load storage adapter from ${adapterPath}: ${err.message}`);
+  }
+}
+
+// src/utils/storage-lifecycle.ts
+import { join as join7 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+async function loadPersistedState(cwd, storage) {
+  let learningsPath = null;
+  let codebaseIndexPath = null;
+  const learnings = await storage.load("learnings");
+  if (learnings) {
+    const dir = join7(cwd, ".jdi", "framework", "learnings");
+    if (!existsSync6(dir))
+      mkdirSync3(dir, { recursive: true });
+    learningsPath = join7(dir, "_consolidated.md");
+    await Bun.write(learningsPath, learnings);
+  }
+  const codebaseIndex = await storage.load("codebase-index");
+  if (codebaseIndex) {
+    const dir = join7(cwd, ".jdi", "codebase");
+    if (!existsSync6(dir))
+      mkdirSync3(dir, { recursive: true });
+    codebaseIndexPath = join7(dir, "INDEX.md");
+    await Bun.write(codebaseIndexPath, codebaseIndex);
+  }
+  return { learningsPath, codebaseIndexPath };
+}
+async function savePersistedState(cwd, storage) {
+  let learningsSaved = false;
+  let codebaseIndexSaved = false;
+  const learningsDir = join7(cwd, ".jdi", "framework", "learnings");
+  if (existsSync6(learningsDir)) {
+    const merged = await mergeLearningFiles(learningsDir);
+    if (merged) {
+      await storage.save("learnings", merged);
+      learningsSaved = true;
+    }
+  }
+  const indexPath = join7(cwd, ".jdi", "codebase", "INDEX.md");
+  if (existsSync6(indexPath)) {
+    const content = await Bun.file(indexPath).text();
+    if (content.trim()) {
+      await storage.save("codebase-index", content);
+      codebaseIndexSaved = true;
+    }
+  }
+  return { learningsSaved, codebaseIndexSaved };
+}
+async function mergeLearningFiles(dir) {
+  const categories = ["general", "backend", "frontend", "testing", "devops"];
+  const sections = [];
+  for (const category of categories) {
+    const filePath = join7(dir, `${category}.md`);
+    if (!existsSync6(filePath))
+      continue;
+    const content = await Bun.file(filePath).text();
+    const trimmed = content.trim();
+    const lines = trimmed.split(`
+`).filter((l2) => l2.trim() && !l2.startsWith("#") && !l2.startsWith("<!--"));
+    if (lines.length === 0)
+      continue;
+    sections.push(trimmed);
+  }
+  const consolidatedPath = join7(dir, "_consolidated.md");
+  if (existsSync6(consolidatedPath)) {
+    const content = await Bun.file(consolidatedPath).text();
+    const trimmed = content.trim();
+    if (trimmed && !sections.some((s2) => s2.includes(trimmed))) {
+      sections.push(trimmed);
+    }
+  }
+  return sections.length > 0 ? sections.join(`
+
+---
+
+`) : null;
 }
 
 // src/commands/plan.ts
 var planCommand = defineCommand({
   meta: {
     name: "plan",
-    description: "Generate a planning prompt for Claude Code"
+    description: "Plan a feature using Claude Code"
   },
   args: {
     description: {
@@ -9307,6 +9714,11 @@ var planCommand = defineCommand({
     output: {
       type: "string",
       description: "Write prompt to file instead of stdout"
+    },
+    print: {
+      type: "boolean",
+      description: "Print the prompt to stdout instead of executing",
+      default: false
     }
   },
   async run({ args }) {
@@ -9336,29 +9748,61 @@ var planCommand = defineCommand({
     if (args.output) {
       await Bun.write(resolve2(cwd, args.output), prompt2);
       consola.success(`Prompt written to ${args.output}`);
-    } else {
+    } else if (args.print) {
       console.log(prompt2);
+    } else {
+      const storage = await createStorage(cwd);
+      await loadPersistedState(cwd, storage);
+      const { exitCode } = await spawnClaude(prompt2, { cwd });
+      await savePersistedState(cwd, storage);
+      if (exitCode !== 0) {
+        consola.error(`Claude exited with code ${exitCode}`);
+        process.exit(exitCode);
+      }
     }
   }
 });
 
 // src/commands/implement.ts
 import { resolve as resolve3 } from "path";
+
+// src/utils/state.ts
+var import_yaml3 = __toESM(require_dist(), 1);
+import { join as join8 } from "path";
+import { existsSync as existsSync7 } from "fs";
+async function readState(cwd) {
+  const statePath = join8(cwd, ".jdi", "config", "state.yaml");
+  if (!existsSync7(statePath))
+    return null;
+  const content = await Bun.file(statePath).text();
+  return import_yaml3.parse(content);
+}
+async function writeState(cwd, state) {
+  const statePath = join8(cwd, ".jdi", "config", "state.yaml");
+  await Bun.write(statePath, import_yaml3.stringify(state));
+}
+
+// src/commands/implement.ts
 var implementCommand = defineCommand({
   meta: {
     name: "implement",
-    description: "Generate an implementation prompt for Claude Code"
+    description: "Execute an implementation plan using Claude Code"
   },
   args: {
     plan: {
       type: "positional",
-      description: "Path to the PLAN.md file to execute",
-      required: true
+      description: "Path to the PLAN.md file (auto-detected from state if omitted)",
+      required: false
     },
     output: {
       type: "string",
       description: "Write prompt to file instead of stdout"
     },
+    print: {
+      type: "boolean",
+      description: "Print the prompt to stdout instead of executing",
+      default: false
+    },
     team: {
       type: "boolean",
       description: "Force Agent Teams mode",
@@ -9372,6 +9816,16 @@ var implementCommand = defineCommand({
   },
   async run({ args }) {
     const cwd = process.cwd();
+    let planPath = args.plan;
+    if (!planPath) {
+      const state = await readState(cwd);
+      planPath = state?.current_plan?.path ?? null;
+      if (!planPath) {
+        consola.error("No plan specified and no current plan found in state. Run `jdi plan` first or provide a plan path.");
+        process.exit(1);
+      }
+      consola.info(`Using current plan: ${planPath}`);
+    }
     const baseProtocol = resolve3(cwd, ".jdi/framework/components/meta/AgentBase.md");
     const complexityRouter = resolve3(cwd, ".jdi/framework/components/meta/ComplexityRouter.md");
     const orchestration = resolve3(cwd, ".jdi/framework/components/meta/AgentTeamsOrchestration.md");
@@ -9394,7 +9848,7 @@ Override: --single (force single-agent mode)` : "";
       `- Working directory: ${cwd}`,
       ``,
       `## Task`,
-      `Execute implementation plan: ${resolve3(cwd, args.plan)}${overrideFlag}`,
+      `Execute implementation plan: ${resolve3(cwd, planPath)}${overrideFlag}`,
       ``,
       `Follow the implement-plan orchestration:`,
       `1. Read codebase context (.jdi/codebase/SUMMARY.md if exists)`,
@@ -9410,27 +9864,21 @@ Override: --single (force single-agent mode)` : "";
     if (args.output) {
       await Bun.write(resolve3(cwd, args.output), prompt2);
       consola.success(`Prompt written to ${args.output}`);
-    } else {
+    } else if (args.print) {
       console.log(prompt2);
+    } else {
+      const storage = await createStorage(cwd);
+      await loadPersistedState(cwd, storage);
+      const { exitCode } = await spawnClaude(prompt2, { cwd });
+      await savePersistedState(cwd, storage);
+      if (exitCode !== 0) {
+        consola.error(`Claude exited with code ${exitCode}`);
+        process.exit(exitCode);
+      }
     }
   }
 });
 
-// src/utils/state.ts
-import { join as join5 } from "path";
-import { existsSync as existsSync4 } from "fs";
-async function readState(cwd) {
-  const statePath = join5(cwd, ".jdi", "config", "state.yaml");
-  if (!existsSync4(statePath))
-    return null;
-  const content = await Bun.file(statePath).text();
-  return $parse(content);
-}
-async function writeState(cwd, state) {
-  const statePath = join5(cwd, ".jdi", "config", "state.yaml");
-  await Bun.write(statePath, $stringify(state));
-}
-
 // src/commands/status.ts
 var statusCommand = defineCommand({
   meta: {
@@ -9478,15 +9926,15 @@ var statusCommand = defineCommand({
 import { relative } from "path";
 
 // src/utils/resolve-components.ts
-import { join as join6, basename } from "path";
+import { join as join9, basename } from "path";
 import { homedir } from "os";
 async function resolveComponents(cwd) {
   const components = [];
   const seen = new Set;
   const sources = [
-    { dir: join6(cwd, ".jdi", "framework", "components"), source: "project" },
-    { dir: join6(homedir(), ".jdi", "components"), source: "user" },
-    { dir: join6(import.meta.dir, "../framework/components"), source: "builtin" }
+    { dir: join9(cwd, ".jdi", "framework", "components"), source: "project" },
+    { dir: join9(homedir(), ".jdi", "components"), source: "user" },
+    { dir: join9(import.meta.dir, "../framework/components"), source: "builtin" }
   ];
   for (const { dir, source } of sources) {
     try {
@@ -9495,7 +9943,7 @@ async function resolveComponents(cwd) {
         const name = basename(file, ".md");
         if (!seen.has(name)) {
           seen.add(name);
-          components.push({ name, path: join6(dir, file), source });
+          components.push({ name, path: join9(dir, file), source });
         }
       }
     } catch {}
@@ -9523,51 +9971,6 @@ var componentsCommand = defineCommand({
   }
 });
 
-// src/utils/git.ts
-async function exec(cmd, cwd) {
-  const proc = Bun.spawn(cmd, {
-    cwd: cwd ?? process.cwd(),
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const stdout2 = await new Response(proc.stdout).text();
-  const exitCode = await proc.exited;
-  return { stdout: stdout2.trim(), exitCode };
-}
-async function gitDiffNames(staged) {
-  const args = ["git", "diff", "--name-only"];
-  if (staged)
-    args.push("--cached");
-  const { stdout: stdout2 } = await exec(args);
-  return stdout2 ? stdout2.split(`
-`) : [];
-}
-async function gitLog(range) {
-  const args = ["git", "log", "--oneline"];
-  if (range)
-    args.push(range);
-  else
-    args.push("-20");
-  const { stdout: stdout2 } = await exec(args);
-  return stdout2;
-}
-async function gitBranch() {
-  const { stdout: stdout2 } = await exec(["git", "rev-parse", "--abbrev-ref", "HEAD"]);
-  return stdout2;
-}
-async function gitRoot() {
-  const { stdout: stdout2 } = await exec(["git", "rev-parse", "--show-toplevel"]);
-  return stdout2;
-}
-async function gitStatus() {
-  const { stdout: stdout2 } = await exec(["git", "status", "--porcelain"]);
-  return stdout2;
-}
-async function gitMergeBase(branch) {
-  const { stdout: stdout2 } = await exec(["git", "merge-base", "HEAD", branch]);
-  return stdout2;
-}
-
 // src/commands/commit.ts
 import { dirname as dirname2 } from "path";
 function detectScope(files) {
@@ -9686,8 +10089,8 @@ Use --all to stage and commit all, or stage files manually.`);
 });
 
 // src/commands/pr.ts
-import { existsSync as existsSync5 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join10 } from "path";
 async function hasGhCli() {
   const { exitCode } = await exec(["which", "gh"]);
   return exitCode === 0;
@@ -9737,8 +10140,8 @@ var prCommand = defineCommand({
 
 **Plan:** ${state.position.plan_name}` : "";
     let template = "";
-    const templatePath = join7(cwd, ".github", "pull_request_template.md");
-    if (existsSync5(templatePath)) {
+    const templatePath = join10(cwd, ".github", "pull_request_template.md");
+    if (existsSync8(templatePath)) {
       template = await Bun.file(templatePath).text();
     }
     const title = branch.replace(/^(feat|fix|chore|docs|refactor|test|ci)\//, "").replace(/[-_]/g, " ").replace(/^\w/, (c3) => c3.toUpperCase());
@@ -9791,7 +10194,7 @@ import { resolve as resolve5 } from "path";
 var reviewCommand = defineCommand({
   meta: {
     name: "review",
-    description: "Fetch PR diff and generate a structured review prompt"
+    description: "Review a PR using Claude Code"
   },
   args: {
     pr: {
@@ -9802,6 +10205,11 @@ var reviewCommand = defineCommand({
     output: {
       type: "string",
       description: "Write prompt to file instead of stdout"
+    },
+    print: {
+      type: "boolean",
+      description: "Print the prompt to stdout instead of executing",
+      default: false
     }
   },
   async run({ args }) {
@@ -9878,8 +10286,14 @@ ${data.body}` : ""
     if (args.output) {
       await Bun.write(resolve5(process.cwd(), args.output), prompt2);
       consola.success(`Review prompt written to ${args.output}`);
-    } else {
+    } else if (args.print) {
       console.log(prompt2);
+    } else {
+      const { exitCode } = await spawnClaude(prompt2, { cwd: process.cwd() });
+      if (exitCode !== 0) {
+        consola.error(`Claude exited with code ${exitCode}`);
+        process.exit(exitCode);
+      }
     }
   }
 });
@@ -10013,7 +10427,7 @@ import { resolve as resolve6 } from "path";
 var quickCommand = defineCommand({
   meta: {
     name: "quick",
-    description: "Generate a focused change prompt for Claude Code"
+    description: "Make a focused change using Claude Code"
   },
   args: {
     description: {
@@ -10024,6 +10438,11 @@ var quickCommand = defineCommand({
     output: {
       type: "string",
       description: "Write prompt to file instead of stdout"
+    },
+    print: {
+      type: "boolean",
+      description: "Print the prompt to stdout instead of executing",
+      default: false
     }
   },
   async run({ args }) {
@@ -10057,14 +10476,20 @@ var quickCommand = defineCommand({
     if (args.output) {
       await Bun.write(resolve6(cwd, args.output), prompt2);
       consola.success(`Prompt written to ${args.output}`);
-    } else {
+    } else if (args.print) {
       console.log(prompt2);
+    } else {
+      const { exitCode } = await spawnClaude(prompt2, { cwd });
+      if (exitCode !== 0) {
+        consola.error(`Claude exited with code ${exitCode}`);
+        process.exit(exitCode);
+      }
     }
   }
 });
 
 // src/commands/worktree.ts
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 function slugify(name) {
   return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
 }
@@ -10098,7 +10523,7 @@ var worktreeCommand = defineCommand({
     }
     const slug = slugify(args.name);
     const worktreePath = `${root}/.worktrees/${slug}`;
-    if (existsSync6(worktreePath)) {
+    if (existsSync9(worktreePath)) {
       consola.error(`Worktree already exists at ${worktreePath}`);
       return;
     }
@@ -10171,7 +10596,6 @@ var worktreeCommand = defineCommand({
     consola.info(`  cd ${worktreePath}`);
   }
 });
-
 // src/commands/worktree-remove.ts
 var worktreeRemoveCommand = defineCommand({
   meta: {
@@ -10265,7 +10689,7 @@ Specify a worktree name: jdi worktree-remove <name>`);
 
 // src/commands/plan-review.ts
 import { resolve as resolve7 } from "path";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 function parsePlanSummary(content) {
   const nameMatch = content.match(/^# .+?: (.+)$/m);
   const name = nameMatch?.[1] ?? "Unknown";
@@ -10304,7 +10728,7 @@ var planReviewCommand = defineCommand({
       consola.error("No plan found. Run `jdi plan` first.");
       return;
     }
-    if (!existsSync7(planPath)) {
+    if (!existsSync10(planPath)) {
       consola.error(`Plan not found: ${planPath}`);
       return;
     }
@@ -10394,7 +10818,7 @@ Tasks (${tasks.length}):`);
 
 // src/commands/plan-approve.ts
 import { resolve as resolve8 } from "path";
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 var planApproveCommand = defineCommand({
   meta: {
     name: "plan-approve",
@@ -10423,7 +10847,7 @@ var planApproveCommand = defineCommand({
       consola.error("No plan to approve. Run `jdi plan` first.");
       return;
     }
-    if (!existsSync8(planPath)) {
+    if (!existsSync11(planPath)) {
       consola.error(`Plan not found: ${planPath}`);
       return;
     }
@@ -10447,15 +10871,576 @@ var planApproveCommand = defineCommand({
     consola.info("Say 'implement this' in Claude Code or run `/jdi:implement-plan` to execute.");
   }
 });
+
+// src/commands/action.ts
+import { resolve as resolve9 } from "path";
+
+// src/utils/clickup.ts
+var CLICKUP_URL_PATTERNS = [
+  /app\.clickup\.com\/t\/([a-z0-9]+)/i,
+  /sharing\.clickup\.com\/t\/([a-z0-9]+)/i,
+  /clickup\.com\/t\/([a-z0-9]+)/i
+];
+function extractClickUpId(text) {
+  for (const pattern of CLICKUP_URL_PATTERNS) {
+    const match = text.match(pattern);
+    if (match)
+      return match[1];
+  }
+  return null;
+}
+async function fetchClickUpTicket(taskId) {
+  const token = process.env.CLICKUP_API_TOKEN;
+  if (!token)
+    return null;
+  try {
+    const res = await fetch(`https://api.clickup.com/api/v2/task/${taskId}`, { headers: { Authorization: token } });
+    if (!res.ok)
+      return null;
+    const data = await res.json();
+    const acceptanceCriteria = [];
+    if (data.checklists) {
+      for (const checklist of data.checklists) {
+        for (const item of checklist.items ?? []) {
+          acceptanceCriteria.push(item.name);
+        }
+      }
+    }
+    const subtasks = (data.subtasks ?? []).map((st) => ({
+      name: st.name,
+      status: st.status?.status ?? "unknown"
+    }));
+    const priorityMap = {
+      1: "urgent",
+      2: "high",
+      3: "normal",
+      4: "low"
+    };
+    return {
+      id: data.id,
+      name: data.name,
+      description: data.description ?? "",
+      status: data.status?.status ?? "unknown",
+      priority: priorityMap[data.priority?.id] ?? "normal",
+      acceptanceCriteria,
+      subtasks
+    };
+  } catch {
+    return null;
+  }
+}
+function formatTicketAsContext(ticket) {
+  const lines = [
+    `## ClickUp Ticket: ${ticket.name}`,
+    `- **ID:** ${ticket.id}`,
+    `- **Status:** ${ticket.status}`,
+    `- **Priority:** ${ticket.priority}`,
+    ``,
+    `### Description`,
+    ticket.description || "_No description_"
+  ];
+  if (ticket.acceptanceCriteria.length > 0) {
+    lines.push(``, `### Acceptance Criteria`);
+    for (const ac of ticket.acceptanceCriteria) {
+      lines.push(`- [ ] ${ac}`);
+    }
+  }
+  if (ticket.subtasks.length > 0) {
+    lines.push(``, `### Subtasks`);
+    for (const st of ticket.subtasks) {
+      const check = st.status === "complete" ? "x" : " ";
+      lines.push(`- [${check}] ${st.name}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+
+// src/utils/github.ts
+async function postGitHubComment(repo, issueNumber, body) {
+  await exec([
+    "gh",
+    "api",
+    `repos/${repo}/issues/${issueNumber}/comments`,
+    "-f",
+    `body=${body}`
+  ]);
+}
+async function reactToComment(repo, commentId, reaction) {
+  await exec([
+    "gh",
+    "api",
+    `repos/${repo}/issues/comments/${commentId}/reactions`,
+    "-f",
+    `content=${reaction}`
+  ]);
+}
+async function fetchCommentThread(repo, issueNumber) {
+  const { stdout: stdout2, exitCode } = await exec([
+    "gh",
+    "api",
+    `repos/${repo}/issues/${issueNumber}/comments`,
+    "--paginate",
+    "--jq",
+    `.[] | {id: .id, author: .user.login, body: .body, createdAt: .created_at}`
+  ]);
+  if (exitCode !== 0 || !stdout2.trim())
+    return [];
+  const comments = [];
+  for (const line of stdout2.trim().split(`
+`)) {
+    if (!line.trim())
+      continue;
+    try {
+      const parsed = JSON.parse(line);
+      comments.push({
+        id: parsed.id,
+        author: parsed.author,
+        body: parsed.body,
+        createdAt: parsed.createdAt,
+        isJedi: parsed.body.includes("Powered by [@benzotti/jedi]") || parsed.body.includes("Jedi plan") || parsed.body.includes("Jedi quick") || parsed.body.includes("Jedi implement")
+      });
+    } catch {}
+  }
+  return comments;
+}
+function buildConversationContext(thread, currentCommentId) {
+  const jediSegments = [];
+  let inJediConversation = false;
+  for (const comment of thread) {
+    if (comment.id === currentCommentId)
+      break;
+    if (comment.body.includes("@jedi")) {
+      inJediConversation = true;
+      jediSegments.push(comment);
+    } else if (inJediConversation) {
+      jediSegments.push(comment);
+      if (comment.isJedi) {}
+    }
+  }
+  const previousJediRuns = jediSegments.filter((c3) => c3.isJedi).length;
+  const isFollowUp = previousJediRuns > 0;
+  if (jediSegments.length === 0) {
+    return { history: "", previousJediRuns: 0, isFollowUp: false };
+  }
+  const lines = ["## Previous Conversation", ""];
+  for (const comment of jediSegments) {
+    const role = comment.isJedi ? "Jedi" : `@${comment.author}`;
+    let body = comment.body;
+    if (comment.isJedi && body.length > 2000) {
+      body = body.slice(0, 2000) + `
+
+... (truncated)`;
+    }
+    lines.push(`**${role}** (${comment.createdAt}):`);
+    lines.push(body);
+    lines.push("");
+  }
+  return { history: lines.join(`
+`), previousJediRuns, isFollowUp };
+}
+function formatResultComment(command, success, summary) {
+  const status = success ? "Completed" : "Failed";
+  const icon = success ? "white_check_mark" : "x";
+  return [
+    `### :${icon}: Jedi ${command} \u2014 ${status}`,
+    ``,
+    `<details>`,
+    `<summary>Details</summary>`,
+    ``,
+    summary,
+    ``,
+    `</details>`,
+    ``,
+    `---`,
+    `_Powered by [@benzotti/jedi](https://github.com/zottiben/jedi)_`
+  ].join(`
+`);
+}
+
+// src/commands/action.ts
+function parseComment(comment, isFollowUp) {
+  const match = comment.match(/@jedi\s+(.+)/is);
+  if (!match) {
+    if (isFollowUp) {
+      return {
+        command: "plan",
+        description: comment.trim(),
+        clickUpUrl: null,
+        fullFlow: false,
+        isFeedback: true
+      };
+    }
+    return null;
+  }
+  const body = match[1].trim();
+  const clickUpMatch = body.match(/(https?:\/\/[^\s]*clickup\.com\/t\/[a-z0-9]+)/i);
+  const clickUpUrl = clickUpMatch ? clickUpMatch[1] : null;
+  const description = body.replace(/(https?:\/\/[^\s]*clickup\.com\/t\/[a-z0-9]+)/i, "").replace(/\s+/g, " ").trim();
+  const lower = body.toLowerCase();
+  if (lower.startsWith("plan ")) {
+    return { command: "plan", description, clickUpUrl, fullFlow: false, isFeedback: false };
+  }
+  if (lower.startsWith("implement")) {
+    return { command: "implement", description, clickUpUrl, fullFlow: false, isFeedback: false };
+  }
+  if (lower.startsWith("quick ")) {
+    return { command: "quick", description, clickUpUrl, fullFlow: false, isFeedback: false };
+  }
+  if (lower.startsWith("review")) {
+    return { command: "review", description, clickUpUrl, fullFlow: false, isFeedback: false };
+  }
+  if (lower.startsWith("feedback")) {
+    return { command: "feedback", description, clickUpUrl, fullFlow: false, isFeedback: false };
+  }
+  if (lower.startsWith("do ")) {
+    if (clickUpUrl) {
+      return { command: "plan", description, clickUpUrl, fullFlow: true, isFeedback: false };
+    }
+    return { command: "quick", description, clickUpUrl, fullFlow: false, isFeedback: false };
+  }
+  if (/^(approved?|lgtm|looks?\s*good|ship\s*it)/i.test(lower)) {
+    return {
+      command: "plan",
+      description: body,
+      clickUpUrl: null,
+      fullFlow: false,
+      isFeedback: true
+    };
+  }
+  if (isFollowUp) {
+    return {
+      command: "plan",
+      description: body,
+      clickUpUrl: null,
+      fullFlow: false,
+      isFeedback: true
+    };
+  }
+  return { command: "plan", description, clickUpUrl, fullFlow: false, isFeedback: false };
+}
+var actionCommand = defineCommand({
+  meta: {
+    name: "action",
+    description: "GitHub Action entry point \u2014 parse @jedi comment and run workflow"
+  },
+  args: {
+    comment: {
+      type: "positional",
+      description: "The raw comment body containing @jedi mention",
+      required: true
+    },
+    "comment-id": {
+      type: "string",
+      description: "GitHub comment ID for reactions"
+    },
+    "pr-number": {
+      type: "string",
+      description: "PR number (if triggered from a PR)"
+    },
+    "issue-number": {
+      type: "string",
+      description: "Issue number (if triggered from an issue)"
+    },
+    repo: {
+      type: "string",
+      description: "Repository in owner/repo format"
+    }
+  },
+  async run({ args }) {
+    const cwd = process.cwd();
+    const repo = args.repo ?? process.env.GITHUB_REPOSITORY;
+    const commentId = args["comment-id"] ? Number(args["comment-id"]) : null;
+    const issueNumber = Number(args["pr-number"] ?? args["issue-number"] ?? 0);
+    let conversationHistory = "";
+    let isFollowUp = false;
+    if (repo && issueNumber) {
+      const thread = await fetchCommentThread(repo, issueNumber);
+      const context = buildConversationContext(thread, commentId ?? 0);
+      conversationHistory = context.history;
+      isFollowUp = context.isFollowUp;
+      if (isFollowUp) {
+        consola.info(`Continuing conversation (${context.previousJediRuns} previous Jedi run(s))`);
+      }
+    }
+    const intent = parseComment(args.comment, isFollowUp);
+    if (!intent) {
+      consola.error("Could not parse @jedi intent from comment");
+      process.exit(1);
+    }
+    consola.info(`Parsed intent: ${intent.isFeedback ? "feedback on previous" : intent.command}${intent.fullFlow ? " (full flow)" : ""}`);
+    if (repo && commentId) {
+      await reactToComment(repo, commentId, "eyes").catch(() => {});
+    }
+    const storage = await createStorage(cwd);
+    const { learningsPath, codebaseIndexPath } = await loadPersistedState(cwd, storage);
+    let ticketContext = "";
+    if (intent.clickUpUrl) {
+      const taskId = extractClickUpId(intent.clickUpUrl);
+      if (taskId) {
+        consola.info(`Fetching ClickUp ticket: ${taskId}`);
+        const ticket = await fetchClickUpTicket(taskId);
+        if (ticket) {
+          ticketContext = formatTicketAsContext(ticket);
+          consola.success(`Loaded ticket: ${ticket.name}`);
+        }
+      }
+    }
+    const projectType = await detectProjectType(cwd);
+    const adapter = await readAdapter(cwd);
+    const techStack = adapter?.tech_stack ? Object.entries(adapter.tech_stack).map(([k2, v2]) => `${k2}: ${v2}`).join(", ") : projectType;
+    const contextLines = [
+      `## Project Context`,
+      `- Type: ${projectType}`,
+      `- Tech stack: ${techStack}`,
+      `- Working directory: ${cwd}`
+    ];
+    if (learningsPath) {
+      contextLines.push(`- Learnings: ${learningsPath}`);
+    }
+    if (codebaseIndexPath) {
+      contextLines.push(`- Codebase index: ${codebaseIndexPath}`);
+    }
+    if (ticketContext) {
+      contextLines.push(``, ticketContext);
+    }
+    const baseProtocol = resolve9(cwd, ".jdi/framework/components/meta/AgentBase.md");
+    let prompt2;
+    if (intent.isFeedback) {
+      prompt2 = [
+        `Read ${baseProtocol} for the base agent protocol.`,
+        ``,
+        ...contextLines,
+        ``,
+        conversationHistory,
+        ``,
+        `## Current Feedback`,
+        `The user has provided feedback on previous Jedi work:`,
+        ``,
+        `> ${intent.description}`,
+        ``,
+        `## Instructions`,
+        `Review the previous conversation above. The user is iterating on work Jedi already started.`,
+        ``,
+        `- If the feedback is an **approval** ("approved", "lgtm", "looks good", "ship it"), finalise the current work \u2014 create commits and/or a PR as appropriate.`,
+        `- If the feedback is a **refinement** ("change task 2", "use a different approach", "add error handling"), apply the requested changes to the existing plan or implementation. Present an updated summary when done.`,
+        `- If the feedback is a **question**, answer it with full context from the conversation.`,
+        ``,
+        `Read state.yaml and any existing plan files to understand what was previously done. Apply changes incrementally \u2014 do not restart from scratch.`
+      ].join(`
+`);
+    } else {
+      const agentSpec = resolve9(cwd, `.jdi/framework/agents/jdi-planner.md`);
+      const historyBlock = conversationHistory ? `
+${conversationHistory}
+
+The above is prior conversation on this issue for context.
+` : "";
+      switch (intent.command) {
+        case "plan":
+          prompt2 = [
+            `Read ${baseProtocol} for the base agent protocol.`,
+            `You are jdi-planner. Read ${agentSpec} for your full specification.`,
+            ``,
+            ...contextLines,
+            historyBlock,
+            `## Task`,
+            `Create an implementation plan for: ${intent.description}`,
+            ticketContext ? `
+Use the ClickUp ticket above as the primary requirements source.` : ``,
+            ``,
+            `Follow the planning workflow in your spec. Present the plan summary when complete and ask for feedback. The user will respond via another GitHub comment.`
+          ].join(`
+`);
+          break;
+        case "implement":
+          prompt2 = [
+            `Read ${baseProtocol} for the base agent protocol.`,
+            `Read ${resolve9(cwd, ".jdi/framework/components/meta/ComplexityRouter.md")} for complexity routing rules.`,
+            `Read ${resolve9(cwd, ".jdi/framework/components/meta/AgentTeamsOrchestration.md")} for Agent Teams orchestration (if needed).`,
+            ``,
+            ...contextLines,
+            historyBlock,
+            `## Task`,
+            `Execute the current implementation plan. Read state.yaml for the active plan path.`,
+            `Follow the implement-plan orchestration. Present a summary when complete and ask for feedback.`
+          ].join(`
+`);
+          break;
+        case "quick":
+          prompt2 = [
+            `Read ${baseProtocol} for the base agent protocol.`,
+            ``,
+            ...contextLines,
+            historyBlock,
+            `## Task`,
+            `Make this quick change: ${intent.description}`,
+            `Keep changes minimal and focused. Commit when done. Present what you changed.`
+          ].join(`
+`);
+          break;
+        case "review":
+          prompt2 = [
+            `Read ${baseProtocol} for the base agent protocol.`,
+            ``,
+            ...contextLines,
+            historyBlock,
+            `## Task`,
+            `Review the current PR. Post line-level review comments via gh api.`
+          ].join(`
+`);
+          break;
+        case "feedback":
+          prompt2 = [
+            `Read ${baseProtocol} for the base agent protocol.`,
+            ``,
+            ...contextLines,
+            historyBlock,
+            `## Task`,
+            `Address PR feedback comments. Read comments via gh api, make changes, reply to each.`
+          ].join(`
+`);
+          break;
+        default:
+          prompt2 = [
+            `Read ${baseProtocol} for the base agent protocol.`,
+            ``,
+            ...contextLines,
+            historyBlock,
+            `## Task`,
+            intent.description
+          ].join(`
+`);
+      }
+    }
+    let success = true;
+    try {
+      const { exitCode } = await spawnClaude(prompt2, {
+        cwd,
+        permissionMode: "bypassPermissions"
+      });
+      if (exitCode !== 0) {
+        success = false;
+        consola.error(`Claude exited with code ${exitCode}`);
+      }
+      if (intent.fullFlow && success) {
+        consola.info("Full flow: now running implement...");
+        const implementPrompt = [
+          `Read ${baseProtocol} for the base agent protocol.`,
+          `Read ${resolve9(cwd, ".jdi/framework/components/meta/ComplexityRouter.md")} for complexity routing rules.`,
+          `Read ${resolve9(cwd, ".jdi/framework/components/meta/AgentTeamsOrchestration.md")} for Agent Teams orchestration (if needed).`,
+          ``,
+          ...contextLines,
+          ``,
+          `## Task`,
+          `Execute the most recently created implementation plan in .jdi/plans/.`,
+          `Follow the implement-plan orchestration. Present a summary when complete.`
+        ].join(`
+`);
+        const implResult = await spawnClaude(implementPrompt, {
+          cwd,
+          permissionMode: "bypassPermissions"
+        });
+        if (implResult.exitCode !== 0) {
+          success = false;
+        }
+      }
+    } catch (err) {
+      success = false;
+      consola.error("Execution failed:", err);
+    }
+    const saved = await savePersistedState(cwd, storage);
+    if (saved.learningsSaved)
+      consola.info("Learnings persisted to storage");
+    if (saved.codebaseIndexSaved)
+      consola.info("Codebase index persisted to storage");
+    if (repo && issueNumber) {
+      const actionLabel = intent.isFeedback ? "feedback" : intent.command;
+      const summary = success ? `Executed \`${actionLabel}\` successfully.${saved.learningsSaved ? " Learnings updated." : ""}` : `Execution of \`${actionLabel}\` failed. Check workflow logs for details.`;
+      const commentBody = formatResultComment(actionLabel, success, summary);
+      await postGitHubComment(repo, issueNumber, commentBody).catch((err) => {
+        consola.error("Failed to post result comment:", err);
+      });
+    }
+    if (repo && commentId) {
+      const reaction = success ? "+1" : "-1";
+      await reactToComment(repo, commentId, reaction).catch(() => {});
+    }
+    if (!success)
+      process.exit(1);
+  }
+});
+
+// src/commands/setup-action.ts
+import { join as join12, dirname as dirname3 } from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync4 } from "fs";
+var setupActionCommand = defineCommand({
+  meta: {
+    name: "setup-action",
+    description: "Set up the Jedi GitHub Action in your repository"
+  },
+  args: {},
+  async run() {
+    const cwd = process.cwd();
+    const workflowDest = join12(cwd, ".github", "workflows", "jedi.yml");
+    if (existsSync12(workflowDest)) {
+      consola.warn(`Workflow already exists at ${workflowDest}`);
+      consola.info("Skipping workflow copy. Delete it manually to regenerate.");
+    } else {
+      const templatePath = join12(import.meta.dir, "../../action/workflow-template.yml");
+      if (!existsSync12(templatePath)) {
+        consola.error("Workflow template not found. Ensure @benzotti/jedi is properly installed.");
+        process.exit(1);
+      }
+      const dir = dirname3(workflowDest);
+      if (!existsSync12(dir))
+        mkdirSync4(dir, { recursive: true });
+      const template = await Bun.file(templatePath).text();
+      await Bun.write(workflowDest, template);
+      consola.success(`Created ${workflowDest}`);
+    }
+    consola.info("");
+    consola.box([
+      "Jedi GitHub Action Setup",
+      "",
+      "Uses: anthropics/claude-code-action@v1",
+      "Trigger: @jedi in issue/PR comments",
+      "",
+      "Required secrets (set via GitHub UI or CLI):",
+      "",
+      "  gh secret set ANTHROPIC_API_KEY --body '<your-key>'",
+      "",
+      "Optional secrets:",
+      "",
+      "  gh secret set CLICKUP_API_TOKEN --body '<your-token>'",
+      "",
+      "Usage: Comment on any issue or PR with:",
+      "",
+      "  @jedi plan <description>",
+      "  @jedi quick <small fix>",
+      "  @jedi do <clickup-ticket-url>",
+      "  @jedi review",
+      "  @jedi feedback",
+      "",
+      "Conversation: Reply to Jedi with feedback to iterate,",
+      "or say 'approved' to finalise."
+    ].join(`
+`));
+  }
+});
 // package.json
 var package_default = {
   name: "@benzotti/jedi",
-  version: "0.1.2",
+  version: "0.1.4",
   description: "JDI - Context-efficient AI development framework for Claude Code",
   type: "module",
   bin: {
     jdi: "./dist/index.js"
   },
+  exports: {
+    ".": "./dist/index.js",
+    "./storage": "./src/storage/index.ts"
+  },
   scripts: {
     build: "bun build src/index.ts --outdir dist --target bun",
     dev: "bun run src/index.ts",
@@ -10472,7 +11457,8 @@ var package_default = {
   },
   files: [
     "dist",
-    "framework"
+    "framework",
+    "action"
   ],
   repository: {
     type: "git",
@@ -10505,7 +11491,9 @@ var main = defineCommand({
     worktree: worktreeCommand,
     "worktree-remove": worktreeRemoveCommand,
     "plan-review": planReviewCommand,
-    "plan-approve": planApproveCommand
+    "plan-approve": planApproveCommand,
+    action: actionCommand,
+    "setup-action": setupActionCommand
   }
 });
 runMain(main);