claude-code-best 1.8.0 → 1.9.0

package/dist/{chunk-yspxy3e8.js → chunk-2q1gcvk9.js}

@@ -4,34 +4,34 @@ import {
   getSecureSocketPath,
   getSocketDir,
   init_common
-} from "./chunk-vvj9yfd6.js";
+} from "./chunk-nb32de90.js";
 import {
   init_lazySchema,
   lazySchema
 } from "./chunk-64c1avct.js";
-import"./chunk-ctr3c1sg.js";
+import"./chunk-rcz0e093.js";
 import"./chunk-3c25bcsw.js";
 import {
   exports_external
 } from "./chunk-d7886r6a.js";
-import"./chunk-24dgse44.js";
-import"./chunk-tv74hgw9.js";
-import"./chunk-jgdm5p7t.js";
+import"./chunk-9d7dhwhn.js";
+import"./chunk-znv3atvc.js";
+import"./chunk-2cyjtt9z.js";
 import"./chunk-8tnsngw2.js";
-import"./chunk-wx6n79wt.js";
-import"./chunk-2bn3rfrp.js";
+import"./chunk-x313wqn1.js";
+import"./chunk-e4c9nm5e.js";
 import"./chunk-5z28bqne.js";
 import"./chunk-qajrkk97.js";
 import {
   init_slowOperations,
   jsonParse,
   jsonStringify
-} from "./chunk-edk6reza.js";
+} from "./chunk-wb2sg18w.js";
 import"./chunk-fbv4apne.js";
-import"./chunk-gzp6rza1.js";
+import"./chunk-wmgyt01k.js";
 import"./chunk-50dgek10.js";
 import"./chunk-7wm5s02e.js";
-import"./chunk-z0csm2zq.js";
+import"./chunk-jg5ac2fy.js";
 import"./chunk-hxhwzgnn.js";
 import"./chunk-qx8z601m.js";
 import"./chunk-cgm6758j.js";

package/dist/{chunk-0y082g7m.js → chunk-2q7ww4pa.js}

@@ -4,22 +4,22 @@ import {
 } from "./chunk-ae76ded0.js";
 import {
   getPollIntervalConfig
-} from "./chunk-21mz4040.js";
+} from "./chunk-m48b7sj9.js";
 import {
   buildCCRv2SdkUrl,
   buildSdkUrl,
   decodeWorkSecret,
   registerWorker,
   sameSessionId
-} from "./chunk-fzzjx191.js";
+} from "./chunk-ywf3v9s7.js";
 import {
   createTokenRefreshScheduler
-} from "./chunk-jw9r1vhk.js";
+} from "./chunk-tzed1ttg.js";
 import {
   getBootstrapArgs,
   getScriptPath,
   init_cliLaunch
-} from "./chunk-f4dvpkzw.js";
+} from "./chunk-hhd42y3a.js";
 import {
   $toString,
   init_server
@@ -45,15 +45,15 @@ import {
   timestamp,
   validateBridgeId,
   wrapWithOsc8Link
-} from "./chunk-m2akjkdt.js";
+} from "./chunk-abcmnpw1.js";
 import {
   init_rcDebugLog,
   rcLog
-} from "./chunk-7rzk7d37.js";
+} from "./chunk-4c843krn.js";
 import {
   getTrustedDeviceToken,
   init_trustedDevice
-} from "./chunk-eg0tc9yh.js";
+} from "./chunk-h4cqgnfp.js";
 import {
   BRIDGE_LOGIN_ERROR,
   DEFAULT_SESSION_TIMEOUT_MS,
@@ -66,11 +66,11 @@ import {
   init_sessionIdCompat,
   toCompatSessionId,
   toInfraSessionId
-} from "./chunk-zwmrhef7.js";
+} from "./chunk-tngbfggd.js";
 import {
   init_datadog,
   shutdownDatadog
-} from "./chunk-abay4sak.js";
+} from "./chunk-dh52jprq.js";
 import {
   BRIDGE_FAILED_INDICATOR,
   BRIDGE_READY_INDICATOR,
@@ -80,7 +80,7 @@ import {
   init_firstPartyEventLogger,
   init_growthbook,
   shutdown1PEventLogging
-} from "./chunk-za24x8e6.js";
+} from "./chunk-1dh9y2g9.js";
 import {
   init_sleep,
   sleep
@@ -89,7 +89,7 @@ import {
   formatDuration,
   init_format,
   truncateToWidth
-} from "./chunk-k3h49w53.js";
+} from "./chunk-0s5rp3xp.js";
 import {
   init_source,
   init_src,
@@ -104,11 +104,11 @@ import {
 import {
   init_diagLogs,
   logForDiagnosticsNoPII
-} from "./chunk-a6aj70ts.js";
+} from "./chunk-e80zc1av.js";
 import {
   init_log,
   logError
-} from "./chunk-jgdm5p7t.js";
+} from "./chunk-2cyjtt9z.js";
 import {
   errorMessage,
   init_debug,
@@ -117,7 +117,7 @@ import {
   jsonParse,
   jsonStringify,
   logForDebugging
-} from "./chunk-edk6reza.js";
+} from "./chunk-wb2sg18w.js";
 import {
   init_envUtils,
   isEnvTruthy,
@@ -1355,7 +1355,7 @@ async function runBridgeLoop(config, environmentId, environmentSecret, api, spaw
               const title = deriveSessionTitle(text);
               logger.setSessionTitle(compatSessionId, title);
               logForDebugging(`[bridge:title] derived title for ${compatSessionId}: ${title}`);
-              import("./chunk-5e8w9mhp.js").then(({ updateBridgeSessionTitle }) => updateBridgeSessionTitle(compatSessionId, title, {
+              import("./chunk-8ktgxh4r.js").then(({ updateBridgeSessionTitle }) => updateBridgeSessionTitle(compatSessionId, title, {
                 baseUrl: config.apiBaseUrl
               })).catch((err) => logForDebugging(`[bridge:title] failed to update title for ${compatSessionId}: ${err}`, { level: "error" }));
             }
@@ -1620,7 +1620,7 @@ async function runBridgeLoop(config, environmentId, environmentSecret, api, spaw
   } catch (err) {
     logger.logVerbose(`Failed to deregister environment: ${errorMessage(err)}`);
   }
-  const { clearBridgePointer } = await import("./chunk-954x38qh.js");
+  const { clearBridgePointer } = await import("./chunk-bvr12bqd.js");
   await clearBridgePointer(config.dir);
   logger.logVerbose("Environment offline.");
 }
@@ -1884,7 +1884,7 @@ function deriveSessionTitle(text) {
   return truncateToWidth(flat, TITLE_MAX_LEN);
 }
 async function fetchSessionTitle(compatSessionId, baseUrl) {
-  const { getBridgeSession } = await import("./chunk-5e8w9mhp.js");
+  const { getBridgeSession } = await import("./chunk-8ktgxh4r.js");
   const session = await getBridgeSession(compatSessionId, { baseUrl });
   return session?.title || undefined;
 }
@@ -1923,9 +1923,9 @@ async function bridgeMain(args) {
     }
   }
   const dir = resolve(".");
-  const { enableConfigs, checkHasTrustDialogAccepted } = await import("./chunk-p90f2nc9.js");
+  const { enableConfigs, checkHasTrustDialogAccepted } = await import("./chunk-3sag2vww.js");
   enableConfigs();
-  const { initSinks } = await import("./chunk-2kdh2xhm.js");
+  const { initSinks } = await import("./chunk-zvgv14qd.js");
   initSinks();
   const multiSessionEnabled = await isMultiSessionSpawnEnabled();
   if (usedMultiSessionFeature && !multiSessionEnabled) {
@@ -1941,15 +1941,15 @@ async function bridgeMain(args) {
     console.error("Error: Multi-session Remote Control is not enabled for your account yet.");
     process.exit(1);
   }
-  const { setOriginalCwd, setCwdState } = await import("./chunk-m1tjr9xq.js");
+  const { setOriginalCwd, setCwdState } = await import("./chunk-h6pgm1qp.js");
   setOriginalCwd(dir);
   setCwdState(dir);
   if (!checkHasTrustDialogAccepted()) {
     console.error(`Error: Workspace not trusted. Please run \`claude\` in ${dir} first to review and accept the workspace trust dialog.`);
     process.exit(1);
   }
-  const { clearOAuthTokenCache, checkAndRefreshOAuthTokenIfNeeded } = await import("./chunk-sdw97qke.js");
-  const { getBridgeAccessToken, getBridgeBaseUrl } = await import("./chunk-x4azk52n.js");
+  const { clearOAuthTokenCache, checkAndRefreshOAuthTokenIfNeeded } = await import("./chunk-v7e85mv1.js");
+  const { getBridgeAccessToken, getBridgeBaseUrl } = await import("./chunk-2501y0qn.js");
   const bridgeToken = getBridgeAccessToken();
   if (!bridgeToken) {
     console.error(BRIDGE_LOGIN_ERROR);
@@ -1960,7 +1960,7 @@ async function bridgeMain(args) {
     saveGlobalConfig,
     getCurrentProjectConfig,
     saveCurrentProjectConfig
-  } = await import("./chunk-p90f2nc9.js");
+  } = await import("./chunk-3sag2vww.js");
   if (!getGlobalConfig().remoteDialogSeen) {
     const readline = await import("readline");
     const rl = readline.createInterface({
@@ -1987,7 +1987,7 @@ You can disconnect remote access anytime by running /remote-control again.
     }
   }
   if (continueSession) {
-    const { readBridgePointerAcrossWorktrees } = await import("./chunk-954x38qh.js");
+    const { readBridgePointerAcrossWorktrees } = await import("./chunk-bvr12bqd.js");
     const found = await readBridgePointerAcrossWorktrees(dir);
     if (!found) {
       console.error(`Error: No recent session found in this directory or its worktrees. Run \`claude remote-control\` to start a new one.`);
@@ -2007,8 +2007,8 @@ You can disconnect remote access anytime by running /remote-control again.
     process.exit(1);
   }
   const sessionIngressUrl = process.env.CLAUDE_BRIDGE_SESSION_INGRESS_URL || baseUrl;
-  const { getBranch, getRemoteUrl, findGitRoot } = await import("./chunk-8qrr3jhc.js");
-  const { hasWorktreeCreateHook } = await import("./chunk-h724wqmb.js");
+  const { getBranch, getRemoteUrl, findGitRoot } = await import("./chunk-906fcbs0.js");
+  const { hasWorktreeCreateHook } = await import("./chunk-a8ea1qyx.js");
   const worktreeAvailable = hasWorktreeCreateHook() || findGitRoot(dir) !== null;
   let savedSpawnMode = multiSessionEnabled ? getCurrentProjectConfig().remoteControlSpawnMode : undefined;
   if (savedSpawnMode === "worktree" && !worktreeAvailable) {
@@ -2068,7 +2068,7 @@ Spawn mode for this project:
   const maxSessions = spawnMode === "single-session" ? 1 : parsedCapacity ?? SPAWN_SESSIONS_DEFAULT;
   const preCreateSession = parsedCreateSessionInDir ?? true;
   if (!resumeSessionId) {
-    const { clearBridgePointer } = await import("./chunk-954x38qh.js");
+    const { clearBridgePointer } = await import("./chunk-bvr12bqd.js");
     await clearBridgePointer(dir);
   }
   if (spawnMode === "worktree" && !worktreeAvailable) {
@@ -2079,7 +2079,7 @@ Spawn mode for this project:
   const gitRepoUrl = await getRemoteUrl();
   const machineName = hostname();
   const bridgeId = randomUUID();
-  const { handleOAuth401Error } = await import("./chunk-sdw97qke.js");
+  const { handleOAuth401Error } = await import("./chunk-v7e85mv1.js");
   const api = createBridgeApiClient({
     baseUrl,
     getAccessToken: getBridgeAccessToken,
@@ -2098,14 +2098,14 @@ Spawn mode for this project:
     }
     await checkAndRefreshOAuthTokenIfNeeded();
     clearOAuthTokenCache();
-    const { getBridgeSession } = await import("./chunk-5e8w9mhp.js");
+    const { getBridgeSession } = await import("./chunk-8ktgxh4r.js");
     const session = await getBridgeSession(resumeSessionId, {
       baseUrl,
       getAccessToken: getBridgeAccessToken
     });
     if (!session) {
       if (resumePointerDir) {
-        const { clearBridgePointer } = await import("./chunk-954x38qh.js");
+        const { clearBridgePointer } = await import("./chunk-bvr12bqd.js");
         await clearBridgePointer(resumePointerDir);
       }
       console.error(`Error: Session ${resumeSessionId} not found. It may have been archived or expired, or your login may have lapsed (run \`claude /login\`).`);
@@ -2113,7 +2113,7 @@ Spawn mode for this project:
     }
     if (!session.environment_id) {
       if (resumePointerDir) {
-        const { clearBridgePointer } = await import("./chunk-954x38qh.js");
+        const { clearBridgePointer } = await import("./chunk-bvr12bqd.js");
         await clearBridgePointer(resumePointerDir);
       }
       console.error(`Error: Session ${resumeSessionId} has no environment_id. It may never have been attached to a bridge.`);
@@ -2182,7 +2182,7 @@ Spawn mode for this project:
         const err = lastReconnectErr;
         const isFatal = err instanceof BridgeFatalError;
         if (resumePointerDir && isFatal) {
-          const { clearBridgePointer } = await import("./chunk-954x38qh.js");
+          const { clearBridgePointer } = await import("./chunk-bvr12bqd.js");
           await clearBridgePointer(resumePointerDir);
         }
         console.error(isFatal ? `Error: ${errorMessage(err)}` : `Error: Failed to reconnect session ${resumeSessionId}: ${errorMessage(err)}
@@ -2227,7 +2227,7 @@ The session may still be resumable \u2014 try running the same command again.`);
     }
   });
   const logger = createBridgeLogger({ verbose });
-  const { parseGitHubRepository } = await import("./chunk-438syzcr.js");
+  const { parseGitHubRepository } = await import("./chunk-vekca08b.js");
   const ownerRepo = gitRepoUrl ? parseGitHubRepository(gitRepoUrl) : null;
   const repoName = ownerRepo ? ownerRepo.split("/").pop() : basename(dir);
   logger.setRepoInfo(repoName, branch);
@@ -2281,7 +2281,7 @@ The session may still be resumable \u2014 try running the same command again.`);
   process.on("SIGTERM", onSigterm);
   let initialSessionId = effectiveResumeSessionId ? effectiveResumeSessionId : null;
   if (preCreateSession && !effectiveResumeSessionId) {
-    const { createBridgeSession } = await import("./chunk-5e8w9mhp.js");
+    const { createBridgeSession } = await import("./chunk-8ktgxh4r.js");
     try {
       initialSessionId = await createBridgeSession({
         environmentId,
@@ -2303,7 +2303,7 @@ The session may still be resumable \u2014 try running the same command again.`);
   }
   let pointerRefreshTimer = null;
   if (initialSessionId && spawnMode === "single-session") {
-    const { writeBridgePointer } = await import("./chunk-954x38qh.js");
+    const { writeBridgePointer } = await import("./chunk-bvr12bqd.js");
     const pointerPayload = {
       sessionId: initialSessionId,
       environmentId,
@@ -2343,12 +2343,12 @@ class BridgeHeadlessPermanentError extends Error {
 async function runBridgeHeadless(opts, signal) {
   const { dir, log } = opts;
   process.chdir(dir);
-  const { setOriginalCwd, setCwdState } = await import("./chunk-m1tjr9xq.js");
+  const { setOriginalCwd, setCwdState } = await import("./chunk-h6pgm1qp.js");
   setOriginalCwd(dir);
   setCwdState(dir);
-  const { enableConfigs, checkHasTrustDialogAccepted } = await import("./chunk-p90f2nc9.js");
+  const { enableConfigs, checkHasTrustDialogAccepted } = await import("./chunk-3sag2vww.js");
   enableConfigs();
-  const { initSinks } = await import("./chunk-2kdh2xhm.js");
+  const { initSinks } = await import("./chunk-zvgv14qd.js");
   initSinks();
   if (!checkHasTrustDialogAccepted()) {
     throw new BridgeHeadlessPermanentError(`Workspace not trusted: ${dir}. Run \`claude\` in that directory first to accept the trust dialog.`);
@@ -2356,14 +2356,14 @@ async function runBridgeHeadless(opts, signal) {
   if (!opts.getAccessToken()) {
     throw new Error(BRIDGE_LOGIN_ERROR);
   }
-  const { getBridgeBaseUrl } = await import("./chunk-x4azk52n.js");
+  const { getBridgeBaseUrl } = await import("./chunk-2501y0qn.js");
   const baseUrl = getBridgeBaseUrl();
   if (baseUrl.startsWith("http://") && !baseUrl.includes("localhost") && !baseUrl.includes("127.0.0.1")) {
     throw new BridgeHeadlessPermanentError("Remote Control base URL uses HTTP. Only HTTPS or localhost HTTP is allowed.");
   }
   const sessionIngressUrl = process.env.CLAUDE_BRIDGE_SESSION_INGRESS_URL || baseUrl;
-  const { getBranch, getRemoteUrl, findGitRoot } = await import("./chunk-8qrr3jhc.js");
-  const { hasWorktreeCreateHook } = await import("./chunk-h724wqmb.js");
+  const { getBranch, getRemoteUrl, findGitRoot } = await import("./chunk-906fcbs0.js");
+  const { hasWorktreeCreateHook } = await import("./chunk-a8ea1qyx.js");
   if (opts.spawnMode === "worktree") {
     const worktreeAvailable = hasWorktreeCreateHook() || findGitRoot(dir) !== null;
     if (!worktreeAvailable) {
@@ -2420,7 +2420,7 @@ async function runBridgeHeadless(opts, signal) {
   logger.printBanner(config, environmentId);
   let initialSessionId;
   if (opts.createSessionOnStart) {
-    const { createBridgeSession } = await import("./chunk-5e8w9mhp.js");
+    const { createBridgeSession } = await import("./chunk-8ktgxh4r.js");
     try {
       const sid = await createBridgeSession({
         environmentId,

package/dist/chunk-2qg5ewk3.js

@@ -0,0 +1,207 @@
+// @bun
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils
+} from "./chunk-hxhwzgnn.js";
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/skillLearning/projectContext.ts
+import { execFileSync } from "child_process";
+import { createHash } from "crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  writeFileSync
+} from "fs";
+import { basename, join, resolve } from "path";
+function getSkillLearningRootDir() {
+  return join(getClaudeConfigHomeDir(), "skill-learning");
+}
+function getProjectsRegistryPath() {
+  return join(getSkillLearningRootDir(), "projects.json");
+}
+function getProjectStorageDir(projectId) {
+  if (projectId === GLOBAL_PROJECT_ID) {
+    return join(getSkillLearningRootDir(), "global");
+  }
+  return join(getSkillLearningRootDir(), "projects", projectId);
+}
+function getProjectContextPath(projectId) {
+  return join(getProjectStorageDir(projectId), "project.json");
+}
+function resolveProjectContext(cwd = process.cwd()) {
+  const cached = contextCache.get(cwd);
+  if (cached) {
+    const now = Date.now();
+    if (now - lastPersistAt > PERSIST_INTERVAL_MS) {
+      lastPersistAt = now;
+      persistProjectContext(cached);
+    }
+    return cached;
+  }
+  const resolved = resolveContext(cwd);
+  contextCache.set(cwd, resolved);
+  persistProjectContext(resolved);
+  lastPersistAt = Date.now();
+  return resolved;
+}
+function resetProjectContextCacheForTest() {
+  contextCache.clear();
+  lastPersistAt = 0;
+}
+function listKnownProjects() {
+  const registry = readProjectsRegistry(getProjectsRegistryPath());
+  return Object.values(registry.projects).sort((a, b) => a.projectName.localeCompare(b.projectName));
+}
+function resolveContext(cwd) {
+  const envProjectDir = process.env.CLAUDE_PROJECT_DIR?.trim();
+  if (envProjectDir) {
+    const projectRoot = normalizePath(envProjectDir);
+    return buildContext({
+      source: "claude_project_dir",
+      scope: "project",
+      cwd,
+      projectRoot,
+      identity: `claude-project-dir:${projectRoot}`,
+      projectName: basename(projectRoot) || "project"
+    });
+  }
+  const gitRemote = git(["remote", "get-url", "origin"], cwd);
+  if (gitRemote) {
+    const projectRoot = git(["rev-parse", "--show-toplevel"], cwd);
+    const normalizedRemote = normalizeGitRemote(gitRemote);
+    return buildContext({
+      source: "git_remote",
+      scope: "project",
+      cwd,
+      projectRoot: projectRoot ? normalizePath(projectRoot) : normalizePath(cwd),
+      gitRemote: normalizedRemote,
+      identity: `git-remote:${normalizedRemote}`,
+      projectName: projectNameFromRemote(normalizedRemote)
+    });
+  }
+  const gitRoot = git(["rev-parse", "--show-toplevel"], cwd);
+  if (gitRoot) {
+    const projectRoot = normalizePath(gitRoot);
+    return buildContext({
+      source: "git_root",
+      scope: "project",
+      cwd,
+      projectRoot,
+      identity: `git-root:${projectRoot}`,
+      projectName: basename(projectRoot) || "project"
+    });
+  }
+  return buildContext({
+    source: "global",
+    scope: "global",
+    cwd,
+    projectRoot: undefined,
+    identity: "global",
+    projectName: GLOBAL_PROJECT_NAME
+  });
+}
+function buildContext(input) {
+  const projectId = input.scope === "global" ? GLOBAL_PROJECT_ID : stableProjectId(input.identity);
+  return {
+    projectId,
+    projectName: input.projectName,
+    scope: input.scope,
+    source: input.source,
+    cwd: normalizePath(input.cwd),
+    projectRoot: input.projectRoot,
+    gitRemote: input.gitRemote,
+    storageDir: getProjectStorageDir(projectId)
+  };
+}
+function persistProjectContext(context) {
+  const now = new Date().toISOString();
+  const registryPath = getProjectsRegistryPath();
+  const registry = readProjectsRegistry(registryPath);
+  const existing = registry.projects[context.projectId];
+  const record = {
+    ...context,
+    firstSeenAt: existing?.firstSeenAt ?? now,
+    lastSeenAt: now
+  };
+  registry.projects[context.projectId] = record;
+  registry.updatedAt = now;
+  mkdirSync(context.storageDir, { recursive: true });
+  mkdirSync(getSkillLearningRootDir(), { recursive: true });
+  writeJson(registryPath, registry);
+  writeJson(getProjectContextPath(context.projectId), record);
+}
+function readProjectsRegistry(path) {
+  if (!existsSync(path)) {
+    return {
+      version: REGISTRY_VERSION,
+      updatedAt: new Date(0).toISOString(),
+      projects: {}
+    };
+  }
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.version === REGISTRY_VERSION && typeof parsed.projects === "object" && parsed.projects) {
+      return {
+        version: REGISTRY_VERSION,
+        updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : new Date(0).toISOString(),
+        projects: parsed.projects
+      };
+    }
+  } catch {}
+  return {
+    version: REGISTRY_VERSION,
+    updatedAt: new Date(0).toISOString(),
+    projects: {}
+  };
+}
+function writeJson(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function git(args, cwd) {
+  try {
+    const output = execFileSync("git", ["-C", cwd, ...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const trimmed = output.trim();
+    return trimmed ? trimmed : null;
+  } catch {
+    return null;
+  }
+}
+function normalizePath(path) {
+  const resolved = resolve(path);
+  try {
+    return realpathSync.native(resolved).normalize("NFC");
+  } catch {
+    return resolved.normalize("NFC");
+  }
+}
+function normalizeGitRemote(remote) {
+  let normalized = remote.trim().replace(/\\/g, "/");
+  normalized = normalized.replace(/\.git$/i, "");
+  normalized = normalized.replace(/\/+$/g, "");
+  return normalized.toLowerCase();
+}
+function projectNameFromRemote(remote) {
+  const match = remote.match(/[:/]([^/:]+?)(?:\.git)?$/);
+  return match?.[1] || "project";
+}
+function stableProjectId(identity) {
+  const hash = createHash("sha256").update(identity).digest("hex").slice(0, 16);
+  return `project-${hash}`;
+}
+var REGISTRY_VERSION = 1, GLOBAL_PROJECT_ID = "global", GLOBAL_PROJECT_NAME = "Global", contextCache, PERSIST_INTERVAL_MS, lastPersistAt = 0;
+var init_projectContext = __esm(() => {
+  init_envUtils();
+  contextCache = new Map;
+  PERSIST_INTERVAL_MS = 5 * 60 * 1000;
+});
+
+export { getSkillLearningRootDir, getProjectsRegistryPath, getProjectStorageDir, getProjectContextPath, resolveProjectContext, resetProjectContextCacheForTest, listKnownProjects, init_projectContext };

package/dist/chunk-2t26mfb1.js

@@ -0,0 +1,80 @@
+// @bun
+import {
+  __esm
+} from "./chunk-qp2qdcda.js";
+
+// src/services/compact/cachedMicrocompact.ts
+function isCachedMicrocompactEnabled() {
+  return process.env.CLAUDE_CACHED_MICROCOMPACT === "1";
+}
+function isModelSupportedForCacheEditing(model) {
+  return /claude-[a-z]+-4[-\d]/.test(model);
+}
+function getCachedMCConfig() {
+  return { triggerThreshold: TRIGGER_THRESHOLD, keepRecent: KEEP_RECENT };
+}
+function createCachedMCState() {
+  return {
+    registeredTools: new Set,
+    toolOrder: [],
+    deletedRefs: new Set,
+    pinnedEdits: [],
+    toolsSentToAPI: false
+  };
+}
+function markToolsSentToAPI(state) {
+  state.toolsSentToAPI = true;
+}
+function resetCachedMCState(state) {
+  state.registeredTools.clear();
+  state.toolOrder = [];
+  state.deletedRefs.clear();
+  state.pinnedEdits = [];
+  state.toolsSentToAPI = false;
+}
+function registerToolResult(state, toolId) {
+  if (!state.registeredTools.has(toolId)) {
+    state.registeredTools.add(toolId);
+    state.toolOrder.push(toolId);
+  }
+}
+function registerToolMessage(state, groupIds) {
+  for (const id of groupIds) {
+    registerToolResult(state, id);
+  }
+}
+function getToolResultsToDelete(state) {
+  const { triggerThreshold, keepRecent } = getCachedMCConfig();
+  const active = state.toolOrder.filter((id) => !state.deletedRefs.has(id));
+  if (active.length <= triggerThreshold)
+    return [];
+  const toDelete = active.slice(0, active.length - keepRecent);
+  return toDelete;
+}
+function createCacheEditsBlock(state, toolIds) {
+  if (toolIds.length === 0)
+    return null;
+  return {
+    type: "cache_edits",
+    edits: toolIds.map((id) => ({
+      type: "delete_tool_result",
+      tool_use_id: id
+    }))
+  };
+}
+var TRIGGER_THRESHOLD = 10, KEEP_RECENT = 5;
+var init_cachedMicrocompact = () => {};
+init_cachedMicrocompact();
+
+export {
+  resetCachedMCState,
+  registerToolResult,
+  registerToolMessage,
+  markToolsSentToAPI,
+  isModelSupportedForCacheEditing,
+  isCachedMicrocompactEnabled,
+  getToolResultsToDelete,
+  getCachedMCConfig,
+  createCachedMCState,
+  createCacheEditsBlock
+};