@contentful/experience-design-system-cli 2.35.1-dev-build-b8da2525.0 → 2.35.1-dev-build-5446cce7.0

package/legacy/dist/src/index.js

@@ -164,18 +164,11 @@ var init_render_with_goodbye = __esm({
 function isAgentName(value) {
   return AGENT_NAMES.includes(value);
 }
-var AGENT_NAMES, DEFAULT_AGENT_NAME, AGENT_BINARIES;
+var AGENT_NAMES, 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_NAMES = ["claude", "codex", "opencode", "cursor", "copilot"];
     AGENT_BINARIES = {
       claude: "claude",
       codex: "codex",
@@ -187,23 +180,6 @@ 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";
@@ -636,17 +612,6 @@ 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";
@@ -690,12 +655,7 @@ function resolveAgentModel(agent, explicit, bedrock = false) {
 }
 function codexBedrockConfigArgs() {
   const region = process.env.AWS_REGION?.trim() || process.env.AWS_DEFAULT_REGION?.trim() || DEFAULT_CODEX_BEDROCK_REGION;
-  return [
-    "-c",
-    "model_provider=amazon-bedrock",
-    "-c",
-    `model_providers.amazon-bedrock.region=${region}`
-  ];
+  return ["-c", "model_provider=amazon-bedrock", "-c", `model_providers.amazon-bedrock.region=${region}`];
 }
 function buildAgentArgs(agent, prompt, model, promptViaStdin = false, bedrock = false) {
   const resolvedModel = resolveAgentModel(agent, model, bedrock);
@@ -706,13 +666,7 @@ function buildAgentArgs(agent, prompt, model, promptViaStdin = false, bedrock =
       return ["--print", ...modelArg, ...promptArg];
     case "codex": {
       const bedrockArgs = bedrock ? codexBedrockConfigArgs() : [];
-      return [
-        "exec",
-        ...bedrockArgs,
-        ...modelArg,
-        "--dangerously-bypass-approvals-and-sandbox",
-        ...promptArg
-      ];
+      return ["exec", ...bedrockArgs, ...modelArg, "--dangerously-bypass-approvals-and-sandbox", ...promptArg];
     }
     case "opencode":
       return ["run", ...modelArg, ...promptArg];
@@ -732,11 +686,7 @@ var init_build_agent_args = __esm({
     BEDROCK_ENV_BY_AGENT = {
       claude: { CLAUDE_CODE_USE_BEDROCK: "1" }
     };
-    BEDROCK_CAPABLE_AGENTS = /* @__PURE__ */ new Set([
-      "claude",
-      "codex",
-      "opencode"
-    ]);
+    BEDROCK_CAPABLE_AGENTS = /* @__PURE__ */ new Set(["claude", "codex", "opencode"]);
     DEFAULT_CODEX_BEDROCK_REGION = "us-east-1";
     DEFAULT_OPENCODE_MODEL = "claude-haiku-4-5";
     DEFAULT_CODEX_BEDROCK_MODEL = "openai.gpt-5.6-luna";
@@ -762,22 +712,6 @@ 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";
@@ -802,7 +736,7 @@ async function runAgent(options) {
     promptLen: prompt.length,
     promptHead: prompt.slice(0, 500)
   });
-  return new Promise((resolve21) => {
+  return new Promise((resolve20) => {
     const bedrockEnv = bedrock ? BEDROCK_ENV_BY_AGENT[agent] : void 0;
     const child = spawn(binary, args, {
       stdio: ["pipe", "pipe", "pipe"],
@@ -851,7 +785,7 @@ async function runAgent(options) {
         stderrLen: stderr.length,
         stderrTail: stderr.slice(-1e3)
       });
-      resolve21(result);
+      resolve20(result);
     });
   });
 }
@@ -868,7 +802,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((resolve21) => {
+  return new Promise((resolve20) => {
     const child = spawn2(binary, ["auth", "status", "--json"], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -878,7 +812,7 @@ function checkClaudeAuth(binary) {
       if (!done) {
         done = true;
         child.kill("SIGTERM");
-        resolve21("unauthenticated");
+        resolve20("unauthenticated");
       }
     }, 5e3);
     child.stdout?.on("data", (chunk) => {
@@ -890,14 +824,14 @@ function checkClaudeAuth(binary) {
       done = true;
       clearTimeout(timer);
       if (code !== 0) {
-        resolve21("unauthenticated");
+        resolve20("unauthenticated");
         return;
       }
       try {
         const status = JSON.parse(stdout);
-        resolve21(status.loggedIn ? "ok" : "unauthenticated");
+        resolve20(status.loggedIn ? "ok" : "unauthenticated");
       } catch {
-        resolve21("unauthenticated");
+        resolve20("unauthenticated");
       }
     });
   });
@@ -912,13 +846,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((resolve21) => {
+  const binaryExists2 = await new Promise((resolve20) => {
     if (binary.startsWith("/")) {
-      import("node:fs/promises").then((fs2) => fs2.access(binary).then(() => resolve21(true), () => resolve21(false)));
+      import("node:fs/promises").then((fs2) => fs2.access(binary).then(() => resolve20(true), () => resolve20(false)));
       return;
     }
     const child = spawn3(process.platform === "win32" ? "where" : "which", [binary], { stdio: "ignore" });
-    child.on("close", (code) => resolve21(code === 0));
+    child.on("close", (code) => resolve20(code === 0));
   });
   if (!binaryExists2)
     return "not-found";
@@ -955,20 +889,6 @@ 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";
@@ -1128,20 +1048,8 @@ var init_parse_prop_tool_calls = __esm({
   "packages/experience-design-system-generation/dist/src/services/parsing/parse-prop-tool-calls.js"() {
     "use strict";
     init_read_tool_call_objects();
-    VALID_TOOL_NAMES = /* @__PURE__ */ new Set([
-      "classify_prop",
-      "exclude_prop",
-      "classify_component",
-      "classify_slot"
-    ]);
-    VALID_CDF_TYPES = /* @__PURE__ */ new Set([
-      "string",
-      "richtext",
-      "media",
-      "enum",
-      "token",
-      "boolean"
-    ]);
+    VALID_TOOL_NAMES = /* @__PURE__ */ new Set(["classify_prop", "exclude_prop", "classify_component", "classify_slot"]);
+    VALID_CDF_TYPES = /* @__PURE__ */ new Set(["string", "richtext", "media", "enum", "token", "boolean"]);
     VALID_CATEGORIES = /* @__PURE__ */ new Set(["content", "design", "state"]);
   }
 });
@@ -1249,10 +1157,7 @@ var init_parse_select_tool_calls = __esm({
     "use strict";
     init_parse_selection_slot_evidence();
     init_read_tool_call_objects();
-    VALID_SELECT_TOOL_NAMES = /* @__PURE__ */ new Set([
-      "select_component",
-      "reject_component"
-    ]);
+    VALID_SELECT_TOOL_NAMES = /* @__PURE__ */ new Set(["select_component", "reject_component"]);
   }
 });
 
@@ -1368,32 +1273,6 @@ 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";
@@ -9676,8 +9555,11 @@ var init_debug_logger = __esm({
 
 // packages/experience-design-system-cli-legacy/src/lib/prop-bucket-debug.ts
 function logPropBuckets(stage, assignments) {
-  for (const assignment of assignments) {
-    getDebugLogger().event("analyze", `prop-buckets.${stage}`, { ...assignment });
+  const logger = getDebugLogger();
+  if (logger.enabled) {
+    for (const assignment of assignments) {
+      logger.event("analyze", `prop-buckets.${stage}`, { ...assignment });
+    }
   }
   return JSON.stringify(assignments.length === 1 && stage === "generate" ? assignments[0] : assignments);
 }
@@ -10426,41 +10308,6 @@ 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);
@@ -10624,47 +10471,17 @@ 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 readFile8 } from "node:fs/promises";
-import { createHash as createHash5 } from "node:crypto";
+import { readFile as readFile7 } from "node:fs/promises";
 import { homedir as homedir3 } from "node:os";
-import { dirname as dirname14, resolve as resolve9 } from "node:path";
+import { dirname as dirname14, resolve as resolve8 } from "node:path";
 function getPipelineDbPath() {
   if (process.env.EDS_PIPELINE_DB_PATH) {
-    return resolve9(process.env.EDS_PIPELINE_DB_PATH);
+    return resolve8(process.env.EDS_PIPELINE_DB_PATH);
   }
-  return resolve9(homedir3(), ".contentful", "experience-design-system-cli", "pipeline.db");
+  return resolve8(homedir3(), ".contentful", "experience-design-system-cli", "pipeline.db");
 }
 function openPipelineDb(dbPath) {
   const path = dbPath ?? getPipelineDbPath();
@@ -10717,7 +10534,6 @@ function applyDbMigrations(db) {
   }
   if (!rawPropColNames.has("dom_attribute")) {
     db.exec("ALTER TABLE raw_props ADD COLUMN dom_attribute INTEGER CHECK (dom_attribute IN (0, 1))");
-    rawPropColNames.add("dom_attribute");
   }
   const rawPropsDdl = db.prepare(`SELECT sql FROM sqlite_master WHERE type = 'table' AND name = 'raw_props'`).get();
   if (rawPropsDdl && !rawPropsDdl.sql.includes(`'unattached'`)) {
@@ -10799,134 +10615,8 @@ function applyDbMigrations(db) {
   if (!rawSlotColsForRationale.some((c2) => c2.name === "rationale")) {
     db.exec("ALTER TABLE raw_slots ADD COLUMN rationale TEXT");
   }
-  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)
-      );
-    `);
+  for (const table of REMOVED_CACHE_TABLES) {
+    db.exec(`DROP TABLE IF EXISTS ${table}`);
   }
 }
 function loadComponentReviewMetadata(db, sessionId2, componentName) {
@@ -11462,16 +11152,16 @@ function extractRelativeImportPaths(sourceText) {
   return [...specifiers];
 }
 async function resolveRelativeImport(specifier, fromDir) {
-  const basePath = resolve9(fromDir, specifier);
+  const basePath = resolve8(fromDir, specifier);
   const candidates = [
     basePath,
     ...rewrittenSourcePaths(basePath),
     ...SIBLING_FILE_EXTENSIONS.map((ext) => `${basePath}${ext}`),
-    ...SIBLING_FILE_EXTENSIONS.map((ext) => resolve9(basePath, `index${ext}`))
+    ...SIBLING_FILE_EXTENSIONS.map((ext) => resolve8(basePath, `index${ext}`))
   ];
   for (const candidate of candidates) {
     try {
-      await readFile8(candidate, "utf8");
+      await readFile7(candidate, "utf8");
       return candidate;
     } catch {
     }
@@ -11487,7 +11177,7 @@ async function resolveImportSpecifiers(sourceText, fromDir) {
   return resolvedPaths;
 }
 async function loadSiblingFiles(sourceText, sourcePath, propNames, candidateTypeNames = []) {
-  const visited = /* @__PURE__ */ new Set([resolve9(sourcePath)]);
+  const visited = /* @__PURE__ */ new Set([resolve8(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++) {
@@ -11501,7 +11191,7 @@ async function loadSiblingFiles(sourceText, sourcePath, propNames, candidateType
         if (discovered.length >= MAX_SIBLING_CANDIDATES_EXPLORED) break;
         let content;
         try {
-          content = await readFile8(resolvedPath, "utf8");
+          content = await readFile7(resolvedPath, "utf8");
         } catch {
           continue;
         }
@@ -11538,7 +11228,7 @@ async function loadComponentSourceRef(name, sourcePath, propNames = [], propType
   let truncatedSiblingCount = 0;
   const usesNotShown = /* @__PURE__ */ new Set();
   try {
-    const rawText = await readFile8(sourcePath, "utf8");
+    const rawText = await readFile7(sourcePath, "utf8");
     let siblingUsesNotShown;
     let declaredTypeNames;
     ({
@@ -11974,108 +11664,6 @@ 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 {
@@ -12158,105 +11746,7 @@ function filterUnknownSlotAllowedComponents(db, sessionId2, allowedComponentName
   }
   return unknown;
 }
-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) {
+function copyTokensBetweenSessions(db, sourceSessionId, targetSessionId) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   db.exec("BEGIN");
   try {
@@ -12277,139 +11767,7 @@ function copyTokensFromCache(db, sourceSessionId, targetSessionId) {
     throw e;
   }
 }
-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 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;
 var init_db = __esm({
   "packages/experience-design-system-cli-legacy/src/session/db.ts"() {
     "use strict";
@@ -12423,8 +11781,6 @@ 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();
@@ -12548,17 +11904,6 @@ 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,
@@ -12604,10 +11949,9 @@ 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;
@@ -12624,16 +11968,15 @@ 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 readFile9 } from "node:fs/promises";
+import { readFile as readFile8 } from "node:fs/promises";
 async function readExistingContentfulEntitiesFromSession(path) {
   if (!path) return void 0;
   try {
-    const raw = await readFile9(path, "utf8");
+    const raw = await readFile8(path, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.components) || !Array.isArray(parsed.tokens)) return void 0;
     return parsed;
@@ -12757,21 +12100,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 readFile10, writeFile as writeFile2 } from "node:fs/promises";
+import { access, appendFile, mkdir as mkdir2, readFile as readFile9, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
-import { resolve as resolve10 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 function getRefineArtifactsRoot() {
   if (process.env.EDS_REVIEW_ARTIFACTS_DIR) {
-    return resolve10(process.env.EDS_REVIEW_ARTIFACTS_DIR);
+    return resolve9(process.env.EDS_REVIEW_ARTIFACTS_DIR);
   }
-  return resolve10(homedir4(), ".contentful", "experience-design-system-cli", "reviews");
+  return resolve9(homedir4(), ".contentful", "experience-design-system-cli", "reviews");
 }
 async function getRefineSessionPaths(sessionId2, artifactsRoot) {
-  const sessionDir = resolve10(artifactsRoot, sessionId2);
+  const sessionDir = resolve9(artifactsRoot, sessionId2);
   return {
     sessionDir,
-    eventsPath: resolve10(sessionDir, "events.jsonl"),
-    statePath: resolve10(sessionDir, "current-review-state.json")
+    eventsPath: resolve9(sessionDir, "events.jsonl"),
+    statePath: resolve9(sessionDir, "current-review-state.json")
   };
 }
 async function saveReviewState(statePath, session) {
@@ -12782,7 +12125,7 @@ async function ensureRefineSession(sessionId2, artifactsRoot, initialSnapshot) {
   await mkdir2(paths.sessionDir, { recursive: true });
   try {
     await access(paths.statePath);
-    const savedState = await readFile10(paths.statePath, "utf8");
+    const savedState = await readFile9(paths.statePath, "utf8");
     return JSON.parse(savedState);
   } catch {
     await writeFile2(paths.statePath, JSON.stringify(initialSnapshot, null, 2), "utf8");
@@ -13267,8 +12610,8 @@ var init_path_exists = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/lib/prompt-overrides.ts
-import { readFile as readFile11 } from "node:fs/promises";
-import { resolve as resolve11 } from "node:path";
+import { readFile as readFile10 } from "node:fs/promises";
+import { resolve as resolve10 } from "node:path";
 function looksLikePath(value) {
   if (value.includes("/") || value.includes("\\")) return true;
   if (value.startsWith("~")) return true;
@@ -13300,9 +12643,9 @@ function parsePromptOverrides(inputs) {
 }
 async function resolvePromptOverride(override) {
   if (override.kind === "text") return override.value;
-  const abs = resolve11(override.value);
+  const abs = resolve10(override.value);
   try {
-    return await readFile11(abs, "utf8");
+    return await readFile10(abs, "utf8");
   } catch {
     throw new Error(`--prompt: could not read prompt file: ${abs}`);
   }
@@ -13317,21 +12660,21 @@ var init_prompt_overrides = __esm({
 
 // packages/experience-design-system-cli-legacy/src/generate/command.ts
 import { createElement } from "react";
-import { readFile as readFile12, readdir, stat } from "node:fs/promises";
-import { join as join14, resolve as resolve12 } from "node:path";
+import { readFile as readFile11, readdir, stat } from "node:fs/promises";
+import { join as join14, resolve as resolve11 } 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 = resolve12(path);
+  const resolved = resolve11(path);
   let s;
   try {
     s = await stat(resolved);
   } catch {
     return void 0;
   }
-  if (!s.isDirectory()) return readFile12(resolved, "utf8");
+  if (!s.isDirectory()) return readFile11(resolved, "utf8");
   const files = [];
   async function walk(dir) {
     let entries;
@@ -13357,7 +12700,7 @@ async function readFileInline(path) {
   }
   await walk(resolved);
   if (files.length === 0) return void 0;
-  const parts = await Promise.all(files.map((f) => readFile12(f, "utf8").catch(() => "")));
+  const parts = await Promise.all(files.map((f) => readFile11(f, "utf8").catch(() => "")));
   return parts.filter(Boolean).join("\n\n");
 }
 function printFallbackInstructions(options) {
@@ -13379,22 +12722,8 @@ 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}
-`);
+function generatePropBuckets(component) {
+  return logPropBuckets("generate", [bucketComponentProps(component)]);
 }
 async function showGenerateView(result) {
   if (process.stdout.isTTY) {
@@ -13416,29 +12745,6 @@ 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,
@@ -13448,13 +12754,10 @@ 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}]`);
@@ -13479,40 +12782,6 @@ 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 rawComponentsInline = JSON.stringify(
     [
       {
@@ -13537,7 +12806,7 @@ async function runOneComponent(options, component, index, total) {
     skill: "components",
     mode: "autonomous",
     rawComponentsInline,
-    propBucketsInline: logPropBuckets("generate", [bucketComponentProps(component)]),
+    propBucketsInline: generatePropBuckets(component),
     tokensInline,
     tokenMapInline,
     outDir: process.cwd(),
@@ -13585,10 +12854,6 @@ ${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,
@@ -13640,7 +12905,7 @@ async function loadAcceptedNames(sessionId2) {
   try {
     const artifactsRoot = getRefineArtifactsRoot();
     const paths = await getRefineSessionPaths(sessionId2, artifactsRoot);
-    const raw = await readFile12(paths.statePath, "utf8");
+    const raw = await readFile11(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;
@@ -13649,15 +12914,6 @@ 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;
@@ -13686,8 +12942,8 @@ async function runGenerateSkill(skill, opts, verbose = false) {
   }
   const generatePromptPath = generatePrompt === void 0 ? configuredGeneratePromptPath : void 0;
   if (generatePromptPath) {
-    if (!await pathExists(resolve12(generatePromptPath))) {
-      die(`Error: custom prompt path not found: ${resolve12(generatePromptPath)}`);
+    if (!await pathExists(resolve11(generatePromptPath))) {
+      die(`Error: custom prompt path not found: ${resolve11(generatePromptPath)}`);
     }
     if (!generatePromptPath.toLowerCase().endsWith(".md")) {
       process.stderr.write(
@@ -13695,7 +12951,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
 `
       );
     }
-    process.stderr.write(formatCustomPromptBanner("components", resolve12(generatePromptPath)));
+    process.stderr.write(formatCustomPromptBanner("components", resolve11(generatePromptPath)));
   }
   if (skill === "tokens" && !opts.rawTokens) {
     die("Error: --raw-tokens is required when using generate tokens");
@@ -13711,7 +12967,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
   let existingContentfulEntities;
   let existingTokensInline;
   if (opts.existingEntitiesPath) {
-    existingContentfulEntities = await readExistingContentfulEntitiesFromSession(resolve12(opts.existingEntitiesPath));
+    existingContentfulEntities = await readExistingContentfulEntitiesFromSession(resolve11(opts.existingEntitiesPath));
     if (existingContentfulEntities) {
       existingTokensInline = JSON.stringify(summarizeForMapTokens(existingContentfulEntities));
     } else {
@@ -13808,9 +13064,9 @@ async function runGenerateSkill(skill, opts, verbose = false) {
       skill,
       mode: "autonomous",
       rawComponentsInline: sampleInline ?? rawTokensInline,
-      propBucketsInline: sampleComponent ? logPropBuckets("generate", [bucketComponentProps(sampleComponent)]) : void 0,
+      propBucketsInline: sampleComponent ? generatePropBuckets(sampleComponent) : void 0,
       rawTokensInline: skill === "tokens" ? rawTokensInline : void 0,
-      rawTokensFilename: opts.rawTokens ? resolve12(opts.rawTokens).split("/").pop() : void 0,
+      rawTokensFilename: opts.rawTokens ? resolve11(opts.rawTokens).split("/").pop() : void 0,
       tokensInline,
       tokenMapInline,
       outDir: process.cwd(),
@@ -13836,64 +13092,7 @@ 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,
@@ -13903,13 +13102,10 @@ 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
@@ -13918,8 +13114,7 @@ async function runGenerateSkill(skill, opts, verbose = false) {
       db.close();
     }
     const failed = componentResults.filter((r) => r.failed);
-    const cachedResults = componentResults.filter((r) => r.cached);
-    const generated = componentResults.filter((r) => !r.failed && !r.cached);
+    const generated = componentResults.filter((r) => !r.failed);
     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");
@@ -13935,21 +13130,17 @@ 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 + cachedResults.length}/${componentResults.length} components` + cachedNote + c.dim(`  ${totalClassified} classified, ${totalExcluded} unattached`) + "\n"
+      (allOk ? c.green("\u2713") : c.yellow("\u26A0")) + `  ${generated.length}/${componentResults.length} components` + c.dim(`  ${totalClassified} classified, ${totalExcluded} unattached`) + "\n"
     );
     process.stdout.write(`renamed-slots: ${totalRenamedSlots}
 `);
-    if (generated.length === 0 && cachedResults.length === 0) {
+    if (generated.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;
@@ -13976,26 +13167,11 @@ 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 ? resolve12(opts.rawTokens).split("/").pop() : void 0,
+        rawTokensFilename: opts.rawTokens ? resolve11(opts.rawTokens).split("/").pop() : void 0,
         tokensInline,
         tokenMapInline,
         outDir: process.cwd()
@@ -14032,9 +13208,6 @@ ${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
@@ -14046,10 +13219,7 @@ ${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").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."
-  );
+  return addAgentModelOptions(cmd).option("--verbose", "Show full agent output including reasoning text").option("--dry-run", "Print the prompt without invoking the agent");
 }
 function registerInternalGenerateCommand(program) {
   const generate = program.command("__generate", { hidden: true }).description("Internal import pipeline generation command");
@@ -14065,12 +13235,6 @@ 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);
   });
@@ -14098,7 +13262,6 @@ 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();
@@ -14814,7 +13977,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((resolve21) => setTimeout(resolve21, delayMs));
+  return new Promise((resolve20) => setTimeout(resolve20, delayMs));
 }
 function isTransientStatus(status) {
   return status >= 500 && status <= 599;
@@ -15204,7 +14367,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((resolve21) => setTimeout(resolve21, baseDelay + jitter));
+            await new Promise((resolve20) => setTimeout(resolve20, baseDelay + jitter));
           }
         }
         throw new Error(`Operation ${operationId} timed out after ${maxAttempts} attempts`);
@@ -16014,7 +15177,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 readFile13, readdir as readdir2, stat as stat2 } from "node:fs/promises";
+import { readFile as readFile12, readdir as readdir2, stat as stat2 } from "node:fs/promises";
 import { join as join16 } from "node:path";
 import {
   validateCDF,
@@ -16035,7 +15198,7 @@ function dieWithApiError(error) {
 async function readJsonFile(flag, p) {
   let text;
   try {
-    text = await readFile13(p, "utf8");
+    text = await readFile12(p, "utf8");
   } catch {
     return await die2(`Error: file not found: ${p} (from ${flag})`);
   }
@@ -16089,7 +15252,7 @@ async function readTokensFromPath(flag, p) {
     for (const file of files.sort()) {
       let text;
       try {
-        text = await readFile13(file, "utf8");
+        text = await readFile12(file, "utf8");
       } catch {
         continue;
       }
@@ -16458,11 +15621,11 @@ var init_command2 = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/print/validate/validators/read-json-file.ts
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile13 } from "node:fs/promises";
 async function readJsonFile2(filePath) {
   let content;
   try {
-    content = await readFile14(filePath, "utf-8");
+    content = await readFile13(filePath, "utf-8");
   } catch (err) {
     return {
       ok: false,
@@ -16873,7 +16036,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 resolve13 } from "node:path";
+import { basename as basename5, resolve as resolve12 } from "node:path";
 import { CDF_SCHEMA_URL } from "@contentful/experience-design-system-types";
 async function die3(message) {
   process.stderr.write(`${message}
@@ -16940,7 +16103,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 = resolve13(opts.out);
+    const outPath = resolve12(opts.out);
     await assertOutIsNotDirectory(outPath);
     const sessionId2 = await resolveSession(opts.session, "generate components");
     await bindAnalyticsSessionId(sessionId2);
@@ -16988,7 +16151,7 @@ function registerPrintCommand(program) {
 `
       );
     }
-    await mkdir3(resolve13(outPath, ".."), { recursive: true });
+    await mkdir3(resolve12(outPath, ".."), { recursive: true });
     await writeFile3(outPath, `${JSON.stringify(cdfObj, null, 2)}
 `);
     process.stdout.write(
@@ -16997,7 +16160,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 = resolve13(opts.out);
+    const outPath = resolve12(opts.out);
     await assertOutIsNotDirectory(outPath);
     const sessionId2 = await resolveSession(opts.session, "generate tokens");
     await bindAnalyticsSessionId(sessionId2);
@@ -17012,7 +16175,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(resolve13(outPath, ".."), { recursive: true });
+    await mkdir3(resolve12(outPath, ".."), { recursive: true });
     await writeFile3(outPath, `${JSON.stringify(tree, null, 2)}
 `);
     process.stdout.write(
@@ -17161,7 +16324,7 @@ function MapTokensView({ result, onExit }) {
     const timer = setTimeout(onExit, 100);
     return () => clearTimeout(timer);
   }, [onExit]);
-  const summary = result.cached ? "reused from cache" : `${result.applied} mapping${result.applied === 1 ? "" : "s"} applied`;
+  const summary = `${result.applied} mapping${result.applied === 1 ? "" : "s"} applied`;
   return /* @__PURE__ */ jsx8(
     CommandCompletionView,
     {
@@ -17295,8 +16458,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 readFile15 } from "node:fs/promises";
-import { resolve as resolve14 } from "node:path";
+import { readFile as readFile14 } from "node:fs/promises";
+import { resolve as resolve13 } from "node:path";
 async function renderResult(result) {
   if (process.stdout.isTTY) {
     const { waitUntilExit } = renderWithGoodbye(
@@ -17304,12 +16467,13 @@ async function renderResult(result) {
     );
     await waitUntilExit();
   } else {
-    const summary = result.cached ? "cached" : `${result.applied} mapping(s) applied`;
-    process.stdout.write(`map tokens complete
+    process.stdout.write(
+      `map tokens complete
 agent: ${result.agent}
 session=${result.sessionId}
-${summary}
-`);
+${result.applied} mapping(s) applied
+`
+    );
     await exitWithAnalytics(0);
   }
 }
@@ -17331,7 +16495,7 @@ async function runMapTokens(opts) {
   let mapPromptPath;
   if (mapPromptOverride?.kind === "text") mapPromptText = mapPromptOverride.value;
   if (mapPromptOverride?.kind === "path") {
-    mapPromptPath = resolve14(mapPromptOverride.value);
+    mapPromptPath = resolve13(mapPromptOverride.value);
     try {
       await resolvePromptOverride(mapPromptOverride);
     } catch (error) {
@@ -17351,7 +16515,7 @@ async function runMapTokens(opts) {
     const knownTokenPaths = new Set(tokenLeaves.map((t) => t.path));
     const tokenMapDiagnostics = [];
     if (opts.tokenMap) {
-      const fileMappings = JSON.parse(await readFile15(opts.tokenMap, "utf8"));
+      const fileMappings = JSON.parse(await readFile14(opts.tokenMap, "utf8"));
       const validMappings = {};
       for (const [rawName, path] of Object.entries(fileMappings)) {
         if (knownTokenPaths.has(path)) {
@@ -17429,7 +16593,7 @@ ${defaultDiagnostics.map((diagnostic) => `  ${diagnostic}`).join("\n")}
     let existingTokensInline;
     if (opts.existingEntitiesPath) {
       const existingContentfulEntities = await readExistingContentfulEntitiesFromSession(
-        resolve14(opts.existingEntitiesPath)
+        resolve13(opts.existingEntitiesPath)
       );
       if (existingContentfulEntities) {
         existingTokensInline = JSON.stringify(summarizeForMapTokens(existingContentfulEntities));
@@ -17464,30 +16628,10 @@ ${defaultDiagnostics.map((diagnostic) => `  ${diagnostic}`).join("\n")}
         skipAgent: "true"
       });
       updateStep(db, stepId2, "complete", { applied: "0", skipAgent: "true" });
-      await renderResult({ agent: resultAgent, sessionId: sessionId2, applied: 0, cached: false });
+      await renderResult({ agent: resultAgent, sessionId: sessionId2, applied: 0 });
       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(
@@ -17507,23 +16651,20 @@ 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, cached: false });
+    await renderResult({ agent, sessionId: sessionId2, applied });
   } 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("--no-cache", "Bypass the map-tokens cache and force a re-run").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(
     "--prompt <stage=value>",
     "Override a stage prompt (repeatable). Used here for the map-tokens stage.",
     (v, acc) => [...acc, v],
@@ -17543,7 +16684,6 @@ 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();
@@ -17560,7 +16700,7 @@ var init_command4 = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/import/path-utils.ts
-import { resolve as resolve15 } from "node:path";
+import { resolve as resolve14 } from "node:path";
 import { homedir as homedir5 } from "node:os";
 function expandTilde(input) {
   if (input === "~" || input.startsWith("~/") || input.startsWith("~\\")) {
@@ -17574,7 +16714,7 @@ function normalizePath(input) {
     p = p.slice(1, -1);
   }
   p = expandTilde(p);
-  return resolve15(p);
+  return resolve14(p);
 }
 var init_path_utils = __esm({
   "packages/experience-design-system-cli-legacy/src/import/path-utils.ts"() {
@@ -17799,7 +16939,7 @@ var init_save_path_resolver = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/runs/store.ts
-import { readFile as readFile16, writeFile as writeFile4, mkdir as mkdir4, rename } from "node:fs/promises";
+import { readFile as readFile15, 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";
@@ -17839,7 +16979,7 @@ function migrateRecord(rec) {
 }
 async function readFileMaybe() {
   try {
-    const raw = await readFile16(RUNS_PATH, "utf8");
+    const raw = await readFile15(RUNS_PATH, "utf8");
     const parsed = JSON.parse(raw);
     if (!READABLE_VERSIONS.has(parsed.version)) {
       throw new Error(
@@ -17903,15 +17043,15 @@ var init_store = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/runs/fingerprint.ts
-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";
+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";
 function rowField(row, key) {
   const v = row[key];
   return typeof v === "string" ? v : null;
 }
 function sha256Hex(buf) {
-  return createHash6("sha256").update(buf).digest("hex");
+  return createHash2("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);
@@ -17921,7 +17061,7 @@ async function buildSourceFingerprint(opts) {
     const sourcePath = rowField(row, "source_path");
     const name = rowField(row, "name");
     if (!sourcePath) continue;
-    const abs = resolve16(sourcePath);
+    const abs = resolve15(sourcePath);
     if (seen.has(abs)) continue;
     seen.add(abs);
     try {
@@ -17936,10 +17076,10 @@ async function buildSourceFingerprint(opts) {
   let rawTokensMtime = null;
   let rawTokensContentHash = null;
   if (opts.rawTokensPath) {
-    const abs = resolve16(opts.rawTokensPath);
+    const abs = resolve15(opts.rawTokensPath);
     rawTokensPath = abs;
     try {
-      const [st, buf] = await Promise.all([stat4(abs), readFile17(abs)]);
+      const [st, buf] = await Promise.all([stat4(abs), readFile16(abs)]);
       rawTokensMtime = st.mtime.toISOString();
       rawTokensContentHash = sha256Hex(buf);
     } catch {
@@ -19694,11 +18834,11 @@ var init_slot_graph = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/analyze/select/parser.ts
-import { createHash as createHash7 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { access as access5 } from "node:fs/promises";
-import { isAbsolute, relative, resolve as resolve17 } from "node:path";
+import { isAbsolute, relative, resolve as resolve16 } from "node:path";
 function createComponentId(name, resolvedSourcePath) {
-  const sourceHash = createHash7("sha256").update(`${name}:${resolvedSourcePath}`).digest("hex").slice(0, 12);
+  const sourceHash = createHash3("sha256").update(`${name}:${resolvedSourcePath}`).digest("hex").slice(0, 12);
   return `${name}-${sourceHash}`;
 }
 async function resolveComponentSourcePath(source, reviewRoot) {
@@ -19710,7 +18850,7 @@ async function resolveComponentSourcePath(source, reviewRoot) {
       throw new Error(`Unable to access component source at ${source}`);
     }
   }
-  const candidate = resolve17(reviewRoot, source);
+  const candidate = resolve16(reviewRoot, source);
   const relativeToRoot = relative(reviewRoot, candidate);
   if (relativeToRoot.startsWith("..") || relativeToRoot === ".." || isAbsolute(relativeToRoot)) {
     throw new Error(
@@ -19725,7 +18865,7 @@ async function resolveComponentSourcePath(source, reviewRoot) {
   }
 }
 async function loadReviewInput(components, options = {}) {
-  const reviewRoot = resolve17(options.reviewRoot ?? process.cwd());
+  const reviewRoot = resolve16(options.reviewRoot ?? process.cwd());
   const records = await Promise.all(
     components.map(async (component) => {
       let resolvedSourcePath;
@@ -19756,7 +18896,7 @@ var init_parser = __esm({
 });
 
 // packages/experience-design-system-cli-legacy/src/analyze/select/command.ts
-import { access as access6, readFile as readFile18 } from "node:fs/promises";
+import { access as access6, readFile as readFile17 } from "node:fs/promises";
 async function loadAndValidateForReview(sessionId2, projectRoot) {
   const db = openPipelineDb();
   let rawComponents;
@@ -19774,7 +18914,7 @@ async function patchReviewStateWithValidationErrors(sessionId2, errors, opts = {
   let snapshot;
   try {
     await access6(paths.statePath);
-    snapshot = JSON.parse(await readFile18(paths.statePath, "utf8"));
+    snapshot = JSON.parse(await readFile17(paths.statePath, "utf8"));
   } catch {
     snapshot = await loadAndValidateForReview(sessionId2, void 0);
     snapshot = await ensureRefineSession(sessionId2, artifactsRoot, snapshot);
@@ -19825,7 +18965,7 @@ async function rejectComponentsByName(sessionId2, names, opts = {}) {
   const nameSet = new Set(names);
   let snapshot;
   try {
-    snapshot = JSON.parse(await readFile18(paths.statePath, "utf8"));
+    snapshot = JSON.parse(await readFile17(paths.statePath, "utf8"));
   } catch {
     return;
   }
@@ -19924,9 +19064,9 @@ function spawnGenerateChild(opts) {
     stderr += chunk;
     opts.onStderr?.(chunk);
   });
-  const donePromise = new Promise((resolve21) => {
+  const donePromise = new Promise((resolve20) => {
     child.on("close", (code, signal) => {
-      resolve21({
+      resolve20({
         exitCode: code ?? 0,
         signal: signal ?? null,
         stdout,
@@ -19934,7 +19074,7 @@ function spawnGenerateChild(opts) {
       });
     });
     child.on("error", (err) => {
-      resolve21({
+      resolve20({
         exitCode: 1,
         signal: null,
         stdout,
@@ -28072,9 +27212,6 @@ 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;
 }
@@ -28101,66 +27238,39 @@ 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,
-    [],
-    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 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 prompt = await buildPrompt({
-      skill: "select",
-      mode: "autonomous",
-      rawComponentsInline: JSON.stringify(
-        componentsToRun.map((component) => ({ ...component, props: component.props.map(stripPropProvenance) })),
-        null,
-        2
-      ),
-      propBucketsInline: logPropBuckets("select", bucketComponentsProps(componentsToRun)),
-      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 invoker2 = createLocalCliAgentInvoker({
+    onDebugEvent: (name, payload) => getDebugLogger().event("agent", name, payload)
+  });
+  const prompt = await buildPrompt({
+    skill: "select",
+    mode: "autonomous",
+    rawComponentsInline: JSON.stringify(
+      components.map((component) => ({ ...component, props: component.props.map(stripPropProvenance) })),
+      null,
+      2
+    ),
+    propBucketsInline: logPropBuckets("select", bucketComponentsProps(components)),
+    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}
 `);
-    calls = parsed.calls;
-  }
-  const byName = new Map(calls.map((call) => [call.name, call]));
+  const byName = new Map(parsed.calls.map((call) => [call.name, call]));
   const writeDb = openPipelineDb();
   try {
     writeDb.exec("BEGIN");
@@ -28168,27 +27278,15 @@ 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 (!cached && !call) continue;
-      const rejected = cached ? cached.decision === "rejected" : call.tool === "reject_component";
-      const reason = cached ? cached.reason : call.reason ?? null;
+      if (!call) continue;
+      const rejected = call.tool === "reject_component";
       update.run(
         rejected ? "rejected" : "accepted",
-        rejected ? reason : null,
+        rejected ? call.reason ?? null : 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) {
@@ -28209,7 +27307,6 @@ var init_run_selection_agent = __esm({
     init_debug_logger();
     init_agent_output();
     init_db();
-    init_cache_keys();
     DEFAULT_TIMEOUT_MS4 = Number(process.env.EDS_AGENT_TIMEOUT_MS ?? 5 * 60 * 1e3);
   }
 });
@@ -28228,7 +27325,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 resolve18 } from "node:path";
+import { join as join23, resolve as resolve17 } 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";
@@ -28241,28 +27338,21 @@ 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);
@@ -28354,7 +27444,6 @@ function WizardApp({
   initialProjectPath,
   host,
   promptOverrides,
-  noCache = false,
   livePreview = true,
   generatePromptPath,
   skipMapTokens = false,
@@ -28379,7 +27468,6 @@ 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);
@@ -28394,9 +27482,8 @@ 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(resolve18(initialProjectPath), ".contentful") : "";
+  const initialOutDir = initialProjectPath ? join23(resolve17(initialProjectPath), ".contentful") : "";
   const [state, setState] = useState23({
     step: initialStepResolved,
     agent: initialAgent ?? "claude",
@@ -28572,14 +27659,13 @@ If you are using AWS Bedrock, run:
     if (!deferStep) update({ step: nextStep });
     return true;
   };
-  const runGenerateTokens = async (rawTokensPath, outDir, forceRegenerate = false) => {
+  const runGenerateTokens = async (rawTokensPath, outDir) => {
     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);
@@ -28628,7 +27714,6 @@ If you are using AWS Bedrock, run:
     const timer = startWizardTimer("token-mapping", {
       sessionId: sessionId2,
       silent,
-      noCache: effectiveNoCache,
       skipAgent: skipMapTokens
     });
     let mappablePropCount = 0;
@@ -28637,7 +27722,7 @@ If you are using AWS Bedrock, run:
       const db = openPipelineDb();
       try {
         if (state.tokenSessionId && state.tokenSessionId !== sessionId2) {
-          copyTokensFromCache(db, state.tokenSessionId, sessionId2);
+          copyTokensBetweenSessions(db, state.tokenSessionId, sessionId2);
         } else if (!state.tokenSessionId && state.tokensPath) {
           const tokens = await readTokensFromPath("tokens", state.tokensPath);
           storeDtcgTokens(db, sessionId2, [], tokens);
@@ -28677,7 +27762,6 @@ 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 } : {}
@@ -28757,7 +27841,7 @@ If you are using AWS Bedrock, run:
     return promise;
   };
   const runExtract = async (projectPath, showProgress = true) => {
-    const outDir = join23(resolve18(projectPath), ".contentful");
+    const outDir = join23(resolve17(projectPath), ".contentful");
     const existingEntitiesExpected = !state.credentialsSkipped && Boolean(state.spaceId && state.environmentId && state.cmaToken && projectPath);
     update({
       ...showProgress ? { step: "extracting" } : {},
@@ -28772,7 +27856,6 @@ 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 {
@@ -28781,7 +27864,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 = resolve18(selectOverride.value);
+        selectionPromptPath = resolve17(selectOverride.value);
         await resolvePromptOverride(selectOverride);
       }
     } catch (error) {
@@ -28805,8 +27888,7 @@ If you are using AWS Bedrock, run:
           agent: state.agent,
           ...state.agentModel ? { model: state.agentModel } : {},
           ...selectionPromptText !== void 0 ? { promptText: selectionPromptText } : {},
-          ...selectionPromptPath ? { promptPath: selectionPromptPath } : {},
-          noCache: effectiveNoCache
+          ...selectionPromptPath ? { promptPath: selectionPromptPath } : {}
         });
       })().catch((error) => {
         selectionError = error;
@@ -28951,136 +28033,17 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
       generateProgress: null
     }));
   };
-  const buildGenerateOptions = (extractSessionId, tokensPath, generatePromptPath2, cachedComponents) => ({
+  const buildGenerateOptions = (extractSessionId, tokensPath, generatePromptPath2) => ({
     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,
-    ...cachedComponents && cachedComponents.length > 0 ? { cachedComponents } : {}
+    promptOverrides
   });
-  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 buildGenerateArgs = (extractSessionId, tokensPath, generatePromptPath2) => buildGenerateProcessArgs(buildGenerateOptions(extractSessionId, tokensPath, generatePromptPath2));
   const startGeneratePrefetch = (extractSessionId, tokensPath) => {
     const args = buildGenerateArgs(extractSessionId, tokensPath);
     let progressCursor = null;
@@ -29135,14 +28098,13 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
     });
     return donePromise;
   };
-  const runGenerate = async (extractSessionId, tokensPath, acceptedCount, suppressScreen = false, cachedComponents = []) => {
+  const runGenerate = async (extractSessionId, tokensPath, acceptedCount, suppressScreen = false) => {
     const timer = startWizardTimer("component-generation", {
       sessionId: extractSessionId,
       acceptedCount,
-      suppressScreen,
-      noCache: effectiveNoCache
+      suppressScreen
     });
-    const args = buildGenerateArgs(extractSessionId, tokensPath, generatePromptPath, cachedComponents);
+    const args = buildGenerateArgs(extractSessionId, tokensPath, generatePromptPath);
     let progressCursor = state.generateProgress;
     const { donePromise } = spawnGenerateChild({
       command: "node",
@@ -29212,25 +28174,6 @@ 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();
@@ -29415,14 +28358,8 @@ Make sure this path contains TypeScript/React/Vue component files (.tsx, .ts, .v
         }
       }
       if (await runAgentAuthCheck("generating", true)) {
-        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);
-        }
+        update({ step: "generating" });
+        void runGenerate(sid, state.tokensPath, state.acceptedCount);
       }
       return;
     }
@@ -29786,7 +28723,7 @@ If using a custom host configuration, make sure the space exists on that host.`
       });
       return { ok: false };
     }
-    await new Promise((resolve21) => setTimeout(resolve21, SAVE_CONFIRMATION_DELAY_MS));
+    await new Promise((resolve20) => setTimeout(resolve20, SAVE_CONFIRMATION_DELAY_MS));
     update(nextStateAfterPrint({ skipGate: opts.skipGate, componentsPath }));
     return { ok: true };
   };
@@ -29863,12 +28800,6 @@ 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);
@@ -29952,7 +28883,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, true);
+                tokenGenerationPromiseRef.current = runGenerateTokens(state.rawTokensPath, state.outDir);
               }
             },
             onQuit: () => process.exit(0)
@@ -30051,29 +28982,6 @@ 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,
@@ -30082,35 +28990,12 @@ 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) {
-                        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
+                        update({
+                          step: "generating",
+                          generateProgress: null,
+                          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);
-                        }
+                        void runGenerate(sid, state.tokensPath, acceptedCount);
                       } else {
                         finishSelectionToReviewTimer("error");
                       }
@@ -30476,7 +29361,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],
     []
-  ).option("--no-cache", "Re-run all steps even if output already exists").action(async (opts) => {
+  ).action(async (opts) => {
     const interactiveTerminalSupported = getInteractiveTerminalSupport().supported;
     if (opts.tokens !== void 0) {
       const { access: access9 } = await import("node:fs/promises");
@@ -30513,7 +29398,6 @@ 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,
@@ -30601,7 +29485,7 @@ async function pathExists3(path) {
   return access8(path).then(() => true).catch(() => false);
 }
 function runSpawn(cmd, args, opts = {}) {
-  return new Promise((resolve21) => {
+  return new Promise((resolve20) => {
     const child = spawn6(cmd, args, {
       cwd: opts.cwd,
       env: opts.env ?? process.env,
@@ -30613,7 +29497,7 @@ function runSpawn(cmd, args, opts = {}) {
     const settle = (result) => {
       if (settled) return;
       settled = true;
-      resolve21(result);
+      resolve20(result);
     };
     child.on("error", (err) => settle({ exitCode: 1, stdout: "", stderr: err.message }));
     child.stdout.on("data", (d) => {
@@ -31814,13 +30698,13 @@ function PrerequisitesScreen({
     const driver = {
       ...base,
       emit: (event) => setEvents((current) => [...current, event]),
-      confirm: (question, defaultYes = true) => new Promise((resolve21) => {
+      confirm: (question, defaultYes = true) => new Promise((resolve20) => {
         setConfirm({
           question,
           defaultYes,
           resolve: (answer) => {
             setConfirm(null);
-            resolve21(answer);
+            resolve20(answer);
           }
         });
       })
@@ -31895,8 +30779,8 @@ function SetupScreen({
   useEffect21(() => {
     if (startedRef.current) return;
     startedRef.current = true;
-    const runScreen = (build) => new Promise((resolve21) => {
-      setScreen(build(resolve21));
+    const runScreen = (build) => new Promise((resolve20) => {
+      setScreen(build(resolve20));
     });
     void (async () => {
       const results = [];
@@ -32504,11 +31388,8 @@ 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 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;
-}
+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";
 function isDenylistedNoiseFile(name) {
   return DENYLISTED_EXACT_FILE_NAMES.has(name) || DENYLISTED_FILE_NAME_PATTERNS.some((pattern) => pattern.test(name));
 }
@@ -32522,12 +31403,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((resolve21) => setTimeout(resolve21, Math.min(250 * attempt, 2e3)));
+      await new Promise((resolve20) => setTimeout(resolve20, Math.min(250 * attempt, 2e3)));
     }
   }
 }
 function resolveFromProjectRoot(projectRoot, inputPath) {
-  return isAbsolute2(inputPath) ? inputPath : resolve19(projectRoot, inputPath);
+  return isAbsolute2(inputPath) ? inputPath : resolve18(projectRoot, inputPath);
 }
 async function pathExists4(path) {
   return Boolean(await stat6(path).catch(() => null));
@@ -32574,7 +31455,7 @@ async function readCandidateFiles(components, extraFiles = []) {
   await Promise.all(
     [...paths].map(async (p) => {
       try {
-        const content = await readFile19(p, "utf8");
+        const content = await readFile18(p, "utf8");
         out.push({ path: p, content });
       } catch {
       }
@@ -32587,8 +31468,7 @@ function registerInternalExtractCommand(program) {
     "--resolve-unreachable <mode>",
     "Retry pass for unresolved Svelte Props types: 'auto' (default), 'always', or 'never'",
     "auto"
-  ).option("--no-cache", "Re-run extraction even when all source files are unchanged").action(async (opts) => {
-    const noCache = resolveExtractNoCache(opts);
+  ).action(async (opts) => {
     const resolveUnreachable = (() => {
       const v = opts.resolveUnreachable ?? "auto";
       if (v !== "auto" && v !== "always" && v !== "never") {
@@ -32598,7 +31478,7 @@ function registerInternalExtractCommand(program) {
       }
       return v;
     })();
-    const projectRoot = resolve19(opts.project);
+    const projectRoot = resolve18(opts.project);
     const outDir = join27(projectRoot, ".contentful");
     let sourceDirectory;
     if (opts.dir !== void 0) {
@@ -32622,50 +31502,16 @@ function registerInternalExtractCommand(program) {
       process.stderr.write(`progress=scan-done:${sourceFiles.length}
 `);
     }
-    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: [] };
+    const extraction = await extractComponents(
+      sourceFiles,
+      ({ filesProcessed, componentsFound }) => {
         if (!process.stdout.isTTY) {
-          process.stderr.write(
-            `progress=extract:${sourceFiles.length}/${sourceFiles.length}:${cachedComponents.length}
-`
-          );
-        }
-        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}
+          process.stderr.write(`progress=extract:${filesProcessed}/${sourceFiles.length}:${componentsFound}
 `);
-            }
-          },
-          { resolveUnreachable, projectRoot }
-        );
-      }
-    } finally {
-      extractionCacheDb.close();
-    }
+        }
+      },
+      { resolveUnreachable, projectRoot }
+    );
     await mkdir6(outDir, { recursive: true });
     const db = openPipelineDb();
     const { sessionId: sessionId2 } = getOrCreateSession(db, void 0, void 0, {
@@ -32680,25 +31526,6 @@ 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 });
@@ -32803,7 +31630,6 @@ var init_extract_command = __esm({
     "use strict";
     init_src2();
     init_db();
-    init_cache_keys();
     init_cycle_detection();
     init_resolve_mapping();
     init_manifest_doc_evidence();
@@ -32902,7 +31728,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 resolve20 } from "node:path";
+import { dirname as dirname18, join as join28, resolve as resolve19 } from "node:path";
 import { readFileSync as readFileSync10 } from "node:fs";
 import { Command } from "commander";
 async function runBuild(opts) {
@@ -32932,7 +31758,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 = resolve20(dirname18(fileURLToPath3(import.meta.url)), "..", "..");
+    const pkgRoot = resolve19(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" }),