@benzotti/jedi 0.1.33 → 0.1.35

package/README.md

@@ -1,13 +1,6 @@
-```
-     ██╗███████╗██████╗ ██╗
-     ██║██╔════╝██╔══██╗██║
-     ██║█████╗  ██║  ██║██║
-██   ██║██╔══╝  ██║  ██║██║
-╚█████╔╝███████╗██████╔╝██║
- ╚════╝ ╚══════╝╚═════╝ ╚═╝
-```
+# Jedi
 
-**Context-efficient AI development framework for Claude Code.**
+**Multi-agent development framework for Claude Code — plan, implement, review, and ship with specialist agents and minimal token overhead.**
 
 [![npm version](https://img.shields.io/npm/v/@benzotti/jedi)](https://www.npmjs.com/package/@benzotti/jedi) [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 

package/action/workflow-template.yml

@@ -7,6 +7,9 @@
 #
 # Optional:
 #   - Set CLICKUP_API_TOKEN secret for ClickUp ticket integration
+#   - Set JEDI_COMMIT_LEARNINGS=true repo variable to persist learnings in git
+#   - Set JEDI_LEARNINGS_REPO variable to push learnings to a central repo (e.g. org/jedi-learnings)
+#   - Set JEDI_LEARNINGS_TOKEN secret (PAT with repo access) when using an external learnings repo
 #   - Run `npx @benzotti/jedi init` locally to customise framework files
 #
 # Usage: Comment on any issue or PR with "Hey Jedi" followed by a command:
@@ -21,7 +24,8 @@
 # reply with feedback to refine, or say "approved" to finalise.
 #
 # Learnings: Jedi accumulates team preferences across PRs automatically.
-# No files to commit — everything lives in the GitHub Actions cache.
+# By default learnings live in the GitHub Actions cache. Set JEDI_COMMIT_LEARNINGS=true
+# to persist them in git (recommended — cache entries expire after 7 days of inactivity).
 
 name: Jedi
 
@@ -117,6 +121,49 @@ jobs:
             grep -qxF "$pattern" .git/info/exclude 2>/dev/null || echo "$pattern" >> .git/info/exclude
           done
 
+      # Fetch shared learnings from an external repo if configured.
+      # This merges cross-project learnings into the local framework before agents run.
+      - name: Fetch shared learnings
+        if: vars.JEDI_LEARNINGS_REPO != ''
+        run: |
+          LEARNINGS_DIR=".jdi/framework/learnings"
+          mkdir -p "$LEARNINGS_DIR"
+
+          # Clone only the directory for this repo's learnings (sparse checkout)
+          REPO_SUBDIR="${{ github.repository }}"
+          TMPDIR=$(mktemp -d)
+          git clone --depth 1 --filter=blob:none --sparse \
+            "https://x-access-token:${LEARNINGS_TOKEN}@github.com/${LEARNINGS_REPO}.git" \
+            "$TMPDIR" 2>/dev/null || {
+              echo "Could not clone learnings repo — continuing without shared learnings"
+              exit 0
+            }
+
+          cd "$TMPDIR"
+          git sparse-checkout set "$REPO_SUBDIR" 2>/dev/null || true
+          cd - > /dev/null
+
+          # Copy learnings from external repo into local framework
+          # External learnings serve as baseline; cache/local files take precedence
+          if [ -d "$TMPDIR/$REPO_SUBDIR" ]; then
+            for f in "$TMPDIR/$REPO_SUBDIR"/*.md; do
+              [ -f "$f" ] || continue
+              BASENAME=$(basename "$f")
+              # Only copy if local file doesn't exist (cache/committed files take precedence)
+              if [ ! -f "$LEARNINGS_DIR/$BASENAME" ]; then
+                cp "$f" "$LEARNINGS_DIR/$BASENAME"
+                echo "Loaded shared learning: $BASENAME"
+              fi
+            done
+          else
+            echo "No shared learnings found for ${{ github.repository }} — continuing"
+          fi
+
+          rm -rf "$TMPDIR"
+        env:
+          LEARNINGS_REPO: ${{ vars.JEDI_LEARNINGS_REPO }}
+          LEARNINGS_TOKEN: ${{ secrets.JEDI_LEARNINGS_TOKEN || github.token }}
+
       # Configure git for Jedi commits (used when implementing changes on PR branches)
       - name: Configure git
         run: |
@@ -171,13 +218,49 @@ jobs:
           key: jedi-state-${{ github.repository }}-${{ steps.pr.outputs.branch || github.head_ref || github.ref_name }}-${{ github.run_id }}
 
   # ── Promote learnings to main baseline when PRs merge ──
+  # Only runs when Jedi was actually used on the merged PR
   promote-learnings:
     if: github.event_name == 'push'
     runs-on: ubuntu-latest
     steps:
+      - name: Check if Jedi was involved
+        id: check
+        run: |
+          # Find the PR associated with this merge commit
+          PR_NUMBER=$(gh api "repos/$REPO/commits/${{ github.sha }}/pulls" --jq '.[0].number // empty' 2>/dev/null || true)
+          if [ -z "$PR_NUMBER" ]; then
+            echo "No associated PR found — skipping"
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+            exit 0
+          fi
+
+          # Check if Jedi commented on this PR (comments from github-actions bot mentioning Jedi)
+          JEDI_ACTIVITY=$(gh api "repos/$REPO/issues/$PR_NUMBER/comments" --paginate \
+            --jq '[.[] | select(.user.login == "github-actions[bot]" and (.body | test("jedi|Jedi|🤖")))] | length' 2>/dev/null || echo "0")
+
+          # Also check if jedi[bot] made any commits on the PR
+          JEDI_COMMITS=$(gh api "repos/$REPO/pulls/$PR_NUMBER/commits" --paginate \
+            --jq '[.[] | select(.commit.author.name == "jedi[bot]")] | length' 2>/dev/null || echo "0")
+
+          if [ "$JEDI_ACTIVITY" -gt 0 ] || [ "$JEDI_COMMITS" -gt 0 ]; then
+            BRANCH=$(gh api "repos/$REPO/pulls/$PR_NUMBER" --jq '.head.ref')
+            echo "Jedi was active on PR #$PR_NUMBER (comments: $JEDI_ACTIVITY, commits: $JEDI_COMMITS) — promoting learnings"
+            echo "skip=false" >> "$GITHUB_OUTPUT"
+            echo "branch=$BRANCH" >> "$GITHUB_OUTPUT"
+            echo "pr_number=$PR_NUMBER" >> "$GITHUB_OUTPUT"
+          else
+            echo "No Jedi activity on PR #$PR_NUMBER — skipping"
+            echo "skip=true" >> "$GITHUB_OUTPUT"
+          fi
+        env:
+          GH_TOKEN: ${{ github.token }}
+          REPO: ${{ github.repository }}
+
       - uses: actions/checkout@v4
+        if: steps.check.outputs.skip != 'true'
 
-      - name: Restore latest Jedi state
+      - name: Restore Jedi state from merged branch
+        if: steps.check.outputs.skip != 'true'
         id: restore
         uses: actions/cache@v4
         with:
@@ -189,10 +272,10 @@ jobs:
             .claude/
           key: jedi-state-${{ github.repository }}-main-promotion-${{ github.sha }}
           restore-keys: |
-            jedi-state-${{ github.repository }}-
+            jedi-state-${{ github.repository }}-${{ steps.check.outputs.branch }}-
 
       - name: Promote to main baseline
-        if: steps.restore.outputs.cache-hit != ''
+        if: steps.check.outputs.skip != 'true' && steps.restore.outputs.cache-hit != ''
         uses: actions/cache/save@v4
         with:
           path: |
@@ -202,3 +285,93 @@ jobs:
             .jdi/plans/
             .claude/
           key: jedi-state-${{ github.repository }}-main-${{ github.sha }}
+
+      # Opt-in: commit learnings so they survive cache eviction.
+      # Set repo variable JEDI_COMMIT_LEARNINGS=true to enable.
+      #
+      # Where learnings are committed:
+      #   - Same repo (default): .jdi/framework/learnings/ on main
+      #   - External repo: set JEDI_LEARNINGS_REPO (e.g. org/jedi-learnings)
+      #     and JEDI_LEARNINGS_TOKEN secret. Learnings are namespaced under
+      #     <owner>/<repo>/ in the external repo to support multiple projects.
+      - name: Commit learnings to repo
+        if: >-
+          steps.check.outputs.skip != 'true'
+          && steps.restore.outputs.cache-hit != ''
+          && vars.JEDI_COMMIT_LEARNINGS == 'true'
+        run: |
+          LEARNINGS_SRC=".jdi/framework/learnings"
+
+          # Only proceed if there are learnings files with content
+          if [ ! -d "$LEARNINGS_SRC" ]; then
+            echo "No learnings directory found — skipping commit"
+            exit 0
+          fi
+
+          # Check if any learnings files have meaningful content (not just headers)
+          HAS_CONTENT=false
+          for f in "$LEARNINGS_SRC"/*.md; do
+            [ -f "$f" ] || continue
+            if grep -qvE '^\s*(#|<!--|$)' "$f" 2>/dev/null; then
+              HAS_CONTENT=true
+              break
+            fi
+          done
+
+          if [ "$HAS_CONTENT" != "true" ]; then
+            echo "No learnings content to commit — skipping"
+            exit 0
+          fi
+
+          git config user.name "jedi[bot]"
+          git config user.email "jedi[bot]@users.noreply.github.com"
+
+          if [ -n "$LEARNINGS_REPO" ]; then
+            # ── External repo: clone, copy learnings, push ──
+            REPO_SUBDIR="${{ github.repository }}"
+            TMPDIR=$(mktemp -d)
+
+            git clone --depth 1 \
+              "https://x-access-token:${LEARNINGS_TOKEN}@github.com/${LEARNINGS_REPO}.git" \
+              "$TMPDIR" 2>/dev/null || {
+                echo "::warning::Could not clone learnings repo ${LEARNINGS_REPO} — skipping commit"
+                exit 0
+              }
+
+            mkdir -p "$TMPDIR/$REPO_SUBDIR"
+            cp "$LEARNINGS_SRC"/*.md "$TMPDIR/$REPO_SUBDIR/"
+
+            cd "$TMPDIR"
+            git config user.name "jedi[bot]"
+            git config user.email "jedi[bot]@users.noreply.github.com"
+            git add "$REPO_SUBDIR"/*.md
+
+            if git diff --cached --quiet; then
+              echo "Learnings unchanged in external repo — nothing to commit"
+            else
+              git commit -m "chore(jedi): update learnings from ${{ github.repository }}
+
+          Source: PR #${{ steps.check.outputs.pr_number }} on ${{ github.repository }}
+          Learnings accumulated from PR reviews and feedback."
+              git push
+              echo "Learnings committed to ${LEARNINGS_REPO}/${REPO_SUBDIR}"
+            fi
+
+            cd - > /dev/null
+            rm -rf "$TMPDIR"
+          else
+            # ── Same repo: commit directly to main ──
+            git add "$LEARNINGS_SRC"/*.md
+            if git diff --cached --quiet; then
+              echo "Learnings unchanged — nothing to commit"
+            else
+              git commit -m "chore(jedi): update team learnings
+
+          Auto-committed by Jedi after PR #${{ steps.check.outputs.pr_number }} merged.
+          These learnings are accumulated from PR reviews and feedback."
+              git push
+            fi
+          fi
+        env:
+          LEARNINGS_REPO: ${{ vars.JEDI_LEARNINGS_REPO || '' }}
+          LEARNINGS_TOKEN: ${{ secrets.JEDI_LEARNINGS_TOKEN || github.token }}

package/dist/index.js

@@ -9748,6 +9748,13 @@ async function loadPersistedState(cwd, storage) {
   } else {
     learningsPath = dir;
   }
+  if (!learningsPath && existsSync6(dir)) {
+    const { readdirSync } = await import("fs");
+    const files = readdirSync(dir).filter((f3) => f3.endsWith(".md"));
+    if (files.length > 0) {
+      learningsPath = dir;
+    }
+  }
   const codebaseIndex = await storage.load("codebase-index");
   if (codebaseIndex) {
     const cbDir = join6(cwd, ".jdi", "codebase");
@@ -10084,17 +10091,55 @@ async function writeState(cwd, state) {
 }
 
 // src/utils/state-handlers.ts
+var import_yaml4 = __toESM(require_dist(), 1);
+import { join as join9 } from "path";
+import { existsSync as existsSync9 } from "fs";
+function parseFrontmatter(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match)
+    return null;
+  try {
+    return import_yaml4.parse(match[1]);
+  } catch {
+    return null;
+  }
+}
 async function transitionToPlanReady(cwd, planPath, planName) {
   const state = await readState(cwd) ?? {};
+  const fullPlanPath = planPath.startsWith("/") ? planPath : join9(cwd, planPath);
+  let phase;
+  let planNumber;
+  let taskFiles = [];
+  if (existsSync9(fullPlanPath)) {
+    const content = await Bun.file(fullPlanPath).text();
+    const fm = parseFrontmatter(content);
+    if (fm) {
+      if (fm.phase != null)
+        phase = Number(fm.phase);
+      if (fm.plan != null)
+        planNumber = String(fm.plan);
+      if (Array.isArray(fm.task_files))
+        taskFiles = fm.task_files;
+    }
+  }
   state.position = {
     ...state.position,
-    plan: planPath,
+    ...phase != null ? { phase } : {},
+    plan: planNumber ?? planPath,
     plan_name: planName,
     status: "planning"
   };
   state.current_plan = {
     ...state.current_plan,
-    path: planPath
+    path: planPath,
+    tasks: taskFiles,
+    completed_tasks: [],
+    current_task_index: taskFiles.length > 0 ? 0 : null
+  };
+  state.progress = {
+    ...state.progress,
+    tasks_total: taskFiles.length,
+    tasks_completed: 0
   };
   state.review = {
     ...state.review,
@@ -10142,9 +10187,10 @@ async function advanceTask(cwd, completedTaskId) {
     const nextIndex = completed.length;
     state.current_plan.current_task_index = nextIndex < tasks.length ? nextIndex : null;
   }
-  if (state.progress) {
-    state.progress.tasks_completed = (state.progress.tasks_completed ?? 0) + 1;
+  if (!state.progress) {
+    state.progress = { phases_total: 0, phases_completed: 0, plans_total: 0, plans_completed: 0, tasks_total: 0, tasks_completed: 0 };
   }
+  state.progress.tasks_completed = (state.progress.tasks_completed ?? 0) + 1;
   await updateSessionActivity(cwd, state);
 }
 async function updateSessionActivity(cwd, state) {
@@ -10327,15 +10373,15 @@ var statusCommand = defineCommand({
 import { relative } from "path";
 
 // src/utils/resolve-components.ts
-import { join as join9, basename } from "path";
+import { join as join10, basename } from "path";
 import { homedir } from "os";
 async function resolveComponents(cwd) {
   const components = [];
   const seen = new Set;
   const sources = [
-    { dir: join9(cwd, ".jdi", "framework", "components"), source: "project" },
-    { dir: join9(homedir(), ".jdi", "components"), source: "user" },
-    { dir: join9(import.meta.dir, "../framework/components"), source: "builtin" }
+    { dir: join10(cwd, ".jdi", "framework", "components"), source: "project" },
+    { dir: join10(homedir(), ".jdi", "components"), source: "user" },
+    { dir: join10(import.meta.dir, "../framework/components"), source: "builtin" }
   ];
   for (const { dir, source } of sources) {
     try {
@@ -10344,7 +10390,7 @@ async function resolveComponents(cwd) {
         const name = basename(file, ".md");
         if (!seen.has(name)) {
           seen.add(name);
-          components.push({ name, path: join9(dir, file), source });
+          components.push({ name, path: join10(dir, file), source });
         }
       }
     } catch {}
@@ -10490,8 +10536,8 @@ Use --all to stage and commit all, or stage files manually.`);
 });
 
 // src/commands/pr.ts
-import { existsSync as existsSync9 } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync10 } from "fs";
+import { join as join11 } from "path";
 async function hasGhCli() {
   const { exitCode } = await exec(["which", "gh"]);
   return exitCode === 0;
@@ -10542,8 +10588,8 @@ var prCommand = defineCommand({
     let verificationChecks = [];
     const planPath = state?.current_plan?.path;
     if (planPath) {
-      const fullPlanPath = join10(cwd, planPath);
-      if (existsSync9(fullPlanPath)) {
+      const fullPlanPath = join11(cwd, planPath);
+      if (existsSync10(fullPlanPath)) {
         try {
           const planContent = await Bun.file(fullPlanPath).text();
           const nameMatch = planContent.match(/^#\s+(.+)/m);
@@ -10566,8 +10612,8 @@ ${taskLines.map((l2) => `- ${l2.split("|").slice(2, 3).join("").trim()}`).join(`
       }
     }
     let template = "";
-    const templatePath = join10(cwd, ".github", "pull_request_template.md");
-    if (existsSync9(templatePath)) {
+    const templatePath = join11(cwd, ".github", "pull_request_template.md");
+    if (existsSync10(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());
@@ -10863,7 +10909,7 @@ var quickCommand = defineCommand({
 });
 
 // src/commands/worktree.ts
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 function slugify(name) {
   return name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
 }
@@ -10897,7 +10943,7 @@ var worktreeCommand = defineCommand({
     }
     const slug = slugify(args.name);
     const worktreePath = `${root}/.worktrees/${slug}`;
-    if (existsSync10(worktreePath)) {
+    if (existsSync11(worktreePath)) {
       consola.error(`Worktree already exists at ${worktreePath}`);
       return;
     }
@@ -11063,7 +11109,7 @@ Specify a worktree name: jdi worktree-remove <name>`);
 
 // src/commands/plan-review.ts
 import { resolve as resolve9 } from "path";
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 function parsePlanSummary(content) {
   const nameMatch = content.match(/^# .+?: (.+)$/m);
   const name = nameMatch?.[1] ?? "Unknown";
@@ -11102,7 +11148,7 @@ var planReviewCommand = defineCommand({
       consola.error("No plan found. Run `jdi plan` first.");
       return;
     }
-    if (!existsSync11(planPath)) {
+    if (!existsSync12(planPath)) {
       consola.error(`Plan not found: ${planPath}`);
       return;
     }
@@ -11192,7 +11238,7 @@ Tasks (${tasks.length}):`);
 
 // src/commands/plan-approve.ts
 import { resolve as resolve10 } from "path";
-import { existsSync as existsSync12 } from "fs";
+import { existsSync as existsSync13 } from "fs";
 var planApproveCommand = defineCommand({
   meta: {
     name: "plan-approve",
@@ -11221,7 +11267,7 @@ var planApproveCommand = defineCommand({
       consola.error("No plan to approve. Run `jdi plan` first.");
       return;
     }
-    if (!existsSync12(planPath)) {
+    if (!existsSync13(planPath)) {
       consola.error(`Plan not found: ${planPath}`);
       return;
     }
@@ -11698,16 +11744,16 @@ Say **\`Hey Jedi implement\`** when you're ready to go.`;
       return;
     }
     if (intent.command === "ping") {
-      const { existsSync: existsSync13 } = await import("fs");
-      const { join: join12 } = await import("path");
-      const frameworkExists = existsSync13(join12(cwd, ".jdi/framework"));
-      const claudeMdExists = existsSync13(join12(cwd, ".claude/CLAUDE.md"));
-      const stateExists = existsSync13(join12(cwd, ".jdi/config/state.yaml"));
-      const learningsExists = existsSync13(join12(cwd, ".jdi/persistence/learnings.md"));
+      const { existsSync: existsSync14 } = await import("fs");
+      const { join: join13 } = await import("path");
+      const frameworkExists = existsSync14(join13(cwd, ".jdi/framework"));
+      const claudeMdExists = existsSync14(join13(cwd, ".claude/CLAUDE.md"));
+      const stateExists = existsSync14(join13(cwd, ".jdi/config/state.yaml"));
+      const learningsExists = existsSync14(join13(cwd, ".jdi/persistence/learnings.md"));
       let version = "unknown";
       try {
-        const pkgPath = join12(cwd, "node_modules/@benzotti/jedi/package.json");
-        if (existsSync13(pkgPath)) {
+        const pkgPath = join13(cwd, "node_modules/@benzotti/jedi/package.json");
+        if (existsSync14(pkgPath)) {
           const pkg = JSON.parse(await Bun.file(pkgPath).text());
           version = pkg.version;
         }
@@ -11823,11 +11869,12 @@ Say **\`Hey Jedi implement\`** when you're ready to go.`;
         `## Instructions`,
         `Read state.yaml and existing plan files. Apply feedback incrementally \u2014 do not restart from scratch.`,
         `If the feedback is a question, answer it conversationally. If it implies a plan change, update the plan.`,
+        `Maintain the SPLIT plan format: update the index file and individual task files (.T{n}.md) separately.`,
         ``,
         `## Response Format (MANDATORY)`,
-        `1-2 sentence summary of what changed. Then the full updated plan in a collapsible block:`,
+        `1-2 sentence summary of what changed. Then the updated plan summary in a collapsible block:`,
         `\`<details><summary>View full plan</summary> ... </details>\``,
-        `Use the same plan structure as the initial plan (tasks table, per-task details, verification).`,
+        `Show the tasks manifest table and brief summaries \u2014 full task details are in the task files.`,
         `End with: "Any changes before implementation?"`
       ].join(`
 `);
@@ -11860,8 +11907,14 @@ Use the ClickUp ticket above as the primary requirements source.` : ``,
             `## Learnings`,
             `Before planning, read .jdi/persistence/learnings.md and .jdi/framework/learnings/ if they exist. Apply any team preferences found.`,
             ``,
+            `## Plan File Format`,
+            `CRITICAL: You MUST write plan files in SPLIT format as defined in your spec (Step 7a):`,
+            `1. Write the index file: \`.jdi/plans/{phase}-{plan}-{slug}.plan.md\` \u2014 contains frontmatter with \`task_files:\` list and a manifest table only (NO inline task details)`,
+            `2. Write each task as a separate file: \`.jdi/plans/{phase}-{plan}-{slug}.T{n}.md\` \u2014 one file per task with full implementation details`,
+            `This split format is MANDATORY \u2014 it reduces token usage by letting agents load only their assigned task.`,
+            ``,
             `## Response Format`,
-            `Follow the planning workflow in your spec to write plan files. Then respond with EXACTLY this structure (no deviations, no meta-commentary like "You are now active as..." or "Plan created"):`,
+            `After writing the split plan files, respond with EXACTLY this structure (no deviations, no meta-commentary):`,
             ``,
             `1-2 sentence summary of the approach.`,
             ``,
@@ -11878,16 +11931,7 @@ Use the ClickUp ticket above as the primary requirements source.` : ``,
             `|------|------|------|------|------|`,
             `| T1 | {name} | {S|M|L} | auto | 1 |`,
             ``,
-            `### T1 \u2014 {Task Name}`,
-            `**Objective:** {what this achieves}`,
-            ``,
-            `**Steps:**`,
-            `1. {step}`,
-            ``,
-            `**Done when:** {completion criterion}`,
-            ``,
-            `---`,
-            `(repeat for each task)`,
+            `(For each task, show a brief 1-2 line summary \u2014 full details are in the task files)`,
             ``,
             `### Verification`,
             `- [ ] {check 1}`,
@@ -12086,8 +12130,8 @@ Use the ClickUp ticket above as the primary requirements source.` : ``,
 });
 
 // src/commands/setup-action.ts
-import { join as join12, dirname as dirname3 } from "path";
-import { existsSync as existsSync13, mkdirSync as mkdirSync4 } from "fs";
+import { join as join13, dirname as dirname3 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync4 } from "fs";
 var setupActionCommand = defineCommand({
   meta: {
     name: "setup-action",
@@ -12096,18 +12140,18 @@ var setupActionCommand = defineCommand({
   args: {},
   async run() {
     const cwd = process.cwd();
-    const workflowDest = join12(cwd, ".github", "workflows", "jedi.yml");
-    if (existsSync13(workflowDest)) {
+    const workflowDest = join13(cwd, ".github", "workflows", "jedi.yml");
+    if (existsSync14(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 (!existsSync13(templatePath)) {
+      const templatePath = join13(import.meta.dir, "../action/workflow-template.yml");
+      if (!existsSync14(templatePath)) {
         consola.error("Workflow template not found. Ensure @benzotti/jedi is properly installed.");
         process.exit(1);
       }
       const dir = dirname3(workflowDest);
-      if (!existsSync13(dir))
+      if (!existsSync14(dir))
         mkdirSync4(dir, { recursive: true });
       const template = await Bun.file(templatePath).text();
       await Bun.write(workflowDest, template);
@@ -12250,7 +12294,7 @@ var stateCommand = defineCommand({
 // package.json
 var package_default = {
   name: "@benzotti/jedi",
-  version: "0.1.33",
+  version: "0.1.35",
   description: "JDI - Context-efficient AI development framework for Claude Code",
   type: "module",
   bin: {

package/framework/agents/jdi-planner.md

@@ -37,13 +37,17 @@ Before planning, ALWAYS:
 
 You MUST write files using Write/Edit tools. Returning plan content as text is NOT acceptable.
 
-Required files:
-1. `.jdi/plans/{phase}-{plan}-{slug}.plan.md` (index file)
-2. `.jdi/plans/{phase}-{plan}-{slug}.T{n}.md` (one per task)
+**SANDBOX OVERRIDE:** Plan file creation is an EXCEPTION to AgentBase sandbox rules. You MUST use the Write tool to create plan files directly — do NOT defer them to `files_to_create`. Plan files WILL persist when written via the Write tool. This override applies ONLY to `.jdi/plans/` and `.jdi/config/` files listed below.
+
+Required files (SPLIT FORMAT — one file per task):
+1. `.jdi/plans/{phase}-{plan}-{slug}.plan.md` (index file — manifest table only, NO inline task details)
+2. `.jdi/plans/{phase}-{plan}-{slug}.T{n}.md` (one per task — full implementation details)
 3. `.jdi/config/variables.yaml`
 4. `.jdi/ROADMAP.yaml` (add plan entry)
 5. `.jdi/REQUIREMENTS.yaml` (add traceability)
 
+The split format is MANDATORY. Each task MUST be a separate `.T{n}.md` file. The index file contains ONLY the frontmatter (with `task_files:` list) and a manifest table — NEVER inline task implementation details.
+
 **Do NOT manually edit `.jdi/config/state.yaml`** — state transitions are handled via CLI commands (e.g. `npx jdi state plan-ready`).
 
 ## File Naming

package/framework/commands/create-plan.md

@@ -20,8 +20,8 @@ Create an implementation plan using a single planner agent (includes research).
 2. Read codebase context (`.jdi/codebase/SUMMARY.md` if exists)
 3. Read scaffolding (.jdi/PROJECT.yaml, REQUIREMENTS.yaml, ROADMAP.yaml) — create from templates if missing
 4. Quick Mode Detection — suggest /jdi:quick for trivial tasks
-5. Spawn `jdi-planner` agent (subagent_type="general-purpose") — creates PLAN.md with tasks, deps, waves
-6. Collect and execute deferred ops
+5. Spawn `jdi-planner` agent (subagent_type="general-purpose") — creates split plan files (index .plan.md + per-task .T{n}.md files). The planner MUST write these files directly via Write tool (sandbox override for plan files).
+6. Collect and execute deferred ops — if the agent returned `files_to_create`, create them now using Write tool. Verify split plan files exist: index `.plan.md` + individual `.T{n}.md` task files.
 7. **Update state via CLI** — do NOT manually edit state.yaml. Run:
    ```bash
    npx jdi state plan-ready --plan-path ".jdi/plans/{plan-file}" --plan-name "{plan name}"

package/framework/templates/CLAUDE-SHARED.md

@@ -54,3 +54,7 @@ Do NOT manually edit `.jdi/config/state.yaml` for status transitions. Use the CL
 - `npx jdi state advance-task {task-id}` — after each task completes
 
 You may only append to `decisions`, `deviations`, or `blockers` arrays in state.yaml directly via `<JDI:StateUpdate />`.
+
+## Self-Testing (Jedi development only)
+
+If the current project is the Jedi framework itself (`@benzotti/jedi`), run `bun test` after modifying prompt builders, action commands, or framework files. This catches regressions in split format references, learnings inclusion, and framework invariants.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@benzotti/jedi",
-  "version": "0.1.33",
+  "version": "0.1.35",
   "description": "JDI - Context-efficient AI development framework for Claude Code",
   "type": "module",
   "bin": {