@anthropologies/claudestory 0.1.57 → 0.1.59

package/dist/cli.js

@@ -5444,8 +5444,48 @@ var init_session_types = __esm({
         maxTicketsPerSession: z9.number().min(0).default(5),
         handoverInterval: z9.number().min(0).default(3),
         compactThreshold: z9.string().default("high"),
-        reviewBackends: z9.array(z9.string()).default(["codex", "agent"])
+        reviewBackends: z9.array(z9.string()).default(["codex", "agent"]),
+        // T-181: Multi-lens review config
+        lensConfig: z9.object({
+          lenses: z9.union([z9.literal("auto"), z9.array(z9.string())]).default("auto"),
+          maxLenses: z9.number().min(1).max(8).default(8),
+          lensTimeout: z9.union([
+            z9.number(),
+            z9.object({ default: z9.number(), opus: z9.number() })
+          ]).default({ default: 60, opus: 120 }),
+          findingBudget: z9.number().min(1).default(10),
+          confidenceFloor: z9.number().min(0).max(1).default(0.6),
+          tokenBudgetPerLens: z9.number().min(1e3).default(32e3),
+          hotPaths: z9.array(z9.string()).default([]),
+          lensModels: z9.record(z9.string()).default({ default: "sonnet", security: "opus", concurrency: "opus" })
+        }).optional(),
+        blockingPolicy: z9.object({
+          neverBlock: z9.array(z9.string()).default([]),
+          alwaysBlock: z9.array(z9.string()).default(["injection", "auth-bypass", "hardcoded-secrets"]),
+          planReviewBlockingLenses: z9.array(z9.string()).default(["security", "error-handling"])
+        }).optional(),
+        requireSecretsGate: z9.boolean().default(false),
+        requireAccessibility: z9.boolean().default(false),
+        testMapping: z9.object({
+          strategy: z9.literal("convention"),
+          patterns: z9.array(z9.object({
+            source: z9.string(),
+            test: z9.string()
+          }))
+        }).optional()
       }).default({ maxTicketsPerSession: 5, compactThreshold: "high", reviewBackends: ["codex", "agent"], handoverInterval: 3 }),
+      // T-181: Lens review findings history (for lessons feedback loop)
+      lensReviewHistory: z9.array(z9.object({
+        ticketId: z9.string(),
+        stage: z9.enum(["CODE_REVIEW", "PLAN_REVIEW"]),
+        lens: z9.string(),
+        category: z9.string(),
+        severity: z9.string(),
+        disposition: z9.enum(["open", "addressed", "contested", "deferred"]),
+        description: z9.string(),
+        dismissReason: z9.string().optional(),
+        timestamp: z9.string()
+      })).default([]),
       // T-123: Issue sweep tracking
       issueSweepState: z9.object({
         remaining: z9.array(z9.string()),
@@ -5474,7 +5514,8 @@ var init_session_types = __esm({
       resolvedDefaults: z9.object({
         maxTicketsPerSession: z9.number(),
         compactThreshold: z9.string(),
-        reviewBackends: z9.array(z9.string())
+        reviewBackends: z9.array(z9.string()),
+        handoverInterval: z9.number().optional()
       }).optional()
     }).passthrough();
   }
@@ -5667,7 +5708,8 @@ function refreshLease(state) {
     contextPressure: {
       ...state.contextPressure,
       guideCallCount: newCallCount,
-      ticketsCompleted: state.completedTickets?.length ?? 0
+      // ISS-084: Include resolved issues in work count
+      ticketsCompleted: (state.completedTickets?.length ?? 0) + (state.resolvedIssues?.length ?? 0)
     }
   };
 }
@@ -5885,7 +5927,7 @@ var init_state_machine = __esm({
       VERIFY: ["FINALIZE", "IMPLEMENT", "VERIFY"],
       // pass → FINALIZE, fail → IMPLEMENT, retry
       FINALIZE: ["COMPLETE", "PICK_TICKET"],
-      // PICK_TICKET for issue-fix flow (bypass COMPLETE)
+      // ISS-084: issues now route through COMPLETE too; PICK_TICKET kept for in-flight session compat
       COMPLETE: ["PICK_TICKET", "HANDOVER", "ISSUE_SWEEP", "SESSION_END"],
       ISSUE_FIX: ["FINALIZE", "PICK_TICKET", "ISSUE_FIX"],
       // T-153: fix done → FINALIZE, cancel → PICK_TICKET, retry self
@@ -5905,7 +5947,7 @@ var init_state_machine = __esm({
 // src/autonomous/context-pressure.ts
 function evaluatePressure(state) {
   const calls = state.contextPressure?.guideCallCount ?? state.guideCallCount ?? 0;
-  const tickets = state.contextPressure?.ticketsCompleted ?? state.completedTickets?.length ?? 0;
+  const tickets = (state.completedTickets?.length ?? 0) + (state.resolvedIssues?.length ?? 0);
   const eventsBytes = state.contextPressure?.eventsLogBytes ?? 0;
   const tier = state.config?.compactThreshold ?? "high";
   const t = THRESHOLDS[tier] ?? THRESHOLDS["high"];
@@ -6314,6 +6356,22 @@ function djb2Hash(content) {
   }
   return hash.toString(36);
 }
+function buildLensHistoryUpdate(findings, existing, ticketId, stage) {
+  const existingKeys = new Set(
+    existing.map((e) => `${e.ticketId}:${e.stage}:${e.lens}:${e.category}`)
+  );
+  const newEntries = findings.map((f) => ({
+    ticketId,
+    stage,
+    lens: typeof f.lens === "string" && f.lens !== "" ? f.lens : "unknown",
+    category: f.category,
+    severity: f.severity,
+    disposition: f.disposition ?? "open",
+    description: f.description,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  })).filter((e) => !existingKeys.has(`${e.ticketId}:${e.stage}:${e.lens}:${e.category}`));
+  return newEntries.length > 0 ? [...existing, ...newEntries] : null;
+}
 var StageContext;
 var init_types2 = __esm({
   "src/autonomous/stages/types.ts"() {
@@ -6448,17 +6506,22 @@ var init_pick_ticket = __esm({
             (c, i) => `${i + 1}. **${c.ticket.id}: ${c.ticket.title}** (${c.ticket.type})`
           ).join("\n");
         }
-        const highIssues = projectState.issues.filter(
-          (i) => i.status === "open" && (i.severity === "critical" || i.severity === "high")
-        );
+        const allOpenIssues = projectState.issues.filter((i) => i.status === "open");
+        const highIssues = allOpenIssues.filter((i) => i.severity === "critical" || i.severity === "high");
+        const otherIssues = allOpenIssues.filter((i) => i.severity !== "critical" && i.severity !== "high");
         let issuesText = "";
         if (highIssues.length > 0) {
           issuesText = "\n\n## Open Issues (high+ severity)\n\n" + highIssues.map(
             (i, idx) => `${idx + 1}. **${i.id}: ${i.title}** (${i.severity})`
           ).join("\n");
         }
+        if (otherIssues.length > 0) {
+          issuesText += "\n\n## Open Issues (medium/low)\n\n" + otherIssues.map(
+            (i, idx) => `${idx + 1}. **${i.id}: ${i.title}** (${i.severity})`
+          ).join("\n");
+        }
         const topCandidate = candidates.kind === "found" ? candidates.candidates[0] : null;
-        const hasIssues = highIssues.length > 0;
+        const hasIssues = allOpenIssues.length > 0;
         if (!topCandidate && candidates.kind !== "found" && !hasIssues) {
           return { action: "goto", target: "COMPLETE" };
         }
@@ -6479,7 +6542,7 @@ var init_pick_ticket = __esm({
               "",
               "Or to fix an issue:",
               "```json",
-              `{ "sessionId": "${ctx.state.sessionId}", "action": "report", "report": { "completedAction": "issue_picked", "issueId": "${highIssues[0].id}" } }`,
+              `{ "sessionId": "${ctx.state.sessionId}", "action": "report", "report": { "completedAction": "issue_picked", "issueId": "${(highIssues[0] ?? allOpenIssues[0]).id}" } }`,
               "```"
             ] : []
           ].join("\n"),
@@ -6697,6 +6760,7 @@ var init_plan_review = __esm({
   "src/autonomous/stages/plan-review.ts"() {
     "use strict";
     init_esm_shims();
+    init_types2();
     init_review_depth();
     PlanReviewStage = class {
       id = "PLAN_REVIEW";
@@ -6707,6 +6771,31 @@ var init_plan_review = __esm({
         const reviewer = nextReviewer(existingReviews, backends);
         const risk = ctx.state.ticket?.risk ?? "low";
         const minRounds = requiredRounds(risk);
+        if (reviewer === "lenses") {
+          return {
+            instruction: [
+              `# Multi-Lens Plan Review \u2014 Round ${roundNum} of ${Math.max(minRounds, roundNum)} minimum`,
+              "",
+              "This round uses the **multi-lens review orchestrator** for plan review. It fans out to specialized review agents (Clean Code, Security, Error Handling, and more) in parallel to evaluate the plan from multiple perspectives.",
+              "",
+              "1. Read the plan file",
+              "2. Call `prepareLensReview()` with the plan text (stage: PLAN_REVIEW)",
+              "3. Spawn all lens subagents in parallel",
+              "4. Collect results and pass through the merger and judge pipeline",
+              "5. Report the final SynthesisResult verdict and findings",
+              "",
+              "When done, call `claudestory_autonomous_guide` with:",
+              "```json",
+              `{ "sessionId": "${ctx.state.sessionId}", "action": "report", "report": { "completedAction": "plan_review_round", "verdict": "<approve|revise|reject>", "findings": [...] } }`,
+              "```"
+            ].join("\n"),
+            reminders: [
+              "Report the exact verdict and findings from the synthesizer.",
+              "Lens subagents run in parallel with read-only tools (Read, Grep, Glob)."
+            ],
+            transitionedFrom: ctx.state.previousState ?? void 0
+          };
+        }
         return {
           instruction: [
             `# Plan Review \u2014 Round ${roundNum} of ${Math.max(minRounds, roundNum)} minimum`,
@@ -6768,9 +6857,19 @@ var init_plan_review = __esm({
           nextAction = "PLAN_REVIEW";
         }
         const reviewsForWrite = isReject ? { ...ctx.state.reviews, plan: [] } : { ...ctx.state.reviews, plan: planReviews };
-        ctx.writeState({
+        const stateUpdate = {
           reviews: reviewsForWrite
-        });
+        };
+        if (reviewerBackend === "lenses" && findings.length > 0) {
+          const updated = buildLensHistoryUpdate(
+            findings,
+            ctx.state.lensReviewHistory ?? [],
+            ctx.state.ticket?.id ?? "unknown",
+            "PLAN_REVIEW"
+          );
+          if (updated) stateUpdate.lensReviewHistory = updated;
+        }
+        ctx.writeState(stateUpdate);
         ctx.appendEvent("plan_review", {
           round: roundNum,
           verdict,
@@ -7134,13 +7233,42 @@ var init_test = __esm({
   }
 });
 
+// src/autonomous/review-lenses/schema-validator.ts
+var init_schema_validator = __esm({
+  "src/autonomous/review-lenses/schema-validator.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/autonomous/review-lenses/cache.ts
+import { createHash } from "crypto";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync9, rmSync as rmSync2, renameSync as renameSync2 } from "fs";
+import { join as join12 } from "path";
+function clearCache(sessionDir2) {
+  const dir = join12(sessionDir2, CACHE_DIR);
+  if (!existsSync9(dir)) return;
+  rmSync2(dir, { recursive: true, force: true });
+}
+var CACHE_DIR;
+var init_cache = __esm({
+  "src/autonomous/review-lenses/cache.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_schema_validator();
+    CACHE_DIR = "lens-cache";
+  }
+});
+
 // src/autonomous/stages/code-review.ts
 var CodeReviewStage;
 var init_code_review = __esm({
   "src/autonomous/stages/code-review.ts"() {
     "use strict";
     init_esm_shims();
+    init_types2();
     init_review_depth();
+    init_cache();
     CodeReviewStage = class {
       id = "CODE_REVIEW";
       async enter(ctx) {
@@ -7153,6 +7281,32 @@ var init_code_review = __esm({
         const mergeBase = ctx.state.git.mergeBase;
         const diffCommand = mergeBase ? `\`git diff ${mergeBase}\`` : `\`git diff HEAD\` AND \`git ls-files --others --exclude-standard\``;
         const diffReminder = mergeBase ? `Run: git diff ${mergeBase} \u2014 pass FULL output to reviewer.` : "Run: git diff HEAD + git ls-files --others --exclude-standard \u2014 pass FULL output to reviewer.";
+        if (reviewer === "lenses") {
+          return {
+            instruction: [
+              `# Multi-Lens Code Review \u2014 Round ${roundNum} of ${rounds} minimum`,
+              "",
+              `Capture the diff with: ${diffCommand}`,
+              "",
+              "This round uses the **multi-lens review orchestrator**. It fans out to specialized review agents (Clean Code, Security, Error Handling, and more) in parallel, then synthesizes findings into a single verdict.",
+              "",
+              "1. Capture the full diff",
+              "2. Call `prepareLensReview()` with the diff and changed file list",
+              "3. Spawn all lens subagents in parallel (each prompt is provided by the orchestrator)",
+              "4. Collect results and pass through the merger and judge pipeline",
+              "5. Report the final SynthesisResult verdict and findings",
+              "",
+              "When done, report verdict and findings."
+            ].join("\n"),
+            reminders: [
+              diffReminder,
+              "Do NOT compress or summarize the diff.",
+              "Lens subagents run in parallel with read-only tools (Read, Grep, Glob).",
+              "If the reviewer flags pre-existing issues unrelated to your changes, file them as issues using claudestory_issue_create with severity and impact. Do not fix them in this ticket."
+            ],
+            transitionedFrom: ctx.state.previousState ?? void 0
+          };
+        }
         return {
           instruction: [
             `# Code Review \u2014 Round ${roundNum} of ${rounds} minimum`,
@@ -7218,8 +7372,10 @@ var init_code_review = __esm({
           nextAction = "CODE_REVIEW";
         }
         if (nextAction === "PLAN") {
+          clearCache(ctx.dir);
           ctx.writeState({
             reviews: { plan: [], code: [] },
+            lensReviewHistory: [],
             ticket: ctx.state.ticket ? { ...ctx.state.ticket, realizedRisk: void 0 } : ctx.state.ticket
           });
           ctx.appendEvent("code_review", {
@@ -7231,9 +7387,19 @@ var init_code_review = __esm({
           await ctx.fileDeferredFindings(findings, "code");
           return { action: "back", target: "PLAN", reason: "plan_redirect" };
         }
-        ctx.writeState({
+        const stateUpdate = {
           reviews: { ...ctx.state.reviews, code: codeReviews }
-        });
+        };
+        if (reviewerBackend === "lenses" && findings.length > 0) {
+          const updated = buildLensHistoryUpdate(
+            findings,
+            ctx.state.lensReviewHistory ?? [],
+            ctx.state.ticket?.id ?? "unknown",
+            "CODE_REVIEW"
+          );
+          if (updated) stateUpdate.lensReviewHistory = updated;
+        }
+        ctx.writeState(stateUpdate);
         ctx.appendEvent("code_review", {
           round: roundNum,
           verdict,
@@ -7798,7 +7964,7 @@ var init_finalize = __esm({
             }
           });
           ctx.appendEvent("commit", { commitHash: normalizedHash, issueId: currentIssue.id });
-          return { action: "goto", target: "PICK_TICKET" };
+          return { action: "goto", target: "COMPLETE" };
         }
         const completedTicket = ctx.state.ticket ? { id: ctx.state.ticket.id, title: ctx.state.ticket.title, commitHash: normalizedHash, risk: ctx.state.ticket.risk, realizedRisk: ctx.state.ticket.realizedRisk } : void 0;
         ctx.writeState({
@@ -7836,6 +8002,8 @@ var init_complete = __esm({
           finalizeCheckpoint: null
         });
         const ticketsDone = ctx.state.completedTickets.length;
+        const issuesDone = (ctx.state.resolvedIssues ?? []).length;
+        const totalWorkDone = ticketsDone + issuesDone;
         const maxTickets = ctx.state.config.maxTicketsPerSession;
         const mode = ctx.state.mode ?? "auto";
         if (mode !== "auto") {
@@ -7856,15 +8024,17 @@ var init_complete = __esm({
           };
         }
         const handoverInterval = ctx.state.config.handoverInterval ?? 5;
-        if (handoverInterval > 0 && ticketsDone > 0 && ticketsDone % handoverInterval === 0) {
+        if (handoverInterval > 0 && totalWorkDone > 0 && totalWorkDone % handoverInterval === 0) {
           try {
             const { handleHandoverCreate: handleHandoverCreate3 } = await Promise.resolve().then(() => (init_handover(), handover_exports));
             const completedIds = ctx.state.completedTickets.map((t) => t.id).join(", ");
+            const resolvedIds = (ctx.state.resolvedIssues ?? []).join(", ");
             const content = [
-              `# Checkpoint \u2014 ${ticketsDone} tickets completed`,
+              `# Checkpoint \u2014 ${totalWorkDone} items completed`,
               "",
               `**Session:** ${ctx.state.sessionId}`,
-              `**Tickets:** ${completedIds}`,
+              ...completedIds ? [`**Tickets:** ${completedIds}`] : [],
+              ...resolvedIds ? [`**Issues resolved:** ${resolvedIds}`] : [],
               "",
               "This is an automatic mid-session checkpoint. The session is still active."
             ].join("\n");
@@ -7878,24 +8048,19 @@ var init_complete = __esm({
             await saveSnapshot2(ctx.root, loadResult);
           } catch {
           }
-          ctx.appendEvent("checkpoint", { ticketsDone, interval: handoverInterval });
+          ctx.appendEvent("checkpoint", { ticketsDone, issuesDone, totalWorkDone, interval: handoverInterval });
         }
+        const { state: projectState } = await ctx.loadProject();
         let nextTarget;
-        if (maxTickets > 0 && ticketsDone >= maxTickets) {
+        if (maxTickets > 0 && totalWorkDone >= maxTickets) {
           nextTarget = "HANDOVER";
         } else {
-          nextTarget = "PICK_TICKET";
-        }
-        const { state: projectState } = await ctx.loadProject();
-        const nextResult = nextTickets(projectState, 1);
-        if (nextResult.kind !== "found") {
-          const highIssues = projectState.issues.filter(
-            (i) => i.status === "open" && (i.severity === "critical" || i.severity === "high")
-          );
-          if (highIssues.length > 0) {
+          const nextResult = nextTickets(projectState, 1);
+          if (nextResult.kind === "found") {
             nextTarget = "PICK_TICKET";
           } else {
-            nextTarget = "HANDOVER";
+            const openIssues = projectState.issues.filter((i) => i.status === "open");
+            nextTarget = openIssues.length > 0 ? "PICK_TICKET" : "HANDOVER";
           }
         }
         if (nextTarget === "HANDOVER") {
@@ -7910,7 +8075,7 @@ var init_complete = __esm({
             target: "HANDOVER",
             result: {
               instruction: [
-                `# Session Complete \u2014 ${ticketsDone} ticket(s) done`,
+                `# Session Complete \u2014 ${ticketsDone} ticket(s) and ${issuesDone} issue(s) done`,
                 "",
                 "Write a session handover summarizing what was accomplished, decisions made, and what's next.",
                 "",
@@ -7979,6 +8144,7 @@ var init_lesson_capture = __esm({
         const planReviews = ctx.state.reviews.plan ?? [];
         const codeReviews = ctx.state.reviews.code ?? [];
         const ticketsDone = ctx.state.completedTickets.length;
+        const issuesDone = (ctx.state.resolvedIssues ?? []).length;
         const planFindings = planReviews.reduce((sum, r) => sum + (r.findingCount ?? 0), 0);
         const planCritical = planReviews.reduce((sum, r) => sum + (r.criticalCount ?? 0), 0);
         const planMajor = planReviews.reduce((sum, r) => sum + (r.majorCount ?? 0), 0);
@@ -7996,11 +8162,49 @@ var init_lesson_capture = __esm({
           planFindings,
           codeFindings
         });
+        const lensHistory = ctx.state.lensReviewHistory ?? [];
+        const dismissed = lensHistory.filter(
+          (f) => f.disposition === "contested"
+        );
+        const tupleCounts = /* @__PURE__ */ new Map();
+        for (const f of lensHistory) {
+          const key = `${f.lens}:${f.category}`;
+          const entry = tupleCounts.get(key) ?? { total: 0, dismissed: 0 };
+          entry.total++;
+          if (f.disposition === "contested") {
+            entry.dismissed++;
+          }
+          tupleCounts.set(key, entry);
+        }
+        const falsePositivePatterns = [];
+        for (const [key, counts] of tupleCounts) {
+          if (counts.total >= 5 && counts.dismissed / counts.total >= 0.6) {
+            falsePositivePatterns.push(
+              `- **${key}**: ${counts.dismissed}/${counts.total} dismissed (${Math.round(counts.dismissed / counts.total * 100)}%)`
+            );
+          }
+        }
+        const lensSection = falsePositivePatterns.length > 0 ? [
+          "",
+          "## Lens False Positive Patterns",
+          "",
+          "These (lens, category) tuples have a >60% dismissal rate over 5+ reviews. Create a lesson for each:",
+          ...falsePositivePatterns,
+          "",
+          'For each pattern above, create a lesson: "Lens X tends to flag category Y, but this project considers it acceptable because [reason from dismiss history]."',
+          'Tag with `source: "lens-feedback"` and `tags: ["lens", lens-name]`.'
+        ].join("\n") : "";
+        const dismissedSection = dismissed.length > 0 && falsePositivePatterns.length === 0 ? [
+          "",
+          `## Dismissed Lens Findings (${dismissed.length})`,
+          "",
+          "Some lens findings were dismissed this session. Not enough data for automatic patterns yet (need 5+ reviews per tuple at >60% dismissal rate)."
+        ].join("\n") : "";
         return {
           instruction: [
             "# Capture Lessons from Review Findings",
             "",
-            `This session completed ${ticketsDone} ticket(s). Review summary:`,
+            `This session completed ${ticketsDone} ticket(s) and ${issuesDone} issue(s). Review summary:`,
             `- **Plan reviews:** ${planReviews.length} round(s), ${planCritical} critical, ${planMajor} major, ${planFindings} total findings`,
             `- **Code reviews:** ${codeReviews.length} round(s), ${codeCritical} critical, ${codeMajor} major, ${codeFindings} total findings`,
             "",
@@ -8011,15 +8215,18 @@ var init_lesson_capture = __esm({
             "   - If it matches an existing lesson \u2192 call `claudestory_lesson_reinforce`",
             '   - If it\'s a new pattern \u2192 call `claudestory_lesson_create` with `source: "review"`',
             "3. Skip patterns that are one-off or already well-covered",
+            lensSection,
+            dismissedSection,
             `4. Call \`claudestory_autonomous_guide\` with completedAction: "lessons_captured"`,
             "",
             "```json",
             `{ "sessionId": "${ctx.state.sessionId}", "action": "report", "report": { "completedAction": "lessons_captured" } }`,
             "```"
-          ].join("\n"),
+          ].filter(Boolean).join("\n"),
           reminders: [
             "Check existing lessons first \u2014 reinforce before creating duplicates.",
-            "Only capture patterns worth remembering across sessions."
+            "Only capture patterns worth remembering across sessions.",
+            ...falsePositivePatterns.length > 0 ? ["Lens false positive patterns MUST be captured as lessons \u2014 they improve future reviews."] : []
           ]
         };
       }
@@ -8218,8 +8425,8 @@ Impact: ${nextIssue.impact}` : ""}` : `Fix issue ${next}.`,
 });
 
 // src/autonomous/stages/handover.ts
-import { writeFileSync as writeFileSync2 } from "fs";
-import { join as join12 } from "path";
+import { writeFileSync as writeFileSync3 } from "fs";
+import { join as join13 } from "path";
 var HandoverStage;
 var init_handover2 = __esm({
   "src/autonomous/stages/handover.ts"() {
@@ -8231,9 +8438,10 @@ var init_handover2 = __esm({
       id = "HANDOVER";
       async enter(ctx) {
         const ticketsDone = ctx.state.completedTickets.length;
+        const issuesDone = (ctx.state.resolvedIssues ?? []).length;
         return {
           instruction: [
-            `# Session Complete \u2014 ${ticketsDone} ticket(s) done`,
+            `# Session Complete \u2014 ${ticketsDone} ticket(s) and ${issuesDone} issue(s) done`,
             "",
             "Write a session handover summarizing what was accomplished, decisions made, and what's next.",
             "",
@@ -8256,8 +8464,8 @@ var init_handover2 = __esm({
         } catch {
           handoverFailed = true;
           try {
-            const fallbackPath = join12(ctx.dir, "handover-fallback.md");
-            writeFileSync2(fallbackPath, content, "utf-8");
+            const fallbackPath = join13(ctx.dir, "handover-fallback.md");
+            writeFileSync3(fallbackPath, content, "utf-8");
           } catch {
           }
         }
@@ -8280,18 +8488,22 @@ var init_handover2 = __esm({
         });
         ctx.appendEvent("session_end", {
           ticketsCompleted: ctx.state.completedTickets.length,
+          issuesResolved: (ctx.state.resolvedIssues ?? []).length,
           handoverFailed
         });
         const ticketsDone = ctx.state.completedTickets.length;
+        const issuesDone = (ctx.state.resolvedIssues ?? []).length;
+        const resolvedList = (ctx.state.resolvedIssues ?? []).map((id) => `- ${id} (resolved)`).join("\n");
         return {
           action: "advance",
           result: {
             instruction: [
               "# Session Complete",
               "",
-              `${ticketsDone} ticket(s) completed.${handoverFailed ? " Handover creation failed \u2014 fallback saved to session directory." : " Handover written."}${stashPopFailed ? " Auto-stash pop failed \u2014 run `git stash pop` manually." : ""} Session ended.`,
+              `${ticketsDone} ticket(s) and ${issuesDone} issue(s) completed.${handoverFailed ? " Handover creation failed \u2014 fallback saved to session directory." : " Handover written."}${stashPopFailed ? " Auto-stash pop failed \u2014 run `git stash pop` manually." : ""} Session ended.`,
               "",
-              ctx.state.completedTickets.map((t) => `- ${t.id}${t.title ? `: ${t.title}` : ""} (${t.commitHash ?? "no commit"})`).join("\n")
+              ctx.state.completedTickets.map((t) => `- ${t.id}${t.title ? `: ${t.title}` : ""} (${t.commitHash ?? "no commit"})`).join("\n"),
+              ...resolvedList ? [resolvedList] : []
             ].join("\n"),
             reminders: [],
             transitionedFrom: "HANDOVER"
@@ -8342,8 +8554,8 @@ var init_stages = __esm({
 });
 
 // src/autonomous/version-check.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { join as join13, dirname as dirname4 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { join as join14, dirname as dirname4 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function checkVersionMismatch(runningVersion, installedVersion) {
   if (!installedVersion) return null;
@@ -8355,12 +8567,12 @@ function getInstalledVersion() {
   try {
     const thisFile = fileURLToPath3(import.meta.url);
     const candidates = [
-      join13(dirname4(thisFile), "..", "..", "package.json"),
-      join13(dirname4(thisFile), "..", "package.json")
+      join14(dirname4(thisFile), "..", "..", "package.json"),
+      join14(dirname4(thisFile), "..", "package.json")
     ];
     for (const candidate of candidates) {
       try {
-        const raw = readFileSync6(candidate, "utf-8");
+        const raw = readFileSync7(candidate, "utf-8");
         const pkg = JSON.parse(raw);
         if (pkg.version) return pkg.version;
       } catch {
@@ -8372,7 +8584,7 @@ function getInstalledVersion() {
   }
 }
 function getRunningVersion() {
-  return "0.1.57";
+  return "0.1.59";
 }
 var init_version_check = __esm({
   "src/autonomous/version-check.ts"() {
@@ -8382,23 +8594,23 @@ var init_version_check = __esm({
 });
 
 // src/autonomous/guide.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, readdirSync as readdirSync4 } from "fs";
-import { join as join14 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, readdirSync as readdirSync4 } from "fs";
+import { join as join15 } from "path";
 function buildGuideRecommendOptions(root) {
   const opts = {};
   try {
-    const handoversDir = join14(root, ".story", "handovers");
+    const handoversDir = join15(root, ".story", "handovers");
     const files = readdirSync4(handoversDir, "utf-8").filter((f) => f.endsWith(".md")).sort();
     if (files.length > 0) {
-      opts.latestHandoverContent = readFileSync7(join14(handoversDir, files[files.length - 1]), "utf-8");
+      opts.latestHandoverContent = readFileSync8(join15(handoversDir, files[files.length - 1]), "utf-8");
     }
   } catch {
   }
   try {
-    const snapshotsDir = join14(root, ".story", "snapshots");
+    const snapshotsDir = join15(root, ".story", "snapshots");
     const snapFiles = readdirSync4(snapshotsDir, "utf-8").filter((f) => f.endsWith(".json")).sort();
     if (snapFiles.length > 0) {
-      const raw = readFileSync7(join14(snapshotsDir, snapFiles[snapFiles.length - 1]), "utf-8");
+      const raw = readFileSync8(join15(snapshotsDir, snapFiles[snapFiles.length - 1]), "utf-8");
       const snap = JSON.parse(raw);
       if (snap.issues) {
         opts.previousOpenIssueCount = snap.issues.filter((i) => i.status !== "resolved").length;
@@ -8780,7 +8992,7 @@ Staged: ${stagedResult.data.join(", ")}`
       }
     }
     const { state: projectState, warnings } = await loadProject(root);
-    const handoversDir = join14(root, ".story", "handovers");
+    const handoversDir = join15(root, ".story", "handovers");
     const ctx = { state: projectState, warnings, root, handoversDir, format: "md" };
     let handoverText = "";
     try {
@@ -8797,7 +9009,7 @@ Staged: ${stagedResult.data.join(", ")}`
       }
     } catch {
     }
-    const rulesText = readFileSafe2(join14(root, "RULES.md"));
+    const rulesText = readFileSafe2(join15(root, "RULES.md"));
     const lessonDigest = buildLessonDigest(projectState.lessons);
     const digestParts = [
       handoverText ? `## Recent Handovers
@@ -8813,7 +9025,7 @@ ${rulesText}` : "",
     ].filter(Boolean);
     const digest = digestParts.join("\n\n---\n\n");
     try {
-      writeFileSync3(join14(dir, "context-digest.md"), digest, "utf-8");
+      writeFileSync4(join15(dir, "context-digest.md"), digest, "utf-8");
     } catch {
     }
     if (mode !== "auto" && args.ticketId) {
@@ -9318,7 +9530,7 @@ ${driftPreamble}Recovered to state: **${mapping.state}**. Continue from here.`,
       instruction: [
         "# Resumed After Compact \u2014 Continue Working",
         "",
-        `${written.completedTickets.length} ticket(s) done so far. Context compacted. Pick the next ticket immediately.`,
+        `${written.completedTickets.length} ticket(s) and ${(written.resolvedIssues ?? []).length} issue(s) done so far. Context compacted. Pick the next ticket or issue immediately.`,
         "",
         candidatesText,
         "",
@@ -9434,7 +9646,8 @@ async function handleCancel(root, args) {
     return guideError(new Error("Session already ended."));
   }
   const isAutoMode = info.state.mode === "auto" || !info.state.mode;
-  const hasTicketsRemaining = info.state.config.maxTicketsPerSession === 0 || info.state.completedTickets.length < info.state.config.maxTicketsPerSession;
+  const totalDone = info.state.completedTickets.length + (info.state.resolvedIssues?.length ?? 0);
+  const hasTicketsRemaining = info.state.config.maxTicketsPerSession === 0 || totalDone < info.state.config.maxTicketsPerSession;
   const isWorkingState = !["SESSION_END", "HANDOVER", "COMPACT"].includes(info.state.state);
   if (isAutoMode && hasTicketsRemaining && isWorkingState) {
     return {
@@ -9443,7 +9656,7 @@ async function handleCancel(root, args) {
         text: [
           "# Cancel Rejected \u2014 Session Still Active",
           "",
-          `You have completed ${info.state.completedTickets.length} ticket(s) with more work remaining.`,
+          `You have completed ${info.state.completedTickets.length} ticket(s) and ${(info.state.resolvedIssues ?? []).length} issue(s) with more work remaining.`,
           "Do NOT cancel an autonomous session due to context size.",
           "If you need to manage context, Claude Code handles compaction automatically.",
           "",
@@ -9511,14 +9724,14 @@ async function handleCancel(root, args) {
   });
   const stashNote = stashPopFailed ? " Auto-stash pop failed \u2014 run `git stash pop` manually." : "";
   return {
-    content: [{ type: "text", text: `Session ${args.sessionId} cancelled. ${written.completedTickets.length} ticket(s) were completed.${stashNote}` }]
+    content: [{ type: "text", text: `Session ${args.sessionId} cancelled. ${written.completedTickets.length} ticket(s) and ${(written.resolvedIssues ?? []).length} issue(s) were completed.${stashNote}` }]
   };
 }
 function guideResult(state, currentState, opts) {
   const summary = {
     ticket: state.ticket ? `${state.ticket.id}: ${state.ticket.title}` : "none",
     risk: state.ticket?.risk ?? "unknown",
-    completed: state.completedTickets.map((t) => t.id),
+    completed: [...state.completedTickets.map((t) => t.id), ...state.resolvedIssues ?? []],
     currentStep: currentState,
     contextPressure: state.contextPressure?.level ?? "low",
     branch: state.git?.branch ?? null
@@ -9564,7 +9777,7 @@ function guideError(err) {
 }
 function readFileSafe2(path2) {
   try {
-    return readFileSync7(path2, "utf-8");
+    return readFileSync8(path2, "utf-8");
   } catch {
     return "";
   }
@@ -9817,8 +10030,8 @@ var init_session_report_formatter = __esm({
 });
 
 // src/cli/commands/session-report.ts
-import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
-import { join as join15 } from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync11 } from "fs";
+import { join as join16 } from "path";
 async function handleSessionReport(sessionId, root, format = "md") {
   if (!UUID_REGEX.test(sessionId)) {
     return {
@@ -9829,7 +10042,7 @@ async function handleSessionReport(sessionId, root, format = "md") {
     };
   }
   const dir = sessionDir(root, sessionId);
-  if (!existsSync10(dir)) {
+  if (!existsSync11(dir)) {
     return {
       output: `Error: Session ${sessionId} not found.`,
       exitCode: 1,
@@ -9837,8 +10050,8 @@ async function handleSessionReport(sessionId, root, format = "md") {
       isError: true
     };
   }
-  const statePath2 = join15(dir, "state.json");
-  if (!existsSync10(statePath2)) {
+  const statePath2 = join16(dir, "state.json");
+  if (!existsSync11(statePath2)) {
     return {
       output: `Error: Session ${sessionId} corrupt \u2014 state.json missing.`,
       exitCode: 1,
@@ -9847,7 +10060,7 @@ async function handleSessionReport(sessionId, root, format = "md") {
     };
   }
   try {
-    const rawJson = JSON.parse(readFileSync8(statePath2, "utf-8"));
+    const rawJson = JSON.parse(readFileSync9(statePath2, "utf-8"));
     if (rawJson && typeof rawJson === "object" && "schemaVersion" in rawJson && rawJson.schemaVersion !== CURRENT_SESSION_SCHEMA_VERSION) {
       return {
         output: `Error: Session ${sessionId} \u2014 unsupported session schema version ${rawJson.schemaVersion}.`,
@@ -9876,7 +10089,7 @@ async function handleSessionReport(sessionId, root, format = "md") {
   const events = readEvents(dir);
   let planContent = null;
   try {
-    planContent = readFileSync8(join15(dir, "plan.md"), "utf-8");
+    planContent = readFileSync9(join16(dir, "plan.md"), "utf-8");
   } catch {
   }
   let gitLog = null;
@@ -9905,7 +10118,7 @@ var init_session_report = __esm({
 });
 
 // src/cli/commands/phase.ts
-import { join as join16, resolve as resolve6 } from "path";
+import { join as join17, resolve as resolve6 } from "path";
 function validatePhaseId(id) {
   if (id.length > PHASE_ID_MAX_LENGTH) {
     throw new CliValidationError("invalid_input", `Phase ID "${id}" exceeds ${PHASE_ID_MAX_LENGTH} characters`);
@@ -10094,21 +10307,21 @@ async function handlePhaseDelete(id, reassign, format, root) {
         const updated = { ...ticket, phase: reassign, order: maxOrder };
         const parsed = TicketSchema.parse(updated);
         const content = serializeJSON(parsed);
-        const target = join16(wrapDir, "tickets", `${parsed.id}.json`);
+        const target = join17(wrapDir, "tickets", `${parsed.id}.json`);
         operations.push({ op: "write", target, content });
       }
       for (const issue of affectedIssues) {
         const updated = { ...issue, phase: reassign };
         const parsed = IssueSchema.parse(updated);
         const content = serializeJSON(parsed);
-        const target = join16(wrapDir, "issues", `${parsed.id}.json`);
+        const target = join17(wrapDir, "issues", `${parsed.id}.json`);
         operations.push({ op: "write", target, content });
       }
       const newPhases = state.roadmap.phases.filter((p) => p.id !== id);
       const newRoadmap = { ...state.roadmap, phases: newPhases };
       const parsedRoadmap = RoadmapSchema.parse(newRoadmap);
       const roadmapContent = serializeJSON(parsedRoadmap);
-      const roadmapTarget = join16(wrapDir, "roadmap.json");
+      const roadmapTarget = join17(wrapDir, "roadmap.json");
       operations.push({ op: "write", target: roadmapTarget, content: roadmapContent });
       await runTransactionUnlocked(root, operations);
     } else {
@@ -10141,14 +10354,14 @@ var init_phase = __esm({
 
 // src/mcp/tools.ts
 import { z as z10 } from "zod";
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 function formatMcpError(code, message) {
   return `[${code}] ${message}`;
 }
 async function runMcpReadTool(pinnedRoot, handler) {
   try {
     const { state, warnings } = await loadProject(pinnedRoot);
-    const handoversDir = join17(pinnedRoot, ".story", "handovers");
+    const handoversDir = join18(pinnedRoot, ".story", "handovers");
     const ctx = { state, warnings, root: pinnedRoot, handoversDir, format: "md" };
     const result = await handler(ctx);
     if (result.errorCode && INFRASTRUCTURE_ERROR_CODES.includes(result.errorCode)) {
@@ -10736,10 +10949,10 @@ var init_tools = __esm({
 
 // src/core/init.ts
 import { mkdir as mkdir4, stat as stat2, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
-import { join as join18, resolve as resolve7 } from "path";
+import { join as join19, resolve as resolve7 } from "path";
 async function initProject(root, options) {
   const absRoot = resolve7(root);
-  const wrapDir = join18(absRoot, ".story");
+  const wrapDir = join19(absRoot, ".story");
   let exists = false;
   try {
     const s = await stat2(wrapDir);
@@ -10759,11 +10972,11 @@ async function initProject(root, options) {
       ".story/ already exists. Use --force to overwrite config and roadmap."
     );
   }
-  await mkdir4(join18(wrapDir, "tickets"), { recursive: true });
-  await mkdir4(join18(wrapDir, "issues"), { recursive: true });
-  await mkdir4(join18(wrapDir, "handovers"), { recursive: true });
-  await mkdir4(join18(wrapDir, "notes"), { recursive: true });
-  await mkdir4(join18(wrapDir, "lessons"), { recursive: true });
+  await mkdir4(join19(wrapDir, "tickets"), { recursive: true });
+  await mkdir4(join19(wrapDir, "issues"), { recursive: true });
+  await mkdir4(join19(wrapDir, "handovers"), { recursive: true });
+  await mkdir4(join19(wrapDir, "notes"), { recursive: true });
+  await mkdir4(join19(wrapDir, "lessons"), { recursive: true });
   const created = [
     ".story/config.json",
     ".story/roadmap.json",
@@ -10803,7 +11016,7 @@ async function initProject(root, options) {
   };
   await writeConfig(config, absRoot);
   await writeRoadmap(roadmap, absRoot);
-  const gitignorePath = join18(wrapDir, ".gitignore");
+  const gitignorePath = join19(wrapDir, ".gitignore");
   await ensureGitignoreEntries(gitignorePath, STORY_GITIGNORE_ENTRIES);
   const warnings = [];
   if (options.force && exists) {
@@ -10850,8 +11063,8 @@ var init_init = __esm({
 
 // src/mcp/index.ts
 var mcp_exports = {};
-import { realpathSync as realpathSync2, existsSync as existsSync11 } from "fs";
-import { resolve as resolve8, join as join19, isAbsolute } from "path";
+import { realpathSync as realpathSync2, existsSync as existsSync12 } from "fs";
+import { resolve as resolve8, join as join20, isAbsolute } from "path";
 import { z as z11 } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
@@ -10866,7 +11079,7 @@ function tryDiscoverRoot() {
     const resolved = resolve8(envRoot);
     try {
       const canonical = realpathSync2(resolved);
-      if (existsSync11(join19(canonical, CONFIG_PATH2))) {
+      if (existsSync12(join20(canonical, CONFIG_PATH2))) {
         return canonical;
       }
       process.stderr.write(`Warning: No .story/config.json at ${canonical}
@@ -10969,7 +11182,7 @@ var init_mcp = __esm({
     init_init();
     ENV_VAR2 = "CLAUDESTORY_PROJECT_ROOT";
     CONFIG_PATH2 = ".story/config.json";
-    version = "0.1.57";
+    version = "0.1.59";
     main().catch((err) => {
       process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -11005,7 +11218,7 @@ __export(run_exports, {
   runReadCommand: () => runReadCommand,
   writeOutput: () => writeOutput
 });
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 function writeOutput(text) {
   try {
     process.stdout.write(text + "\n");
@@ -11033,7 +11246,7 @@ async function runReadCommand(format, handler) {
       return;
     }
     const { state, warnings } = await loadProject(root);
-    const handoversDir = join20(root, ".story", "handovers");
+    const handoversDir = join21(root, ".story", "handovers");
     const result = await handler({ state, warnings, root, handoversDir, format });
     writeOutput(result.output);
     let exitCode = result.exitCode ?? ExitCode.OK;
@@ -11068,7 +11281,7 @@ async function runDeleteCommand(format, force, handler) {
       return;
     }
     const { state, warnings } = await loadProject(root);
-    const handoversDir = join20(root, ".story", "handovers");
+    const handoversDir = join21(root, ".story", "handovers");
     if (!force && hasIntegrityWarnings(warnings)) {
       writeOutput(
         formatError(
@@ -11582,8 +11795,8 @@ __export(setup_skill_exports, {
   resolveSkillSourceDir: () => resolveSkillSourceDir
 });
 import { mkdir as mkdir5, writeFile as writeFile3, readFile as readFile5, readdir as readdir4, copyFile, rm, rename as rename2, unlink as unlink3 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import { join as join21, dirname as dirname5 } from "path";
+import { existsSync as existsSync13 } from "fs";
+import { join as join22, dirname as dirname5 } from "path";
 import { homedir } from "os";
 import { execFileSync } from "child_process";
 import { fileURLToPath as fileURLToPath4 } from "url";
@@ -11592,10 +11805,10 @@ function log(msg) {
 }
 function resolveSkillSourceDir() {
   const thisDir = dirname5(fileURLToPath4(import.meta.url));
-  const bundledPath = join21(thisDir, "..", "src", "skill");
-  if (existsSync12(join21(bundledPath, "SKILL.md"))) return bundledPath;
-  const sourcePath = join21(thisDir, "..", "..", "skill");
-  if (existsSync12(join21(sourcePath, "SKILL.md"))) return sourcePath;
+  const bundledPath = join22(thisDir, "..", "src", "skill");
+  if (existsSync13(join22(bundledPath, "SKILL.md"))) return bundledPath;
+  const sourcePath = join22(thisDir, "..", "..", "skill");
+  if (existsSync13(join22(sourcePath, "SKILL.md"))) return sourcePath;
   throw new Error(
     `Cannot find bundled skill files. Checked:
   ${bundledPath}
@@ -11605,31 +11818,31 @@ function resolveSkillSourceDir() {
 async function copyDirRecursive(srcDir, destDir) {
   const tmpDir = destDir + ".tmp";
   const bakDir = destDir + ".bak";
-  if (!existsSync12(destDir) && existsSync12(bakDir)) {
+  if (!existsSync13(destDir) && existsSync13(bakDir)) {
     await rename2(bakDir, destDir);
   }
-  if (existsSync12(tmpDir)) await rm(tmpDir, { recursive: true, force: true });
-  if (existsSync12(bakDir)) await rm(bakDir, { recursive: true, force: true });
+  if (existsSync13(tmpDir)) await rm(tmpDir, { recursive: true, force: true });
+  if (existsSync13(bakDir)) await rm(bakDir, { recursive: true, force: true });
   await mkdir5(tmpDir, { recursive: true });
   const entries = await readdir4(srcDir, { withFileTypes: true, recursive: true });
   const written = [];
   for (const entry of entries) {
     if (!entry.isFile()) continue;
     const parent = entry.parentPath ?? entry.path ?? srcDir;
-    const relativePath = join21(parent, entry.name).slice(srcDir.length + 1);
-    const srcPath = join21(srcDir, relativePath);
-    const destPath = join21(tmpDir, relativePath);
+    const relativePath = join22(parent, entry.name).slice(srcDir.length + 1);
+    const srcPath = join22(srcDir, relativePath);
+    const destPath = join22(tmpDir, relativePath);
     await mkdir5(dirname5(destPath), { recursive: true });
     await copyFile(srcPath, destPath);
     written.push(relativePath);
   }
-  if (existsSync12(destDir)) {
+  if (existsSync13(destDir)) {
     await rename2(destDir, bakDir);
   }
   try {
     await rename2(tmpDir, destDir);
   } catch (err) {
-    if (existsSync12(bakDir)) await rename2(bakDir, destDir).catch(() => {
+    if (existsSync13(bakDir)) await rename2(bakDir, destDir).catch(() => {
     });
     await rm(tmpDir, { recursive: true, force: true }).catch(() => {
     });
@@ -11645,9 +11858,9 @@ function isHookWithCommand(entry, command) {
   return e.type === "command" && typeof e.command === "string" && e.command.trim() === command;
 }
 async function registerHook(hookType, hookEntry, settingsPath, matcher) {
-  const path2 = settingsPath ?? join21(homedir(), ".claude", "settings.json");
+  const path2 = settingsPath ?? join22(homedir(), ".claude", "settings.json");
   let raw = "{}";
-  if (existsSync12(path2)) {
+  if (existsSync13(path2)) {
     try {
       raw = await readFile5(path2, "utf-8");
     } catch {
@@ -11743,9 +11956,9 @@ async function registerStopHook(settingsPath) {
   return registerHook("Stop", { type: "command", command: STOP_HOOK_COMMAND, async: true }, settingsPath);
 }
 async function removeHook(hookType, command, settingsPath) {
-  const path2 = settingsPath ?? join21(homedir(), ".claude", "settings.json");
+  const path2 = settingsPath ?? join22(homedir(), ".claude", "settings.json");
   let raw = "{}";
-  if (existsSync12(path2)) {
+  if (existsSync13(path2)) {
     try {
       raw = await readFile5(path2, "utf-8");
     } catch {
@@ -11790,7 +12003,7 @@ async function removeHook(hookType, command, settingsPath) {
 }
 async function handleSetupSkill(options = {}) {
   const { skipHooks = false } = options;
-  const skillDir = join21(homedir(), ".claude", "skills", "story");
+  const skillDir = join22(homedir(), ".claude", "skills", "story");
   await mkdir5(skillDir, { recursive: true });
   let srcSkillDir;
   try {
@@ -11803,30 +12016,30 @@ async function handleSetupSkill(options = {}) {
     process.exitCode = 1;
     return;
   }
-  const oldPrimeDir = join21(homedir(), ".claude", "skills", "prime");
-  if (existsSync12(oldPrimeDir)) {
+  const oldPrimeDir = join22(homedir(), ".claude", "skills", "prime");
+  if (existsSync13(oldPrimeDir)) {
     await rm(oldPrimeDir, { recursive: true, force: true });
     log("Removed old /prime skill (migrated to /story)");
   }
-  const existed = existsSync12(join21(skillDir, "SKILL.md"));
-  const skillContent = await readFile5(join21(srcSkillDir, "SKILL.md"), "utf-8");
-  await writeFile3(join21(skillDir, "SKILL.md"), skillContent, "utf-8");
+  const existed = existsSync13(join22(skillDir, "SKILL.md"));
+  const skillContent = await readFile5(join22(srcSkillDir, "SKILL.md"), "utf-8");
+  await writeFile3(join22(skillDir, "SKILL.md"), skillContent, "utf-8");
   const supportFiles = ["setup-flow.md", "autonomous-mode.md", "reference.md"];
   const writtenFiles = ["SKILL.md"];
   const missingFiles = [];
   for (const filename of supportFiles) {
-    const srcPath = join21(srcSkillDir, filename);
-    if (existsSync12(srcPath)) {
+    const srcPath = join22(srcSkillDir, filename);
+    if (existsSync13(srcPath)) {
       const content = await readFile5(srcPath, "utf-8");
-      await writeFile3(join21(skillDir, filename), content, "utf-8");
+      await writeFile3(join22(skillDir, filename), content, "utf-8");
       writtenFiles.push(filename);
     } else {
       missingFiles.push(filename);
     }
   }
-  const designSrcDir = join21(srcSkillDir, "design");
-  if (existsSync12(designSrcDir)) {
-    const designDestDir = join21(skillDir, "design");
+  const designSrcDir = join22(srcSkillDir, "design");
+  if (existsSync13(designSrcDir)) {
+    const designDestDir = join22(skillDir, "design");
     try {
       const designFiles = await copyDirRecursive(designSrcDir, designDestDir);
       for (const f of designFiles) writtenFiles.push(`design/${f}`);
@@ -11949,8 +12162,8 @@ var hook_status_exports = {};
 __export(hook_status_exports, {
   handleHookStatus: () => handleHookStatus
 });
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync4, renameSync as renameSync2, unlinkSync as unlinkSync4 } from "fs";
-import { join as join22 } from "path";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync5, renameSync as renameSync3, unlinkSync as unlinkSync4 } from "fs";
+import { join as join23 } from "path";
 async function readStdinSilent() {
   try {
     const chunks = [];
@@ -11967,8 +12180,8 @@ async function readStdinSilent() {
 function atomicWriteSync(targetPath, content) {
   const tmp = `${targetPath}.${process.pid}.tmp`;
   try {
-    writeFileSync4(tmp, content, "utf-8");
-    renameSync2(tmp, targetPath);
+    writeFileSync5(tmp, content, "utf-8");
+    renameSync3(tmp, targetPath);
     return true;
   } catch {
     try {
@@ -12000,10 +12213,10 @@ function activePayload(session) {
   };
 }
 function ensureGitignore(root) {
-  const gitignorePath = join22(root, ".story", ".gitignore");
+  const gitignorePath = join23(root, ".story", ".gitignore");
   let existing = "";
   try {
-    existing = readFileSync9(gitignorePath, "utf-8");
+    existing = readFileSync10(gitignorePath, "utf-8");
   } catch {
   }
   const lines = existing.split("\n").map((l) => l.trim());
@@ -12013,13 +12226,13 @@ function ensureGitignore(root) {
   if (content.length > 0 && !content.endsWith("\n")) content += "\n";
   content += missing.join("\n") + "\n";
   try {
-    writeFileSync4(gitignorePath, content, "utf-8");
+    writeFileSync5(gitignorePath, content, "utf-8");
   } catch {
   }
 }
 function writeStatus(root, payload) {
   ensureGitignore(root);
-  const statusPath = join22(root, ".story", "status.json");
+  const statusPath = join23(root, ".story", "status.json");
   const content = JSON.stringify(payload, null, 2) + "\n";
   atomicWriteSync(statusPath, content);
 }
@@ -12078,8 +12291,8 @@ var config_update_exports = {};
 __export(config_update_exports, {
   handleConfigSetOverrides: () => handleConfigSetOverrides
 });
-import { readFileSync as readFileSync10 } from "fs";
-import { join as join23 } from "path";
+import { readFileSync as readFileSync11 } from "fs";
+import { join as join24 } from "path";
 async function handleConfigSetOverrides(root, format, options) {
   const { json: jsonArg, clear } = options;
   if (!clear && !jsonArg) {
@@ -12107,8 +12320,8 @@ async function handleConfigSetOverrides(root, format, options) {
   }
   let resultOverrides = null;
   await withProjectLock(root, { strict: false }, async () => {
-    const configPath = join23(root, ".story", "config.json");
-    const rawContent = readFileSync10(configPath, "utf-8");
+    const configPath = join24(root, ".story", "config.json");
+    const rawContent = readFileSync11(configPath, "utf-8");
     const raw = JSON.parse(rawContent);
     if (clear) {
       delete raw.recipeOverrides;
@@ -14451,7 +14664,7 @@ async function runCli() {
     registerSessionCommand: registerSessionCommand2,
     registerRepairCommand: registerRepairCommand2
   } = await Promise.resolve().then(() => (init_register(), register_exports));
-  const version2 = "0.1.57";
+  const version2 = "0.1.59";
   class HandledError extends Error {
     constructor() {
       super("HANDLED_ERROR");