@contentful/experience-design-system-cli 2.35.1-dev-build-98f1ba74.0 → 2.35.1-dev-build-c8bff53c.0

package/legacy/dist/src/index.js

@@ -164,11 +164,12 @@ var init_render_with_goodbye = __esm({
 function isAgentName(value) {
   return AGENT_NAMES.includes(value);
 }
-var AGENT_NAMES, AGENT_BINARIES;
+var AGENT_NAMES, DEFAULT_AGENT_NAME, AGENT_BINARIES;
 var init_agent_names = __esm({
   "packages/experience-design-system-generation/dist/src/agent-names.js"() {
     "use strict";
     AGENT_NAMES = ["claude", "codex", "opencode", "cursor", "copilot"];
+    DEFAULT_AGENT_NAME = "claude";
     AGENT_BINARIES = {
       claude: "claude",
       codex: "codex",
@@ -180,6 +181,23 @@ var init_agent_names = __esm({
 });
 
 // packages/experience-design-system-generation/dist/src/controller/helpers/validate-generation-request.js
+function validateGenerationRequest(request2) {
+  if (request2 === null || typeof request2 !== "object") {
+    throw new TypeError("createGenerationEndpoint requires a request object");
+  }
+  if (!isAgentName(request2.agent)) {
+    throw new TypeError(`createGenerationEndpoint requires agent to be a valid agent name, got: ${String(request2.agent)}`);
+  }
+  if (typeof request2.timeoutMs !== "number" || request2.timeoutMs <= 0) {
+    throw new TypeError("createGenerationEndpoint requires timeoutMs to be a positive number");
+  }
+  if (request2.promptOptions === null || typeof request2.promptOptions !== "object") {
+    throw new TypeError("createGenerationEndpoint requires promptOptions to be an object");
+  }
+  if (request2.onOutput !== void 0 && typeof request2.onOutput !== "function") {
+    throw new TypeError("createGenerationEndpoint requires onOutput to be a function when provided");
+  }
+}
 var init_validate_generation_request = __esm({
   "packages/experience-design-system-generation/dist/src/controller/helpers/validate-generation-request.js"() {
     "use strict";
@@ -612,6 +630,17 @@ var init_build_prompt = __esm({
 });
 
 // packages/experience-design-system-generation/dist/src/orchestrator/execute-generation-orchestrator.js
+async function executeGenerationOrchestrator(request2) {
+  const prompt = await buildPrompt(request2.promptOptions);
+  return request2.invoker.invoke({
+    agent: request2.agent,
+    model: request2.model,
+    bedrock: request2.bedrock,
+    prompt,
+    timeoutMs: request2.timeoutMs,
+    onOutput: request2.onOutput
+  });
+}
 var init_execute_generation_orchestrator = __esm({
   "packages/experience-design-system-generation/dist/src/orchestrator/execute-generation-orchestrator.js"() {
     "use strict";
@@ -712,6 +741,22 @@ var init_describe_agent_failure = __esm({
 });
 
 // packages/experience-design-system-generation/dist/src/services/agent/helpers/extract-sentinel-output.js
+function extractSentinelOutput(stdout) {
+  const START = "<<<EDS_OUTPUT_START>>>";
+  const END = "<<<EDS_OUTPUT_END>>>";
+  const startIdx = stdout.indexOf(START);
+  const endIdx = stdout.indexOf(END);
+  if (startIdx === -1 || endIdx === -1 || endIdx <= startIdx)
+    return null;
+  const secondStart = stdout.indexOf(START, startIdx + START.length);
+  if (secondStart !== -1 && secondStart < endIdx)
+    return "multiple";
+  const afterStart = stdout.indexOf(END, startIdx);
+  const secondEnd = stdout.indexOf(END, afterStart + END.length);
+  if (secondEnd !== -1)
+    return "multiple";
+  return stdout.slice(startIdx + START.length, endIdx).trim();
+}
 var init_extract_sentinel_output = __esm({
   "packages/experience-design-system-generation/dist/src/services/agent/helpers/extract-sentinel-output.js"() {
     "use strict";
@@ -736,7 +781,7 @@ async function runAgent(options) {
     promptLen: prompt.length,
     promptHead: prompt.slice(0, 500)
   });
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const bedrockEnv = bedrock ? BEDROCK_ENV_BY_AGENT[agent] : void 0;
     const child = spawn(binary, args, {
       stdio: ["pipe", "pipe", "pipe"],
@@ -785,7 +830,7 @@ async function runAgent(options) {
         stderrLen: stderr.length,
         stderrTail: stderr.slice(-1e3)
       });
-      resolve20(result);
+      resolve21(result);
     });
   });
 }
@@ -802,7 +847,7 @@ var init_run_agent = __esm({
 // packages/experience-design-system-generation/dist/src/services/agent/helpers/check-claude-auth.js
 import { spawn as spawn2 } from "node:child_process";
 function checkClaudeAuth(binary) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const child = spawn2(binary, ["auth", "status", "--json"], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -812,7 +857,7 @@ function checkClaudeAuth(binary) {
       if (!done) {
         done = true;
         child.kill("SIGTERM");
-        resolve20("unauthenticated");
+        resolve21("unauthenticated");
       }
     }, 5e3);
     child.stdout?.on("data", (chunk) => {
@@ -824,14 +869,14 @@ function checkClaudeAuth(binary) {
       done = true;
       clearTimeout(timer);
       if (code !== 0) {
-        resolve20("unauthenticated");
+        resolve21("unauthenticated");
         return;
       }
       try {
         const status = JSON.parse(stdout);
-        resolve20(status.loggedIn ? "ok" : "unauthenticated");
+        resolve21(status.loggedIn ? "ok" : "unauthenticated");
       } catch {
-        resolve20("unauthenticated");
+        resolve21("unauthenticated");
       }
     });
   });
@@ -846,13 +891,13 @@ var init_check_claude_auth = __esm({
 import { spawn as spawn3 } from "node:child_process";
 async function checkAgentAuth(agent) {
   const binary = resolveAgentBinary(agent);
-  const binaryExists2 = await new Promise((resolve20) => {
+  const binaryExists2 = await new Promise((resolve21) => {
     if (binary.startsWith("/")) {
-      import("node:fs/promises").then((fs2) => fs2.access(binary).then(() => resolve20(true), () => resolve20(false)));
+      import("node:fs/promises").then((fs2) => fs2.access(binary).then(() => resolve21(true), () => resolve21(false)));
       return;
     }
     const child = spawn3(process.platform === "win32" ? "where" : "which", [binary], { stdio: "ignore" });
-    child.on("close", (code) => resolve20(code === 0));
+    child.on("close", (code) => resolve21(code === 0));
   });
   if (!binaryExists2)
     return "not-found";
@@ -889,6 +934,20 @@ var init_local_cli_agent_invoker = __esm({
 });
 
 // packages/experience-design-system-generation/dist/src/controller/create-generation-endpoint.js
+function createGenerationEndpoint(options = {}) {
+  const invoker2 = createLocalCliAgentInvoker({
+    onDebugEvent: options.onDebugEvent
+  });
+  return {
+    async run(request2) {
+      validateGenerationRequest(request2);
+      return executeGenerationOrchestrator({ ...request2, invoker: invoker2 });
+    },
+    checkAuth(agent) {
+      return invoker2.checkAuth(agent);
+    }
+  };
+}
 var init_create_generation_endpoint = __esm({
   "packages/experience-design-system-generation/dist/src/controller/create-generation-endpoint.js"() {
     "use strict";
@@ -1273,6 +1332,32 @@ var init_progress = __esm({
 });
 
 // packages/experience-design-system-generation/dist/src/index.js
+var src_exports = {};
+__export(src_exports, {
+  AGENT_BINARIES: () => AGENT_BINARIES,
+  AGENT_NAMES: () => AGENT_NAMES,
+  DEFAULT_AGENT_NAME: () => DEFAULT_AGENT_NAME,
+  agentSupportsBedrock: () => agentSupportsBedrock,
+  buildArgs: () => buildAgentArgs,
+  buildPrompt: () => buildPrompt,
+  checkAgentAuth: () => checkAgentAuth,
+  createGenerationEndpoint: () => createGenerationEndpoint,
+  createLocalCliAgentInvoker: () => createLocalCliAgentInvoker,
+  describeAgentFailure: () => describeAgentFailure,
+  executeGenerationOrchestrator: () => executeGenerationOrchestrator,
+  extractSentinelOutput: () => extractSentinelOutput,
+  formatCustomPromptBanner: () => formatCustomPromptBanner,
+  formatGenerateProgressLine: () => formatGenerateProgressLine,
+  isAgentName: () => isAgentName,
+  parseMapTokenPropToolCallLines: () => parseMapTokenPropToolCallLines,
+  parseSelectToolCallLines: () => parseSelectToolCallLines,
+  parseTokenToolCallLines: () => parseTokenToolCallLines,
+  parseToolCallLines: () => parsePropToolCallLines,
+  resolveAgentModel: () => resolveAgentModel,
+  resolveBinary: () => resolveAgentBinary,
+  resolveSkillPath: () => resolveSkillPath,
+  runAgent: () => runAgent
+});
 var init_src = __esm({
   "packages/experience-design-system-generation/dist/src/index.js"() {
     "use strict";
@@ -10272,6 +10357,41 @@ var init_read3 = __esm({
   }
 });
 
+// packages/experience-design-system-cli-legacy/src/session/core/components/hash-component-shape.ts
+import { createHash as createHash2 } from "node:crypto";
+function hashComponentShape(component) {
+  const payload = {
+    framework: component.framework,
+    name: component.name,
+    source: component.source,
+    props: component.props.map((p) => ({
+      name: p.name,
+      type: p.type
+    })),
+    slots: component.slots.map((s) => ({
+      name: s.name,
+      isDefault: s.isDefault
+    }))
+  };
+  return createHash2("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+var init_hash_component_shape = __esm({
+  "packages/experience-design-system-cli-legacy/src/session/core/components/hash-component-shape.ts"() {
+    "use strict";
+  }
+});
+
+// packages/experience-design-system-cli-legacy/src/session/core/tokens/hash-token-content.ts
+import { createHash as createHash3 } from "node:crypto";
+function hashTokenContent(rawTokenContent) {
+  return createHash3("sha256").update(rawTokenContent.trim()).digest("hex");
+}
+var init_hash_token_content = __esm({
+  "packages/experience-design-system-cli-legacy/src/session/core/tokens/hash-token-content.ts"() {
+    "use strict";
+  }
+});
+
 // packages/experience-design-system-cli-legacy/src/session/repositories/tokens/write.ts
 function deleteRawTokensForSession(db, sessionId2) {
   db.prepare("DELETE FROM raw_token_groups WHERE session_id = ?").run(sessionId2);
@@ -10435,17 +10555,47 @@ var init_replace_raw_prop_token_paths = __esm({
   }
 });
 
+// packages/experience-design-system-cli-legacy/src/session/cache-keys.ts
+var cache_keys_exports = {};
+__export(cache_keys_exports, {
+  hashContent: () => hashContent,
+  hashFile: () => hashFile,
+  hashPromptForSkill: () => hashPromptForSkill
+});
+import { createHash as createHash4 } from "node:crypto";
+import { readFile as readFile7 } from "node:fs/promises";
+import { resolve as resolve8 } from "node:path";
+function hashContent(content) {
+  return createHash4("sha256").update(content).digest("hex");
+}
+async function hashFile(filePath) {
+  const content = await readFile7(filePath, "utf8");
+  return hashContent(content);
+}
+async function hashPromptForSkill(skill, agent, model, skillPathOverride, extraInputs = [], skillContentOverride) {
+  const promptHash = skillContentOverride ? hashContent(skillContentOverride) : skillPathOverride ? await hashFile(resolve8(skillPathOverride)) : await hashFile(resolveSkillPath(skill));
+  const extraSegment = extraInputs.length > 0 ? `|${extraInputs.join("|")}` : "";
+  return hashContent(`${promptHash}|${agent}|${model ?? ""}${extraSegment}`);
+}
+var init_cache_keys = __esm({
+  "packages/experience-design-system-cli-legacy/src/session/cache-keys.ts"() {
+    "use strict";
+    init_src();
+  }
+});
+
 // packages/experience-design-system-cli-legacy/src/session/db.ts
 import { DatabaseSync } from "node:sqlite";
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync5 } from "node:fs";
-import { readFile as readFile7 } from "node:fs/promises";
+import { readFile as readFile8 } from "node:fs/promises";
+import { createHash as createHash5 } from "node:crypto";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname14, resolve as resolve8 } from "node:path";
+import { dirname as dirname14, resolve as resolve9 } from "node:path";
 function getPipelineDbPath() {
   if (process.env.EDS_PIPELINE_DB_PATH) {
-    return resolve8(process.env.EDS_PIPELINE_DB_PATH);
+    return resolve9(process.env.EDS_PIPELINE_DB_PATH);
   }
-  return resolve8(homedir3(), ".contentful", "experience-design-system-cli", "pipeline.db");
+  return resolve9(homedir3(), ".contentful", "experience-design-system-cli", "pipeline.db");
 }
 function openPipelineDb(dbPath) {
   const path = dbPath ?? getPipelineDbPath();
@@ -10579,8 +10729,134 @@ function applyDbMigrations(db) {
   if (!rawSlotColsForRationale.some((c2) => c2.name === "rationale")) {
     db.exec("ALTER TABLE raw_slots ADD COLUMN rationale TEXT");
   }
-  for (const table of REMOVED_CACHE_TABLES) {
-    db.exec(`DROP TABLE IF EXISTS ${table}`);
+  const hasExtractCache = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='extract_cache'`).all();
+  if (hasExtractCache.length === 0) {
+    db.exec(`
+      CREATE TABLE extract_cache (
+        file_path        TEXT NOT NULL,
+        file_hash        TEXT NOT NULL,
+        cli_version      TEXT NOT NULL,
+        created_at       TEXT NOT NULL,
+        updated_at       TEXT NOT NULL,
+        components_json  TEXT NOT NULL,
+        PRIMARY KEY (file_hash, cli_version)
+      );
+      CREATE INDEX idx_extract_cache_file ON extract_cache(file_path);
+    `);
+  }
+  const hasSelectCache = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='select_cache'`).all();
+  if (hasSelectCache.length === 0) {
+    db.exec(`
+      CREATE TABLE select_cache (
+        component_hash TEXT NOT NULL,
+        prompt_hash    TEXT NOT NULL,
+        cli_version    TEXT NOT NULL,
+        decision       TEXT NOT NULL CHECK (decision IN ('accepted','rejected')),
+        reason         TEXT,
+        created_at     TEXT NOT NULL,
+        updated_at     TEXT NOT NULL,
+        PRIMARY KEY (component_hash, prompt_hash, cli_version)
+      );
+    `);
+  }
+  const tables = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='generation_cache'`).all();
+  if (tables.length === 0) {
+    db.exec(`
+      CREATE TABLE generation_cache (
+        input_hash        TEXT NOT NULL,
+        entity_type       TEXT NOT NULL CHECK (entity_type IN ('component', 'token_set', 'token_mapping')),
+        entity_id         TEXT NOT NULL,
+        source_session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+        human_edited      INTEGER NOT NULL DEFAULT 0 CHECK (human_edited IN (0, 1)),
+        created_at        TEXT NOT NULL,
+        updated_at        TEXT NOT NULL,
+        PRIMARY KEY (input_hash, entity_type, entity_id)
+      );
+      CREATE INDEX idx_generation_cache_entity ON generation_cache(entity_type, entity_id);
+      CREATE INDEX idx_generation_cache_session ON generation_cache(source_session_id);
+    `);
+  }
+  const genCacheCols = db.prepare(`PRAGMA table_info(generation_cache)`).all();
+  const hasPromptHash = genCacheCols.some((c2) => c2.name === "prompt_hash");
+  const oldPkCols = genCacheCols.filter((c2) => c2.pk > 0).map((c2) => c2.name);
+  const promptHashInPk = oldPkCols.includes("prompt_hash");
+  if (!hasPromptHash) {
+    db.exec(`ALTER TABLE generation_cache ADD COLUMN prompt_hash TEXT NOT NULL DEFAULT ''`);
+  }
+  if (!promptHashInPk) {
+    db.exec("BEGIN");
+    try {
+      db.exec(`
+        CREATE TABLE generation_cache__new (
+          input_hash        TEXT NOT NULL,
+          entity_type       TEXT NOT NULL CHECK (entity_type IN ('component', 'token_set', 'token_mapping')),
+          entity_id         TEXT NOT NULL,
+          source_session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          human_edited      INTEGER NOT NULL DEFAULT 0 CHECK (human_edited IN (0, 1)),
+          created_at        TEXT NOT NULL,
+          updated_at        TEXT NOT NULL,
+          prompt_hash       TEXT NOT NULL DEFAULT '',
+          PRIMARY KEY (input_hash, prompt_hash, entity_type, entity_id)
+        );
+        INSERT INTO generation_cache__new
+          (input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at, prompt_hash)
+          SELECT input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at, prompt_hash
+          FROM generation_cache;
+        DROP TABLE generation_cache;
+        ALTER TABLE generation_cache__new RENAME TO generation_cache;
+        CREATE INDEX IF NOT EXISTS idx_generation_cache_entity  ON generation_cache(entity_type, entity_id);
+        CREATE INDEX IF NOT EXISTS idx_generation_cache_session ON generation_cache(source_session_id);
+      `);
+      db.exec("COMMIT");
+    } catch (e) {
+      db.exec("ROLLBACK");
+      throw e;
+    }
+  }
+  const genCacheTableSql = db.prepare(`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'generation_cache'`).get();
+  const hasTokenMappingEntityType = genCacheTableSql?.sql.includes("'token_mapping'") ?? true;
+  if (!hasTokenMappingEntityType) {
+    db.exec("BEGIN");
+    try {
+      db.exec(`
+        CREATE TABLE generation_cache__new2 (
+          input_hash        TEXT NOT NULL,
+          entity_type       TEXT NOT NULL CHECK (entity_type IN ('component', 'token_set', 'token_mapping')),
+          entity_id         TEXT NOT NULL,
+          source_session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+          human_edited      INTEGER NOT NULL DEFAULT 0 CHECK (human_edited IN (0, 1)),
+          created_at        TEXT NOT NULL,
+          updated_at        TEXT NOT NULL,
+          prompt_hash       TEXT NOT NULL DEFAULT '',
+          PRIMARY KEY (input_hash, prompt_hash, entity_type, entity_id)
+        );
+        INSERT INTO generation_cache__new2
+          (input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at, prompt_hash)
+          SELECT input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at, prompt_hash
+          FROM generation_cache;
+        DROP TABLE generation_cache;
+        ALTER TABLE generation_cache__new2 RENAME TO generation_cache;
+        CREATE INDEX IF NOT EXISTS idx_generation_cache_entity  ON generation_cache(entity_type, entity_id);
+        CREATE INDEX IF NOT EXISTS idx_generation_cache_session ON generation_cache(source_session_id);
+      `);
+      db.exec("COMMIT");
+    } catch (e) {
+      db.exec("ROLLBACK");
+      throw e;
+    }
+  }
+  const hasCompositionCache = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='composition_cache'`).all();
+  if (hasCompositionCache.length === 0) {
+    db.exec(`
+      CREATE TABLE composition_cache (
+        input_hash   TEXT NOT NULL,
+        cli_version  TEXT NOT NULL,
+        agent_output TEXT NOT NULL,
+        created_at   TEXT NOT NULL,
+        updated_at   TEXT NOT NULL,
+        PRIMARY KEY (input_hash, cli_version)
+      );
+    `);
   }
 }
 function loadComponentReviewMetadata(db, sessionId2, componentName) {
@@ -11120,16 +11396,16 @@ function extractRelativeImportPaths(sourceText) {
   return [...specifiers];
 }
 async function resolveRelativeImport(specifier, fromDir) {
-  const basePath = resolve8(fromDir, specifier);
+  const basePath = resolve9(fromDir, specifier);
   const candidates = [
     basePath,
     ...rewrittenSourcePaths(basePath),
     ...SIBLING_FILE_EXTENSIONS.map((ext) => `${basePath}${ext}`),
-    ...SIBLING_FILE_EXTENSIONS.map((ext) => resolve8(basePath, `index${ext}`))
+    ...SIBLING_FILE_EXTENSIONS.map((ext) => resolve9(basePath, `index${ext}`))
   ];
   for (const candidate of candidates) {
     try {
-      await readFile7(candidate, "utf8");
+      await readFile8(candidate, "utf8");
       return candidate;
     } catch {
     }
@@ -11145,7 +11421,7 @@ async function resolveImportSpecifiers(sourceText, fromDir) {
   return resolvedPaths;
 }
 async function loadSiblingFiles(sourceText, sourcePath, propNames, candidateTypeNames = []) {
-  const visited = /* @__PURE__ */ new Set([resolve8(sourcePath)]);
+  const visited = /* @__PURE__ */ new Set([resolve9(sourcePath)]);
   const discovered = [];
   let frontier = [{ text: sourceText, dir: dirname14(sourcePath) }];
   for (let hop = 0; hop < MAX_SIBLING_DEPTH && discovered.length < MAX_SIBLING_CANDIDATES_EXPLORED; hop++) {
@@ -11159,7 +11435,7 @@ async function loadSiblingFiles(sourceText, sourcePath, propNames, candidateType
         if (discovered.length >= MAX_SIBLING_CANDIDATES_EXPLORED) break;
         let content;
         try {
-          content = await readFile7(resolvedPath, "utf8");
+          content = await readFile8(resolvedPath, "utf8");
         } catch {
           continue;
         }
@@ -11196,7 +11472,7 @@ async function loadComponentSourceRef(name, sourcePath, propNames = [], propType
   let truncatedSiblingCount = 0;
   const usesNotShown = /* @__PURE__ */ new Set();
   try {
-    const rawText = await readFile7(sourcePath, "utf8");
+    const rawText = await readFile8(sourcePath, "utf8");
     let siblingUsesNotShown;
     let declaredTypeNames;
     ({
@@ -11632,6 +11908,108 @@ function backfillUnclassifiedProps(db, sessionId2) {
   ).run(sessionId2, sessionId2);
   return Number(withCategory.changes) + Number(withoutCategory.changes);
 }
+function computeMapTokensInputHash(db, sessionId2, componentSourceRefs = []) {
+  const props = db.prepare(
+    `SELECT rc.name AS component_name, rp.name AS prop_name, rp.cdf_token_kind, rp.default_value
+       FROM raw_props rp
+       JOIN raw_components rc ON rc.session_id = rp.session_id AND rc.component_id = rp.component_id
+       WHERE rp.session_id = ? AND rp.cdf_type = 'token' AND rp.cdf_category = 'design'
+       ORDER BY rc.name, rp.name`
+  ).all(sessionId2);
+  const tokens = db.prepare(`SELECT path, type FROM raw_tokens WHERE session_id = ? ORDER BY path`).all(sessionId2);
+  const defaultMappings = db.prepare("SELECT raw_name, path, source FROM raw_token_name_paths WHERE session_id = ? ORDER BY raw_name").all(sessionId2);
+  const payload = {
+    props: props.map((p) => ({
+      component: p.component_name,
+      prop: p.prop_name,
+      tokenKind: p.cdf_token_kind,
+      rawDefault: p.default_value
+    })),
+    tokens,
+    defaultMappings,
+    // The agent's evidence, not just its inputs: a comment or allowlist edit
+    // in a source file (or a sibling it reads) changes the correct answer
+    // without touching props or tokens, so it must invalidate the cache too.
+    sourceRefs: [...componentSourceRefs].sort((a, b) => a.component.localeCompare(b.component)).map((ref) => ({
+      component: ref.component,
+      content: ref.content,
+      siblingFiles: (ref.siblingFiles ?? []).map((s) => ({ path: s.path, content: s.content })).sort((a, b) => a.path.localeCompare(b.path)),
+      usesNotShown: [...ref.usesNotShown ?? []].sort()
+    }))
+  };
+  return createHash5("sha256").update(JSON.stringify(payload)).digest("hex");
+}
+function lookupCache(db, inputHash, entityType, entityId, promptHash = "") {
+  const row = db.prepare(
+    `SELECT input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at, prompt_hash
+       FROM generation_cache
+       WHERE input_hash = ? AND entity_type = ? AND entity_id = ? AND prompt_hash = ?`
+  ).get(inputHash, entityType, entityId, promptHash);
+  if (!row) return null;
+  return {
+    inputHash: row.input_hash,
+    entityType: row.entity_type,
+    entityId: row.entity_id,
+    sourceSessionId: row.source_session_id,
+    humanEdited: row.human_edited === 1,
+    promptHash: row.prompt_hash,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function lookupCacheByEntity(db, entityType, entityId) {
+  const row = db.prepare(
+    `SELECT input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at, prompt_hash
+       FROM generation_cache
+       WHERE entity_type = ? AND entity_id = ?
+       ORDER BY updated_at DESC LIMIT 1`
+  ).get(entityType, entityId);
+  if (!row) return null;
+  return {
+    inputHash: row.input_hash,
+    entityType: row.entity_type,
+    entityId: row.entity_id,
+    sourceSessionId: row.source_session_id,
+    humanEdited: row.human_edited === 1,
+    promptHash: row.prompt_hash,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+function storeCache(db, inputHash, entityType, entityId, sourceSessionId, humanEdited, promptHash = "") {
+  storeCaches(db, [{ inputHash, entityType, entityId, sourceSessionId, humanEdited, promptHash }]);
+}
+function storeCaches(db, entries) {
+  if (entries.length === 0) return;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const insert = db.prepare(
+    `INSERT INTO generation_cache (input_hash, entity_type, entity_id, source_session_id, human_edited, created_at, updated_at, prompt_hash)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(input_hash, prompt_hash, entity_type, entity_id) DO UPDATE SET
+       source_session_id = excluded.source_session_id,
+       human_edited = CASE WHEN generation_cache.human_edited = 1 THEN 1 ELSE excluded.human_edited END,
+       updated_at = excluded.updated_at`
+  );
+  db.exec("BEGIN");
+  try {
+    for (const entry of entries) {
+      insert.run(
+        entry.inputHash,
+        entry.entityType,
+        entry.entityId,
+        entry.sourceSessionId,
+        entry.humanEdited ? 1 : 0,
+        now,
+        now,
+        entry.promptHash ?? ""
+      );
+    }
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+}
 function storeScannedFiles(db, sessionId2, filePaths) {
   db.exec("BEGIN");
   try {
@@ -11714,7 +12092,105 @@ function filterUnknownSlotAllowedComponents(db, sessionId2, allowedComponentName
   }
   return unknown;
 }
-function copyTokensBetweenSessions(db, sourceSessionId, targetSessionId) {
+function copyComponentFromCache(db, sourceSessionId, targetSessionId, componentId, manageTransaction = true, options = {}) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (manageTransaction) db.exec("BEGIN");
+  try {
+    const srcComp = db.prepare(
+      `SELECT description, status, component_description_rationale, props_rationale, slots_rationale
+         FROM raw_components WHERE session_id = ? AND component_id = ?`
+    ).get(sourceSessionId, componentId);
+    if (srcComp) {
+      db.prepare(
+        `UPDATE raw_components
+         SET description = ?, status = ?, component_description_rationale = ?, props_rationale = ?, slots_rationale = ?, extracted_at = ?
+         WHERE session_id = ? AND component_id = ?`
+      ).run(
+        srcComp.description,
+        srcComp.status,
+        srcComp.component_description_rationale,
+        srcComp.props_rationale,
+        srcComp.slots_rationale,
+        now,
+        targetSessionId,
+        componentId
+      );
+    }
+    const srcProps = db.prepare(
+      `SELECT name, cdf_type, cdf_category, cdf_token_kind, required, description, default_value, rationale
+         FROM raw_props WHERE session_id = ? AND component_id = ?`
+    ).all(sourceSessionId, componentId);
+    for (const p of srcProps) {
+      db.prepare(
+        `UPDATE raw_props SET cdf_type = ?, cdf_category = ?, cdf_token_kind = ?, required = ?, description = ?, default_value = ?, rationale = ?
+         WHERE session_id = ? AND component_id = ? AND name = ?`
+      ).run(
+        p.cdf_type,
+        p.cdf_category,
+        p.cdf_token_kind,
+        p.required,
+        p.description,
+        p.default_value,
+        p.rationale,
+        targetSessionId,
+        componentId,
+        p.name
+      );
+    }
+    db.prepare(`DELETE FROM raw_prop_allowed_values WHERE session_id = ? AND component_id = ?`).run(
+      targetSessionId,
+      componentId
+    );
+    const srcAV = db.prepare(
+      `SELECT prop_name, position, value FROM raw_prop_allowed_values WHERE session_id = ? AND component_id = ?`
+    ).all(sourceSessionId, componentId);
+    const insertAV = db.prepare(
+      `INSERT INTO raw_prop_allowed_values (session_id, component_id, prop_name, position, value) VALUES (?, ?, ?, ?, ?)`
+    );
+    for (const av of srcAV) {
+      insertAV.run(targetSessionId, componentId, av.prop_name, av.position, av.value);
+    }
+    const srcSlots = db.prepare(`SELECT name, required, description, rationale FROM raw_slots WHERE session_id = ? AND component_id = ?`).all(sourceSessionId, componentId);
+    for (const s of srcSlots) {
+      db.prepare(
+        `UPDATE raw_slots SET required = ?, description = ?, rationale = ? WHERE session_id = ? AND component_id = ? AND name = ?`
+      ).run(s.required, s.description, s.rationale, targetSessionId, componentId, s.name);
+    }
+    db.prepare(`DELETE FROM raw_slot_allowed_components WHERE session_id = ? AND component_id = ?`).run(
+      targetSessionId,
+      componentId
+    );
+    const srcSAC = db.prepare(
+      `SELECT slot_name, position, allowed_component FROM raw_slot_allowed_components WHERE session_id = ? AND component_id = ?`
+    ).all(sourceSessionId, componentId);
+    const insertSAC = db.prepare(
+      `INSERT INTO raw_slot_allowed_components (session_id, component_id, slot_name, allowed_component, position) VALUES (?, ?, ?, ?, ?)`
+    );
+    const allowedSAC = options.allowedComponentNames ? srcSAC.filter((sac) => options.allowedComponentNames.has(sac.allowed_component)) : srcSAC;
+    for (const sac of allowedSAC) {
+      insertSAC.run(targetSessionId, componentId, sac.slot_name, sac.allowed_component, sac.position);
+    }
+    db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, targetSessionId);
+    if (manageTransaction) db.exec("COMMIT");
+  } catch (e) {
+    if (manageTransaction) db.exec("ROLLBACK");
+    throw e;
+  }
+}
+function copyComponentsFromCache(db, entries, options = {}) {
+  if (entries.length === 0) return;
+  db.exec("BEGIN");
+  try {
+    for (const entry of entries) {
+      copyComponentFromCache(db, entry.sourceSessionId, entry.targetSessionId, entry.componentId, false, options);
+    }
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+}
+function copyTokensFromCache(db, sourceSessionId, targetSessionId) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.exec("BEGIN");
   try {
@@ -11735,7 +12211,139 @@ function copyTokensBetweenSessions(db, sourceSessionId, targetSessionId) {
     throw e;
   }
 }
-var SCHEMA, REMOVED_CACHE_TABLES, MAX_COMPONENT_SOURCE_CHARS, MAX_SIBLING_FILES, MAX_SIBLING_SNIPPET_CHARS, MAX_TYPE_DECLARING_SIBLING_CHARS, MAX_ENLARGED_SIBLINGS, MAX_SIBLING_DEPTH, MAX_SIBLING_CANDIDATES_EXPLORED, RELATIVE_IMPORT_PATTERN, SIBLING_FILE_EXTENSIONS, TS_ESM_EXTENSION_REWRITES, IDENTIFIER_PATTERN;
+function copyMapTokensFromCache(db, sourceSessionId, targetSessionId) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let copiedCount = 0;
+  db.exec("BEGIN");
+  try {
+    const sourceRows = db.prepare(
+      `SELECT rc.name AS component_name, rptp.prop_name, rptp.source, rptp.position, rptp.path
+         FROM raw_prop_token_paths rptp
+         JOIN raw_components rc ON rc.session_id = rptp.session_id AND rc.component_id = rptp.component_id
+         WHERE rptp.session_id = ?
+         ORDER BY rc.name, rptp.prop_name, rptp.position`
+    ).all(sourceSessionId);
+    const targetComponents = db.prepare(`SELECT component_id, name FROM raw_components WHERE session_id = ?`).all(targetSessionId);
+    const targetIdByName = new Map(targetComponents.map((c2) => [c2.name, c2.component_id]));
+    const targetProps = new Set(
+      db.prepare(`SELECT component_id, name FROM raw_props WHERE session_id = ?`).all(targetSessionId).map((p) => `${p.component_id}::${p.name}`)
+    );
+    const insertPath = db.prepare(
+      `INSERT INTO raw_prop_token_paths (session_id, component_id, prop_name, source, position, path)
+       VALUES (?, ?, ?, ?, ?, ?)`
+    );
+    const clearedProps = /* @__PURE__ */ new Set();
+    const copiedProps = /* @__PURE__ */ new Set();
+    for (const row of sourceRows) {
+      const targetComponentId = targetIdByName.get(row.component_name);
+      if (!targetComponentId) continue;
+      if (!targetProps.has(`${targetComponentId}::${row.prop_name}`)) continue;
+      const propKey = `${targetComponentId}::${row.prop_name}`;
+      if (!clearedProps.has(propKey)) {
+        clearedProps.add(propKey);
+        db.prepare(`DELETE FROM raw_prop_token_paths WHERE session_id = ? AND component_id = ? AND prop_name = ?`).run(
+          targetSessionId,
+          targetComponentId,
+          row.prop_name
+        );
+      }
+      insertPath.run(targetSessionId, targetComponentId, row.prop_name, row.source, row.position, row.path);
+      copiedProps.add(propKey);
+    }
+    copiedCount = copiedProps.size;
+    db.prepare("UPDATE sessions SET updated_at = ? WHERE id = ?").run(now, targetSessionId);
+    db.exec("COMMIT");
+  } catch (e) {
+    db.exec("ROLLBACK");
+    throw e;
+  }
+  return copiedCount;
+}
+async function getCliCacheVersion() {
+  if (_cliCacheVersionCache) return _cliCacheVersionCache;
+  try {
+    const { hashContent: hashContent2 } = await Promise.resolve().then(() => (init_cache_keys(), cache_keys_exports));
+    const { resolveSkillPath: resolveSkillPath2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const skills = ["components", "tokens", "select"];
+    const parts = [];
+    for (const s of skills) {
+      try {
+        const p = resolveSkillPath2(s);
+        parts.push(readFileSync5(p, "utf8"));
+      } catch {
+        parts.push(`<missing:${s}>`);
+      }
+    }
+    _cliCacheVersionCache = hashContent2(parts.join("\n---\n"));
+    return _cliCacheVersionCache;
+  } catch {
+    _cliCacheVersionCache = "fallback";
+    return _cliCacheVersionCache;
+  }
+}
+function storeExtractCache(db, filePath, fileHash, cliVersion2, components) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const componentsJson = JSON.stringify(components);
+  db.prepare(
+    `INSERT INTO extract_cache (file_path, file_hash, cli_version, created_at, updated_at, components_json)
+     VALUES (?, ?, ?, ?, ?, ?)
+     ON CONFLICT(file_hash, cli_version) DO UPDATE SET
+       file_path = excluded.file_path,
+       updated_at = excluded.updated_at,
+       components_json = excluded.components_json`
+  ).run(filePath, fileHash, cliVersion2, now, now, componentsJson);
+}
+function lookupExtractCache(db, fileHash, cliVersion2) {
+  const row = db.prepare(
+    `SELECT file_path, file_hash, cli_version, created_at, updated_at, components_json
+       FROM extract_cache
+       WHERE file_hash = ? AND cli_version = ?`
+  ).get(fileHash, cliVersion2);
+  if (!row) return null;
+  let components = [];
+  try {
+    components = JSON.parse(row.components_json);
+  } catch {
+    return null;
+  }
+  return {
+    filePath: row.file_path,
+    fileHash: row.file_hash,
+    cliVersion: row.cli_version,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    components
+  };
+}
+function storeSelectCache(db, componentHash, promptHash, cliVersion2, decision, reason) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(
+    `INSERT INTO select_cache (component_hash, prompt_hash, cli_version, decision, reason, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(component_hash, prompt_hash, cli_version) DO UPDATE SET
+       decision = excluded.decision,
+       reason = excluded.reason,
+       updated_at = excluded.updated_at`
+  ).run(componentHash, promptHash, cliVersion2, decision, reason, now, now);
+}
+function lookupSelectCache(db, componentHash, promptHash, cliVersion2) {
+  const row = db.prepare(
+    `SELECT component_hash, prompt_hash, cli_version, decision, reason, created_at, updated_at
+       FROM select_cache
+       WHERE component_hash = ? AND prompt_hash = ? AND cli_version = ?`
+  ).get(componentHash, promptHash, cliVersion2);
+  if (!row) return null;
+  return {
+    componentHash: row.component_hash,
+    promptHash: row.prompt_hash,
+    cliVersion: row.cli_version,
+    decision: row.decision,
+    reason: row.reason,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at
+  };
+}
+var SCHEMA, MAX_COMPONENT_SOURCE_CHARS, MAX_SIBLING_FILES, MAX_SIBLING_SNIPPET_CHARS, MAX_TYPE_DECLARING_SIBLING_CHARS, MAX_ENLARGED_SIBLINGS, MAX_SIBLING_DEPTH, MAX_SIBLING_CANDIDATES_EXPLORED, RELATIVE_IMPORT_PATTERN, SIBLING_FILE_EXTENSIONS, TS_ESM_EXTENSION_REWRITES, IDENTIFIER_PATTERN, _cliCacheVersionCache;
 var init_db = __esm({
   "packages/experience-design-system-cli-legacy/src/session/db.ts"() {
     "use strict";
@@ -11749,6 +12357,8 @@ var init_db = __esm({
     init_write2();
     init_session_resolver();
     init_read3();
+    init_hash_component_shape();
+    init_hash_token_content();
     init_read3();
     init_store_dtcg_tokens();
     init_apply_tool_calls();
@@ -11872,6 +12482,17 @@ CREATE TABLE IF NOT EXISTS raw_tokens (
   FOREIGN KEY (session_id) REFERENCES sessions(id) ON DELETE CASCADE
 );
 
+CREATE TABLE IF NOT EXISTS generation_cache (
+  input_hash        TEXT NOT NULL,
+  entity_type       TEXT NOT NULL CHECK (entity_type IN ('component', 'token_set', 'token_mapping')),
+  entity_id         TEXT NOT NULL,
+  source_session_id TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
+  human_edited      INTEGER NOT NULL DEFAULT 0 CHECK (human_edited IN (0, 1)),
+  created_at        TEXT NOT NULL,
+  updated_at        TEXT NOT NULL,
+  PRIMARY KEY (input_hash, entity_type, entity_id)
+);
+
 CREATE TABLE IF NOT EXISTS scanned_files (
   session_id  TEXT NOT NULL REFERENCES sessions(id) ON DELETE CASCADE,
   path        TEXT NOT NULL,
@@ -11917,9 +12538,10 @@ CREATE INDEX IF NOT EXISTS idx_raw_props_session        ON raw_props(session_id,
 CREATE INDEX IF NOT EXISTS idx_raw_slots_session        ON raw_slots(session_id, component_id);
 CREATE INDEX IF NOT EXISTS idx_raw_tokens_session       ON raw_tokens(session_id);
 CREATE INDEX IF NOT EXISTS idx_raw_token_groups_session ON raw_token_groups(session_id);
+CREATE INDEX IF NOT EXISTS idx_generation_cache_entity  ON generation_cache(entity_type, entity_id);
+CREATE INDEX IF NOT EXISTS idx_generation_cache_session ON generation_cache(source_session_id);
 CREATE INDEX IF NOT EXISTS idx_scanned_files_session    ON scanned_files(session_id);
 `;
-    REMOVED_CACHE_TABLES = ["generation_cache", "extract_cache", "composition_cache", "select_cache"];
     MAX_COMPONENT_SOURCE_CHARS = 8e3;
     MAX_SIBLING_FILES = 5;
     MAX_SIBLING_SNIPPET_CHARS = 1200;
@@ -11936,15 +12558,16 @@ CREATE INDEX IF NOT EXISTS idx_scanned_files_session    ON scanned_files(session
       [".cjs", [".cts", ".cjs"]]
     ];
     IDENTIFIER_PATTERN = /[A-Za-z_$][A-Za-z0-9_$]*/g;
+    _cliCacheVersionCache = null;
   }
 });
 
 // packages/experience-design-system-cli-legacy/src/helpers/read-existing-contentful-entities-from-session.ts
-import { readFile as readFile8 } from "node:fs/promises";
+import { readFile as readFile9 } from "node:fs/promises";
 async function readExistingContentfulEntitiesFromSession(path) {
   if (!path) return void 0;
   try {
-    const raw = await readFile8(path, "utf8");
+    const raw = await readFile9(path, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.components) || !Array.isArray(parsed.tokens)) return void 0;
     return parsed;
@@ -12068,21 +12691,21 @@ var init_resolve_session_id = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/analyze/select/persistence.ts
-import { access, appendFile, mkdir as mkdir2, readFile as readFile9, writeFile as writeFile2 } from "node:fs/promises";
+import { access, appendFile, mkdir as mkdir2, readFile as readFile10, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { resolve as resolve9 } from "node:path";
+import { resolve as resolve10 } from "node:path";
 function getRefineArtifactsRoot() {
   if (process.env.EDS_REVIEW_ARTIFACTS_DIR) {
-    return resolve9(process.env.EDS_REVIEW_ARTIFACTS_DIR);
+    return resolve10(process.env.EDS_REVIEW_ARTIFACTS_DIR);
   }
-  return resolve9(homedir4(), ".contentful", "experience-design-system-cli", "reviews");
+  return resolve10(homedir4(), ".contentful", "experience-design-system-cli", "reviews");
 }
 async function getRefineSessionPaths(sessionId2, artifactsRoot) {
-  const sessionDir = resolve9(artifactsRoot, sessionId2);
+  const sessionDir = resolve10(artifactsRoot, sessionId2);
   return {
     sessionDir,
-    eventsPath: resolve9(sessionDir, "events.jsonl"),
-    statePath: resolve9(sessionDir, "current-review-state.json")
+    eventsPath: resolve10(sessionDir, "events.jsonl"),
+    statePath: resolve10(sessionDir, "current-review-state.json")
   };
 }
 async function saveReviewState(statePath, session) {
@@ -12093,7 +12716,7 @@ async function ensureRefineSession(sessionId2, artifactsRoot, initialSnapshot) {
   await mkdir2(paths.sessionDir, { recursive: true });
   try {
     await access(paths.statePath);
-    const savedState = await readFile9(paths.statePath, "utf8");
+    const savedState = await readFile10(paths.statePath, "utf8");
     return JSON.parse(savedState);
   } catch {
     await writeFile2(paths.statePath, JSON.stringify(initialSnapshot, null, 2), "utf8");
@@ -12578,8 +13201,8 @@ var init_path_exists = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/lib/prompt-overrides.ts
-import { readFile as readFile10 } from "node:fs/promises";
-import { resolve as resolve10 } from "node:path";
+import { readFile as readFile11 } from "node:fs/promises";
+import { resolve as resolve11 } from "node:path";
 function looksLikePath(value) {
   if (value.includes("/") || value.includes("\\")) return true;
   if (value.startsWith("~")) return true;
@@ -12611,9 +13234,9 @@ function parsePromptOverrides(inputs) {
 }
 async function resolvePromptOverride(override) {
   if (override.kind === "text") return override.value;
-  const abs = resolve10(override.value);
+  const abs = resolve11(override.value);
   try {
-    return await readFile10(abs, "utf8");
+    return await readFile11(abs, "utf8");
   } catch {
     throw new Error(`--prompt: could not read prompt file: ${abs}`);
   }
@@ -12628,21 +13251,21 @@ var init_prompt_overrides = __esm({
 
 // packages/experience-design-system-cli-legacy/src/generate/command.ts
 import { createElement } from "react";
-import { readFile as readFile11, readdir, stat } from "node:fs/promises";
-import { join as join14, resolve as resolve11 } from "node:path";
+import { readFile as readFile12, readdir, stat } from "node:fs/promises";
+import { join as join14, resolve as resolve12 } from "node:path";
 async function assertFileExists(flag, p) {
   if (!await pathExists(p)) die(`Error: file not found: ${p} (from ${flag})`);
 }
 async function readFileInline(path) {
   if (!path) return void 0;
-  const resolved = resolve11(path);
+  const resolved = resolve12(path);
   let s;
   try {
     s = await stat(resolved);
   } catch {
     return void 0;
   }
-  if (!s.isDirectory()) return readFile11(resolved, "utf8");
+  if (!s.isDirectory()) return readFile12(resolved, "utf8");
   const files = [];
   async function walk(dir) {
     let entries;
@@ -12668,7 +13291,7 @@ async function readFileInline(path) {
   }
   await walk(resolved);
   if (files.length === 0) return void 0;
-  const parts = await Promise.all(files.map((f) => readFile11(f, "utf8").catch(() => "")));
+  const parts = await Promise.all(files.map((f) => readFile12(f, "utf8").catch(() => "")));
   return parts.filter(Boolean).join("\n\n");
 }
 function printFallbackInstructions(options) {
@@ -12690,6 +13313,23 @@ function printFallbackInstructions(options) {
   lines.push(`  Re-run the generate command with the agent available, or use --dry-run to inspect the prompt.`);
   process.stderr.write(lines.join("\n") + "\n");
 }
+function createCachedComponentResult(componentName, warnings = []) {
+  return {
+    componentName,
+    classified: 0,
+    excluded: 0,
+    slots: 0,
+    warnings,
+    failed: false,
+    cached: true,
+    renamedSlotsCount: 0
+  };
+}
+function writeCachedComponentStatus(position, componentName, pinned) {
+  const status = pinned ? c.cyan("pinned (human-edited)") : c.green("cached");
+  process.stderr.write(`  ${position}  ${c.bold(componentName)}  ${status}
+`);
+}
 async function showGenerateView(result) {
   if (process.stdout.isTTY) {
     const { waitUntilExit } = renderWithGoodbye(
@@ -12710,6 +13350,29 @@ session=${result.sessionId}
   );
   await exitWithAnalytics(0);
 }
+function normalizeComponentForCache(component) {
+  const slots = component.slots.map((slot, index, allSlots) => ({
+    ...slot,
+    name: slot.name.trim() || (allSlots.length === 1 ? "children" : `slot_${index}`)
+  }));
+  return { ...component, slots };
+}
+function lookupComponentCache(db, component, promptHash) {
+  const normalized = normalizeComponentForCache(component);
+  const inputHash = hashComponentShape(normalized);
+  const cached = lookupCache(db, inputHash, "component", component.component_id, promptHash);
+  if (cached) return cached;
+  const legacyInputHash = hashComponentShape(component);
+  return legacyInputHash === inputHash ? null : lookupCache(db, legacyInputHash, "component", component.component_id, promptHash);
+}
+function resolveComponentCache(db, component, promptHash, allowedComponentNames2) {
+  const cached = lookupComponentCache(db, component, promptHash);
+  if (cached && findUnknownSlotAllowedComponents(db, cached.sourceSessionId, allowedComponentNames2, component.component_id).length === 0) {
+    return { entry: cached, humanEdited: cached.humanEdited };
+  }
+  const pinned = lookupCacheByEntity(db, "component", component.component_id);
+  return pinned?.humanEdited && findUnknownSlotAllowedComponents(db, pinned.sourceSessionId, allowedComponentNames2, component.component_id).length === 0 ? { entry: pinned, humanEdited: true } : null;
+}
 async function runOneComponent(options, component, index, total) {
   const {
     agent,
@@ -12719,10 +13382,13 @@ async function runOneComponent(options, component, index, total) {
     tokensInline,
     tokenMapInline,
     verbose,
+    noCache,
     skillPathOverride,
     skillContentOverride,
+    promptHash,
     existingContentfulEntities,
     existingTokensInline,
+    precomputedCachedNames,
     allowedComponentNames: allowedComponentNames2
   } = options;
   const pos = c.dim(`[${index + 1}/${total}]`);
@@ -12747,6 +13413,40 @@ async function runOneComponent(options, component, index, total) {
       allowedComponents: slot.allowedComponents.filter((name) => allowedComponentNames2.has(name))
     };
   });
+  const cacheComponent = normalizeComponentForCache(component);
+  if (!noCache && precomputedCachedNames.has(component.name)) {
+    writeCachedComponentStatus(pos, component.name, false);
+    return createCachedComponentResult(component.name);
+  }
+  if (!noCache) {
+    const inputHash = hashComponentShape(cacheComponent);
+    const resolution = resolveComponentCache(db, component, promptHash, allowedComponentNames2);
+    if (resolution && !resolution.humanEdited) {
+      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId2, component.component_id, true, {
+        allowedComponentNames: allowedComponentNames2
+      });
+      storeCache(
+        db,
+        inputHash,
+        "component",
+        component.component_id,
+        resolution.entry.sourceSessionId,
+        resolution.entry.humanEdited,
+        promptHash
+      );
+      writeCachedComponentStatus(pos, component.name, false);
+      return createCachedComponentResult(component.name);
+    }
+    if (resolution?.humanEdited) {
+      copyComponentFromCache(db, resolution.entry.sourceSessionId, sessionId2, component.component_id, true, {
+        allowedComponentNames: allowedComponentNames2
+      });
+      writeCachedComponentStatus(pos, component.name, true);
+      return createCachedComponentResult(`${component.name}`, [
+        `${component.name}: source changed but human edits preserved`
+      ]);
+    }
+  }
   const componentBuckets = bucketComponentProps(component);
   getDebugLogger().event("analyze", "prop-buckets.generate", { ...componentBuckets });
   const rawComponentsInline = JSON.stringify(
@@ -12821,6 +13521,10 @@ ${outputBuf}`);
     const applied = applyToolCalls(db, sessionId2, component.component_id, component.name, calls, warnings, {
       allowedComponentNames: allowedComponentNames2
     });
+    if (!noCache) {
+      const inputHash = hashComponentShape(cacheComponent);
+      storeCache(db, inputHash, "component", component.component_id, sessionId2, false, promptHash);
+    }
     return {
       componentName: component.name,
       classified: applied.classified,
@@ -12872,7 +13576,7 @@ async function loadAcceptedNames(sessionId2) {
   try {
     const artifactsRoot = getRefineArtifactsRoot();
     const paths = await getRefineSessionPaths(sessionId2, artifactsRoot);
-    const raw = await readFile11(paths.statePath, "utf8");
+    const raw = await readFile12(paths.statePath, "utf8");
     const snapshot = JSON.parse(raw);
     const accepted = snapshot.components.filter((c2) => c2.status === "accepted").map((c2) => c2.name);
     if (accepted.length === 0) return null;
@@ -12881,6 +13585,15 @@ async function loadAcceptedNames(sessionId2) {
     return null;
   }
 }
+function parsePrecomputedCachedNames(value) {
+  if (!value) return /* @__PURE__ */ new Set();
+  try {
+    const parsed = JSON.parse(value);
+    return new Set(Array.isArray(parsed) ? parsed.filter((name) => typeof name === "string") : []);
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
 async function runGenerateSkill(skill, opts, verbose = false) {
   const savedCreds = await readExperiencesCredentials();
   const agentName = opts.agent ?? savedCreds.agent;
@@ -12909,8 +13622,8 @@ async function runGenerateSkill(skill, opts, verbose = false) {
   }
   const generatePromptPath = generatePrompt === void 0 ? configuredGeneratePromptPath : void 0;
   if (generatePromptPath) {
-    if (!await pathExists(resolve11(generatePromptPath))) {
-      die(`Error: custom prompt path not found: ${resolve11(generatePromptPath)}`);
+    if (!await pathExists(resolve12(generatePromptPath))) {
+      die(`Error: custom prompt path not found: ${resolve12(generatePromptPath)}`);
     }
     if (!generatePromptPath.toLowerCase().endsWith(".md")) {
       process.stderr.write(
@@ -12918,7 +13631,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
 `
       );
     }
-    process.stderr.write(formatCustomPromptBanner("components", resolve11(generatePromptPath)));
+    process.stderr.write(formatCustomPromptBanner("components", resolve12(generatePromptPath)));
   }
   if (skill === "tokens" && !opts.rawTokens) {
     die("Error: --raw-tokens is required when using generate tokens");
@@ -12934,7 +13647,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
   let existingContentfulEntities;
   let existingTokensInline;
   if (opts.existingEntitiesPath) {
-    existingContentfulEntities = await readExistingContentfulEntitiesFromSession(resolve11(opts.existingEntitiesPath));
+    existingContentfulEntities = await readExistingContentfulEntitiesFromSession(resolve12(opts.existingEntitiesPath));
     if (existingContentfulEntities) {
       existingTokensInline = JSON.stringify(summarizeForMapTokens(existingContentfulEntities));
     } else {
@@ -13035,7 +13748,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
       rawComponentsInline: sampleInline ?? rawTokensInline,
       propBucketsInline: sampleBuckets ? JSON.stringify(sampleBuckets) : void 0,
       rawTokensInline: skill === "tokens" ? rawTokensInline : void 0,
-      rawTokensFilename: opts.rawTokens ? resolve11(opts.rawTokens).split("/").pop() : void 0,
+      rawTokensFilename: opts.rawTokens ? resolve12(opts.rawTokens).split("/").pop() : void 0,
       tokensInline,
       tokenMapInline,
       outDir: process.cwd(),
@@ -13061,7 +13774,64 @@ async function runGenerateSkill(skill, opts, verbose = false) {
   if (skill === "components" && allComponents && sessionId2) {
     const db = openPipelineDb();
     let componentResults;
+    const precomputedCachedNames = parsePrecomputedCachedNames(opts.cachedComponents);
     try {
+      const existingContentfulEntitiesHashInputs = [];
+      if (existingTokensInline) existingContentfulEntitiesHashInputs.push(hashContent(existingTokensInline));
+      const promptHash = await hashPromptForSkill(
+        "components",
+        agent,
+        model,
+        generatePromptPath,
+        existingContentfulEntitiesHashInputs,
+        generatePrompt
+      );
+      if (opts.cacheStatus) {
+        const cacheEnabled = opts.cache !== false && process.env.EDS_NO_CACHE !== "1";
+        const cachedComponents = cacheEnabled ? allComponents.flatMap((component) => {
+          const resolution = resolveComponentCache(db, component, promptHash, allowedComponentNames2);
+          return resolution ? [{ component, resolution }] : [];
+        }) : [];
+        if (cacheEnabled && opts.restoreCache) {
+          const restorations = [];
+          const rekeyed = [];
+          const componentStatus = db.prepare(
+            "SELECT status FROM raw_components WHERE session_id = ? AND component_id = ?"
+          );
+          for (const { component, resolution } of cachedComponents) {
+            const current = componentStatus.get(sessionId2, component.component_id);
+            if (current?.status === "generated") continue;
+            renameEmptySlots(db, sessionId2, component.component_id, component.name, component.slots.length);
+            restorations.push({
+              sourceSessionId: resolution.entry.sourceSessionId,
+              targetSessionId: sessionId2,
+              componentId: component.component_id
+            });
+            rekeyed.push({ component, cached: resolution.entry });
+          }
+          copyComponentsFromCache(db, restorations, { allowedComponentNames: allowedComponentNames2 });
+          storeCaches(
+            db,
+            rekeyed.map(({ component, cached }) => ({
+              inputHash: hashComponentShape(normalizeComponentForCache(component)),
+              entityType: "component",
+              entityId: component.component_id,
+              sourceSessionId: cached.sourceSessionId,
+              humanEdited: cached.humanEdited,
+              promptHash
+            }))
+          );
+        }
+        const fullyCached = cacheEnabled && cachedComponents.length === allComponents.length;
+        process.stdout.write(`cache-status=${fullyCached ? "hit" : "miss"}
+`);
+        process.stdout.write(
+          `cache-components=${JSON.stringify(cachedComponents.map(({ component }) => component.name))}
+`
+        );
+        await exitWithAnalytics(0);
+        return;
+      }
       componentResults = await runAllComponents(
         {
           agent,
@@ -13071,10 +13841,13 @@ async function runGenerateSkill(skill, opts, verbose = false) {
           tokensInline,
           tokenMapInline,
           verbose,
+          noCache: opts.cache === false || process.env.EDS_NO_CACHE === "1",
           skillPathOverride: generatePromptPath,
           skillContentOverride: generatePrompt,
+          promptHash,
           existingContentfulEntities,
           existingTokensInline,
+          precomputedCachedNames,
           allowedComponentNames: allowedComponentNames2
         },
         allComponents
@@ -13083,7 +13856,8 @@ async function runGenerateSkill(skill, opts, verbose = false) {
       db.close();
     }
     const failed = componentResults.filter((r) => r.failed);
-    const generated = componentResults.filter((r) => !r.failed);
+    const cachedResults = componentResults.filter((r) => r.cached);
+    const generated = componentResults.filter((r) => !r.failed && !r.cached);
     const allWarnings = componentResults.flatMap((r) => r.warnings.map((w) => `  ${r.componentName}: ${w}`));
     if (allWarnings.length > 0) {
       process.stderr.write(c.yellow("Warnings:") + "\n" + allWarnings.join("\n") + "\n");
@@ -13099,17 +13873,21 @@ async function runGenerateSkill(skill, opts, verbose = false) {
     const totalExcluded = generated.reduce((s, r) => s + r.excluded, 0);
     const totalRenamedSlots = componentResults.reduce((s, r) => s + r.renamedSlotsCount, 0);
     const allOk = failed.length === 0;
+    const cachedNote = cachedResults.length > 0 ? c.dim(`  (${cachedResults.length} cached)`) : "";
     process.stderr.write(
-      (allOk ? c.green("\u2713") : c.yellow("\u26A0")) + `  ${generated.length}/${componentResults.length} components` + c.dim(`  ${totalClassified} classified, ${totalExcluded} unattached`) + "\n"
+      (allOk ? c.green("\u2713") : c.yellow("\u26A0")) + `  ${generated.length + cachedResults.length}/${componentResults.length} components` + cachedNote + c.dim(`  ${totalClassified} classified, ${totalExcluded} unattached`) + "\n"
     );
     process.stdout.write(`renamed-slots: ${totalRenamedSlots}
 `);
-    if (generated.length === 0) {
+    if (generated.length === 0 && cachedResults.length === 0) {
       die(
         `Error: all ${componentResults.length} component(s) failed to generate \u2014 see the per-component errors above.`
       );
     }
   } else if (skill === "tokens") {
+    const noCache = opts.cache === false || process.env.EDS_NO_CACHE === "1";
+    const tokenInputContent = rawTokensInline ?? "";
+    const tokenInputHash = hashTokenContent(tokenInputContent);
     const db = openPipelineDb();
     try {
       let resolvedSessionId = opts.session;
@@ -13136,11 +13914,26 @@ async function runGenerateSkill(skill, opts, verbose = false) {
       }
       sessionId2 = resolvedSessionId;
       await bindAnalyticsSessionId(resolvedSessionId);
+      const tokenPromptHash = await hashPromptForSkill("tokens", agent, model);
+      if (!noCache) {
+        const tokenCached = lookupCache(db, tokenInputHash, "token_set", "__tokens__", tokenPromptHash);
+        if (tokenCached) {
+          copyTokensFromCache(db, tokenCached.sourceSessionId, resolvedSessionId);
+          sessionId2 = resolvedSessionId;
+          process.stderr.write(
+            `Done: tokens reused from cache ${c.dim(`(source: ${tokenCached.sourceSessionId.slice(0, 12)})`)}
+`
+          );
+          db.close();
+          await showGenerateView({ skill, agent, sessionId: sessionId2 ?? "" });
+          return;
+        }
+      }
       const prompt = await buildPrompt({
         skill,
         mode: "autonomous",
         rawTokensInline,
-        rawTokensFilename: opts.rawTokens ? resolve11(opts.rawTokens).split("/").pop() : void 0,
+        rawTokensFilename: opts.rawTokens ? resolve12(opts.rawTokens).split("/").pop() : void 0,
         tokensInline,
         tokenMapInline,
         outDir: process.cwd()
@@ -13177,6 +13970,9 @@ ${tokenWarnings.map((w) => `  ${w}`).join("\n")}
 `);
       }
       applyTokenToolCalls(db, resolvedSessionId, tokenCalls, []);
+      if (!noCache) {
+        storeCache(db, tokenInputHash, "token_set", "__tokens__", resolvedSessionId, false, tokenPromptHash);
+      }
       sessionId2 = resolvedSessionId;
       const groupCount = tokenCalls.filter((tc) => tc.tool === "set_group").length;
       process.stderr.write(`Done: ${tokenCount} tokens, ${groupCount} groups stored
@@ -13188,7 +13984,10 @@ ${tokenWarnings.map((w) => `  ${w}`).join("\n")}
   await showGenerateView({ skill, agent, sessionId: sessionId2 ?? "" });
 }
 function addAgentFlags(cmd) {
-  return addAgentModelOptions(cmd).option("--verbose", "Show full agent output including reasoning text").option("--dry-run", "Print the prompt without invoking the agent");
+  return addAgentModelOptions(cmd).option("--verbose", "Show full agent output including reasoning text").option("--dry-run", "Print the prompt without invoking the agent").option(
+    "--no-cache",
+    "Bypass ALL fine-grained caches (extract, select, generate) and force AI re-run. Cache keys now factor in prompt content \u2014 changing the prompt file via --generate-prompt-path or --select-prompt-path will already bust the corresponding stage. Use --no-cache to force a full re-run."
+  );
 }
 function registerInternalGenerateCommand(program) {
   const generate = program.command("__generate", { hidden: true }).description("Internal import pipeline generation command");
@@ -13204,6 +14003,12 @@ function registerInternalGenerateCommand(program) {
     "--existing-entities-path <path>",
     "Path to the .existing-entities.json file written after CMA credentials are supplied. When present, per-component prompts include a summary of the target space so classifications can align to existing prop names/tokens. Missing/malformed files are treated as no-op."
   );
+  componentsCmd.option("--cache-status", "Check whether all selected component definitions are cached");
+  componentsCmd.option("--restore-cache", "Restore cached component definitions into the current session");
+  componentsCmd.option(
+    "--cached-components <json>",
+    "Component names already restored by a prior cache-status lookup; skip per-component cache lookup"
+  );
   addAgentFlags(componentsCmd).action(async (opts) => {
     await runGenerateSkill("components", opts, opts.verbose ?? false);
   });
@@ -13229,6 +14034,7 @@ var init_command = __esm({
     init_agent_output();
     init_GenerateView();
     init_db();
+    init_cache_keys();
     init_read_existing_contentful_entities_from_session();
     init_summarize_existing_contentful_entities();
     init_resolve_session_id();
@@ -13944,7 +14750,7 @@ var init_user_agent = __esm({
 // packages/experience-design-system-cli-legacy/src/apply/api-client.ts
 import { parseCDFComponents } from "@contentful/experience-design-system-types";
 function defaultSleep(delayMs) {
-  return new Promise((resolve20) => setTimeout(resolve20, delayMs));
+  return new Promise((resolve21) => setTimeout(resolve21, delayMs));
 }
 function isTransientStatus(status) {
   return status >= 500 && status <= 599;
@@ -14334,7 +15140,7 @@ ${trimmed}`;
             const progress = maxAttempts > 1 ? attempt / (maxAttempts - 1) : 0;
             const baseDelay = intervalMs + (maxIntervalMs - intervalMs) * progress;
             const jitter = Math.random() * baseDelay * 0.15;
-            await new Promise((resolve20) => setTimeout(resolve20, baseDelay + jitter));
+            await new Promise((resolve21) => setTimeout(resolve21, baseDelay + jitter));
           }
         }
         throw new Error(`Operation ${operationId} timed out after ${maxAttempts} attempts`);
@@ -15144,7 +15950,7 @@ var init_terminal_capabilities = __esm({
 
 // packages/experience-design-system-cli-legacy/src/apply/command.ts
 import { createElement as createElement2 } from "react";
-import { readFile as readFile12, readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { readFile as readFile13, readdir as readdir2, stat as stat2 } from "node:fs/promises";
 import { join as join16 } from "node:path";
 import {
   validateCDF,
@@ -15165,7 +15971,7 @@ function dieWithApiError(error) {
 async function readJsonFile(flag, p) {
   let text;
   try {
-    text = await readFile12(p, "utf8");
+    text = await readFile13(p, "utf8");
   } catch {
     return await die2(`Error: file not found: ${p} (from ${flag})`);
   }
@@ -15219,7 +16025,7 @@ async function readTokensFromPath(flag, p) {
     for (const file of files.sort()) {
       let text;
       try {
-        text = await readFile12(file, "utf8");
+        text = await readFile13(file, "utf8");
       } catch {
         continue;
       }
@@ -15588,11 +16394,11 @@ var init_command2 = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/print/validate/validators/read-json-file.ts
-import { readFile as readFile13 } from "node:fs/promises";
+import { readFile as readFile14 } from "node:fs/promises";
 async function readJsonFile2(filePath) {
   let content;
   try {
-    content = await readFile13(filePath, "utf-8");
+    content = await readFile14(filePath, "utf-8");
   } catch (err) {
     return {
       ok: false,
@@ -16003,7 +16809,7 @@ var init_ValidateView = __esm({
 // packages/experience-design-system-cli-legacy/src/print/command.ts
 import { createElement as createElement3 } from "react";
 import { access as access3, mkdir as mkdir3, stat as stat3, writeFile as writeFile3 } from "node:fs/promises";
-import { basename as basename5, resolve as resolve12 } from "node:path";
+import { basename as basename5, resolve as resolve13 } from "node:path";
 import { CDF_SCHEMA_URL } from "@contentful/experience-design-system-types";
 async function die3(message) {
   process.stderr.write(`${message}
@@ -16070,7 +16876,7 @@ function registerPrintCommand(program) {
     "--allow-empty",
     "Write an empty-but-present CDF file when no components are accepted (a subsequent push then removes ALL components from the target space). Without this, an empty accepted set is an error."
   ).action(async (opts) => {
-    const outPath = resolve12(opts.out);
+    const outPath = resolve13(opts.out);
     await assertOutIsNotDirectory(outPath);
     const sessionId2 = await resolveSession(opts.session, "generate components");
     await bindAnalyticsSessionId(sessionId2);
@@ -16118,7 +16924,7 @@ function registerPrintCommand(program) {
 `
       );
     }
-    await mkdir3(resolve12(outPath, ".."), { recursive: true });
+    await mkdir3(resolve13(outPath, ".."), { recursive: true });
     await writeFile3(outPath, `${JSON.stringify(cdfObj, null, 2)}
 `);
     process.stdout.write(
@@ -16127,7 +16933,7 @@ function registerPrintCommand(program) {
     );
   });
   print.command("tokens").description("Write generated tokens to a DTCG JSON file").option("--session <id>", "Session ID to print from (default: most recent generate tokens session)").option("--out <path>", "Output file path", "tokens.json").action(async (opts) => {
-    const outPath = resolve12(opts.out);
+    const outPath = resolve13(opts.out);
     await assertOutIsNotDirectory(outPath);
     const sessionId2 = await resolveSession(opts.session, "generate tokens");
     await bindAnalyticsSessionId(sessionId2);
@@ -16142,7 +16948,7 @@ function registerPrintCommand(program) {
       await die3(`Error: no generated tokens in session '${sessionId2}'. Run generate tokens first.`);
     }
     const tree = rebuildDTCGTree(result.groups, result.tokens);
-    await mkdir3(resolve12(outPath, ".."), { recursive: true });
+    await mkdir3(resolve13(outPath, ".."), { recursive: true });
     await writeFile3(outPath, `${JSON.stringify(tree, null, 2)}
 `);
     process.stdout.write(
@@ -16291,7 +17097,7 @@ function MapTokensView({ result, onExit }) {
     const timer = setTimeout(onExit, 100);
     return () => clearTimeout(timer);
   }, [onExit]);
-  const summary = `${result.applied} mapping${result.applied === 1 ? "" : "s"} applied`;
+  const summary = result.cached ? "reused from cache" : `${result.applied} mapping${result.applied === 1 ? "" : "s"} applied`;
   return /* @__PURE__ */ jsx8(
     CommandCompletionView,
     {
@@ -16425,8 +17231,8 @@ var init_resolve_defaults = __esm({
 
 // packages/experience-design-system-cli-legacy/src/map-tokens/command.ts
 import { createElement as createElement4 } from "react";
-import { readFile as readFile14 } from "node:fs/promises";
-import { resolve as resolve13 } from "node:path";
+import { readFile as readFile15 } from "node:fs/promises";
+import { resolve as resolve14 } from "node:path";
 async function renderResult(result) {
   if (process.stdout.isTTY) {
     const { waitUntilExit } = renderWithGoodbye(
@@ -16434,13 +17240,12 @@ async function renderResult(result) {
     );
     await waitUntilExit();
   } else {
-    process.stdout.write(
-      `map tokens complete
+    const summary = result.cached ? "cached" : `${result.applied} mapping(s) applied`;
+    process.stdout.write(`map tokens complete
 agent: ${result.agent}
 session=${result.sessionId}
-${result.applied} mapping(s) applied
-`
-    );
+${summary}
+`);
     await exitWithAnalytics(0);
   }
 }
@@ -16462,7 +17267,7 @@ async function runMapTokens(opts) {
   let mapPromptPath;
   if (mapPromptOverride?.kind === "text") mapPromptText = mapPromptOverride.value;
   if (mapPromptOverride?.kind === "path") {
-    mapPromptPath = resolve13(mapPromptOverride.value);
+    mapPromptPath = resolve14(mapPromptOverride.value);
     try {
       await resolvePromptOverride(mapPromptOverride);
     } catch (error) {
@@ -16482,7 +17287,7 @@ async function runMapTokens(opts) {
     const knownTokenPaths = new Set(tokenLeaves.map((t) => t.path));
     const tokenMapDiagnostics = [];
     if (opts.tokenMap) {
-      const fileMappings = JSON.parse(await readFile14(opts.tokenMap, "utf8"));
+      const fileMappings = JSON.parse(await readFile15(opts.tokenMap, "utf8"));
       const validMappings = {};
       for (const [rawName, path] of Object.entries(fileMappings)) {
         if (knownTokenPaths.has(path)) {
@@ -16560,7 +17365,7 @@ ${defaultDiagnostics.map((diagnostic) => `  ${diagnostic}`).join("\n")}
     let existingTokensInline;
     if (opts.existingEntitiesPath) {
       const existingContentfulEntities = await readExistingContentfulEntitiesFromSession(
-        resolve13(opts.existingEntitiesPath)
+        resolve14(opts.existingEntitiesPath)
       );
       if (existingContentfulEntities) {
         existingTokensInline = JSON.stringify(summarizeForMapTokens(existingContentfulEntities));
@@ -16595,10 +17400,30 @@ ${defaultDiagnostics.map((diagnostic) => `  ${diagnostic}`).join("\n")}
         skipAgent: "true"
       });
       updateStep(db, stepId2, "complete", { applied: "0", skipAgent: "true" });
-      await renderResult({ agent: resultAgent, sessionId: sessionId2, applied: 0 });
+      await renderResult({ agent: resultAgent, sessionId: sessionId2, applied: 0, cached: false });
       return;
     }
     const agent = configuredAgent;
+    const noCache = opts.cache === false || process.env.EDS_NO_CACHE === "1";
+    const promptHash = await hashPromptForSkill(
+      "map-tokens",
+      agent,
+      model,
+      void 0,
+      existingTokensInline ? [hashContent(existingTokensInline)] : [],
+      mapPromptText
+    );
+    const inputHash = computeMapTokensInputHash(db, sessionId2, componentSourceRefs);
+    if (!noCache) {
+      const cached = lookupCache(db, inputHash, "token_mapping", "__map_tokens__", promptHash);
+      if (cached) {
+        const appliedFromCache = copyMapTokensFromCache(db, cached.sourceSessionId, sessionId2);
+        const stepId2 = createStep(db, sessionId2, "map tokens", { agent, model: model ?? "" });
+        updateStep(db, stepId2, "complete", { cached: "true", applied: String(appliedFromCache) });
+        await renderResult({ agent, sessionId: sessionId2, applied: appliedFromCache, cached: true });
+        return;
+      }
+    }
     const binary = resolveAgentBinary(agent);
     if (!await assertBinaryInPath(binary)) {
       die(
@@ -16618,20 +17443,23 @@ Install it, choose another agent with --agent, or use --print-prompt to run the
     }
     const { calls, warnings: parseWarnings } = parseMapTokenPropToolCallLines(result.stdout);
     const { applied, warnings } = applyMapTokenPropCalls(db, sessionId2, calls, parseWarnings);
+    if (!noCache) {
+      storeCache(db, inputHash, "token_mapping", "__map_tokens__", sessionId2, false, promptHash);
+    }
     updateStep(db, stepId, "complete", { applied: String(applied), warnings: String(warnings.length) });
     if (warnings.length > 0) {
       process.stderr.write(`Warnings:
 ${warnings.map((w) => `  ${w}`).join("\n")}
 `);
     }
-    await renderResult({ agent, sessionId: sessionId2, applied });
+    await renderResult({ agent, sessionId: sessionId2, applied, cached: false });
   } finally {
     db.close();
   }
 }
 function registerMapTokensCommand(program) {
   const map = program.command("map", { hidden: true }).description("Suggest token restrictions for generated design-token props");
-  const tokensCmd = map.command("tokens").description("Invoke a coding agent to suggest $token.allowed for design-category token props").option("--session <id>", "Session ID from generate components (defaults to most recent)").option("--print-prompt", "Print the prompt without invoking the agent").option("--skip-agent", "Resolve token defaults without agentic $token.allowed inference").option(
+  const tokensCmd = map.command("tokens").description("Invoke a coding agent to suggest $token.allowed for design-category token props").option("--session <id>", "Session ID from generate components (defaults to most recent)").option("--print-prompt", "Print the prompt without invoking the agent").option("--skip-agent", "Resolve token defaults without agentic $token.allowed inference").option("--no-cache", "Bypass the map-tokens cache and force a re-run").option(
     "--prompt <stage=value>",
     "Override a stage prompt (repeatable). Used here for the map-tokens stage.",
     (v, acc) => [...acc, v],
@@ -16651,6 +17479,7 @@ var init_command4 = __esm({
     init_render_with_goodbye();
     init_src();
     init_db();
+    init_cache_keys();
     init_read_existing_contentful_entities_from_session();
     init_summarize_existing_contentful_entities();
     init_command3();
@@ -16667,7 +17496,7 @@ var init_command4 = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/import/path-utils.ts
-import { resolve as resolve14 } from "node:path";
+import { resolve as resolve15 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 function expandTilde(input) {
   if (input === "~" || input.startsWith("~/") || input.startsWith("~\\")) {
@@ -16681,7 +17510,7 @@ function normalizePath(input) {
     p = p.slice(1, -1);
   }
   p = expandTilde(p);
-  return resolve14(p);
+  return resolve15(p);
 }
 var init_path_utils = __esm({
   "packages/experience-design-system-cli-legacy/src/import/path-utils.ts"() {
@@ -16906,7 +17735,7 @@ var init_save_path_resolver = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/runs/store.ts
-import { readFile as readFile15, writeFile as writeFile4, mkdir as mkdir4, rename } from "node:fs/promises";
+import { readFile as readFile16, writeFile as writeFile4, mkdir as mkdir4, rename } from "node:fs/promises";
 import { join as join20 } from "node:path";
 import { homedir as homedir6 } from "node:os";
 import { randomBytes as randomBytes2 } from "node:crypto";
@@ -16946,7 +17775,7 @@ function migrateRecord(rec) {
 }
 async function readFileMaybe() {
   try {
-    const raw = await readFile15(RUNS_PATH, "utf8");
+    const raw = await readFile16(RUNS_PATH, "utf8");
     const parsed = JSON.parse(raw);
     if (!READABLE_VERSIONS.has(parsed.version)) {
       throw new Error(
@@ -17010,15 +17839,15 @@ var init_store = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/runs/fingerprint.ts
-import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile16, stat as stat4 } from "node:fs/promises";
-import { resolve as resolve15 } from "node:path";
+import { createHash as createHash6 } from "node:crypto";
+import { readFile as readFile17, stat as stat4 } from "node:fs/promises";
+import { resolve as resolve16 } from "node:path";
 function rowField(row, key) {
   const v = row[key];
   return typeof v === "string" ? v : null;
 }
 function sha256Hex(buf) {
-  return createHash2("sha256").update(buf).digest("hex");
+  return createHash6("sha256").update(buf).digest("hex");
 }
 async function buildSourceFingerprint(opts) {
   const rows = opts.db.prepare("SELECT name, source_path FROM raw_components WHERE session_id = ?").all(opts.extractSessionId);
@@ -17028,7 +17857,7 @@ async function buildSourceFingerprint(opts) {
     const sourcePath = rowField(row, "source_path");
     const name = rowField(row, "name");
     if (!sourcePath) continue;
-    const abs = resolve15(sourcePath);
+    const abs = resolve16(sourcePath);
     if (seen.has(abs)) continue;
     seen.add(abs);
     try {
@@ -17043,10 +17872,10 @@ async function buildSourceFingerprint(opts) {
   let rawTokensMtime = null;
   let rawTokensContentHash = null;
   if (opts.rawTokensPath) {
-    const abs = resolve15(opts.rawTokensPath);
+    const abs = resolve16(opts.rawTokensPath);
     rawTokensPath = abs;
     try {
-      const [st, buf] = await Promise.all([stat4(abs), readFile16(abs)]);
+      const [st, buf] = await Promise.all([stat4(abs), readFile17(abs)]);
       rawTokensMtime = st.mtime.toISOString();
       rawTokensContentHash = sha256Hex(buf);
     } catch {
@@ -18801,11 +19630,11 @@ var init_slot_graph = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/analyze/select/parser.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash7 } from "node:crypto";
 import { access as access5 } from "node:fs/promises";
-import { isAbsolute, relative, resolve as resolve16 } from "node:path";
+import { isAbsolute, relative, resolve as resolve17 } from "node:path";
 function createComponentId(name, resolvedSourcePath) {
-  const sourceHash = createHash3("sha256").update(`${name}:${resolvedSourcePath}`).digest("hex").slice(0, 12);
+  const sourceHash = createHash7("sha256").update(`${name}:${resolvedSourcePath}`).digest("hex").slice(0, 12);
   return `${name}-${sourceHash}`;
 }
 async function resolveComponentSourcePath(source, reviewRoot) {
@@ -18817,7 +19646,7 @@ async function resolveComponentSourcePath(source, reviewRoot) {
       throw new Error(`Unable to access component source at ${source}`);
     }
   }
-  const candidate = resolve16(reviewRoot, source);
+  const candidate = resolve17(reviewRoot, source);
   const relativeToRoot = relative(reviewRoot, candidate);
   if (relativeToRoot.startsWith("..") || relativeToRoot === ".." || isAbsolute(relativeToRoot)) {
     throw new Error(
@@ -18832,7 +19661,7 @@ async function resolveComponentSourcePath(source, reviewRoot) {
   }
 }
 async function loadReviewInput(components, options = {}) {
-  const reviewRoot = resolve16(options.reviewRoot ?? process.cwd());
+  const reviewRoot = resolve17(options.reviewRoot ?? process.cwd());
   const records = await Promise.all(
     components.map(async (component) => {
       let resolvedSourcePath;
@@ -18863,7 +19692,7 @@ var init_parser = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/analyze/select/command.ts
-import { access as access6, readFile as readFile17 } from "node:fs/promises";
+import { access as access6, readFile as readFile18 } from "node:fs/promises";
 async function loadAndValidateForReview(sessionId2, projectRoot) {
   const db = openPipelineDb();
   let rawComponents;
@@ -18881,7 +19710,7 @@ async function patchReviewStateWithValidationErrors(sessionId2, errors, opts = {
   let snapshot;
   try {
     await access6(paths.statePath);
-    snapshot = JSON.parse(await readFile17(paths.statePath, "utf8"));
+    snapshot = JSON.parse(await readFile18(paths.statePath, "utf8"));
   } catch {
     snapshot = await loadAndValidateForReview(sessionId2, void 0);
     snapshot = await ensureRefineSession(sessionId2, artifactsRoot, snapshot);
@@ -18932,7 +19761,7 @@ async function rejectComponentsByName(sessionId2, names, opts = {}) {
   const nameSet = new Set(names);
   let snapshot;
   try {
-    snapshot = JSON.parse(await readFile17(paths.statePath, "utf8"));
+    snapshot = JSON.parse(await readFile18(paths.statePath, "utf8"));
   } catch {
     return;
   }
@@ -19031,9 +19860,9 @@ function spawnGenerateChild(opts) {
     stderr += chunk;
     opts.onStderr?.(chunk);
   });
-  const donePromise = new Promise((resolve20) => {
+  const donePromise = new Promise((resolve21) => {
     child.on("close", (code, signal) => {
-      resolve20({
+      resolve21({
         exitCode: code ?? 0,
         signal: signal ?? null,
         stdout,
@@ -19041,7 +19870,7 @@ function spawnGenerateChild(opts) {
       });
     });
     child.on("error", (err) => {
-      resolve20({
+      resolve21({
         exitCode: 1,
         signal: null,
         stdout,
@@ -27179,6 +28008,9 @@ function shouldGenerateAfterCredentialsValidated(opts) {
 function shouldSkipFinalReviewAfterCredentials(state) {
   return state.finalReviewPassed && state.generateSessionId != null;
 }
+function resolveNoCacheForGenerate(opts) {
+  return opts.cliNoCache;
+}
 function shouldBypassPreview(state) {
   return state.credentialsSkipped === true;
 }
@@ -27205,43 +28037,70 @@ var init_wizard_state_transitions = __esm({
 async function runSelectionAgent(options) {
   const db = openPipelineDb();
   let components;
+  const cachedDecisions = /* @__PURE__ */ new Map();
+  const cliVersion2 = await getCliCacheVersion();
+  const promptHash = await hashPromptForSkill(
+    "select",
+    options.agent,
+    options.model,
+    options.promptPath,
+    [SELECT_PAYLOAD_FORMAT],
+    options.promptText
+  );
   try {
     components = loadRawComponents(db, options.sessionId);
+    if (!options.noCache) {
+      for (const component of components) {
+        const componentHash = hashComponentShape(component);
+        const cached = lookupSelectCache(db, componentHash, promptHash, cliVersion2);
+        if (cached) {
+          cachedDecisions.set(component.name, {
+            decision: cached.decision,
+            reason: cached.reason
+          });
+        }
+      }
+    }
   } finally {
     db.close();
   }
   if (components.length === 0) return;
-  const invoker2 = createLocalCliAgentInvoker({
-    onDebugEvent: (name, payload) => getDebugLogger().event("agent", name, payload)
-  });
-  const selectBuckets = bucketComponentsProps(components);
-  for (const assignment of selectBuckets) {
-    getDebugLogger().event("analyze", "prop-buckets.select", { ...assignment });
-  }
-  const prompt = await buildPrompt({
-    skill: "select",
-    mode: "autonomous",
-    rawComponentsInline: JSON.stringify(
-      components.map((component) => ({ ...component, props: component.props.map(stripPropProvenance) })),
-      null,
-      2
-    ),
-    propBucketsInline: JSON.stringify(selectBuckets),
-    outDir: process.cwd(),
-    ...options.promptText !== void 0 ? { skillContentOverride: options.promptText } : {},
-    ...options.promptText === void 0 && options.promptPath ? { skillPathOverride: options.promptPath } : {}
-  });
-  const { result } = await invokeAgentWithOutput(
-    invoker2,
-    { agent: options.agent, model: options.model, prompt, timeoutMs: DEFAULT_TIMEOUT_MS4 },
-    false
-  );
-  if (result.timedOut) throw new Error("selection agent timed out");
-  if (result.exitCode !== 0) throw new Error(`selection agent exited with code ${result.exitCode}`);
-  const parsed = parseSelectToolCallLines(result.stdout);
-  for (const warning of parsed.warnings) process.stderr.write(`Warning: selection agent: ${warning}
+  const componentsToRun = components.filter((component) => !cachedDecisions.has(component.name));
+  let calls = [];
+  if (componentsToRun.length > 0) {
+    const invoker2 = createLocalCliAgentInvoker({
+      onDebugEvent: (name, payload) => getDebugLogger().event("agent", name, payload)
+    });
+    const selectBuckets = bucketComponentsProps(componentsToRun);
+    for (const assignment of selectBuckets) {
+      getDebugLogger().event("analyze", "prop-buckets.select", { ...assignment });
+    }
+    const prompt = await buildPrompt({
+      skill: "select",
+      mode: "autonomous",
+      rawComponentsInline: JSON.stringify(
+        componentsToRun.map((component) => ({ ...component, props: component.props.map(stripPropProvenance) })),
+        null,
+        2
+      ),
+      propBucketsInline: JSON.stringify(selectBuckets),
+      outDir: process.cwd(),
+      ...options.promptText !== void 0 ? { skillContentOverride: options.promptText } : {},
+      ...options.promptText === void 0 && options.promptPath ? { skillPathOverride: options.promptPath } : {}
+    });
+    const { result } = await invokeAgentWithOutput(
+      invoker2,
+      { agent: options.agent, model: options.model, prompt, timeoutMs: DEFAULT_TIMEOUT_MS4 },
+      false
+    );
+    if (result.timedOut) throw new Error("selection agent timed out");
+    if (result.exitCode !== 0) throw new Error(`selection agent exited with code ${result.exitCode}`);
+    const parsed = parseSelectToolCallLines(result.stdout);
+    for (const warning of parsed.warnings) process.stderr.write(`Warning: selection agent: ${warning}
 `);
-  const byName = new Map(parsed.calls.map((call) => [call.name, call]));
+    calls = parsed.calls;
+  }
+  const byName = new Map(calls.map((call) => [call.name, call]));
   const writeDb = openPipelineDb();
   try {
     writeDb.exec("BEGIN");
@@ -27249,15 +28108,27 @@ async function runSelectionAgent(options) {
       `UPDATE raw_components SET status = ?, reject_reason = ? WHERE session_id = ? AND component_id = ?`
     );
     for (const component of components) {
+      const cached = cachedDecisions.get(component.name);
       const call = byName.get(component.name);
-      if (!call) continue;
-      const rejected = call.tool === "reject_component";
+      if (!cached && !call) continue;
+      const rejected = cached ? cached.decision === "rejected" : call.tool === "reject_component";
+      const reason = cached ? cached.reason : call.reason ?? null;
       update.run(
         rejected ? "rejected" : "accepted",
-        rejected ? call.reason ?? null : null,
+        rejected ? reason : null,
         options.sessionId,
         component.component_id
       );
+      if (!cached) {
+        storeSelectCache(
+          writeDb,
+          hashComponentShape(component),
+          promptHash,
+          cliVersion2,
+          rejected ? "rejected" : "accepted",
+          rejected ? reason : null
+        );
+      }
     }
     writeDb.exec("COMMIT");
   } catch (error) {
@@ -27267,7 +28138,7 @@ async function runSelectionAgent(options) {
     writeDb.close();
   }
 }
-var DEFAULT_TIMEOUT_MS4;
+var SELECT_PAYLOAD_FORMAT, DEFAULT_TIMEOUT_MS4;
 var init_run_selection_agent = __esm({
   "packages/experience-design-system-cli-legacy/src/import/tui/run-selection-agent.ts"() {
     "use strict";
@@ -27276,6 +28147,8 @@ var init_run_selection_agent = __esm({
     init_debug_logger();
     init_agent_output();
     init_db();
+    init_cache_keys();
+    SELECT_PAYLOAD_FORMAT = "prop-buckets-v1";
     DEFAULT_TIMEOUT_MS4 = Number(process.env.EDS_AGENT_TIMEOUT_MS ?? 5 * 60 * 1e3);
   }
 });
@@ -27294,7 +28167,7 @@ __export(WizardApp_exports, {
 });
 import { useEffect as useEffect15, useRef as useRef10, useState as useState23 } from "react";
 import { Box as Box42, Text as Text46 } from "ink";
-import { join as join23, resolve as resolve17 } from "node:path";
+import { join as join23, resolve as resolve18 } from "node:path";
 import { appendFileSync as appendFileSync2, writeFileSync } from "node:fs";
 import { access as access7, stat as stat5, writeFile as writeFile6 } from "node:fs/promises";
 import { tmpdir } from "node:os";
@@ -27307,21 +28180,28 @@ function buildGenerateComponentsArgs(opts) {
   if (opts.tokensPath) args.push("--tokens", opts.tokensPath);
   if (opts.model) args.push("--model", opts.model);
   if (opts.bedrock) args.push("--bedrock");
+  if (opts.noCache) args.push("--no-cache");
   if (opts.generatePromptPath) args.push("--generate-prompt-path", opts.generatePromptPath);
   for (const prompt of opts.promptOverrides ?? []) args.push("--prompt", prompt);
   if (opts.existingEntitiesPath) args.push("--existing-entities-path", opts.existingEntitiesPath);
+  if (opts.restoreCache) args.push("--restore-cache");
+  if (opts.cachedComponents && opts.cachedComponents.length > 0) {
+    args.push("--cached-components", JSON.stringify(opts.cachedComponents));
+  }
   return args;
 }
 function buildGenerateTokensArgs(opts) {
   const args = [findCliPath(), "__generate", "tokens", "--agent", opts.agent, "--raw-tokens", opts.rawTokensPath];
   if (opts.model) args.push("--model", opts.model);
   if (opts.bedrock) args.push("--bedrock");
+  if (opts.noCache) args.push("--no-cache");
   for (const prompt of opts.promptOverrides ?? []) args.push("--prompt", prompt);
   return args;
 }
 function buildMapTokensArgs(opts) {
   const args = ["map", "tokens", "--session", opts.sessionId, "--agent", opts.agent];
   if (opts.model) args.push("--model", opts.model);
+  if (opts.noCache) args.push("--no-cache");
   if (opts.skipAgent) args.push("--skip-agent");
   for (const prompt of opts.promptOverrides ?? []) args.push("--prompt", prompt);
   if (opts.existingEntitiesPath) args.push("--existing-entities-path", opts.existingEntitiesPath);
@@ -27413,6 +28293,7 @@ function WizardApp({
   initialProjectPath,
   host,
   promptOverrides,
+  noCache = false,
   livePreview = true,
   generatePromptPath,
   skipMapTokens = false,
@@ -27437,6 +28318,7 @@ function WizardApp({
   });
   const allowEmptyDeleteAllRef = useRef10(false);
   const generateChildRef = useRef10(null);
+  const generationCachePreflightRef = useRef10(null);
   const selectionToReviewStartedAtRef = useRef10(null);
   const credentialsValidationIdRef = useRef10(0);
   const pendingCredentialValidationRef = useRef10(null);
@@ -27451,8 +28333,9 @@ function WizardApp({
   const existingEntitiesPromiseRef = useRef10(null);
   const generatePromiseRef = useRef10(null);
   const rawTokensEntryReady = !!initialRawTokensPath;
+  const effectiveNoCache = resolveNoCacheForGenerate({ cliNoCache: noCache });
   const initialStepResolved = rawTokensEntryReady ? initialProjectPath ? "path-validation" : "credentials" : initialProjectPath ? "token-input" : "welcome";
-  const initialOutDir = initialProjectPath ? join23(resolve17(initialProjectPath), ".contentful") : "";
+  const initialOutDir = initialProjectPath ? join23(resolve18(initialProjectPath), ".contentful") : "";
   const [state, setState] = useState23({
     step: initialStepResolved,
     agent: initialAgent ?? "claude",
@@ -27628,13 +28511,14 @@ If you are using AWS Bedrock, run:
     if (!deferStep) update({ step: nextStep });
     return true;
   };
-  const runGenerateTokens = async (rawTokensPath, outDir) => {
+  const runGenerateTokens = async (rawTokensPath, outDir, forceRegenerate = false) => {
     update({ tokenGenerationStatus: "running" });
     const tokenArgs = buildGenerateTokensArgs({
       rawTokensPath,
       agent: state.agent,
       ...state.agentModel ? { model: state.agentModel } : {},
       ...state.bedrock ? { bedrock: true } : {},
+      noCache: effectiveNoCache || forceRegenerate,
       promptOverrides
     });
     const result = await runSpawnedCli(tokenArgs);
@@ -27683,6 +28567,7 @@ If you are using AWS Bedrock, run:
     const timer = startWizardTimer("token-mapping", {
       sessionId: sessionId2,
       silent,
+      noCache: effectiveNoCache,
       skipAgent: skipMapTokens
     });
     let mappablePropCount = 0;
@@ -27691,7 +28576,7 @@ If you are using AWS Bedrock, run:
       const db = openPipelineDb();
       try {
         if (state.tokenSessionId && state.tokenSessionId !== sessionId2) {
-          copyTokensBetweenSessions(db, state.tokenSessionId, sessionId2);
+          copyTokensFromCache(db, state.tokenSessionId, sessionId2);
         } else if (!state.tokenSessionId && state.tokensPath) {
           const tokens = await readTokensFromPath("tokens", state.tokensPath);
           storeDtcgTokens(db, sessionId2, [], tokens);
@@ -27731,6 +28616,7 @@ If you are using AWS Bedrock, run:
       sessionId: sessionId2,
       agent: state.agent,
       ...state.agentModel ? { model: state.agentModel } : {},
+      noCache: effectiveNoCache,
       skipAgent: skipMapTokens,
       promptOverrides,
       ...state.existingEntitiesPath ? { existingEntitiesPath: state.existingEntitiesPath } : {}
@@ -27810,7 +28696,7 @@ If you are using AWS Bedrock, run:
     return promise;
   };
   const runExtract = async (projectPath, showProgress = true) => {
-    const outDir = join23(resolve17(projectPath), ".contentful");
+    const outDir = join23(resolve18(projectPath), ".contentful");
     const existingEntitiesExpected = !state.credentialsSkipped && Boolean(state.spaceId && state.environmentId && state.cmaToken && projectPath);
     update({
       ...showProgress ? { step: "extracting" } : {},
@@ -27825,6 +28711,7 @@ If you are using AWS Bedrock, run:
     });
     const existingEntitiesPromise = startExistingEntitiesFetch(projectPath, outDir);
     const extractArgs = [findCliPath(), "__extract", "--project", projectPath];
+    if (effectiveNoCache) extractArgs.push("--no-cache");
     let selectionPromptText;
     let selectionPromptPath;
     try {
@@ -27833,7 +28720,7 @@ If you are using AWS Bedrock, run:
       const selectOverride = overrides.get("select");
       if (selectOverride?.kind === "text") selectionPromptText = selectOverride.value;
       if (selectOverride?.kind === "path") {
-        selectionPromptPath = resolve17(selectOverride.value);
+        selectionPromptPath = resolve18(selectOverride.value);
         await resolvePromptOverride(selectOverride);
       }
     } catch (error) {
@@ -27857,7 +28744,8 @@ If you are using AWS Bedrock, run:
           agent: state.agent,
           ...state.agentModel ? { model: state.agentModel } : {},
           ...selectionPromptText !== void 0 ? { promptText: selectionPromptText } : {},
-          ...selectionPromptPath ? { promptPath: selectionPromptPath } : {}
+          ...selectionPromptPath ? { promptPath: selectionPromptPath } : {},
+          noCache: effectiveNoCache
         });
       })().catch((error) => {
         selectionError = error;
@@ -28002,17 +28890,136 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
       generateProgress: null
     }));
   };
-  const buildGenerateOptions = (extractSessionId, tokensPath, generatePromptPath2) => ({
+  const buildGenerateOptions = (extractSessionId, tokensPath, generatePromptPath2, cachedComponents) => ({
     sessionId: extractSessionId,
     tokensPath,
     agent: state.agent,
     ...state.agentModel ? { model: state.agentModel } : {},
     ...state.bedrock ? { bedrock: true } : {},
+    noCache: effectiveNoCache,
     ...state.existingEntitiesPath ? { existingEntitiesPath: state.existingEntitiesPath } : {},
     ...generatePromptPath2 ? { generatePromptPath: generatePromptPath2 } : {},
-    promptOverrides
+    promptOverrides,
+    ...cachedComponents && cachedComponents.length > 0 ? { cachedComponents } : {}
   });
-  const buildGenerateArgs = (extractSessionId, tokensPath, generatePromptPath2) => buildGenerateProcessArgs(buildGenerateOptions(extractSessionId, tokensPath, generatePromptPath2));
+  const buildGenerateArgs = (extractSessionId, tokensPath, generatePromptPath2, cachedComponents) => buildGenerateProcessArgs(buildGenerateOptions(extractSessionId, tokensPath, generatePromptPath2, cachedComponents));
+  const buildGenerateCliArgs = (extractSessionId, tokensPath, generatePromptPath2, cachedComponents) => buildGenerateComponentsArgs(
+    buildGenerateOptions(extractSessionId, tokensPath, generatePromptPath2, cachedComponents)
+  );
+  const checkGenerateCache = async (extractSessionId, tokensPath) => {
+    const timer = startWizardTimer("generation-cache-status", {
+      sessionId: extractSessionId,
+      noCache: effectiveNoCache
+    });
+    if (effectiveNoCache) {
+      finishWizardTimer("generation-cache-status", timer, { status: "skipped" });
+      return false;
+    }
+    const result = await runCli([...buildGenerateCliArgs(extractSessionId, tokensPath), "--cache-status"]);
+    const hit = result.exitCode === 0 && /^cache-status=hit$/m.test(result.stdout);
+    finishWizardTimer("generation-cache-status", timer, {
+      status: hit ? "hit" : "miss",
+      exitCode: result.exitCode,
+      ...result.exitCode !== 0 ? { stderrTail: result.stderr.trim().slice(-500) } : {}
+    });
+    return hit;
+  };
+  const checkGenerateCacheComponents = async (extractSessionId, tokensPath, restoreCache = false) => {
+    const timer = startWizardTimer("generation-cache-components", {
+      sessionId: extractSessionId,
+      restoreCache,
+      noCache: effectiveNoCache
+    });
+    if (effectiveNoCache) {
+      finishWizardTimer("generation-cache-components", timer, { status: "skipped" });
+      return /* @__PURE__ */ new Set();
+    }
+    const args = [...buildGenerateCliArgs(extractSessionId, tokensPath), "--cache-status"];
+    if (restoreCache) args.push("--restore-cache");
+    const result = await runCli(args);
+    if (result.exitCode !== 0) {
+      finishWizardTimer("generation-cache-components", timer, {
+        status: "error",
+        exitCode: result.exitCode,
+        stderrTail: result.stderr.trim().slice(-500)
+      });
+      return /* @__PURE__ */ new Set();
+    }
+    const line = /^cache-components=(.+)$/m.exec(result.stdout)?.[1];
+    if (!line) {
+      finishWizardTimer("generation-cache-components", timer, {
+        status: "missing-output",
+        exitCode: result.exitCode,
+        cachedCount: 0
+      });
+      return /* @__PURE__ */ new Set();
+    }
+    try {
+      const names = JSON.parse(line);
+      const cachedNames = new Set(
+        Array.isArray(names) ? names.filter((name) => typeof name === "string") : []
+      );
+      finishWizardTimer("generation-cache-components", timer, {
+        status: "complete",
+        exitCode: result.exitCode,
+        cachedCount: cachedNames.size
+      });
+      return cachedNames;
+    } catch {
+      finishWizardTimer("generation-cache-components", timer, {
+        status: "invalid-output",
+        exitCode: result.exitCode,
+        cachedCount: 0
+      });
+      return /* @__PURE__ */ new Set();
+    }
+  };
+  useEffect15(() => {
+    if (state.step !== "extracting" && state.step !== "scope-gate" || !state.extractSessionId || state.existingEntitiesStatus === "running" || state.existingEntitiesStatus === "idle" || state.selectionAgentStatus !== "complete" || state.compositionPhase !== "done" || state.rawTokensPath && state.tokenGenerationStatus !== "complete" || effectiveNoCache) {
+      return;
+    }
+    const sessionId2 = state.extractSessionId;
+    if (generationCachePreflightRef.current?.sessionId === sessionId2) return;
+    const timer = startWizardTimer("generation-cache-preflight", { sessionId: sessionId2 });
+    const db = openPipelineDb();
+    let generatedNames = null;
+    try {
+      const rows = db.prepare("SELECT name, status FROM raw_components WHERE session_id = ?").all(sessionId2);
+      if (rows.length > 0 && rows.every((row) => row.status === "generated")) {
+        generatedNames = new Set(rows.map((row) => row.name));
+      }
+    } finally {
+      db.close();
+    }
+    if (generatedNames) {
+      generationCachePreflightRef.current = { sessionId: sessionId2, promise: Promise.resolve(generatedNames) };
+      finishWizardTimer("generation-cache-preflight", timer, {
+        status: "complete",
+        source: "session-db",
+        cachedCount: generatedNames.size
+      });
+      return;
+    }
+    const promise = checkGenerateCacheComponents(sessionId2, state.tokensPath, true);
+    generationCachePreflightRef.current = { sessionId: sessionId2, promise };
+    void promise.then((cachedNames) => {
+      finishWizardTimer("generation-cache-preflight", timer, {
+        status: "complete",
+        source: "cache-status",
+        cachedCount: cachedNames.size
+      });
+    });
+  }, [
+    state.step,
+    state.extractSessionId,
+    state.tokensPath,
+    state.rawTokensPath,
+    state.tokenGenerationStatus,
+    state.selectionAgentStatus,
+    state.compositionPhase,
+    state.existingEntitiesStatus,
+    state.existingEntitiesPath
+  ]);
   const startGeneratePrefetch = (extractSessionId, tokensPath) => {
     const args = buildGenerateArgs(extractSessionId, tokensPath);
     let progressCursor = null;
@@ -28067,13 +29074,14 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
     });
     return donePromise;
   };
-  const runGenerate = async (extractSessionId, tokensPath, acceptedCount, suppressScreen = false) => {
+  const runGenerate = async (extractSessionId, tokensPath, acceptedCount, suppressScreen = false, cachedComponents = []) => {
     const timer = startWizardTimer("component-generation", {
       sessionId: extractSessionId,
       acceptedCount,
-      suppressScreen
+      suppressScreen,
+      noCache: effectiveNoCache
     });
-    const args = buildGenerateArgs(extractSessionId, tokensPath, generatePromptPath);
+    const args = buildGenerateArgs(extractSessionId, tokensPath, generatePromptPath, cachedComponents);
     let progressCursor = state.generateProgress;
     const { donePromise } = spawnGenerateChild({
       command: "node",
@@ -28143,6 +29151,25 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
       finishSelectionToReviewTimer("error");
     }
   };
+  const finishCachedGeneration = async (sessionId2, acceptedCount) => {
+    if (await runMapTokens2(sessionId2, true)) {
+      finishSelectionToReviewTimer("cached");
+      update(
+        {
+          acceptedCount,
+          autoRejectedCount: 0,
+          generateSessionId: sessionId2,
+          generatedCount: acceptedCount,
+          generateProgress: null,
+          mapTokensStatus: "complete",
+          step: "final-review"
+        },
+        { clearScreen: false }
+      );
+    } else {
+      finishSelectionToReviewTimer("error");
+    }
+  };
   const advanceToPushFlow = (generatedAcceptedCount) => {
     update({ generatedAcceptedCount });
     void runSaveAndPush();
@@ -28327,8 +29354,14 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
         }
       }
       if (await runAgentAuthCheck("generating", true)) {
-        update({ step: "generating" });
-        void runGenerate(sid, state.tokensPath, state.acceptedCount);
+        const cacheHit = await checkGenerateCache(sid, state.tokensPath);
+        if (cacheHit) {
+          update({ step: "generating" });
+          void finishCachedGeneration(sid, state.acceptedCount);
+        } else {
+          update({ step: "generating" });
+          void runGenerate(sid, state.tokensPath, state.acceptedCount);
+        }
       }
       return;
     }
@@ -28692,7 +29725,7 @@ If using a custom host configuration, make sure the space exists on that host.`
       });
       return { ok: false };
     }
-    await new Promise((resolve20) => setTimeout(resolve20, SAVE_CONFIRMATION_DELAY_MS));
+    await new Promise((resolve21) => setTimeout(resolve21, SAVE_CONFIRMATION_DELAY_MS));
     update(nextStateAfterPrint({ skipGate: opts.skipGate, componentsPath }));
     return { ok: true };
   };
@@ -28769,6 +29802,12 @@ If using a custom host configuration, make sure the space exists on that host.`
       tokenReuseChecked.current = true;
       const tokenNextStep = state.projectPath ? "path-validation" : "credentials";
       const existingTokensPath = join23(state.outDir, "tokens.json");
+      if (effectiveNoCache) {
+        tokenGenerationPromiseRef.current = runAgentAuthCheck(tokenNextStep).then(
+          (ok2) => ok2 ? runGenerateTokens(state.rawTokensPath, state.outDir) : false
+        );
+        return;
+      }
       (async () => {
         try {
           await access7(existingTokensPath);
@@ -28852,7 +29891,7 @@ If using a custom host configuration, make sure the space exists on that host.`
               const tokenNextStep = state.projectPath ? "path-validation" : "credentials";
               update({ step: tokenNextStep });
               if (await runAgentAuthCheck(tokenNextStep)) {
-                tokenGenerationPromiseRef.current = runGenerateTokens(state.rawTokensPath, state.outDir);
+                tokenGenerationPromiseRef.current = runGenerateTokens(state.rawTokensPath, state.outDir, true);
               }
             },
             onQuit: () => process.exit(0)
@@ -28951,6 +29990,29 @@ If using a custom host configuration, make sure the space exists on that host.`
                   acceptedCount: decisions.accepted.length,
                   rejectedCount: decisions.rejected.length
                 }) : null;
+                const preflight = generationCachePreflightRef.current;
+                const cachePromise = preflight?.sessionId === sessionId2 ? preflight.promise : checkGenerateCacheComponents(sessionId2, state.tokensPath, true);
+                if (!preflight || preflight.sessionId !== sessionId2) {
+                  generationCachePreflightRef.current = { sessionId: sessionId2, promise: cachePromise };
+                }
+                const cacheWaitStartedAt = startWizardTimer("selection-cache-restoration-wait", {
+                  sessionId: sessionId2,
+                  preflight: Boolean(preflight?.sessionId === sessionId2)
+                });
+                try {
+                  const cachedNames = await cachePromise;
+                  finishWizardTimer("selection-cache-restoration-wait", cacheWaitStartedAt, {
+                    status: "complete",
+                    cachedCount: cachedNames.size
+                  });
+                } catch (error) {
+                  finishWizardTimer("selection-cache-restoration-wait", cacheWaitStartedAt, {
+                    status: "error",
+                    error: error instanceof Error ? error.message : String(error)
+                  });
+                  finishSelectionToReviewTimer("error");
+                  throw error;
+                }
                 await runScopeGate({
                   sessionId: sessionId2,
                   decisions,
@@ -28959,12 +30021,35 @@ If using a custom host configuration, make sure the space exists on that host.`
                     if (shouldGenerateAfterScopeGate({ acceptedCount })) {
                       const authPromise = runAgentAuthCheck("generating", true);
                       if (await authPromise) {
-                        update({
-                          step: "generating",
-                          generateProgress: null,
-                          acceptedCount
+                        const comparisonStartedAt = startWizardTimer("generation-cache-set-comparison", {
+                          sessionId: sid,
+                          acceptedCount: decisions?.accepted.length ?? 0
+                        });
+                        let cachedNames = await cachePromise;
+                        const acceptedNames = decisions?.accepted ?? [];
+                        let cacheHit = !effectiveNoCache && acceptedNames.length > 0 && acceptedNames.every((name) => cachedNames.has(name));
+                        if (!cacheHit && !effectiveNoCache && acceptedNames.length > 0) {
+                          cachedNames = await checkGenerateCacheComponents(sid, state.tokensPath, true);
+                          cacheHit = acceptedNames.every((name) => cachedNames.has(name));
+                        }
+                        finishWizardTimer("generation-cache-set-comparison", comparisonStartedAt, {
+                          status: "complete",
+                          cacheHit,
+                          cachedCount: cachedNames.size,
+                          acceptedCount: acceptedNames.length
                         });
-                        void runGenerate(sid, state.tokensPath, acceptedCount);
+                        if (cacheHit) {
+                          void finishCachedGeneration(sid, acceptedCount);
+                        } else {
+                          const acceptedNameSet = new Set(acceptedNames);
+                          const restoredCachedNames = [...cachedNames].filter((name) => acceptedNameSet.has(name));
+                          update({
+                            step: "generating",
+                            generateProgress: null,
+                            acceptedCount
+                          });
+                          void runGenerate(sid, state.tokensPath, acceptedCount, false, restoredCachedNames);
+                        }
                       } else {
                         finishSelectionToReviewTimer("error");
                       }
@@ -29330,7 +30415,7 @@ function registerImportCommand(program) {
     "Override a composition, selection, token, generation, or token-mapping prompt (repeatable). value is a file path or literal text, e.g. --prompt select=./p.md",
     (v, acc) => [...acc, v],
     []
-  ).action(async (opts) => {
+  ).option("--no-cache", "Re-run all steps even if output already exists").action(async (opts) => {
     const interactiveTerminalSupported = getInteractiveTerminalSupport().supported;
     if (opts.tokens !== void 0) {
       const { access: access9 } = await import("node:fs/promises");
@@ -29367,6 +30452,7 @@ function registerImportCommand(program) {
           ...resolvedModel ? { initialModel: resolvedModel } : {},
           initialProjectPath: opts.project !== "." ? normalizePath(opts.project) : void 0,
           ...buildCompositionForwardingOptions(opts),
+          noCache: opts.cache === false,
           skipMapTokens: false,
           livePreview: true,
           generatePromptPath: creds.generatePromptPath,
@@ -29454,7 +30540,7 @@ async function pathExists3(path) {
   return access8(path).then(() => true).catch(() => false);
 }
 function runSpawn(cmd, args, opts = {}) {
-  return new Promise((resolve20) => {
+  return new Promise((resolve21) => {
     const child = spawn6(cmd, args, {
       cwd: opts.cwd,
       env: opts.env ?? process.env,
@@ -29466,7 +30552,7 @@ function runSpawn(cmd, args, opts = {}) {
     const settle = (result) => {
       if (settled) return;
       settled = true;
-      resolve20(result);
+      resolve21(result);
     };
     child.on("error", (err) => settle({ exitCode: 1, stdout: "", stderr: err.message }));
     child.stdout.on("data", (d) => {
@@ -30667,13 +31753,13 @@ function PrerequisitesScreen({
     const driver = {
       ...base,
       emit: (event) => setEvents((current) => [...current, event]),
-      confirm: (question, defaultYes = true) => new Promise((resolve20) => {
+      confirm: (question, defaultYes = true) => new Promise((resolve21) => {
         setConfirm({
           question,
           defaultYes,
           resolve: (answer) => {
             setConfirm(null);
-            resolve20(answer);
+            resolve21(answer);
           }
         });
       })
@@ -30748,8 +31834,8 @@ function SetupScreen({
   useEffect21(() => {
     if (startedRef.current) return;
     startedRef.current = true;
-    const runScreen = (build) => new Promise((resolve20) => {
-      setScreen(build(resolve20));
+    const runScreen = (build) => new Promise((resolve21) => {
+      setScreen(build(resolve21));
     });
     void (async () => {
       const results = [];
@@ -31357,8 +32443,11 @@ var init_source_call_site_evidence = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/analyze/extract-command.ts
-import { mkdir as mkdir6, readdir as readdir3, readFile as readFile18, stat as stat6 } from "node:fs/promises";
-import { isAbsolute as isAbsolute2, join as join27, relative as relative2, resolve as resolve18 } from "node:path";
+import { mkdir as mkdir6, readdir as readdir3, readFile as readFile19, stat as stat6 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, join as join27, relative as relative2, resolve as resolve19 } from "node:path";
+function resolveExtractNoCache(opts) {
+  return opts.noCache === true || opts.cache === false;
+}
 function isDenylistedNoiseFile(name) {
   return DENYLISTED_EXACT_FILE_NAMES.has(name) || DENYLISTED_FILE_NAME_PATTERNS.some((pattern) => pattern.test(name));
 }
@@ -31372,12 +32461,12 @@ async function retryDatabaseWrite(operation, attempts = 8) {
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       if (!/database is locked|database is busy/i.test(message) || attempt >= attempts) throw error;
-      await new Promise((resolve20) => setTimeout(resolve20, Math.min(250 * attempt, 2e3)));
+      await new Promise((resolve21) => setTimeout(resolve21, Math.min(250 * attempt, 2e3)));
     }
   }
 }
 function resolveFromProjectRoot(projectRoot, inputPath) {
-  return isAbsolute2(inputPath) ? inputPath : resolve18(projectRoot, inputPath);
+  return isAbsolute2(inputPath) ? inputPath : resolve19(projectRoot, inputPath);
 }
 async function pathExists4(path) {
   return Boolean(await stat6(path).catch(() => null));
@@ -31424,7 +32513,7 @@ async function readCandidateFiles(components, extraFiles = []) {
   await Promise.all(
     [...paths].map(async (p) => {
       try {
-        const content = await readFile18(p, "utf8");
+        const content = await readFile19(p, "utf8");
         out.push({ path: p, content });
       } catch {
       }
@@ -31437,7 +32526,8 @@ function registerInternalExtractCommand(program) {
     "--resolve-unreachable <mode>",
     "Retry pass for unresolved Svelte Props types: 'auto' (default), 'always', or 'never'",
     "auto"
-  ).action(async (opts) => {
+  ).option("--no-cache", "Re-run extraction even when all source files are unchanged").action(async (opts) => {
+    const noCache = resolveExtractNoCache(opts);
     const resolveUnreachable = (() => {
       const v = opts.resolveUnreachable ?? "auto";
       if (v !== "auto" && v !== "always" && v !== "never") {
@@ -31447,7 +32537,7 @@ function registerInternalExtractCommand(program) {
       }
       return v;
     })();
-    const projectRoot = resolve18(opts.project);
+    const projectRoot = resolve19(opts.project);
     const outDir = join27(projectRoot, ".contentful");
     let sourceDirectory;
     if (opts.dir !== void 0) {
@@ -31471,16 +32561,50 @@ function registerInternalExtractCommand(program) {
       process.stderr.write(`progress=scan-done:${sourceFiles.length}
 `);
     }
-    const extraction = await extractComponents(
-      sourceFiles,
-      ({ filesProcessed, componentsFound }) => {
+    const extractionCacheDb = openPipelineDb();
+    let extraction;
+    let extractionCacheHits = 0;
+    try {
+      const cacheVersion = await getCliCacheVersion();
+      const cachedByPath = /* @__PURE__ */ new Map();
+      if (!noCache && sourceFiles.length > 0) {
+        const hashes = await Promise.all(
+          sourceFiles.map(async (filePath) => [filePath, await hashFile(filePath)])
+        );
+        for (const [filePath, fileHash] of hashes) {
+          cachedByPath.set(filePath, lookupExtractCache(extractionCacheDb, fileHash, cacheVersion));
+        }
+      }
+      const allFilesCached = !noCache && sourceFiles.length > 0 && sourceFiles.every((filePath) => cachedByPath.get(filePath) !== null);
+      if (allFilesCached) {
+        const cachedComponents = sourceFiles.flatMap((filePath) => cachedByPath.get(filePath).components);
+        extractionCacheHits = sourceFiles.length;
+        extraction = { components: cachedComponents, warnings: [], exclusions: [] };
         if (!process.stdout.isTTY) {
-          process.stderr.write(`progress=extract:${filesProcessed}/${sourceFiles.length}:${componentsFound}
-`);
+          process.stderr.write(
+            `progress=extract:${sourceFiles.length}/${sourceFiles.length}:${cachedComponents.length}
+`
+          );
         }
-      },
-      { resolveUnreachable, projectRoot }
-    );
+        getDebugLogger().event("analyze", "extract.cache-hit", {
+          files: sourceFiles.length,
+          components: cachedComponents.length
+        });
+      } else {
+        extraction = await extractComponents(
+          sourceFiles,
+          ({ filesProcessed, componentsFound }) => {
+            if (!process.stdout.isTTY) {
+              process.stderr.write(`progress=extract:${filesProcessed}/${sourceFiles.length}:${componentsFound}
+`);
+            }
+          },
+          { resolveUnreachable, projectRoot }
+        );
+      }
+    } finally {
+      extractionCacheDb.close();
+    }
     await mkdir6(outDir, { recursive: true });
     const db = openPipelineDb();
     const { sessionId: sessionId2 } = getOrCreateSession(db, void 0, void 0, {
@@ -31495,6 +32619,25 @@ function registerInternalExtractCommand(program) {
     const stepId = createStep(db, sessionId2, "analyze extract", {
       project: projectRoot
     });
+    if (extractionCacheHits === 0 && !noCache) {
+      const cacheVersion = await getCliCacheVersion();
+      const componentsBySourcePath = /* @__PURE__ */ new Map();
+      for (const component of extraction.components) {
+        if (!component.sourcePath) continue;
+        const components = componentsBySourcePath.get(component.sourcePath) ?? [];
+        components.push(component);
+        componentsBySourcePath.set(component.sourcePath, components);
+      }
+      for (const filePath of sourceFiles) {
+        storeExtractCache(
+          db,
+          filePath,
+          await hashFile(filePath),
+          cacheVersion,
+          componentsBySourcePath.get(filePath) ?? []
+        );
+      }
+    }
     const classifiedComponents = extraction.components.map(preClassifyComponent);
     for (const exclusion of extraction.exclusions ?? []) {
       getDebugLogger().event("filter", "extract.excluded", { ...exclusion });
@@ -31599,6 +32742,7 @@ var init_extract_command = __esm({
     "use strict";
     init_src2();
     init_db();
+    init_cache_keys();
     init_cycle_detection();
     init_resolve_mapping();
     init_manifest_doc_evidence();
@@ -31697,7 +32841,7 @@ __export(program_exports, {
 });
 import { spawn as spawn7 } from "node:child_process";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
-import { dirname as dirname18, join as join28, resolve as resolve19 } from "node:path";
+import { dirname as dirname18, join as join28, resolve as resolve20 } from "node:path";
 import { readFileSync as readFileSync10 } from "node:fs";
 import { Command } from "commander";
 async function runBuild(opts) {
@@ -31727,7 +32871,7 @@ function resolveBedrockFromAncestors(actionCommand) {
 }
 function registerBuildCommand(program) {
   program.command("build").description("Rebuild from source and re-link exo/experiences binaries to this build").helpOption(false).action(async () => {
-    const pkgRoot = resolve19(dirname18(fileURLToPath3(import.meta.url)), "..", "..");
+    const pkgRoot = resolve20(dirname18(fileURLToPath3(import.meta.url)), "..", "..");
     process.stderr.write("\u2699  Building from source...\n");
     const { exitCode } = await runBuild({
       spawnFn: () => spawn7("pnpm", ["build"], { cwd: pkgRoot, stdio: "inherit" }),