@harness-engineering/cli 2.7.0 → 2.7.1

package/dist/{chunk-4EGPFB7V.js → chunk-7PLIWP7U.js}

@@ -3,20 +3,20 @@ import {
   handleGetSecurityTrends,
   handleRunSecurityScan,
   runSecurityScanDefinition
-} from "./chunk-67RP7MLR.js";
+} from "./chunk-CZPOPMMI.js";
 import {
   handleRunCodeReview,
   runCodeReviewDefinition,
   sortFindingsBySeverity
-} from "./chunk-HMMSWRWR.js";
+} from "./chunk-KN3EMDZ5.js";
 import {
   assessProjectDefinition,
   handleAssessProject
-} from "./chunk-TIZ3L6CU.js";
+} from "./chunk-VI4IS55S.js";
 import {
   detectEntropyDefinition,
   handleDetectEntropy
-} from "./chunk-QUPC37UB.js";
+} from "./chunk-LYIPI2SJ.js";
 import {
   checkPerformanceDefinition,
   getCriticalPathsDefinition,
@@ -26,7 +26,7 @@ import {
   handleGetPerfBaselines,
   handleUpdatePerfBaselines,
   updatePerfBaselinesDefinition
-} from "./chunk-CXAHK5PJ.js";
+} from "./chunk-FEKBXX2J.js";
 import {
   getBusinessKnowledgeResource
 } from "./chunk-IOW3MW2K.js";
@@ -37,7 +37,7 @@ import {
   handleCreateSelfReview,
   handleRequestPeerReview,
   requestPeerReviewDefinition
-} from "./chunk-Z2GUITAS.js";
+} from "./chunk-Z3TMCCZB.js";
 import {
   GENERATED_HEADER_CLAUDE,
   GENERATED_HEADER_CODEX,
@@ -53,18 +53,18 @@ import {
 import {
   handleValidateProject,
   validateToolDefinition
-} from "./chunk-MQG7FHXX.js";
+} from "./chunk-7AF6C5GE.js";
 import {
   checkDependenciesDefinition,
   handleCheckDependencies
-} from "./chunk-6T5AYG5S.js";
+} from "./chunk-GGSNWH7P.js";
 import {
   resolveProjectConfig
-} from "./chunk-VG6UK6G6.js";
+} from "./chunk-VSIRUZQP.js";
 import {
   checkDocsDefinition,
   handleCheckDocs
-} from "./chunk-P7EO7USC.js";
+} from "./chunk-NIVWM7OW.js";
 import {
   resultToMcpResponse
 } from "./chunk-RC3OI5NK.js";
@@ -87,8 +87,10 @@ import {
   SkillMetadataSchema
 } from "./chunk-HIK6OEUF.js";
 import {
+  findConfigFile,
+  loadConfig,
   resolveConfig
-} from "./chunk-B4OLYXZ4.js";
+} from "./chunk-FXZI6NJ2.js";
 import {
   logger
 } from "./chunk-EBJQ6N4M.js";
@@ -118,7 +120,7 @@ import {
   scanForInjection,
   serializeEnvelope,
   writeTaint
-} from "./chunk-IY2TZLY5.js";
+} from "./chunk-WZY5U6NS.js";
 import {
   Err,
   INDEXED_FILE_KINDS,
@@ -571,7 +573,7 @@ init_dist2();
 init_dist();
 var searchSessionsDefinition = {
   name: "search_sessions",
-  description: "Full-text search over archived + live session content (Hermes Phase 1, FTS5/BM25).",
+  description: "Full-text search over archived + live session content (FTS5/BM25).",
   inputSchema: {
     type: "object",
     properties: {
@@ -627,7 +629,7 @@ import * as fs2 from "fs";
 import * as path2 from "path";
 var summarizeSessionDefinition = {
   name: "summarize_session",
-  description: "Generate or regenerate the LLM `llm-summary.md` for an archived session (Hermes Phase 1).",
+  description: "Generate or regenerate the LLM `llm-summary.md` for an archived session.",
   inputSchema: {
     type: "object",
     properties: {
@@ -714,7 +716,7 @@ init_dist2();
 init_dist();
 var insightsSummaryDefinition = {
   name: "insights_summary",
-  description: "Composite report combining health, entropy, decay, attention, and impact (Hermes Phase 1).",
+  description: "Composite report combining health, entropy, decay, attention, and impact.",
   inputSchema: {
     type: "object",
     properties: {
@@ -735,7 +737,7 @@ async function handleInsightsSummary(input) {
     const skip = Array.isArray(input.skip) ? input.skip.filter(
       (k) => typeof k === "string" && INSIGHTS_KEYS.includes(k)
     ) : void 0;
-    const { composeInsights } = await import("./dist-XIJWWQ5N.js");
+    const { composeInsights } = await import("./dist-72ID44UE.js");
     const report = await composeInsights(projectPath, {
       ...skip && skip.length > 0 && { skip }
     });
@@ -911,7 +913,7 @@ ${skippedMsg}`
 async function handleInitProject(input) {
   const i = input;
   try {
-    const { TemplateEngine } = await import("./engine-J64WPH5K.js");
+    const { TemplateEngine } = await import("./engine-BSFKOGPN.js");
     const engine = new TemplateEngine(resolveTemplatesDir());
     const safePath = sanitizePath(i.path);
     const detected = tryDetectFramework(engine, safePath, i);
@@ -933,7 +935,7 @@ var listPersonasDefinition = {
   inputSchema: { type: "object", properties: {} }
 };
 async function handleListPersonas() {
-  const { listPersonas } = await import("./loader-HZKJ5ABV.js");
+  const { listPersonas } = await import("./loader-6RHWU5FH.js");
   const result = listPersonas(resolvePersonasDir());
   return resultToMcpResponse(result);
 }
@@ -957,10 +959,10 @@ async function handleGeneratePersonaArtifacts(input) {
   if (!/^[a-z0-9][a-z0-9._-]*$/i.test(input.name)) {
     return resultToMcpResponse(Err(new Error(`Invalid persona name: ${input.name}`)));
   }
-  const { loadPersona } = await import("./loader-HZKJ5ABV.js");
-  const { generateRuntime } = await import("./runtime-IP6FVV5M.js");
-  const { generateAgentsMd } = await import("./agents-md-267R2NUJ.js");
-  const { generateCIWorkflow } = await import("./ci-workflow-YGTQTNVC.js");
+  const { loadPersona } = await import("./loader-6RHWU5FH.js");
+  const { generateRuntime } = await import("./runtime-DALTAVTN.js");
+  const { generateAgentsMd } = await import("./agents-md-FKMKH6ZF.js");
+  const { generateCIWorkflow } = await import("./ci-workflow-MDSTHJOY.js");
   const personasDir = resolvePersonasDir();
   const filePath = path4.join(personasDir, `${input.name}.yaml`);
   if (!filePath.startsWith(personasDir)) {
@@ -1015,7 +1017,7 @@ async function handleRunPersona(input) {
   if (!/^[a-z0-9][a-z0-9._-]*$/i.test(input.persona)) {
     return resultToMcpResponse(Err(new Error(`Invalid persona name: ${input.persona}`)));
   }
-  const { loadPersona } = await import("./loader-HZKJ5ABV.js");
+  const { loadPersona } = await import("./loader-6RHWU5FH.js");
   const { runPersona } = await import("./runner-AAEF2TXY.js");
   const { executeSkill } = await import("./skill-executor-MOCUIAYS.js");
   const personasDir = resolvePersonasDir();
@@ -1460,7 +1462,7 @@ function loadOrGenerateProfile(projectRoot) {
 // src/mcp/tools/event-emitter.ts
 async function emitSkillEvent(projectPath, event) {
   try {
-    const { emitEvent } = await import("./dist-XIJWWQ5N.js");
+    const { emitEvent } = await import("./dist-72ID44UE.js");
     await emitEvent(projectPath, event);
   } catch {
   }
@@ -1732,7 +1734,7 @@ async function autoSyncRoadmap(projectPath) {
   try {
     const roadmapFile = path11.join(projectPath, "docs", "roadmap.md");
     if (!fs10.existsSync(roadmapFile)) return;
-    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges } = await import("./dist-XIJWWQ5N.js");
+    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges } = await import("./dist-72ID44UE.js");
     const raw = fs10.readFileSync(roadmapFile, "utf-8");
     const parseResult = parseRoadmap(raw);
     if (!parseResult.ok) return;
@@ -1762,7 +1764,7 @@ async function triggerExternalSync(projectPath, roadmapFile) {
       console.warn("[roadmap-sync] GITHUB_TOKEN not found \u2014 external sync skipped");
       return;
     }
-    const { fullSync, GitHubIssuesSyncAdapter } = await import("./dist-XIJWWQ5N.js");
+    const { fullSync, GitHubIssuesSyncAdapter } = await import("./dist-72ID44UE.js");
     const adapter = new GitHubIssuesSyncAdapter({
       token,
       config: trackerConfig
@@ -1859,12 +1861,12 @@ var manageStateDefinition = {
   }
 };
 async function handleShow(projectPath, input) {
-  const { loadState } = await import("./dist-XIJWWQ5N.js");
+  const { loadState } = await import("./dist-72ID44UE.js");
   return resultToMcpResponse(await loadState(projectPath, input.stream, input.session));
 }
 async function handleLearn(projectPath, input) {
   if (!input.learning) return mcpError("Error: learning is required for learn action");
-  const { appendLearning } = await import("./dist-XIJWWQ5N.js");
+  const { appendLearning } = await import("./dist-72ID44UE.js");
   const result = await appendLearning(
     projectPath,
     input.learning,
@@ -1879,7 +1881,7 @@ async function handleLearn(projectPath, input) {
 async function handleFailure(projectPath, input) {
   if (!input.description) return mcpError("Error: description is required for failure action");
   if (!input.failureType) return mcpError("Error: failureType is required for failure action");
-  const { appendFailure } = await import("./dist-XIJWWQ5N.js");
+  const { appendFailure } = await import("./dist-72ID44UE.js");
   const result = await appendFailure(
     projectPath,
     input.description,
@@ -1898,19 +1900,19 @@ async function handleFailure(projectPath, input) {
   return resultToMcpResponse(Ok({ recorded: true }));
 }
 async function handleArchive(projectPath, input) {
-  const { archiveFailures } = await import("./dist-XIJWWQ5N.js");
+  const { archiveFailures } = await import("./dist-72ID44UE.js");
   const result = await archiveFailures(projectPath, input.stream, input.session);
   if (!result.ok) return resultToMcpResponse(result);
   return resultToMcpResponse(Ok({ archived: true }));
 }
 async function handleReset(projectPath, input) {
-  const { saveState, DEFAULT_STATE } = await import("./dist-XIJWWQ5N.js");
+  const { saveState, DEFAULT_STATE } = await import("./dist-72ID44UE.js");
   const result = await saveState(projectPath, { ...DEFAULT_STATE }, input.stream, input.session);
   if (!result.ok) return resultToMcpResponse(result);
   return resultToMcpResponse(Ok({ reset: true }));
 }
 async function handleGate(projectPath, input) {
-  const { runMechanicalGate } = await import("./dist-XIJWWQ5N.js");
+  const { runMechanicalGate } = await import("./dist-72ID44UE.js");
   const result = await runMechanicalGate(projectPath);
   if (result.ok) {
     await emitSkillEvent(projectPath, {
@@ -1930,7 +1932,7 @@ async function handleGate(projectPath, input) {
 }
 async function handleSaveHandoff(projectPath, input) {
   if (!input.handoff) return mcpError("Error: handoff is required for save-handoff action");
-  const { saveHandoff } = await import("./dist-XIJWWQ5N.js");
+  const { saveHandoff } = await import("./dist-72ID44UE.js");
   const result = await saveHandoff(
     projectPath,
     input.handoff,
@@ -1952,7 +1954,7 @@ async function handleSaveHandoff(projectPath, input) {
   return resultToMcpResponse(Ok({ saved: true }));
 }
 async function handleLoadHandoff(projectPath, input) {
-  const { loadHandoff } = await import("./dist-XIJWWQ5N.js");
+  const { loadHandoff } = await import("./dist-72ID44UE.js");
   return resultToMcpResponse(await loadHandoff(projectPath, input.stream, input.session));
 }
 async function handleAppendEntry(projectPath, input) {
@@ -1960,7 +1962,7 @@ async function handleAppendEntry(projectPath, input) {
   if (!input.authorSkill) return mcpError("Error: authorSkill is required for append_entry action");
   if (!input.content) return mcpError("Error: content is required for append_entry action");
   if (input.session) {
-    const { appendSessionEntry } = await import("./dist-XIJWWQ5N.js");
+    const { appendSessionEntry } = await import("./dist-72ID44UE.js");
     const result = await appendSessionEntry(
       projectPath,
       input.session,
@@ -1973,7 +1975,7 @@ async function handleAppendEntry(projectPath, input) {
   if (input.section !== "decisions") {
     return mcpError("Error: session is required for non-decisions sections");
   }
-  const { loadState, saveState } = await import("./dist-XIJWWQ5N.js");
+  const { loadState, saveState } = await import("./dist-72ID44UE.js");
   const lr = await loadState(projectPath, input.stream);
   if (!lr.ok) return resultToMcpResponse(lr);
   lr.value.decisions.push({
@@ -1991,7 +1993,7 @@ async function handleUpdateEntryStatus(projectPath, input) {
   if (!input.entryId) return mcpError("Error: entryId is required for update_entry_status action");
   if (!input.newStatus)
     return mcpError("Error: newStatus is required for update_entry_status action");
-  const { updateSessionEntryStatus } = await import("./dist-XIJWWQ5N.js");
+  const { updateSessionEntryStatus } = await import("./dist-72ID44UE.js");
   const result = await updateSessionEntryStatus(
     projectPath,
     input.session,
@@ -2004,7 +2006,7 @@ async function handleUpdateEntryStatus(projectPath, input) {
 async function handleReadSection(projectPath, input) {
   if (!input.session) return mcpError("Error: session is required for read_section action");
   if (!input.section) return mcpError("Error: section is required for read_section action");
-  const { readSessionSection } = await import("./dist-XIJWWQ5N.js");
+  const { readSessionSection } = await import("./dist-72ID44UE.js");
   const result = await readSessionSection(
     projectPath,
     input.session,
@@ -2014,13 +2016,13 @@ async function handleReadSection(projectPath, input) {
 }
 async function handleReadSections(projectPath, input) {
   if (!input.session) return mcpError("Error: session is required for read_sections action");
-  const { readSessionSections } = await import("./dist-XIJWWQ5N.js");
+  const { readSessionSections } = await import("./dist-72ID44UE.js");
   const result = await readSessionSections(projectPath, input.session);
   return resultToMcpResponse(result);
 }
 async function handleArchiveSession(projectPath, input) {
   if (!input.session) return mcpError("Error: session is required for archive_session action");
-  const { archiveSession } = await import("./dist-XIJWWQ5N.js");
+  const { archiveSession } = await import("./dist-72ID44UE.js");
   const { buildArchiveHooks } = await import("@harness-engineering/orchestrator");
   const hooks = buildArchiveHooks({ projectPath });
   const result = await archiveSession(projectPath, input.session, { hooks });
@@ -2102,7 +2104,7 @@ var listStreamsDefinition = {
 };
 async function handleListStreams(input) {
   try {
-    const { listStreams, loadStreamIndex } = await import("./dist-XIJWWQ5N.js");
+    const { listStreams, loadStreamIndex } = await import("./dist-72ID44UE.js");
     const projectPath = sanitizePath(input.path);
     const indexResult = await loadStreamIndex(projectPath);
     const streamsResult = await listStreams(projectPath);
@@ -2140,7 +2142,7 @@ var checkPhaseGateDefinition = {
 };
 async function handleCheckPhaseGate(input) {
   try {
-    const { runCheckPhaseGate } = await import("./check-phase-gate-YJWFDW66.js");
+    const { runCheckPhaseGate } = await import("./check-phase-gate-HS5KYLRO.js");
     const result = await runCheckPhaseGate({ cwd: sanitizePath(input.path) });
     if (result.ok) {
       return { content: [{ type: "text", text: JSON.stringify(result.value) }] };
@@ -2196,7 +2198,7 @@ async function handleValidateCrossCheck(input) {
     };
   }
   try {
-    const { runCrossCheck } = await import("./validate-cross-check-SNE3SQOB.js");
+    const { runCrossCheck } = await import("./validate-cross-check-AUUZFNVL.js");
     const specsDir = path12.resolve(projectPath, input.specsDir ?? "docs/specs");
     if (!specsDir.startsWith(projectPath)) {
       return {
@@ -2705,11 +2707,11 @@ function resolveOutputDir(platform, opts) {
 }
 async function confirmDeletion(files) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     rl.question(`
 Remove ${files.length} orphaned command(s)? (y/N) `, (answer) => {
       rl.close();
-      resolve4(answer.toLowerCase() === "y");
+      resolve5(answer.toLowerCase() === "y");
     });
   });
 }
@@ -3019,7 +3021,7 @@ async function handleGenerateSlashCommands(input) {
 // src/mcp/resources/state.ts
 async function getStateResource(projectRoot) {
   try {
-    const { loadState, migrateToStreams } = await import("./dist-XIJWWQ5N.js");
+    const { loadState, migrateToStreams } = await import("./dist-72ID44UE.js");
     await migrateToStreams(projectRoot);
     const result = await loadState(projectRoot);
     if (result.ok) {
@@ -3630,8 +3632,8 @@ async function handleIngestSource(input) {
     const projectPath = sanitizePath(input.path);
     const graphDir = path16.join(projectPath, ".harness", "graph");
     const { GraphStore, CodeIngestor, TopologicalLinker, KnowledgeIngestor, GitIngestor } = await import("./dist-R3TOOPJ7.js");
-    const fs42 = await import("fs/promises");
-    await fs42.mkdir(graphDir, { recursive: true });
+    const fs44 = await import("fs/promises");
+    await fs44.mkdir(graphDir, { recursive: true });
     const store = new GraphStore();
     await store.load(graphDir);
     const results = [];
@@ -4039,7 +4041,7 @@ var generateAgentDefinitionsDefinition = {
   }
 };
 async function handleGenerateAgentDefinitions(input) {
-  const { generateAgentDefinitions } = await import("./generate-agent-definitions-RNMU5U5R.js");
+  const { generateAgentDefinitions } = await import("./generate-agent-definitions-HZ3XENWO.js");
   const platforms = input.platform === "all" || !input.platform ? ["claude-code", "gemini-cli"] : [input.platform];
   const results = generateAgentDefinitions({
     platforms: [...platforms],
@@ -4533,7 +4535,7 @@ async function handleManageRoadmap(input) {
     return handleManageRoadmapFileLess(input, clientResult.value);
   }
   try {
-    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges, assignFeature } = await import("./dist-XIJWWQ5N.js");
+    const { parseRoadmap, serializeRoadmap, syncRoadmap, applySyncChanges, assignFeature } = await import("./dist-72ID44UE.js");
     const { Ok: Ok2 } = await import("./dist-E3SAAHCM.js");
     const projectPath = projectPathPre;
     const deps = {
@@ -4972,7 +4974,7 @@ async function handleTransition(validInput, projectPath, id) {
   const transition = transitionResult.data;
   const prompt = renderTransition(transition);
   try {
-    const { saveHandoff } = await import("./dist-XIJWWQ5N.js");
+    const { saveHandoff } = await import("./dist-72ID44UE.js");
     await saveHandoff(
       projectPath,
       {
@@ -5053,7 +5055,7 @@ async function handleEmitInteraction(input) {
 }
 async function recordInteraction(projectPath, id, type, decision, stream) {
   try {
-    const { loadState, saveState } = await import("./dist-XIJWWQ5N.js");
+    const { loadState, saveState } = await import("./dist-72ID44UE.js");
     const stateResult = await loadState(projectPath, stream);
     if (stateResult.ok) {
       const state = stateResult.value;
@@ -5214,10 +5216,10 @@ async function handleGatherContext(input) {
     input.include ?? ["state", "learnings", "handoff", "graph", "validation", "businessKnowledge"]
   );
   const errors = [];
-  const statePromise = includeSet.has("state") ? import("./dist-XIJWWQ5N.js").then(
+  const statePromise = includeSet.has("state") ? import("./dist-72ID44UE.js").then(
     (core) => core.loadState(projectPath, void 0, input.session)
   ) : Promise.resolve(null);
-  const learningsPromise = includeSet.has("learnings") ? import("./dist-XIJWWQ5N.js").then(
+  const learningsPromise = includeSet.has("learnings") ? import("./dist-72ID44UE.js").then(
     (core) => core.loadBudgetedLearnings(projectPath, {
       intent: input.intent,
       tokenBudget: input.learningsBudget ?? 1e3,
@@ -5226,7 +5228,7 @@ async function handleGatherContext(input) {
       ...input.depth !== void 0 && { depth: input.depth }
     })
   ) : Promise.resolve(null);
-  const handoffPromise = includeSet.has("handoff") ? import("./dist-XIJWWQ5N.js").then(
+  const handoffPromise = includeSet.has("handoff") ? import("./dist-72ID44UE.js").then(
     (core) => core.loadHandoff(projectPath, void 0, input.session)
   ) : Promise.resolve(null);
   const graphPromise = includeSet.has("graph") ? (async () => {
@@ -5270,11 +5272,11 @@ async function handleGatherContext(input) {
       context: contextBlocks
     };
   })() : Promise.resolve(null);
-  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-XIJWWQ5N.js").then(
+  const sessionsPromise = includeSet.has("sessions") && input.session ? import("./dist-72ID44UE.js").then(
     (core) => core.readSessionSections(projectPath, input.session)
   ) : Promise.resolve(null);
   const shouldIncludeEvents = input.includeEvents !== void 0 ? input.includeEvents : includeSet.has("events") || !!input.session && !input.include;
-  const eventsPromise = shouldIncludeEvents ? import("./dist-XIJWWQ5N.js").then(async (core) => {
+  const eventsPromise = shouldIncludeEvents ? import("./dist-72ID44UE.js").then(async (core) => {
     const result = await core.loadEvents(projectPath, {
       session: input.session
     });
@@ -5282,7 +5284,7 @@ async function handleGatherContext(input) {
     return core.formatEventTimeline(result.value);
   }) : Promise.resolve(null);
   const validationPromise = includeSet.has("validation") ? (async () => {
-    const { handleValidateProject: handleValidateProject2 } = await import("./validate-EVH3UXIC.js");
+    const { handleValidateProject: handleValidateProject2 } = await import("./validate-R7DZRDFK.js");
     const result = await handleValidateProject2({ path: projectPath });
     const first = result.content[0];
     return first ? JSON.parse(first.text) : null;
@@ -5385,7 +5387,7 @@ async function handleGatherContext(input) {
   };
   if (input.session) {
     try {
-      const core = await import("./dist-XIJWWQ5N.js");
+      const core = await import("./dist-72ID44UE.js");
       core.updateSessionIndex(
         projectPath,
         input.session,
@@ -5537,7 +5539,7 @@ async function handleReviewChanges(input) {
   }
 }
 async function runQuickReview(projectPath, diff, diffLines, downgraded, offset, limit) {
-  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-W25QO3OL.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2 } = await import("./feedback-CVCFYND4.js");
   const result = await handleAnalyzeDiff2({ diff, path: projectPath });
   const firstContent = result.content[0];
   if (!firstContent) throw new Error("Empty analyze_diff response");
@@ -5572,7 +5574,7 @@ function extractFileCount(diffParsed) {
   return files?.length ?? 0;
 }
 async function runStandardReview(projectPath, diff, diffLines, downgraded, offset, limit) {
-  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-W25QO3OL.js");
+  const { handleAnalyzeDiff: handleAnalyzeDiff2, handleCreateSelfReview: handleCreateSelfReview2 } = await import("./feedback-CVCFYND4.js");
   const [diffResult, reviewResult] = await Promise.all([
     handleAnalyzeDiff2({ diff, path: projectPath }),
     handleCreateSelfReview2({ path: projectPath, diff })
@@ -5607,7 +5609,7 @@ async function runStandardReview(projectPath, diff, diffLines, downgraded, offse
   };
 }
 async function runDeepReview(projectPath, diff, diffLines, _downgraded, offset, limit) {
-  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-KA7SGUXJ.js");
+  const { handleRunCodeReview: handleRunCodeReview2 } = await import("./review-pipeline-BHQZIXWZ.js");
   const result = await handleRunCodeReview2({
     path: projectPath,
     diff,
@@ -5901,7 +5903,7 @@ async function handleDetectStaleConstraints(input) {
         ]
       };
     }
-    const { detectStaleConstraints } = await import("./dist-XIJWWQ5N.js");
+    const { detectStaleConstraints } = await import("./dist-72ID44UE.js");
     const result = detectStaleConstraints(
       store,
       windowDays,
@@ -5987,8 +5989,18 @@ function deriveSignals(checks, metrics) {
   return [...signals];
 }
 var DEFAULT_CHECK = { passed: true, issueCount: 0 };
-function parseToolResult(result) {
-  return JSON.parse(result.content[0]?.text ?? "{}");
+function parseToolResult(result, toolName) {
+  const text = result.content[0]?.text ?? "{}";
+  if (result.isError) {
+    logger.warn(`${toolName} reported an error: ${text}`);
+    return {};
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    logger.warn(`${toolName} returned non-JSON output: ${text.slice(0, 120)}`);
+    return {};
+  }
 }
 function buildCheckMap(assessData) {
   const map = /* @__PURE__ */ new Map();
@@ -6021,10 +6033,10 @@ function countCriticalFindings(securityData) {
   return findings.filter((f) => f.severity === "error").length;
 }
 async function runHealthChecks(projectPath) {
-  const { handleAssessProject: handleAssessProject2 } = await import("./assess-project-OKDW3YSK.js");
-  const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-ZTEHGIHD.js");
-  const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-M27JUL3V.js");
-  const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-EAR4FJWI.js");
+  const { handleAssessProject: handleAssessProject2 } = await import("./assess-project-OJWECOP2.js");
+  const { handleCheckDependencies: handleCheckDependencies2 } = await import("./architecture-LUR2I67H.js");
+  const { handleDetectEntropy: handleDetectEntropy2 } = await import("./entropy-3UX6644G.js");
+  const { handleRunSecurityScan: handleRunSecurityScan2 } = await import("./security-RMLMYFPB.js");
   const [assessResult, depsResult, entropyResult, securityResult] = await Promise.all([
     handleAssessProject2({
       path: projectPath,
@@ -6034,11 +6046,13 @@ async function runHealthChecks(projectPath) {
     handleDetectEntropy2({ path: projectPath, type: "all" }),
     handleRunSecurityScan2({ path: projectPath })
   ]);
-  const assessData = parseToolResult(assessResult);
+  const assessData = parseToolResult(assessResult, "assess_project");
   const checkMap = buildCheckMap(assessData);
-  const { circularDeps, layerViolations } = countViolations(parseToolResult(depsResult));
-  const entropyGranular = parseEntropyGranular(parseToolResult(entropyResult));
-  const criticalCount = countCriticalFindings(parseToolResult(securityResult));
+  const { circularDeps, layerViolations } = countViolations(
+    parseToolResult(depsResult, "check_dependencies")
+  );
+  const entropyGranular = parseEntropyGranular(parseToolResult(entropyResult, "detect_entropy"));
+  const criticalCount = countCriticalFindings(parseToolResult(securityResult, "run_security_scan"));
   return assembleHealthChecks(
     checkMap,
     circularDeps,
@@ -6865,7 +6879,7 @@ async function handleGetDecayTrends(input) {
     };
   }
   try {
-    const core = await import("./dist-XIJWWQ5N.js");
+    const core = await import("./dist-72ID44UE.js");
     const { TimelineManager } = core;
     const manager = new TimelineManager(projectPath);
     const timeline = manager.load();
@@ -7000,7 +7014,7 @@ async function handleCodeOutline(input) {
     };
   }
   try {
-    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-XIJWWQ5N.js");
+    const { getOutline, formatOutline, EXTENSION_MAP } = await import("./dist-72ID44UE.js");
     const { stat } = await import("fs/promises");
     const stats = await stat(targetPath).catch(() => null);
     if (stats?.isFile()) {
@@ -7019,7 +7033,7 @@ async function handleCodeOutline(input) {
         })
       );
       fileStats.sort((a, b) => b.mtimeMs - a.mtimeMs);
-      const { paginate: paginate2 } = await import("./dist-XIJWWQ5N.js");
+      const { paginate: paginate2 } = await import("./dist-72ID44UE.js");
       const paged = paginate2(fileStats, input.offset ?? 0, input.limit ?? 30);
       const results = [];
       for (const entry of paged.items) {
@@ -7092,7 +7106,7 @@ async function handleCodeSearch(input) {
     };
   }
   try {
-    const { searchSymbols } = await import("./dist-XIJWWQ5N.js");
+    const { searchSymbols } = await import("./dist-72ID44UE.js");
     const result = await searchSymbols(input.query, directory, input.glob);
     const lines = [`Search: "${result.query}" \u2014 ${result.matches.length} matches`];
     for (const match of result.matches) {
@@ -7161,7 +7175,7 @@ async function handleCodeUnfold(input) {
   }
   try {
     if (input.symbol) {
-      const { unfoldSymbol } = await import("./dist-XIJWWQ5N.js");
+      const { unfoldSymbol } = await import("./dist-72ID44UE.js");
       const result = await unfoldSymbol(filePath, input.symbol);
       const header = result.warning ? `${result.file}:${result.startLine}-${result.endLine} ${result.warning}
 ` : `${result.file}:${result.startLine}-${result.endLine}
@@ -7169,7 +7183,7 @@ async function handleCodeUnfold(input) {
       return { content: [{ type: "text", text: header + result.content }] };
     }
     if (input.startLine != null && input.endLine != null) {
-      const { unfoldRange } = await import("./dist-XIJWWQ5N.js");
+      const { unfoldRange } = await import("./dist-72ID44UE.js");
       const result = await unfoldRange(filePath, input.startLine, input.endLine);
       const header = `${result.file}:${result.startLine}-${result.endLine}
 `;
@@ -7354,7 +7368,7 @@ async function handlePredictFailures(input) {
     };
   }
   try {
-    const core = await import("./dist-XIJWWQ5N.js");
+    const core = await import("./dist-72ID44UE.js");
     const { TimelineManager, PredictionEngine, SpecImpactEstimator } = core;
     const manager = new TimelineManager(projectPath);
     const includeRoadmap = input.includeRoadmap !== false;
@@ -8463,7 +8477,7 @@ async function handleDetectConstraintEmergence(input) {
     }
     const nodePath = await import("path");
     const historyPath = nodePath.resolve(projectPath, ".harness/arch/violation-history.json");
-    const { ViolationHistoryManager, detectEmergentConstraints } = await import("./dist-XIJWWQ5N.js");
+    const { ViolationHistoryManager, detectEmergentConstraints } = await import("./dist-72ID44UE.js");
     const manager = new ViolationHistoryManager(historyPath);
     const history = manager.load();
     const options = { windowWeeks, minOccurrences };
@@ -8551,7 +8565,7 @@ async function handleRunCIChecks(input) {
     };
   }
   try {
-    const { runCIChecks } = await import("./dist-XIJWWQ5N.js");
+    const { runCIChecks } = await import("./dist-72ID44UE.js");
     const skip = input.checks ? VALID_CHECKS.filter((c) => !input.checks.includes(c)) : [];
     const result = await runCIChecks({
       projectRoot: projectPath,
@@ -8613,7 +8627,7 @@ async function handleGenerateBlueprint(input) {
     };
   }
   try {
-    const { ProjectScanner } = await import("./dist-XIJWWQ5N.js");
+    const { ProjectScanner } = await import("./dist-72ID44UE.js");
     const scanner = new ProjectScanner(projectPath);
     const data = await scanner.scan();
     return {
@@ -8812,7 +8826,7 @@ async function handleEmitSkillProposal(input) {
   let createProposal;
   let ProposalConflictError;
   try {
-    const core = await import("./dist-XIJWWQ5N.js");
+    const core = await import("./dist-72ID44UE.js");
     createProposal = core.createProposal;
     ProposalConflictError = core.ProposalConflictError;
   } catch (err2) {
@@ -9481,6 +9495,234 @@ var hierarchyClarityRubric = {
   }
 };
 
+// src/shared/craft/llm/in-session.ts
+var PromptDeferredError = class extends Error {
+  promptId;
+  constructor(promptId) {
+    super(`In-session prompt ${promptId} deferred to calling agent`);
+    this.name = "PromptDeferredError";
+    this.promptId = promptId;
+  }
+};
+var InSessionLlmProvider = class {
+  providerId = "in-session";
+  model = "host-chat";
+  deferred = [];
+  costs = [];
+  counter = 0;
+  async callText(prompt, opts) {
+    const promptId = `p${(++this.counter).toString(36)}`;
+    this.deferred.push({
+      promptId,
+      systemPrompt: opts?.systemPrompt,
+      userPrompt: prompt
+    });
+    throw new PromptDeferredError(promptId);
+  }
+  async callVision(_prompt, _image) {
+    throw new Error(
+      "InSessionLlmProvider.callVision is not implemented \u2014 vision flows must use a real provider."
+    );
+  }
+  recordCost(cost) {
+    this.costs.push(cost);
+  }
+  getCosts() {
+    return this.costs;
+  }
+  /** Read out the queue of deferred prompts (in the order callText was invoked). */
+  getDeferred() {
+    return this.deferred;
+  }
+};
+
+// src/shared/craft/llm/adapters.ts
+import { z as z2 } from "zod";
+var RAW_SCHEMA = z2.object({ raw: z2.string() });
+var RAW_INSTRUCTIONS = 'Return a JSON object with a single field "raw" whose string value is the fenced JSON block you would normally emit. Do not add prose outside the JSON object.';
+var AnalysisProviderAdapter = class {
+  providerId;
+  model;
+  inner;
+  costs = [];
+  constructor(opts) {
+    this.providerId = opts.providerId;
+    this.model = opts.model;
+    this.inner = opts.inner;
+  }
+  async callText(prompt, opts) {
+    const wrappedSystem = [opts?.systemPrompt, RAW_INSTRUCTIONS].filter(Boolean).join("\n\n");
+    const response = await this.inner.analyze({
+      prompt,
+      systemPrompt: wrappedSystem,
+      responseSchema: RAW_SCHEMA
+    });
+    this.recordCost({
+      provider: this.providerId,
+      model: response.model || this.model,
+      inputTokens: response.tokenUsage.inputTokens,
+      outputTokens: response.tokenUsage.outputTokens,
+      costUsd: 0
+    });
+    return response.result.raw;
+  }
+  async callVision(_prompt, _image) {
+    throw new Error(
+      `${this.providerId} adapter does not implement callVision \u2014 wire vision when needed.`
+    );
+  }
+  recordCost(cost) {
+    this.costs.push(cost);
+  }
+  getCosts() {
+    return this.costs;
+  }
+};
+function adaptClaudeCli(inner, model) {
+  return new AnalysisProviderAdapter({
+    providerId: "claude-cli",
+    model: model ?? "claude",
+    inner
+  });
+}
+function adaptAnthropic(inner, model) {
+  return new AnalysisProviderAdapter({
+    providerId: "anthropic",
+    model: model ?? "claude-sonnet-4-20250514",
+    inner
+  });
+}
+function adaptOpenAICompatible(inner, model) {
+  return new AnalysisProviderAdapter({
+    providerId: "openai-compatible",
+    model: model ?? "unknown",
+    inner
+  });
+}
+
+// src/shared/craft/llm/lazy-local-adapter.ts
+import { OpenAICompatibleAnalysisProvider } from "@harness-engineering/intelligence";
+import { defaultFetchModels } from "@harness-engineering/orchestrator";
+var LazyLocalAdapter = class {
+  providerId;
+  model;
+  opts;
+  costs = [];
+  /** Cached resolution. Populated on first probe; subsequent calls reuse. */
+  resolved = null;
+  resolvePromise = null;
+  constructor(opts, providerId = "local") {
+    this.opts = opts;
+    this.providerId = providerId;
+    this.model = opts.configured[0] ?? "unresolved";
+  }
+  async callText(prompt, callOpts) {
+    const { provider } = await this.resolve();
+    return provider.callText(prompt, callOpts);
+  }
+  async callVision(_prompt, _image) {
+    throw new Error(`${this.providerId}: callVision is not wired for local backends.`);
+  }
+  recordCost(cost) {
+    this.costs.push(cost);
+  }
+  getCosts() {
+    return this.costs;
+  }
+  /** Test/debug surface — read the resolved model id (null before first probe). */
+  getResolvedModel() {
+    return this.resolved?.modelId ?? null;
+  }
+  async resolve() {
+    if (this.resolved !== null) return this.resolved;
+    if (this.resolvePromise !== null) return this.resolvePromise;
+    const fetcher = this.opts.fetchModels ?? defaultFetchModels;
+    this.resolvePromise = (async () => {
+      let detected;
+      try {
+        detected = await fetcher(this.opts.endpoint, this.opts.apiKey);
+      } catch (err2) {
+        const message = err2 instanceof Error ? err2.message : String(err2);
+        throw new Error(
+          `${this.providerId}: probe failed against ${this.opts.endpoint}: ${message}. Is the server running? (Ollama: \`ollama serve\`; LM Studio: enable the server.)`,
+          { cause: err2 }
+        );
+      }
+      const match = this.opts.configured.find((id) => detected.includes(id));
+      if (match === void 0) {
+        throw new Error(
+          `${this.providerId}: no configured model is loaded at ${this.opts.endpoint}. Configured: [${this.opts.configured.join(", ")}]. Detected: [${detected.join(", ")}]. Load one of the configured models or update agent.backends.<name>.model.`
+        );
+      }
+      const inner = new OpenAICompatibleAnalysisProvider({
+        apiKey: this.opts.apiKey,
+        baseUrl: this.opts.endpoint,
+        defaultModel: match
+      });
+      const provider = new AnalysisProviderAdapter({
+        providerId: this.providerId,
+        model: match,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        inner
+      });
+      const resolved = { provider, modelId: match };
+      this.resolved = resolved;
+      return resolved;
+    })().finally(() => {
+      this.resolvePromise = null;
+    });
+    return this.resolvePromise;
+  }
+};
+
+// src/shared/craft/llm/provider.ts
+import {
+  AnthropicAnalysisProvider,
+  ClaudeCliAnalysisProvider,
+  OpenAICompatibleAnalysisProvider as OpenAICompatibleAnalysisProvider2
+} from "@harness-engineering/intelligence";
+
+// src/shared/craft/llm/orchestrator-md.ts
+import * as fs21 from "fs";
+import * as path24 from "path";
+import { parse as parse4 } from "yaml";
+var FILENAME = "harness.orchestrator.md";
+function findOrchestratorMd(startDir) {
+  let cur = path24.resolve(startDir);
+  const root = path24.parse(cur).root;
+  while (cur !== root) {
+    const candidate = path24.join(cur, FILENAME);
+    if (fs21.existsSync(candidate)) return candidate;
+    cur = path24.dirname(cur);
+  }
+  return null;
+}
+function readBackendsFromOrchestratorMd(startDir) {
+  const file = findOrchestratorMd(startDir);
+  if (file === null) return null;
+  let raw;
+  try {
+    raw = fs21.readFileSync(file, "utf-8");
+  } catch {
+    return null;
+  }
+  const parts = raw.split("---");
+  if (parts.length < 3) return null;
+  const yamlContent = parts[1].trim();
+  let parsed;
+  try {
+    parsed = parse4(yamlContent);
+  } catch {
+    return null;
+  }
+  if (parsed === null || typeof parsed !== "object") return null;
+  const agent = parsed.agent;
+  if (agent === null || typeof agent !== "object") return null;
+  const backends = agent.backends;
+  if (backends === null || typeof backends !== "object") return null;
+  return backends;
+}
+
 // src/shared/craft/llm/provider.ts
 var MockLlmProvider = class {
   constructor(responses = []) {
@@ -9528,8 +9770,206 @@ var MockLlmProvider = class {
     return this.costs;
   }
 };
-function getProvider(_opts) {
-  return new MockLlmProvider();
+function hasEnvValue(raw) {
+  return raw.length > 0;
+}
+function resolveCraftLlmConfig(opts = {}) {
+  const projectRoot = opts.projectRoot ?? process.cwd();
+  const fileConfig = readCraftConfigFromFile(projectRoot);
+  const envRaw = (process.env.HARNESS_CRAFT_LLM ?? "").trim();
+  if (hasEnvValue(envRaw)) {
+    if (envRaw === "in-session" || envRaw === "mock") {
+      return { mode: envRaw };
+    }
+    const def = fileConfig?.backends?.[envRaw];
+    if (def !== void 0 && typeof def === "object" && def !== null) {
+      const backendDef = def;
+      const type = backendDef.type;
+      if (typeof type === "string" && isBackendType(type)) {
+        return { mode: type, backendName: envRaw, backendDef };
+      }
+    }
+  }
+  const backendName = fileConfig?.craft?.backend;
+  if (fileConfig !== null && typeof backendName === "string" && backendName.length > 0) {
+    const def = fileConfig.backends?.[backendName];
+    if (def === void 0 || typeof def !== "object" || def === null) {
+      throw new Error(
+        `craft.llm.backend="${backendName}" references an entry that is missing from agent.backends.`
+      );
+    }
+    const backendDef = def;
+    const type = backendDef.type;
+    if (typeof type !== "string" || !isBackendType(type)) {
+      throw new Error(
+        `agent.backends["${backendName}"] has unsupported type "${String(type)}" for craft skills.`
+      );
+    }
+    return { mode: type, backendName, backendDef };
+  }
+  const mode2 = fileConfig?.craft?.mode;
+  if (mode2 === "in-session" || mode2 === "mock") return { mode: mode2 };
+  return { mode: "in-session" };
+}
+function resolveCraftLlmMode(envValue) {
+  if (envValue !== void 0) {
+    const trimmed = envValue.trim();
+    if (trimmed === "in-session" || trimmed === "mock") return trimmed;
+  }
+  return resolveCraftLlmConfig().mode;
+}
+var BACKEND_TYPES = ["claude", "anthropic", "openai", "gemini", "local", "pi", "mock"];
+function isBackendType(t) {
+  return BACKEND_TYPES.includes(t);
+}
+function readJsonCraftView(startDir) {
+  const view = {};
+  const found = findConfigFile(startDir);
+  if (!found.ok) return view;
+  const loaded = loadConfig(found.value);
+  if (!loaded.ok) return view;
+  const craft = loaded.value.craft?.llm;
+  if (craft !== void 0) {
+    view.craft = {};
+    if (craft.backend !== void 0) view.craft.backend = craft.backend;
+    if (craft.mode !== void 0) view.craft.mode = craft.mode;
+  }
+  const backends = loaded.value.agent?.backends;
+  if (backends !== void 0) view.backends = backends;
+  return view;
+}
+function readCraftConfigFromFile(startDir) {
+  const view = readJsonCraftView(startDir);
+  if (view.backends === void 0) {
+    const fromMd = readBackendsFromOrchestratorMd(startDir);
+    if (fromMd !== null) {
+      view.backends = fromMd;
+      view.backendsFromOrchestratorMd = true;
+      warnOrchestratorMdFallback();
+    }
+  }
+  return view.craft !== void 0 || view.backends !== void 0 ? view : null;
+}
+var warnedOrchestratorMd = false;
+function warnOrchestratorMdFallback() {
+  if (warnedOrchestratorMd) return;
+  warnedOrchestratorMd = true;
+  if (process.env.HARNESS_SUPPRESS_BACKEND_MIGRATION_WARNING) return;
+  console.warn(
+    "[craft] agent.backends read from harness.orchestrator.md. Run `harness migrate backends` to copy them into harness.config.json (single source of truth). Suppress with HARNESS_SUPPRESS_BACKEND_MIGRATION_WARNING=1."
+  );
+}
+function getProvider(opts) {
+  if (opts?.mode === "in-session") return new InSessionLlmProvider();
+  if (opts?.mode === "mock") return new MockLlmProvider();
+  const resolved = resolveCraftLlmConfig(
+    opts?.projectRoot !== void 0 ? { projectRoot: opts.projectRoot } : {}
+  );
+  return providerForResolution(resolved);
+}
+function providerForResolution(resolved) {
+  switch (resolved.mode) {
+    case "in-session":
+      return new InSessionLlmProvider();
+    case "mock":
+      return new MockLlmProvider();
+    case "claude":
+      return buildClaudeProvider(resolved);
+    case "anthropic":
+      return buildAnthropicProvider(resolved);
+    case "openai":
+    case "local":
+    case "pi":
+      return buildOpenAICompatibleProvider(resolved);
+    case "gemini":
+      throw new Error(
+        `agent.backends["${resolved.backendName}"]: 'gemini' backend is not yet wired into the craft adapter.`
+      );
+  }
+}
+function buildClaudeProvider(resolved) {
+  const def = resolved.backendDef ?? {};
+  const command = stringField(def, "command");
+  return adaptClaudeCli(new ClaudeCliAnalysisProvider(command !== void 0 ? { command } : {}));
+}
+function buildAnthropicProvider(resolved) {
+  const def = resolved.backendDef ?? {};
+  const model = stringField(def, "model");
+  if (model === void 0) {
+    throw new Error(
+      `agent.backends["${resolved.backendName}"]: 'anthropic' backend requires a 'model'.`
+    );
+  }
+  const apiKey = stringField(def, "apiKey") ?? process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    throw new Error(
+      `agent.backends["${resolved.backendName}"]: 'anthropic' backend requires apiKey or ANTHROPIC_API_KEY.`
+    );
+  }
+  return adaptAnthropic(new AnthropicAnalysisProvider({ apiKey, defaultModel: model }), model);
+}
+function pickConfiguredModels(modelField) {
+  if (typeof modelField === "string") return [modelField];
+  if (Array.isArray(modelField)) {
+    return modelField.filter((m) => typeof m === "string");
+  }
+  return [];
+}
+function resolveOpenAICompatibleEndpoint(resolved) {
+  const def = resolved.backendDef ?? {};
+  const fallback = resolved.mode === "openai" ? "https://api.openai.com/v1" : void 0;
+  const endpoint = stringField(def, "endpoint") ?? fallback;
+  if (endpoint === void 0) {
+    throw new Error(
+      `agent.backends["${resolved.backendName}"]: '${resolved.mode}' backend requires 'endpoint'.`
+    );
+  }
+  return endpoint;
+}
+function resolveOpenAICompatibleApiKey(resolved) {
+  const def = resolved.backendDef ?? {};
+  const fallback = resolved.mode === "openai" ? void 0 : "local";
+  const apiKey = stringField(def, "apiKey") ?? process.env.OPENAI_API_KEY ?? fallback;
+  if (!apiKey) {
+    throw new Error(
+      `agent.backends["${resolved.backendName}"]: 'openai' backend requires apiKey or OPENAI_API_KEY.`
+    );
+  }
+  return apiKey;
+}
+function resolveOpenAICompatibleInputs(resolved) {
+  const configured = pickConfiguredModels(resolved.backendDef?.model);
+  if (configured.length === 0) {
+    throw new Error(
+      `agent.backends["${resolved.backendName}"]: '${resolved.mode}' backend requires 'model' (string or non-empty array of strings).`
+    );
+  }
+  return {
+    endpoint: resolveOpenAICompatibleEndpoint(resolved),
+    apiKey: resolveOpenAICompatibleApiKey(resolved),
+    configured
+  };
+}
+function buildOpenAICompatibleProvider(resolved) {
+  const { endpoint, apiKey, configured } = resolveOpenAICompatibleInputs(resolved);
+  if (configured.length === 1) {
+    return adaptOpenAICompatible(
+      new OpenAICompatibleAnalysisProvider2({
+        apiKey,
+        baseUrl: endpoint,
+        defaultModel: configured[0]
+      }),
+      configured[0]
+    );
+  }
+  return new LazyLocalAdapter(
+    { endpoint, apiKey, configured },
+    resolved.mode === "pi" ? "pi" : "local"
+  );
+}
+function stringField(obj, key) {
+  const v = obj[key];
+  return typeof v === "string" ? v : void 0;
 }
 
 // src/mcp/tools/design-craft.ts
@@ -9657,18 +10097,18 @@ async function handleDesignCraft(input) {
 }
 
 // src/drift/index.ts
-import * as fs23 from "fs";
-import * as path26 from "path";
+import * as fs24 from "fs";
+import * as path27 from "path";
 
 // src/drift/resolvers/tokens.ts
-import * as fs21 from "fs";
-import * as path24 from "path";
+import * as fs22 from "fs";
+import * as path25 from "path";
 function loadTokenSet(projectRoot) {
-  const tokenPath = path24.join(projectRoot, "design-system", "tokens.json");
-  if (!fs21.existsSync(tokenPath)) return null;
+  const tokenPath = path25.join(projectRoot, "design-system", "tokens.json");
+  if (!fs22.existsSync(tokenPath)) return null;
   let raw;
   try {
-    raw = fs21.readFileSync(tokenPath, "utf-8");
+    raw = fs22.readFileSync(tokenPath, "utf-8");
   } catch {
     return null;
   }
@@ -9692,11 +10132,11 @@ function extractTokens(root) {
   return set;
 }
 function loadTokenPathIndex(projectRoot) {
-  const tokenPath = path24.join(projectRoot, "design-system", "tokens.json");
-  if (!fs21.existsSync(tokenPath)) return null;
+  const tokenPath = path25.join(projectRoot, "design-system", "tokens.json");
+  if (!fs22.existsSync(tokenPath)) return null;
   let raw;
   try {
-    raw = fs21.readFileSync(tokenPath, "utf-8");
+    raw = fs22.readFileSync(tokenPath, "utf-8");
   } catch {
     return null;
   }
@@ -9746,9 +10186,9 @@ function walkForPaths(node, breadcrumb, idx) {
     }
   }
 }
-function pushPath(map, key, path45) {
+function pushPath(map, key, path47) {
   const list = map.get(key) ?? [];
-  list.push(path45);
+  list.push(path47);
   map.set(key, list);
 }
 function walk(node, breadcrumb, set) {
@@ -9795,8 +10235,8 @@ function parsePxValue(s) {
 }
 
 // src/drift/resolvers/component-registry.ts
-import * as fs22 from "fs";
-import * as path25 from "path";
+import * as fs23 from "fs";
+import * as path26 from "path";
 var HTML_PRIMITIVE_MAP = {
   Button: "button",
   Input: "input",
@@ -9805,11 +10245,11 @@ var HTML_PRIMITIVE_MAP = {
   Anchor: "a"
 };
 function loadComponentRegistry(projectRoot) {
-  const designMdPath = path25.join(projectRoot, "design-system", "DESIGN.md");
-  if (!fs22.existsSync(designMdPath)) return null;
+  const designMdPath = path26.join(projectRoot, "design-system", "DESIGN.md");
+  if (!fs23.existsSync(designMdPath)) return null;
   let raw;
   try {
-    raw = fs22.readFileSync(designMdPath, "utf-8");
+    raw = fs23.readFileSync(designMdPath, "utf-8");
   } catch {
     return null;
   }
@@ -10107,7 +10547,7 @@ async function runDetectDrift(input) {
   for (const file of filesToScan) {
     let source;
     try {
-      source = fs23.readFileSync(file, "utf-8");
+      source = fs24.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -10142,7 +10582,7 @@ async function runDetectDrift(input) {
 }
 async function collectFiles(projectRoot, explicitFiles) {
   if (explicitFiles !== void 0 && explicitFiles.length > 0) {
-    return explicitFiles.map((f) => path26.isAbsolute(f) ? f : path26.join(projectRoot, f));
+    return explicitFiles.map((f) => path27.isAbsolute(f) ? f : path27.join(projectRoot, f));
   }
   const out = [];
   walk2(projectRoot, out, 0);
@@ -10152,7 +10592,7 @@ function walk2(dir, out, depth) {
   if (depth > 8) return;
   let entries;
   try {
-    entries = fs23.readdirSync(dir, { withFileTypes: true });
+    entries = fs24.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -10160,7 +10600,7 @@ function walk2(dir, out, depth) {
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
       continue;
     }
-    const full = path26.join(dir, entry.name);
+    const full = path27.join(dir, entry.name);
     if (entry.isDirectory()) {
       walk2(full, out, depth + 1);
     } else if (entry.isFile() && DEFAULT_GLOB_EXTENSIONS.some((ext) => entry.name.endsWith(ext))) {
@@ -10228,8 +10668,8 @@ async function handleDetectDrift(input) {
 }
 
 // src/align/index.ts
-import * as fs24 from "fs";
-import * as path28 from "path";
+import * as fs25 from "fs";
+import * as path29 from "path";
 
 // src/align/classifier/token-import.ts
 var NAMED_IMPORT = /^\s*import\s*\{\s*tokens(?:\s+as\s+\w+)?\s*\}\s*from\s+['"][^'"]+['"];?\s*$/m;
@@ -10369,9 +10809,9 @@ function sourceLine(source, line) {
 }
 
 // src/align/codemods/common.ts
-import * as path27 from "path";
+import * as path28 from "path";
 function renderTokenReference(file, tokenPath) {
-  const ext = path27.extname(file).toLowerCase();
+  const ext = path28.extname(file).toLowerCase();
   if (ext === ".css" || ext === ".scss") {
     return `var(--${tokenPath.replace(/\./g, "-")})`;
   }
@@ -10563,10 +11003,10 @@ async function runAlignDesignSystem(input) {
 }
 async function loadFindings(projectRoot, input, mode2) {
   if (mode2 === "pipeline") {
-    const handoffPath = path28.join(projectRoot, HANDOFF_PATH);
-    if (!fs24.existsSync(handoffPath)) return [];
+    const handoffPath = path29.join(projectRoot, HANDOFF_PATH);
+    if (!fs25.existsSync(handoffPath)) return [];
     try {
-      const raw = fs24.readFileSync(handoffPath, "utf-8");
+      const raw = fs25.readFileSync(handoffPath, "utf-8");
       const parsed = JSON.parse(raw);
       return parsed.pipeline?.driftFindings ?? [];
     } catch {
@@ -10591,7 +11031,7 @@ async function processFinding(finding, tokenPaths, sourceCache, dryRun) {
   }
   let source;
   try {
-    source = sourceCache.get(finding.file) ?? fs24.readFileSync(finding.file, "utf-8");
+    source = sourceCache.get(finding.file) ?? fs25.readFileSync(finding.file, "utf-8");
     sourceCache.set(finding.file, source);
   } catch (err2) {
     return {
@@ -10619,7 +11059,7 @@ async function processFinding(finding, tokenPaths, sourceCache, dryRun) {
   }
   if (!dryRun) {
     try {
-      fs24.writeFileSync(finding.file, result.newSource, "utf-8");
+      fs25.writeFileSync(finding.file, result.newSource, "utf-8");
       sourceCache.set(finding.file, result.newSource);
     } catch (err2) {
       return {
@@ -10680,19 +11120,19 @@ function aggregateOutput(outcomes, meta) {
   };
 }
 function writePipelineFixesApplied(projectRoot, outcomes) {
-  const handoffPath = path28.join(projectRoot, HANDOFF_PATH);
+  const handoffPath = path29.join(projectRoot, HANDOFF_PATH);
   let handoff = {};
-  if (fs24.existsSync(handoffPath)) {
+  if (fs25.existsSync(handoffPath)) {
     try {
-      handoff = JSON.parse(fs24.readFileSync(handoffPath, "utf-8"));
+      handoff = JSON.parse(fs25.readFileSync(handoffPath, "utf-8"));
     } catch {
       handoff = {};
     }
   }
   handoff.pipeline = handoff.pipeline ?? {};
   handoff.pipeline.fixesApplied = outcomes;
-  fs24.mkdirSync(path28.dirname(handoffPath), { recursive: true });
-  fs24.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2) + "\n", "utf-8");
+  fs25.mkdirSync(path29.dirname(handoffPath), { recursive: true });
+  fs25.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2) + "\n", "utf-8");
 }
 function findingKey(finding) {
   return `${finding.code}@${finding.file}:${finding.line ?? "?"}`;
@@ -10764,18 +11204,18 @@ async function handleAlignDesignSystem(input) {
 }
 
 // src/brand/index.ts
-import * as fs27 from "fs";
-import * as path31 from "path";
+import * as fs28 from "fs";
+import * as path32 from "path";
 
 // src/brand/resolvers/design-md-brand.ts
-import * as fs25 from "fs";
-import * as path29 from "path";
+import * as fs26 from "fs";
+import * as path30 from "path";
 function loadBrandRules(projectRoot) {
-  const designMdPath = path29.join(projectRoot, "design-system", "DESIGN.md");
-  if (!fs25.existsSync(designMdPath)) return null;
+  const designMdPath = path30.join(projectRoot, "design-system", "DESIGN.md");
+  if (!fs26.existsSync(designMdPath)) return null;
   let raw;
   try {
-    raw = fs25.readFileSync(designMdPath, "utf-8");
+    raw = fs26.readFileSync(designMdPath, "utf-8");
   } catch {
     return null;
   }
@@ -10886,14 +11326,14 @@ function parseAssets(block) {
 }
 
 // src/brand/resolvers/token-extensions.ts
-import * as fs26 from "fs";
-import * as path30 from "path";
+import * as fs27 from "fs";
+import * as path31 from "path";
 function loadBrandTokenIndex(projectRoot) {
-  const tokenPath = path30.join(projectRoot, "design-system", "tokens.json");
-  if (!fs26.existsSync(tokenPath)) return null;
+  const tokenPath = path31.join(projectRoot, "design-system", "tokens.json");
+  if (!fs27.existsSync(tokenPath)) return null;
   let raw;
   try {
-    raw = fs26.readFileSync(tokenPath, "utf-8");
+    raw = fs27.readFileSync(tokenPath, "utf-8");
   } catch {
     return null;
   }
@@ -11142,7 +11582,7 @@ async function runAuditBrand(input) {
   for (const file of filesToScan) {
     let source;
     try {
-      source = fs27.readFileSync(file, "utf-8");
+      source = fs28.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -11184,7 +11624,7 @@ async function runAuditBrand(input) {
 }
 function collectFiles2(projectRoot, explicitFiles) {
   if (explicitFiles !== void 0 && explicitFiles.length > 0) {
-    return explicitFiles.map((f) => path31.isAbsolute(f) ? f : path31.join(projectRoot, f));
+    return explicitFiles.map((f) => path32.isAbsolute(f) ? f : path32.join(projectRoot, f));
   }
   const out = [];
   walk4(projectRoot, out, 0);
@@ -11194,7 +11634,7 @@ function walk4(dir, out, depth) {
   if (depth > 8) return;
   let entries;
   try {
-    entries = fs27.readdirSync(dir, { withFileTypes: true });
+    entries = fs28.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -11202,7 +11642,7 @@ function walk4(dir, out, depth) {
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
       continue;
     }
-    const full = path31.join(dir, entry.name);
+    const full = path32.join(dir, entry.name);
     if (entry.isDirectory()) {
       walk4(full, out, depth + 1);
     } else if (entry.isFile() && DEFAULT_GLOB_EXTENSIONS2.some((ext) => entry.name.endsWith(ext))) {
@@ -11320,15 +11760,15 @@ var VerifierRegistry = class {
 };
 
 // src/design-pipeline/phases/freshen.ts
-import * as fs28 from "fs";
-import * as path32 from "path";
+import * as fs29 from "fs";
+import * as path33 from "path";
 function runFreshen(input) {
   const { projectRoot, context } = input;
-  context.graphAvailable = fs28.existsSync(path32.join(projectRoot, ".harness", "graph"));
-  const designMdPath = path32.join(projectRoot, "design-system", "DESIGN.md");
-  const tokensJsonPath = path32.join(projectRoot, "design-system", "tokens.json");
-  context.inputs.designMdExists = fs28.existsSync(designMdPath);
-  context.inputs.tokensJsonExists = fs28.existsSync(tokensJsonPath);
+  context.graphAvailable = fs29.existsSync(path33.join(projectRoot, ".harness", "graph"));
+  const designMdPath = path33.join(projectRoot, "design-system", "DESIGN.md");
+  const tokensJsonPath = path33.join(projectRoot, "design-system", "tokens.json");
+  context.inputs.designMdExists = fs29.existsSync(designMdPath);
+  context.inputs.tokensJsonExists = fs29.existsSync(tokensJsonPath);
   if (context.inputs.designMdExists) {
     const content = readFileSafe(designMdPath);
     context.inputs.componentRegistryExists = content !== null && /^##\s+component\s+registry\b/im.test(content);
@@ -11337,7 +11777,7 @@ function runFreshen(input) {
 }
 function readFileSafe(p) {
   try {
-    return fs28.readFileSync(p, "utf-8");
+    return fs29.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -11364,8 +11804,8 @@ async function runDetect(input) {
 }
 
 // src/design-pipeline/phases/fix.ts
-import * as fs29 from "fs";
-import * as path33 from "path";
+import * as fs30 from "fs";
+import * as path34 from "path";
 var MAX_ITERATIONS = 5;
 async function runFix(input) {
   const { projectRoot, context, mode: mode2, files, designStrictness } = input;
@@ -11414,11 +11854,11 @@ async function safelyRedetect(projectRoot, mode2, files, designStrictness) {
   }
 }
 function writePipelineHandoff(projectRoot, context) {
-  const handoffPath = path33.join(projectRoot, ".harness", "handoff.json");
+  const handoffPath = path34.join(projectRoot, ".harness", "handoff.json");
   let handoff = {};
-  if (fs29.existsSync(handoffPath)) {
+  if (fs30.existsSync(handoffPath)) {
     try {
-      handoff = JSON.parse(fs29.readFileSync(handoffPath, "utf-8"));
+      handoff = JSON.parse(fs30.readFileSync(handoffPath, "utf-8"));
     } catch {
       handoff = {};
     }
@@ -11426,8 +11866,8 @@ function writePipelineHandoff(projectRoot, context) {
   handoff.pipeline = {
     driftFindings: context.driftFindings
   };
-  fs29.mkdirSync(path33.dirname(handoffPath), { recursive: true });
-  fs29.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2) + "\n");
+  fs30.mkdirSync(path34.dirname(handoffPath), { recursive: true });
+  fs30.writeFileSync(handoffPath, JSON.stringify(handoff, null, 2) + "\n");
 }
 
 // src/design-pipeline/phases/audit.ts
@@ -11457,8 +11897,8 @@ async function runAudit2(input) {
 }
 
 // src/design-pipeline/phases/fill.ts
-import * as fs30 from "fs";
-import * as path34 from "path";
+import * as fs31 from "fs";
+import * as path35 from "path";
 var DESIGN_MD_STUB = `# Design System
 
 <!-- TODO: author this file. See harness-design skill for guidance. -->
@@ -11518,11 +11958,11 @@ async function runFill(input) {
 }
 function bootstrapMissingInputs(input) {
   const { projectRoot, context } = input;
-  const designMdPath = path34.join(projectRoot, "design-system", "DESIGN.md");
-  const tokensJsonPath = path34.join(projectRoot, "design-system", "tokens.json");
-  if (!fs30.existsSync(designMdPath)) {
-    fs30.mkdirSync(path34.dirname(designMdPath), { recursive: true });
-    fs30.writeFileSync(designMdPath, DESIGN_MD_STUB);
+  const designMdPath = path35.join(projectRoot, "design-system", "DESIGN.md");
+  const tokensJsonPath = path35.join(projectRoot, "design-system", "tokens.json");
+  if (!fs31.existsSync(designMdPath)) {
+    fs31.mkdirSync(path35.dirname(designMdPath), { recursive: true });
+    fs31.writeFileSync(designMdPath, DESIGN_MD_STUB);
     context.bootstrapped.designMd = true;
     context.inputs.designMdExists = true;
     context.inputs.componentRegistryExists = true;
@@ -11542,16 +11982,16 @@ function bootstrapMissingInputs(input) {
       }
     }
   }
-  if (!fs30.existsSync(tokensJsonPath)) {
-    fs30.mkdirSync(path34.dirname(tokensJsonPath), { recursive: true });
-    fs30.writeFileSync(tokensJsonPath, TOKENS_JSON_STUB);
+  if (!fs31.existsSync(tokensJsonPath)) {
+    fs31.mkdirSync(path35.dirname(tokensJsonPath), { recursive: true });
+    fs31.writeFileSync(tokensJsonPath, TOKENS_JSON_STUB);
     context.bootstrapped.tokensJson = true;
     context.inputs.tokensJsonExists = true;
   }
 }
 function readFileSafe2(p) {
   try {
-    return fs30.readFileSync(p, "utf-8");
+    return fs31.readFileSync(p, "utf-8");
   } catch {
     return null;
   }
@@ -11586,10 +12026,10 @@ async function invokeCraftPolish(input) {
 function appendToFile(p, content) {
   let existing = "";
   try {
-    existing = fs30.readFileSync(p, "utf-8");
+    existing = fs31.readFileSync(p, "utf-8");
   } catch {
   }
-  fs30.writeFileSync(p, existing + content);
+  fs31.writeFileSync(p, existing + content);
 }
 
 // src/design-pipeline/phases/report.ts
@@ -11738,8 +12178,8 @@ async function handleDesignPipeline(input) {
 }
 
 // src/naming-craft/index.ts
-import * as fs31 from "fs";
-import * as path35 from "path";
+import * as fs33 from "fs";
+import * as path37 from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 
 // src/naming-craft/extract/identifiers.ts
@@ -11971,12 +12411,14 @@ var SEED_RUBRICS = [
 ];
 
 // src/naming-craft/phases/critique.ts
+var CRITIQUE_SYSTEM_PROMPT = "You are a senior engineer critiquing identifier names against a single naming rubric. Respond ONLY with a fenced JSON block. If the rubric does not apply or the name is fine, return `null` (literally the word null inside the JSON block).";
 async function critiqueOne(input) {
   const { identifier, rubric, provider } = input;
   const prompt = buildPrompt(input);
-  const raw = await provider.callText(prompt, {
-    systemPrompt: "You are a senior engineer critiquing identifier names against a single naming rubric. Respond ONLY with a fenced JSON block. If the rubric does not apply or the name is fine, return `null` (literally the word null inside the JSON block)."
-  });
+  const raw = await provider.callText(prompt, { systemPrompt: CRITIQUE_SYSTEM_PROMPT });
+  return parseFindingFromRaw(raw, { identifier, rubric });
+}
+function parseFindingFromRaw(raw, ctx) {
   const parsed = parseFencedJson(raw);
   if (parsed === null) return null;
   if (typeof parsed !== "object") return null;
@@ -11985,23 +12427,22 @@ async function critiqueOne(input) {
   const confidence = parsed.confidence;
   if (!isTier2(tier) || !isImpact2(impact) || !isConfidence2(confidence)) return null;
   if (typeof parsed.message !== "string" || parsed.message.length === 0) return null;
-  const finding = {
-    code: rubric.id,
+  return {
+    code: ctx.rubric.id,
     phase: "critique",
     tier,
     impact,
     confidence,
     target: {
-      file: identifier.file,
-      line: identifier.line,
-      identifier: identifier.name,
-      kind: identifier.kind
+      file: ctx.identifier.file,
+      line: ctx.identifier.line,
+      identifier: ctx.identifier.name,
+      kind: ctx.identifier.kind
     },
     message: parsed.message,
-    cite: { rubricId: rubric.id, source: rubric.source },
+    cite: { rubricId: ctx.rubric.id, source: ctx.rubric.source },
     derived: { priority: derivePriority(tier, impact, confidence) }
   };
-  return finding;
 }
 function buildPrompt(input) {
   const { identifier, rubric, convention } = input;
@@ -12061,23 +12502,74 @@ function isConfidence2(v) {
   return v === "high" || v === "medium" || v === "low";
 }
 
+// src/shared/craft/runs/store.ts
+import * as fs32 from "fs";
+import * as path36 from "path";
+var RUN_TTL_MS = 24 * 60 * 60 * 1e3;
+function runsDir(projectRoot) {
+  return path36.join(projectRoot, ".harness", "craft", "runs");
+}
+function runPath(projectRoot, runId) {
+  return path36.join(runsDir(projectRoot), `${runId}.json`);
+}
+function saveRunState(projectRoot, state) {
+  const dir = runsDir(projectRoot);
+  fs32.mkdirSync(dir, { recursive: true });
+  const file = runPath(projectRoot, state.runId);
+  fs32.writeFileSync(file, JSON.stringify(state, null, 2));
+  return { runFile: file };
+}
+function loadRunState(projectRoot, runId) {
+  const file = runPath(projectRoot, runId);
+  if (!fs32.existsSync(file)) return null;
+  try {
+    const raw = fs32.readFileSync(file, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function deleteRunState(projectRoot, runId) {
+  const file = runPath(projectRoot, runId);
+  try {
+    fs32.unlinkSync(file);
+  } catch {
+  }
+}
+function pruneOldRuns(projectRoot, now = Date.now()) {
+  const dir = runsDir(projectRoot);
+  let entries;
+  try {
+    entries = fs32.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+    const full = path36.join(dir, entry.name);
+    try {
+      const stat = fs32.statSync(full);
+      if (now - stat.mtimeMs > RUN_TTL_MS) fs32.unlinkSync(full);
+    } catch {
+    }
+  }
+}
+
 // src/naming-craft/index.ts
+var DEFAULT_PROMPT_BUDGET = 100;
 var DEFAULT_MAX_FILES = 100;
 var DEFAULT_MAX_IDENTIFIERS_PER_FILE = 15;
 var EXTENSIONS = [".ts", ".tsx", ".js", ".jsx"];
-async function runNamingCraft(input) {
-  const startedAt = Date.now();
+function gatherProjectContext(input) {
   const projectRoot = sanitizePath(input.path);
   const maxFiles = input.maxFiles ?? DEFAULT_MAX_FILES;
-  const maxIdentifiersPerFile = input.maxIdentifiersPerFile ?? DEFAULT_MAX_IDENTIFIERS_PER_FILE;
-  const provider = input.__testProvider ?? getProvider();
   const files = collectFiles3(projectRoot, input.files).slice(0, maxFiles);
   const allIdentifiers = [];
   const perFile = /* @__PURE__ */ new Map();
   for (const file of files) {
     let source;
     try {
-      source = fs31.readFileSync(file, "utf-8");
+      source = fs33.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -12086,6 +12578,18 @@ async function runNamingCraft(input) {
     allIdentifiers.push(...ids);
   }
   const convention = sampleConventions(allIdentifiers, files);
+  return { projectRoot, files, perFile, convention };
+}
+async function runNamingCraft(input) {
+  const startedAt = Date.now();
+  const maxIdentifiersPerFile = input.maxIdentifiersPerFile ?? DEFAULT_MAX_IDENTIFIERS_PER_FILE;
+  const provider = input.__testProvider ?? getProvider();
+  if (provider instanceof InSessionLlmProvider) {
+    throw new Error(
+      "runNamingCraft is the inline entry point; the in-session provider requires the two-step flow. Call collectNamingCraftPrompts(...) and then finalizeNamingCraft(...), or set HARNESS_CRAFT_LLM=mock for tests."
+    );
+  }
+  const { perFile, convention } = gatherProjectContext(input);
   const rubrics = SEED_RUBRICS;
   const findings = [];
   for (const [, identifiers] of perFile) {
@@ -12120,9 +12624,109 @@ async function runNamingCraft(input) {
     }
   };
 }
+async function collectNamingCraftPrompts(input) {
+  const maxIdentifiersPerFile = input.maxIdentifiersPerFile ?? DEFAULT_MAX_IDENTIFIERS_PER_FILE;
+  const budget = input.promptBudget ?? DEFAULT_PROMPT_BUDGET;
+  const { projectRoot, perFile, convention } = gatherProjectContext(input);
+  const rubrics = SEED_RUBRICS;
+  const runId = randomUUID3();
+  const promptRecords = [];
+  const pending = [];
+  outer: for (const [, identifiers] of perFile) {
+    const sample = sampleIdentifiers(identifiers, maxIdentifiersPerFile, input.kinds);
+    for (const identifier of sample) {
+      for (const rubric of rubrics) {
+        if (!rubric.appliesTo.includes(identifier.kind)) continue;
+        const promptId = `p${promptRecords.length + 1}`;
+        const userPrompt = buildPrompt({ identifier, rubric, convention });
+        promptRecords.push({ promptId, identifier, rubricId: rubric.id });
+        pending.push({ promptId, systemPrompt: CRITIQUE_SYSTEM_PROMPT, userPrompt });
+        if (pending.length > budget) break outer;
+      }
+    }
+  }
+  if (pending.length > budget) {
+    return {
+      status: "budget-exceeded",
+      runId,
+      pendingPrompts: [],
+      projection: { promptCount: pending.length, budget },
+      hint: `Projected at least ${pending.length} LLM prompts (budget: ${budget}). Re-invoke with smaller maxFiles / maxIdentifiersPerFile, or pass promptBudget to raise the ceiling.`
+    };
+  }
+  const meta = {
+    projectRoot,
+    startedAt: Date.now(),
+    convention,
+    rubricsApplied: rubrics.map((r) => r.id),
+    prompts: promptRecords
+  };
+  pruneOldRuns(projectRoot);
+  const { runFile } = saveRunState(projectRoot, {
+    v: 1,
+    runId,
+    skill: "naming-craft",
+    createdAt: Date.now(),
+    meta
+  });
+  return {
+    status: "collected",
+    runId,
+    pendingPrompts: pending,
+    projection: { promptCount: pending.length, budget },
+    runFile
+  };
+}
+async function finalizeNamingCraft(input) {
+  const startedAt = Date.now();
+  const projectRoot = sanitizePath(input.path);
+  const state = loadRunState(projectRoot, input.runId);
+  if (state === null) {
+    throw new Error(
+      `naming-craft: no persisted run found for runId=${input.runId} under ${projectRoot}. Run collectNamingCraftPrompts first, or ensure the path matches the project root used at collection time.`
+    );
+  }
+  if (state.skill !== "naming-craft") {
+    throw new Error(
+      `naming-craft: runId=${input.runId} belongs to skill ${state.skill}, not naming-craft.`
+    );
+  }
+  const rubricById = new Map(SEED_RUBRICS.map((r) => [r.id, r]));
+  const promptById = new Map(state.meta.prompts.map((p) => [p.promptId, p]));
+  const findings = [];
+  for (const response of input.responses) {
+    const promptRecord = promptById.get(response.promptId);
+    if (promptRecord === void 0) continue;
+    const rubric = rubricById.get(promptRecord.rubricId);
+    if (rubric === void 0) continue;
+    const finding = parseFindingFromRaw(response.raw, {
+      identifier: promptRecord.identifier,
+      rubric
+    });
+    if (finding !== null) findings.push(finding);
+  }
+  deleteRunState(projectRoot, input.runId);
+  return {
+    findings,
+    summary: {
+      phaseRun: ["critique"],
+      mode: "fast",
+      durationMs: Date.now() - startedAt,
+      llmCalls: {
+        provider: "in-session",
+        model: "host-chat",
+        count: input.responses.length,
+        costUsd: 0
+      },
+      catalog: { rubricsApplied: state.meta.rubricsApplied },
+      convention: state.meta.convention,
+      runId: input.runId
+    }
+  };
+}
 function collectFiles3(projectRoot, explicitFiles) {
   if (explicitFiles !== void 0 && explicitFiles.length > 0) {
-    return explicitFiles.map((f) => path35.isAbsolute(f) ? f : path35.join(projectRoot, f));
+    return explicitFiles.map((f) => path37.isAbsolute(f) ? f : path37.join(projectRoot, f));
   }
   const out = [];
   walk5(projectRoot, out, 0);
@@ -12132,7 +12736,7 @@ function walk5(dir, out, depth) {
   if (depth > 8) return;
   let entries;
   try {
-    entries = fs31.readdirSync(dir, { withFileTypes: true });
+    entries = fs33.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -12140,7 +12744,7 @@ function walk5(dir, out, depth) {
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
       continue;
     }
-    const full = path35.join(dir, entry.name);
+    const full = path37.join(dir, entry.name);
     if (entry.isDirectory()) walk5(full, out, depth + 1);
     else if (entry.isFile() && EXTENSIONS.some((ext) => entry.name.endsWith(ext))) out.push(full);
   }
@@ -12179,7 +12783,7 @@ function sumCosts(provider) {
 // src/mcp/tools/naming-craft.ts
 var namingCraftDefinition = {
   name: "naming_craft",
-  description: "LLM-judgment critique of identifier names (variables, functions, types, files). First craft-pipeline ceiling skill; uses a curated rubric catalog seeded from Martin / Beck / Karlton. Emits 3-axis findings (tier x impact x confidence per ADR 0019).",
+  description: "LLM-judgment critique of identifier names (variables, functions, types, files). First craft-pipeline ceiling skill; uses a curated rubric catalog seeded from Martin / Beck / Karlton. Emits 3-axis findings (tier x impact x confidence per ADR 0019). In-session mode (default in Claude Code) returns prompts for the calling agent to answer; call naming_craft_finalize with the responses to get findings.",
   inputSchema: {
     type: "object",
     properties: {
@@ -12198,11 +12802,52 @@ var namingCraftDefinition = {
       maxIdentifiersPerFile: {
         type: "number",
         description: "Cap per-file identifier sampling (default: 15)"
+      },
+      mode: {
+        type: "string",
+        enum: ["inline", "in-session"],
+        description: "'in-session' (default): return prompts for the calling agent to answer, then call naming_craft_finalize. 'inline': run end-to-end via the configured provider (HARNESS_CRAFT_LLM)."
+      },
+      promptBudget: {
+        type: "number",
+        description: "Cap prompt count in in-session mode (default: 100)"
       }
     },
     required: ["path"]
   }
 };
+var namingCraftFinalizeDefinition = {
+  name: "naming_craft_finalize",
+  description: "Finalize a naming_craft in-session run by submitting the calling agent's responses to the prompts collected by naming_craft. Returns the standard NamingCraftOutput with findings.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Project root path used in the collect call (must match)"
+      },
+      runId: { type: "string", description: "runId returned by the naming_craft collect call" },
+      responses: {
+        type: "array",
+        description: "Per-prompt responses. `raw` is the fenced JSON block the calling agent produced.",
+        items: {
+          type: "object",
+          properties: {
+            promptId: { type: "string" },
+            raw: { type: "string" }
+          },
+          required: ["promptId", "raw"]
+        }
+      }
+    },
+    required: ["path", "runId", "responses"]
+  }
+};
+function effectiveMode(input) {
+  if (input.mode !== void 0) return input.mode;
+  const envMode = resolveCraftLlmMode();
+  return envMode === "in-session" ? "in-session" : "inline";
+}
 async function handleNamingCraft(input) {
   if (typeof input?.path !== "string" || input.path.length === 0) {
     return {
@@ -12213,6 +12858,10 @@ async function handleNamingCraft(input) {
     };
   }
   try {
+    if (effectiveMode(input) === "in-session") {
+      const result2 = await collectNamingCraftPrompts(input);
+      return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };
+    }
     const result = await runNamingCraft(input);
     return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
   } catch (err2) {
@@ -12225,34 +12874,86 @@ async function handleNamingCraft(input) {
     };
   }
 }
+async function handleNamingCraftFinalize(input) {
+  if (typeof input?.path !== "string" || input.path.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: "naming_craft_finalize: `path` is required" })
+        }
+      ],
+      isError: true
+    };
+  }
+  if (typeof input?.runId !== "string" || input.runId.length === 0) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: "naming_craft_finalize: `runId` is required" })
+        }
+      ],
+      isError: true
+    };
+  }
+  if (!Array.isArray(input?.responses)) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "naming_craft_finalize: `responses` must be an array"
+          })
+        }
+      ],
+      isError: true
+    };
+  }
+  try {
+    const result = await finalizeNamingCraft(input);
+    return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+  } catch (err2) {
+    const message = err2 instanceof Error ? err2.message : String(err2);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ error: `naming_craft_finalize failed: ${message}` })
+        }
+      ],
+      isError: true
+    };
+  }
+}
 
 // src/spec-craft/index.ts
-import * as fs33 from "fs";
+import * as fs35 from "fs";
 import { randomUUID as randomUUID4 } from "crypto";
 
 // src/spec-craft/extract/discover.ts
-import * as fs32 from "fs";
-import * as path36 from "path";
+import * as fs34 from "fs";
+import * as path38 from "path";
 function discoverSpecs(projectRoot, kindsFilter) {
   const wantProposal = kindsFilter === void 0 || kindsFilter.includes("proposal");
   const wantADR = kindsFilter === void 0 || kindsFilter.includes("adr");
   const out = [];
   if (wantProposal) {
-    const changesDir = path36.join(projectRoot, "docs", "changes");
-    if (fs32.existsSync(changesDir)) {
-      for (const entry of fs32.readdirSync(changesDir, { withFileTypes: true })) {
+    const changesDir = path38.join(projectRoot, "docs", "changes");
+    if (fs34.existsSync(changesDir)) {
+      for (const entry of fs34.readdirSync(changesDir, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
         if (entry.name.startsWith(".")) continue;
-        const topicDir = path36.join(changesDir, entry.name);
-        const direct = path36.join(topicDir, "proposal.md");
-        if (fs32.existsSync(direct)) {
+        const topicDir = path38.join(changesDir, entry.name);
+        const direct = path38.join(topicDir, "proposal.md");
+        if (fs34.existsSync(direct)) {
           out.push({ file: direct, kind: "proposal" });
         }
-        for (const sub of fs32.readdirSync(topicDir, { withFileTypes: true })) {
+        for (const sub of fs34.readdirSync(topicDir, { withFileTypes: true })) {
           if (!sub.isDirectory()) continue;
           if (sub.name.startsWith(".")) continue;
-          const subProposal = path36.join(topicDir, sub.name, "proposal.md");
-          if (fs32.existsSync(subProposal)) {
+          const subProposal = path38.join(topicDir, sub.name, "proposal.md");
+          if (fs34.existsSync(subProposal)) {
             out.push({ file: subProposal, kind: "proposal" });
           }
         }
@@ -12260,13 +12961,13 @@ function discoverSpecs(projectRoot, kindsFilter) {
     }
   }
   if (wantADR) {
-    const decisionsDir = path36.join(projectRoot, "docs", "knowledge", "decisions");
-    if (fs32.existsSync(decisionsDir)) {
-      for (const entry of fs32.readdirSync(decisionsDir, { withFileTypes: true })) {
+    const decisionsDir = path38.join(projectRoot, "docs", "knowledge", "decisions");
+    if (fs34.existsSync(decisionsDir)) {
+      for (const entry of fs34.readdirSync(decisionsDir, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         if (!entry.name.endsWith(".md")) continue;
         if (entry.name.startsWith(".") || entry.name.toUpperCase() === "README.MD") continue;
-        out.push({ file: path36.join(decisionsDir, entry.name), kind: "adr" });
+        out.push({ file: path38.join(decisionsDir, entry.name), kind: "adr" });
       }
     }
   }
@@ -12514,7 +13215,7 @@ async function runSpecCraft(input) {
   for (const spec of specs) {
     let source;
     try {
-      source = fs33.readFileSync(spec.file, "utf-8");
+      source = fs35.readFileSync(spec.file, "utf-8");
     } catch {
       continue;
     }
@@ -12634,13 +13335,13 @@ async function handleSpecCraft(input) {
 }
 
 // src/copy-craft/index.ts
-import * as fs35 from "fs";
-import * as path39 from "path";
+import * as fs37 from "fs";
+import * as path41 from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // src/copy-craft/extract/source.ts
 import ts5 from "typescript";
-import * as path37 from "path";
+import * as path39 from "path";
 var LOG_LEVELS = ["log", "info", "warn", "warning", "error", "debug", "trace", "fatal"];
 function extractFromSource(input) {
   if (!/\.(?:ts|tsx|js|jsx)$/i.test(input.file)) return [];
@@ -12780,7 +13481,7 @@ function isLikelyLogger(name) {
 }
 function fileMatchesCliPaths(file, cliPaths) {
   const paths = cliPaths ?? defaultCliOutputPaths();
-  const normalized = file.split(path37.sep).join("/");
+  const normalized = file.split(path39.sep).join("/");
   return paths.some((p) => normalized.includes(p));
 }
 function defaultCliOutputPaths() {
@@ -12800,8 +13501,8 @@ function cleanCommentText(raw) {
 
 // src/copy-craft/extract/commits.ts
 import { spawnSync } from "child_process";
-import * as fs34 from "fs";
-import * as path38 from "path";
+import * as fs36 from "fs";
+import * as path40 from "path";
 var GIT_TIMEOUT_MS = 1e4;
 function extractCommits(input) {
   const { projectRoot, since = "1 month ago", limit = 100 } = input;
@@ -12840,8 +13541,8 @@ function extractCommits(input) {
 function isGitRepo(projectRoot) {
   let dir = projectRoot;
   for (let i = 0; i < 10; i++) {
-    if (fs34.existsSync(path38.join(dir, ".git"))) return true;
-    const parent = path38.dirname(dir);
+    if (fs36.existsSync(path40.join(dir, ".git"))) return true;
+    const parent = path40.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -13147,7 +13848,7 @@ async function runCopyCraft(input) {
     for (const file of files) {
       let source;
       try {
-        source = fs35.readFileSync(file, "utf-8");
+        source = fs37.readFileSync(file, "utf-8");
       } catch {
         continue;
       }
@@ -13231,7 +13932,7 @@ async function runCopyCraft(input) {
 }
 function collectSourceFiles(projectRoot, explicitFiles) {
   if (explicitFiles !== void 0 && explicitFiles.length > 0) {
-    return explicitFiles.map((f) => path39.isAbsolute(f) ? f : path39.join(projectRoot, f));
+    return explicitFiles.map((f) => path41.isAbsolute(f) ? f : path41.join(projectRoot, f));
   }
   const out = [];
   walk6(projectRoot, out, 0);
@@ -13241,7 +13942,7 @@ function walk6(dir, out, depth) {
   if (depth > 8) return;
   let entries;
   try {
-    entries = fs35.readdirSync(dir, { withFileTypes: true });
+    entries = fs37.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -13249,7 +13950,7 @@ function walk6(dir, out, depth) {
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
       continue;
     }
-    const full = path39.join(dir, entry.name);
+    const full = path41.join(dir, entry.name);
     if (entry.isDirectory()) walk6(full, out, depth + 1);
     else if (entry.isFile() && SOURCE_EXTENSIONS.some((ext) => entry.name.endsWith(ext)))
       out.push(full);
@@ -13319,8 +14020,8 @@ async function handleCopyCraft(input) {
 }
 
 // src/test-craft/index.ts
-import * as fs37 from "fs";
-import * as path41 from "path";
+import * as fs39 from "fs";
+import * as path43 from "path";
 import { randomUUID as randomUUID6 } from "crypto";
 
 // src/test-craft/extract/framework.ts
@@ -13426,25 +14127,25 @@ function extractCallbackText(node, fullSource) {
 }
 
 // src/test-craft/extract/source-pair.ts
-import * as fs36 from "fs";
-import * as path40 from "path";
+import * as fs38 from "fs";
+import * as path42 from "path";
 var MAX_SOURCE_CHARS = 2e3;
 function resolveSourceFile(testFile) {
-  const dir = path40.dirname(testFile);
+  const dir = path42.dirname(testFile);
   const ext = /\.tsx$/.test(testFile) ? ".tsx" : ".ts";
-  const base = path40.basename(testFile).replace(/\.(?:test|spec)\.(?:tsx?|jsx?)$/, "");
+  const base = path42.basename(testFile).replace(/\.(?:test|spec)\.(?:tsx?|jsx?)$/, "");
   const candidates = [
     // Sibling (most common in co-located setups)
-    path40.join(dir, base + ext),
+    path42.join(dir, base + ext),
     // tests/ peer to src/
-    path40.join(dir, "..", "src", base + ext),
+    path42.join(dir, "..", "src", base + ext),
     // tests/ one level deeper than src/
-    path40.join(dir, "..", "..", "src", base + ext)
+    path42.join(dir, "..", "..", "src", base + ext)
   ];
   for (const candidate of candidates) {
-    if (fs36.existsSync(candidate)) {
+    if (fs38.existsSync(candidate)) {
       try {
-        const raw = fs36.readFileSync(candidate, "utf-8");
+        const raw = fs38.readFileSync(candidate, "utf-8");
         const content = raw.length > MAX_SOURCE_CHARS ? raw.slice(0, MAX_SOURCE_CHARS) + "\n[\u2026truncated for prompt cost\u2026]" : raw;
         return { file: candidate, content };
       } catch {
@@ -13680,7 +14381,7 @@ async function runTestCraft(input) {
   for (const file of files) {
     let source;
     try {
-      source = fs37.readFileSync(file, "utf-8");
+      source = fs39.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -13745,7 +14446,7 @@ async function runTestCraft(input) {
 }
 function collectTestFiles(projectRoot, explicitFiles) {
   if (explicitFiles !== void 0 && explicitFiles.length > 0) {
-    return explicitFiles.map((f) => path41.isAbsolute(f) ? f : path41.join(projectRoot, f));
+    return explicitFiles.map((f) => path43.isAbsolute(f) ? f : path43.join(projectRoot, f));
   }
   const out = [];
   walk7(projectRoot, out, 0);
@@ -13755,7 +14456,7 @@ function walk7(dir, out, depth) {
   if (depth > 10) return;
   let entries;
   try {
-    entries = fs37.readdirSync(dir, { withFileTypes: true });
+    entries = fs39.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -13763,7 +14464,7 @@ function walk7(dir, out, depth) {
     if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "coverage") {
       continue;
     }
-    const full = path41.join(dir, entry.name);
+    const full = path43.join(dir, entry.name);
     if (entry.isDirectory()) walk7(full, out, depth + 1);
     else if (entry.isFile() && TEST_FILE_EXTS.some((ext) => entry.name.endsWith(ext))) {
       out.push(full);
@@ -13836,18 +14537,18 @@ async function handleTestCraft(input) {
 }
 
 // src/knowledge-craft/index.ts
-import * as fs39 from "fs";
-import * as path43 from "path";
+import * as fs41 from "fs";
+import * as path45 from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 
 // src/knowledge-craft/extract/discover.ts
-import * as fs38 from "fs";
-import * as path42 from "path";
+import * as fs40 from "fs";
+import * as path44 from "path";
 var KNOWLEDGE_ROOT = "docs/knowledge";
 var DEFAULT_EXCLUDED_DIRS = ["decisions"];
 function discoverKnowledgeEntries(projectRoot, extraExcludeDirs) {
-  const root = path42.join(projectRoot, KNOWLEDGE_ROOT);
-  if (!fs38.existsSync(root)) return [];
+  const root = path44.join(projectRoot, KNOWLEDGE_ROOT);
+  if (!fs40.existsSync(root)) return [];
   const exclude = /* @__PURE__ */ new Set([...DEFAULT_EXCLUDED_DIRS, ...extraExcludeDirs ?? []]);
   const out = [];
   walk8(root, root, out, exclude);
@@ -13856,13 +14557,13 @@ function discoverKnowledgeEntries(projectRoot, extraExcludeDirs) {
 function walk8(dir, root, out, exclude) {
   let entries;
   try {
-    entries = fs38.readdirSync(dir, { withFileTypes: true });
+    entries = fs40.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.name.startsWith(".")) continue;
-    const full = path42.join(dir, entry.name);
+    const full = path44.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (exclude.has(entry.name)) continue;
       walk8(full, root, out, exclude);
@@ -13871,7 +14572,7 @@ function walk8(dir, root, out, exclude) {
     if (!entry.isFile()) continue;
     if (!entry.name.endsWith(".md")) continue;
     if (entry.name.toLowerCase() === "readme.md") continue;
-    const rel = path42.relative(root, full).replaceAll("\\", "/");
+    const rel = path44.relative(root, full).replaceAll("\\", "/");
     out.push({ file: full, relative: rel });
   }
 }
@@ -14051,7 +14752,7 @@ async function runKnowledgeCraft(input) {
   for (const entry of entries) {
     let content;
     try {
-      content = fs39.readFileSync(entry.file, "utf-8");
+      content = fs41.readFileSync(entry.file, "utf-8");
     } catch {
       filesSkipped++;
       continue;
@@ -14092,10 +14793,10 @@ async function runKnowledgeCraft(input) {
 }
 function collectEntries(projectRoot, input) {
   if (input.files !== void 0 && input.files.length > 0) {
-    const root = path43.join(projectRoot, KNOWLEDGE_ROOT);
+    const root = path45.join(projectRoot, KNOWLEDGE_ROOT);
     return input.files.map((f) => ({
       file: f,
-      relative: path43.relative(root, f).replaceAll("\\", "/")
+      relative: path45.relative(root, f).replaceAll("\\", "/")
     }));
   }
   return discoverKnowledgeEntries(projectRoot, input.excludeDirs);
@@ -14157,12 +14858,12 @@ async function handleKnowledgeCraft(input) {
 }
 
 // src/security-craft/index.ts
-import * as fs41 from "fs";
+import * as fs43 from "fs";
 import { randomUUID as randomUUID8 } from "crypto";
 
 // src/security-craft/extract/discover.ts
-import * as fs40 from "fs";
-import * as path44 from "path";
+import * as fs42 from "fs";
+import * as path46 from "path";
 var SOURCE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
 var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
@@ -14182,12 +14883,12 @@ var EXCLUDED_DIRS = /* @__PURE__ */ new Set([
 ]);
 var TEST_FILE_PATTERN = /\.(test|spec)\.(ts|tsx|js|jsx|mjs|cjs)$/i;
 function discoverSourceFiles(projectRoot, packagesFilter) {
-  const packagesDir = path44.join(projectRoot, "packages");
-  if (!fs40.existsSync(packagesDir)) return [];
+  const packagesDir = path46.join(projectRoot, "packages");
+  if (!fs42.existsSync(packagesDir)) return [];
   const out = [];
   let entries;
   try {
-    entries = fs40.readdirSync(packagesDir, { withFileTypes: true });
+    entries = fs42.readdirSync(packagesDir, { withFileTypes: true });
   } catch {
     return [];
   }
@@ -14195,8 +14896,8 @@ function discoverSourceFiles(projectRoot, packagesFilter) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
     if (packagesFilter !== void 0 && !packagesFilter.includes(entry.name)) continue;
-    const srcDir = path44.join(packagesDir, entry.name, "src");
-    if (!fs40.existsSync(srcDir)) continue;
+    const srcDir = path46.join(packagesDir, entry.name, "src");
+    if (!fs42.existsSync(srcDir)) continue;
     walk9(srcDir, out);
   }
   return out;
@@ -14204,13 +14905,13 @@ function discoverSourceFiles(projectRoot, packagesFilter) {
 function walk9(dir, out) {
   let entries;
   try {
-    entries = fs40.readdirSync(dir, { withFileTypes: true });
+    entries = fs42.readdirSync(dir, { withFileTypes: true });
   } catch {
     return;
   }
   for (const entry of entries) {
     if (entry.name.startsWith(".")) continue;
-    const full = path44.join(dir, entry.name);
+    const full = path46.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (EXCLUDED_DIRS.has(entry.name)) continue;
       walk9(full, out);
@@ -14218,7 +14919,7 @@ function walk9(dir, out) {
     }
     if (!entry.isFile()) continue;
     if (TEST_FILE_PATTERN.test(entry.name)) continue;
-    const ext = path44.extname(entry.name);
+    const ext = path46.extname(entry.name);
     if (!SOURCE_EXTENSIONS2.has(ext)) continue;
     out.push(full);
   }
@@ -14715,7 +15416,7 @@ async function runSecurityCraft(input) {
   for (const file of candidateFiles) {
     let source;
     try {
-      source = fs41.readFileSync(file, "utf-8");
+      source = fs43.readFileSync(file, "utf-8");
     } catch {
       continue;
     }
@@ -14900,6 +15601,7 @@ var TOOL_DEFINITIONS = [
   auditBrandDefinition,
   designPipelineDefinition,
   namingCraftDefinition,
+  namingCraftFinalizeDefinition,
   specCraftDefinition,
   copyCraftDefinition,
   testCraftDefinition,
@@ -14982,6 +15684,7 @@ var TOOL_HANDLERS = {
   audit_brand: handleAuditBrand,
   run_design_pipeline: handleDesignPipeline,
   naming_craft: handleNamingCraft,
+  naming_craft_finalize: handleNamingCraftFinalize,
   spec_craft: handleSpecCraft,
   copy_craft: handleCopyCraft,
   test_craft: handleTestCraft,
@@ -15088,7 +15791,7 @@ async function appendUpdateNotification(result, resolvedRoot) {
       shouldRunCheck,
       readCheckState,
       spawnBackgroundCheck
-    } = await import("./dist-XIJWWQ5N.js");
+    } = await import("./dist-72ID44UE.js");
     const { CLI_VERSION } = await import("./version-CUI434OP.js");
     const configInterval = readConfigInterval(resolvedRoot);
     const DEFAULT_INTERVAL = 864e5;
@@ -15186,6 +15889,8 @@ export {
   runDetectDrift,
   runAlignDesignSystem,
   runAudit,
+  findOrchestratorMd,
+  readBackendsFromOrchestratorMd,
   runDesignCraft,
   runAuditBrand,
   runCopyCraft,