@anthropologies/claudestory 0.1.58 → 0.1.60

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();
   }
@@ -6315,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"() {
@@ -6703,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";
@@ -6713,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`,
@@ -6774,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,
@@ -7140,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) {
@@ -7159,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`,
@@ -7224,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", {
@@ -7237,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,
@@ -8002,6 +8162,44 @@ 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",
@@ -8017,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."] : []
           ]
         };
       }
@@ -8224,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"() {
@@ -8263,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 {
           }
         }
@@ -8353,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;
@@ -8366,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 {
@@ -8383,7 +8584,7 @@ function getInstalledVersion() {
   }
 }
 function getRunningVersion() {
-  return "0.1.58";
+  return "0.1.60";
 }
 var init_version_check = __esm({
   "src/autonomous/version-check.ts"() {
@@ -8393,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;
@@ -8791,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 {
@@ -8808,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
@@ -8824,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) {
@@ -9576,7 +9777,7 @@ function guideError(err) {
 }
 function readFileSafe2(path2) {
   try {
-    return readFileSync7(path2, "utf-8");
+    return readFileSync8(path2, "utf-8");
   } catch {
     return "";
   }
@@ -9829,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 {
@@ -9841,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,
@@ -9849,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,
@@ -9859,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}.`,
@@ -9888,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;
@@ -9917,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`);
@@ -10106,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 {
@@ -10153,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)) {
@@ -10748,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);
@@ -10771,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",
@@ -10815,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) {
@@ -10862,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";
@@ -10878,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}
@@ -10981,7 +11182,7 @@ var init_mcp = __esm({
     init_init();
     ENV_VAR2 = "CLAUDESTORY_PROJECT_ROOT";
     CONFIG_PATH2 = ".story/config.json";
-    version = "0.1.58";
+    version = "0.1.60";
     main().catch((err) => {
       process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}
 `);
@@ -11017,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");
@@ -11045,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;
@@ -11080,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(
@@ -11594,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";
@@ -11604,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}
@@ -11617,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(() => {
     });
@@ -11657,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 {
@@ -11755,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 {
@@ -11802,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 {
@@ -11815,38 +12016,40 @@ 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");
-    try {
-      const designFiles = await copyDirRecursive(designSrcDir, designDestDir);
-      for (const f of designFiles) writtenFiles.push(`design/${f}`);
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      process.stderr.write(`Warning: design skill copy failed: ${msg}
+  for (const subdir of ["design", "review-lenses"]) {
+    const srcDir = join22(srcSkillDir, subdir);
+    if (existsSync13(srcDir)) {
+      const destDir = join22(skillDir, subdir);
+      try {
+        const files = await copyDirRecursive(srcDir, destDir);
+        for (const f of files) writtenFiles.push(`${subdir}/${f}`);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`Warning: ${subdir} skill copy failed: ${msg}
 `);
-      missingFiles.push("design/");
+        missingFiles.push(`${subdir}/`);
+      }
     }
   }
   log(`${existed ? "Updated" : "Installed"} /story skill at ${skillDir}/`);
@@ -11961,8 +12164,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 = [];
@@ -11979,8 +12182,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 {
@@ -12012,10 +12215,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());
@@ -12025,13 +12228,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);
 }
@@ -12090,8 +12293,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) {
@@ -12119,8 +12322,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;
@@ -14463,7 +14666,7 @@ async function runCli() {
     registerSessionCommand: registerSessionCommand2,
     registerRepairCommand: registerRepairCommand2
   } = await Promise.resolve().then(() => (init_register(), register_exports));
-  const version2 = "0.1.58";
+  const version2 = "0.1.60";
   class HandledError extends Error {
     constructor() {
       super("HANDLED_ERROR");