@koed-labs/server 0.0.0-stage → 0.10.3

package/vendor/chunk-TSRPHKAC.js

@@ -0,0 +1,780 @@
+import { createRequire as createKoedRequire } from "node:module"; const require = createKoedRequire(import.meta.url);
+import {
+  resolveActiveIntegrationApiToken
+} from "./chunk-QT24SAW6.js";
+import {
+  applyPersistedLocalPorts
+} from "./chunk-HFM6ROJL.js";
+import {
+  readActiveRuntimeState
+} from "./chunk-G4IIVVJO.js";
+import {
+  require_proper_lockfile
+} from "./chunk-7NXKPDF3.js";
+import {
+  loadRepoEnv,
+  resolveApiUrl
+} from "./chunk-W2HNI6AA.js";
+import {
+  deriveLocalProjectId,
+  external_exports,
+  fetchBoundedJsonObject,
+  hmacProjectValue,
+  isLoopbackHostname,
+  isPortableGitRemote,
+  normalizeGitRemoteUrl,
+  normalizeProjectDisplayName,
+  normalizeRecordedProjectDirectory,
+  repositoryChangeInputSchema,
+  repositoryIdentityMatches,
+  repositoryIdentitySchema
+} from "./chunk-473OA62O.js";
+import {
+  __toESM
+} from "./chunk-BTS4ZTF3.js";
+
+// packages/koed-server/dist/project-metadata.js
+import { execFile as nodeExecFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync as mkdirSync2, readFileSync, renameSync, writeFileSync, statSync as statSync2, rmSync } from "node:fs";
+import path, { dirname as dirname3, relative, resolve as resolve2 } from "node:path";
+
+// packages/koed-server/dist/git-project-probe.js
+import { execFile } from "node:child_process";
+import { statSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+var createGitProjectProbe = (deps = {}) => {
+  const execute = deps.execFile ?? execFile;
+  const stat = deps.statSync ?? statSync;
+  const now = deps.now ?? Date.now;
+  const ttl = deps.ttlMs ?? 2e3;
+  const cache = /* @__PURE__ */ new Map();
+  const signature = (paths) => JSON.stringify(paths.map((file) => {
+    try {
+      const value = stat(file);
+      return [
+        file,
+        value.dev,
+        value.ino,
+        value.size,
+        value.mtimeMs,
+        value.ctimeMs
+      ];
+    } catch {
+      return [file, null];
+    }
+  }));
+  const command = (cwd, args) => new Promise((done) => {
+    const finish = (error, stdout, stderr) => {
+      done({
+        value: error ? null : String(stdout).trim() || null,
+        failed: Boolean(error),
+        nonGit: Boolean(error) && /not a git repository/i.test(typeof stderr === "string" ? stderr : "")
+      });
+    };
+    try {
+      execute("git", ["-C", cwd, ...args], {
+        timeout: 5e3,
+        maxBuffer: 1024 * 1024,
+        encoding: "utf8"
+      }, finish);
+    } catch (error) {
+      finish(error instanceof Error ? error : new Error("Git execution failed"), "");
+    }
+  });
+  return async (input) => {
+    const cwd = resolve(input.cwd);
+    const key = JSON.stringify([
+      resolve(input.profile),
+      cwd,
+      input.deviceSalt,
+      input.configurationRevision ?? ""
+    ]);
+    const cached = cache.get(key);
+    if (cached && cached.expiresAt > now() && cached.signature === signature(cached.watchedPaths)) {
+      return structuredClone(cached.result);
+    }
+    const result = {
+      status: "non_git",
+      failedCommands: [],
+      root: null,
+      remotes: [],
+      branch: null,
+      headCommit: null,
+      commonDir: null,
+      gitDir: null
+    };
+    const root = await command(cwd, ["rev-parse", "--show-toplevel"]);
+    if (root.failed) {
+      result.status = root.nonGit ? "non_git" : "failed";
+      if (!root.nonGit)
+        result.failedCommands.push("rev-parse --show-toplevel");
+      return result;
+    }
+    if (!root.value || root.value.includes("\n")) {
+      result.status = "ambiguous";
+      return result;
+    }
+    result.root = resolve(root.value);
+    result.status = "git";
+    const read = async (args) => {
+      const observation = await command(result.root, args);
+      if (observation.failed) {
+        result.failedCommands.push(args.join(" "));
+        result.status = "failed";
+      }
+      return observation.value;
+    };
+    const rawRemotes = await read(["remote", "-v"]);
+    const remotes = /* @__PURE__ */ new Map();
+    for (const line of rawRemotes?.split("\n") ?? []) {
+      const match = line.match(/^(\S+)\s+(\S+)\s+\((fetch|push)\)$/);
+      if (!match) {
+        if (result.failedCommands.length === 0)
+          result.status = "ambiguous";
+        continue;
+      }
+      const [, name, url] = match;
+      remotes.set(`${name}
+${url}`, normalizeGitRemoteUrl(url, name));
+    }
+    result.remotes = [...remotes.values()].sort((a, b) => `${a.name}:${a.fingerprint}`.localeCompare(`${b.name}:${b.fingerprint}`));
+    result.branch = await read(["branch", "--show-current"]);
+    result.headCommit = await read(["rev-parse", "HEAD"]);
+    const commonDir = await read(["rev-parse", "--git-common-dir"]);
+    const gitDir = await read(["rev-parse", "--git-dir"]);
+    result.commonDir = commonDir ? resolve(result.root, commonDir) : null;
+    result.gitDir = gitDir ? resolve(result.root, gitDir) : null;
+    if (result.status === "git") {
+      const watchedPaths = /* @__PURE__ */ new Set();
+      for (let parent = cwd; ; parent = dirname(parent)) {
+        watchedPaths.add(resolve(parent, ".git"));
+        if (dirname(parent) === parent)
+          break;
+      }
+      for (const directory of [result.commonDir, result.gitDir]) {
+        if (!directory)
+          continue;
+        watchedPaths.add(directory);
+        for (const file of [
+          "config",
+          "config.worktree",
+          "HEAD",
+          "commondir",
+          "packed-refs"
+        ]) {
+          watchedPaths.add(resolve(directory, file));
+        }
+        if (result.branch)
+          watchedPaths.add(resolve(directory, "refs", "heads", result.branch));
+      }
+      if (cache.size >= 256)
+        cache.delete(cache.keys().next().value);
+      const paths = [...watchedPaths];
+      cache.set(key, {
+        result: structuredClone(result),
+        watchedPaths: paths,
+        signature: signature(paths),
+        expiresAt: now() + ttl
+      });
+    }
+    return result;
+  };
+};
+var probeGitProject = createGitProjectProbe();
+
+// packages/koed-server/dist/repository-identity.js
+var resolveRepositoryIdentity = (input) => {
+  const { observation, deviceSalt, checkoutId } = input;
+  const base = {
+    root: observation.root ?? input.cwd,
+    branch: observation.branch,
+    checkoutId,
+    originatingDeviceId: deviceSalt,
+    selectedRemote: null,
+    anchorDisplay: null
+  };
+  const unresolved = (reason, selectedRemote = null) => ({
+    ...base,
+    kind: "unresolved",
+    key: null,
+    reason,
+    selectedRemote
+  });
+  if (observation.status === "failed" && (!observation.root || observation.failedCommands.some((command) => !["branch --show-current", "rev-parse HEAD"].includes(command))))
+    return unresolved("probe_failed");
+  if (observation.status === "ambiguous")
+    return unresolved("probe_ambiguous");
+  if (!checkoutId)
+    return unresolved("checkout_unavailable");
+  const selected = (remoteName, reason) => {
+    const candidates = observation.remotes.filter((remote2) => remote2.name === remoteName);
+    if (!candidates.length)
+      return unresolved("selection_missing", remoteName);
+    const keys = new Set(candidates.map((remote2) => remote2.fingerprint));
+    if (keys.size !== 1)
+      return unresolved("selection_conflict", remoteName);
+    const remote = candidates[0];
+    if (!isPortableGitRemote(remote))
+      return unresolved("selection_not_portable", remoteName);
+    return {
+      ...base,
+      kind: "portable_repository",
+      key: remote.fingerprint,
+      reason,
+      selectedRemote: remoteName,
+      anchorDisplay: remote.display
+    };
+  };
+  if (input.localSelection !== void 0)
+    return selected(input.localSelection, "local_selection");
+  if (input.associatedSelection) {
+    const { selection } = input.associatedSelection;
+    if (selection.state === "conflict")
+      return unresolved("selection_conflict");
+    const remote = observation.remotes.find((entry) => isPortableGitRemote(entry) && entry.fingerprint === selection.anchorFingerprint);
+    if (!remote)
+      return unresolved("replicated_anchor_missing");
+    return selected(remote.name, "replicated_selection");
+  }
+  if (observation.status === "non_git") {
+    return {
+      ...base,
+      kind: "non_git_project",
+      key: `ng_${hmacProjectValue(deviceSalt, `${input.cwd}
+${checkoutId}`).slice(12)}`,
+      reason: "non_git"
+    };
+  }
+  for (const remoteName of ["upstream", "origin"]) {
+    const remotes = observation.remotes.filter((remote) => remote.name === remoteName);
+    if (remotes.some(isPortableGitRemote))
+      return selected(remoteName, remoteName);
+  }
+  if (!observation.commonDir || !input.commonDirMarker)
+    return unresolved("probe_failed");
+  return {
+    ...base,
+    kind: "device_local_repository",
+    key: `dl_${hmacProjectValue(deviceSalt, `${observation.commonDir}
+${input.commonDirMarker}`).slice(12)}`,
+    reason: "local_fallback"
+  };
+};
+
+// packages/koed-server/dist/project-associated-selection.js
+var selectionSchema = external_exports.discriminatedUnion("state", [
+  external_exports.object({
+    state: external_exports.literal("selected"),
+    anchorFingerprint: external_exports.string().min(1).max(512)
+  }).strict(),
+  external_exports.object({ state: external_exports.literal("conflict") }).strict()
+]);
+var responseSchema = external_exports.object({
+  association: external_exports.object({
+    groupId: external_exports.string().min(1),
+    associationId: external_exports.string().min(1),
+    selectionId: external_exports.string().min(1),
+    selection: selectionSchema.nullable()
+  }).strict().nullable()
+}).strict();
+var lookupAcceptedProjectSelection = async (paths, checkout, deps = {}) => {
+  const environment = deps.environment ?? process.env;
+  const repoEnv = loadRepoEnv(paths.repoRoot);
+  const token = resolveActiveIntegrationApiToken(paths, environment, repoEnv);
+  if (!token)
+    throw new Error("Project association lookup requires the local API credential");
+  const runtime = readActiveRuntimeState(paths.runtimeStatePath);
+  const origin = new URL(runtime?.apiUrl ?? resolveApiUrl(applyPersistedLocalPorts(paths, environment, { force: true }), repoEnv));
+  if (!isLoopbackHostname(origin.hostname) || !["http:", "https:"].includes(origin.protocol) || origin.username || origin.password)
+    throw new Error("Project association lookup requires the local Personal API");
+  const url = new URL("/v1/memory/repository-selection", origin);
+  url.search = new URLSearchParams(checkout).toString();
+  const { response, payload } = await fetchBoundedJsonObject(deps.fetch ?? globalThis.fetch, url, {
+    headers: { authorization: `Bearer ${token.token}` },
+    redirect: "error"
+  }, { timeoutMs: 1e4, maxBytes: 64 * 1024 });
+  if (!response.ok) {
+    throw new Error("Project association lookup is unavailable; retry discovery");
+  }
+  const result = responseSchema.parse(payload);
+  const association = result.association;
+  return association?.selection ? {
+    associationId: association.associationId,
+    selection: association.selection
+  } : void 0;
+};
+
+// packages/koed-server/dist/project-metadata-lock.js
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import { mkdirSync } from "node:fs";
+import { dirname as dirname2 } from "node:path";
+var withProjectMetadataLock = (file, operation) => {
+  mkdirSync(dirname2(file), { recursive: true, mode: 448 });
+  const deadline = Date.now() + 5e3;
+  let release;
+  while (true) {
+    try {
+      release = import_proper_lockfile.default.lockSync(file, { realpath: false, stale: 3e4 });
+      break;
+    } catch (error) {
+      if (error.code !== "ELOCKED" || Date.now() >= deadline)
+        throw error;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+  }
+  try {
+    return operation();
+  } finally {
+    release();
+  }
+};
+
+// packages/koed-server/dist/project-metadata.js
+var depsWithDefaults = (deps = {}) => ({
+  existsSync: deps.existsSync ?? existsSync,
+  readFileSync: deps.readFileSync ?? readFileSync,
+  writeFileSync: deps.writeFileSync ?? writeFileSync,
+  renameSync: deps.renameSync ?? renameSync,
+  mkdirSync: deps.mkdirSync ?? mkdirSync2,
+  statSync: deps.statSync ?? statSync2,
+  lookupAssociatedSelection: deps.lookupAssociatedSelection ?? lookupAcceptedProjectSelection,
+  execFile: deps.execFile ?? nodeExecFile,
+  now: deps.now ?? (() => /* @__PURE__ */ new Date()),
+  randomId: deps.randomId ?? randomUUID,
+  probeGit: deps.probeGit ?? (deps.execFile ? createGitProjectProbe({ execFile: deps.execFile }) : probeGitProject)
+});
+var defaultStore = (now, deps) => ({
+  schemaVersion: 3,
+  updatedAt: now,
+  deviceSaltId: `pms_${deps.randomId()}`,
+  repositoryChanges: [],
+  checkouts: [],
+  namedProjects: [],
+  projects: []
+});
+var historicalFolderRepositoryIdentity = (paths, cwd, depsInput = {}) => {
+  const root = normalizeRecordedProjectDirectory(cwd);
+  if (!root)
+    return null;
+  const deps = depsWithDefaults(depsInput);
+  const store = readStore(paths, deps);
+  return {
+    kind: "non_git_project",
+    key: `ng_${hmacProjectValue(store.deviceSaltId, JSON.stringify(["historical_folder", root])).slice(12)}`,
+    root,
+    branch: null,
+    reason: "non_git",
+    checkoutId: null,
+    originatingDeviceId: store.deviceSaltId,
+    selectedRemote: null,
+    anchorDisplay: null
+  };
+};
+var readStoreUnlocked = (paths, deps) => {
+  const now = deps.now().toISOString();
+  if (!deps.existsSync(paths.projectMetadataPath)) {
+    return defaultStore(now, deps);
+  }
+  try {
+    const parsed = JSON.parse(deps.readFileSync(paths.projectMetadataPath, "utf8"));
+    const store = {
+      schemaVersion: 3,
+      updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : now,
+      deviceSaltId: typeof parsed.deviceSaltId === "string" && parsed.deviceSaltId.trim() ? parsed.deviceSaltId.trim() : `pms_${deps.randomId()}`,
+      repositoryChanges: Array.isArray(parsed.repositoryChanges) ? parsed.repositoryChanges.map((change) => repositoryChangeInputSchema.parse(change)) : [],
+      checkouts: Array.isArray(parsed.checkouts) ? parsed.checkouts.filter((entry) => typeof entry.id === "string" && typeof entry.root === "string" && typeof entry.marker === "string" && (entry.selectedRemote === void 0 || typeof entry.selectedRemote === "string") && (entry.associationLookupRequired === void 0 || typeof entry.associationLookupRequired === "boolean")) : [],
+      projects: Array.isArray(parsed.projects) ? parsed.projects.filter(isProjectMetadata).map(normalizeProjectMetadata) : [],
+      namedProjects: Array.isArray(parsed.namedProjects) ? parsed.namedProjects.map((project) => {
+        if (!project || typeof project.id !== "string" || typeof project.name !== "string" || !project.name.trim() || project.name.length > 160 || typeof project.createdAt !== "string")
+          throw new Error("Invalid named Project");
+        const repository = repositoryIdentitySchema.parse(project.repository);
+        if (repository.kind !== "local_project")
+          throw new Error("Invalid named Project identity");
+        return {
+          id: project.id,
+          name: project.name,
+          createdAt: project.createdAt,
+          repository
+        };
+      }) : []
+    };
+    if (parsed.schemaVersion !== 3 || parsed.deviceSaltId !== store.deviceSaltId) {
+      writeStore(paths, store, deps);
+    }
+    return store;
+  } catch (error) {
+    throw new Error("Project metadata config is malformed.", { cause: error });
+  }
+};
+var updateStore = (paths, deps, mutate) => withProjectMetadataLock(paths.projectMetadataPath, () => {
+  const store = readStoreUnlocked(paths, deps);
+  const result = mutate(store);
+  writeStore(paths, store, deps);
+  return result;
+});
+var readStore = (paths, deps) => withProjectMetadataLock(paths.projectMetadataPath, () => {
+  const store = readStoreUnlocked(paths, deps);
+  if (!deps.existsSync(paths.projectMetadataPath))
+    writeStore(paths, store, deps);
+  return store;
+});
+var writeStore = (paths, store, deps) => {
+  deps.mkdirSync(dirname3(paths.projectMetadataPath), {
+    recursive: true,
+    mode: 448
+  });
+  const tmpPath = `${paths.projectMetadataPath}.${randomUUID()}.tmp`;
+  try {
+    deps.writeFileSync(tmpPath, `${JSON.stringify(store, null, 2)}
+`, {
+      mode: 384
+    });
+    deps.renameSync(tmpPath, paths.projectMetadataPath);
+  } finally {
+    rmSync(tmpPath, { force: true });
+  }
+};
+var isProjectMetadata = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value) && value.schemaVersion === 1 && typeof value.localProjectId === "string" && typeof value.displayName === "string" && Boolean(value.path);
+var isNormalizedGitRemote = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const remote = value;
+  return typeof remote.name === "string" && (remote.host === null || typeof remote.host === "string") && (remote.namespace === null || typeof remote.namespace === "string") && (remote.repo === null || typeof remote.repo === "string") && (remote.display === null || typeof remote.display === "string") && typeof remote.fingerprint === "string";
+};
+var withoutFields = (value, ...fields) => {
+  const copy = { ...value };
+  for (const field of fields)
+    delete copy[field];
+  return copy;
+};
+var normalizeProjectMetadata = (value) => {
+  const metadata = withoutFields(value, "sourceProjectId");
+  if (!metadata.git)
+    return metadata;
+  const git = withoutFields(metadata.git, "remoteSetFingerprint", "remoteAliases", "commonDirHash");
+  const remotes = Array.isArray(git.remotes) ? git.remotes.filter(isNormalizedGitRemote) : [];
+  return {
+    ...metadata,
+    git: {
+      ...git,
+      remotes
+    }
+  };
+};
+var readPackageName = (packageJsonPath, deps) => {
+  try {
+    const parsed = JSON.parse(deps.readFileSync(packageJsonPath, "utf8"));
+    return typeof parsed.name === "string" && parsed.name.trim() ? parsed.name.trim() : null;
+  } catch {
+    return null;
+  }
+};
+var discoverPackages = (projectRoot, cwd, deps) => {
+  const root = projectRoot ?? cwd;
+  const packageJsonPath = resolve2(root, "package.json");
+  if (!deps.existsSync(packageJsonPath)) {
+    return [];
+  }
+  const manager = deps.existsSync(resolve2(root, "pnpm-lock.yaml")) ? "pnpm" : deps.existsSync(resolve2(root, "package-lock.json")) ? "npm" : deps.existsSync(resolve2(root, "yarn.lock")) ? "yarn" : deps.existsSync(resolve2(root, "bun.lockb")) ? "bun" : "unknown";
+  return [
+    {
+      manager,
+      name: readPackageName(packageJsonPath, deps),
+      relativePath: relative(root, packageJsonPath) || "package.json"
+    }
+  ];
+};
+var discoverProjectMetadata = async (paths, input, depsInput = {}) => {
+  const deps = depsWithDefaults(depsInput);
+  const initial = readStore(paths, deps);
+  const now = deps.now().toISOString();
+  const cwd = resolve2(input.cwd);
+  const observation = await deps.probeGit({
+    profile: paths.projectMetadataPath,
+    cwd,
+    deviceSalt: initial.deviceSaltId
+  });
+  const gitRoot = observation.root;
+  const remotes = observation.remotes;
+  const checkoutRoot = gitRoot ?? cwd;
+  let checkoutMarker = null;
+  try {
+    const stat = deps.statSync(observation.gitDir ?? checkoutRoot);
+    checkoutMarker = JSON.stringify([stat.dev, stat.ino, stat.birthtimeMs]);
+  } catch {
+  }
+  const observedCheckout = updateStore(paths, deps, (store) => {
+    let checkout = store.checkouts.find((entry) => entry.root === checkoutRoot && entry.marker === checkoutMarker);
+    if (!checkout && checkoutMarker) {
+      checkout = {
+        id: `checkout_${deps.randomId()}`,
+        root: checkoutRoot,
+        marker: checkoutMarker
+      };
+      store.checkouts.push(checkout);
+    }
+    return checkout;
+  });
+  let associatedSelection = input.associatedSelection;
+  const lookedUp = !associatedSelection && observedCheckout?.associationLookupRequired && observedCheckout.selectedRemote === void 0;
+  if (lookedUp) {
+    associatedSelection = await deps.lookupAssociatedSelection(paths, {
+      originatingDeviceId: initial.deviceSaltId,
+      checkoutId: observedCheckout.id
+    });
+  }
+  return updateStore(paths, deps, (store) => {
+    const checkout = store.checkouts.find((entry) => entry.id === observedCheckout?.id);
+    if (store.deviceSaltId !== initial.deviceSaltId || observedCheckout && !checkout)
+      throw new Error("Checkout changed during discovery; retry discovery");
+    if (checkoutMarker) {
+      const currentStat = deps.statSync(observation.gitDir ?? checkoutRoot);
+      if (JSON.stringify([
+        currentStat.dev,
+        currentStat.ino,
+        currentStat.birthtimeMs
+      ]) !== checkoutMarker)
+        throw new Error("Checkout changed during discovery; retry discovery");
+    }
+    if (lookedUp && !checkout?.associationLookupRequired)
+      associatedSelection = void 0;
+    const repository = resolveRepositoryIdentity({
+      observation,
+      cwd,
+      deviceSalt: store.deviceSaltId,
+      checkoutId: checkout?.id ?? null,
+      localSelection: checkout?.selectedRemote,
+      associatedSelection,
+      commonDirMarker: (() => {
+        try {
+          const stat = deps.statSync(observation.commonDir);
+          return JSON.stringify([stat.dev, stat.ino, stat.birthtimeMs]);
+        } catch {
+          return null;
+        }
+      })()
+    });
+    const packages = discoverPackages(gitRoot, cwd, deps);
+    const localProjectId = deriveLocalProjectId({
+      salt: store.deviceSaltId,
+      projectRoot: gitRoot,
+      cwd
+    });
+    const previousProject = store.projects.find((entry) => entry.localProjectId === localProjectId && entry.repository?.checkoutId === repository.checkoutId);
+    const previous = previousProject?.repository;
+    if (checkout && previous && previous.checkoutId === repository.checkoutId && !(previous.kind === "unresolved" && repository.kind === "unresolved" && previous.reason === repository.reason) && !repositoryIdentityMatches(previous, repository)) {
+      checkout.repositoryRevision = (checkout.repositoryRevision ?? 0) + 1;
+      store.repositoryChanges.push(repositoryChangeInputSchema.parse({
+        id: randomUUID(),
+        kind: "anchor_change",
+        originatingDeviceId: repository.originatingDeviceId,
+        checkoutId: checkout.id,
+        originatingRevision: checkout.repositoryRevision,
+        previousIdentity: previous,
+        targetIdentity: repository
+      }));
+    }
+    const { branch, headCommit, commonDir: resolvedCommonDir, gitDir: resolvedGitDir } = observation;
+    const isWorktree = Boolean(resolvedCommonDir && resolvedGitDir && resolvedCommonDir !== resolvedGitDir);
+    const displayName = normalizeProjectDisplayName({
+      cwd,
+      projectRoot: gitRoot,
+      packages,
+      remotes
+    });
+    const project = {
+      schemaVersion: 1,
+      discoveredAt: previousProject?.discoveredAt ?? now,
+      lastSeenAt: now,
+      localProjectId,
+      displayName,
+      path: {
+        cwd,
+        projectRoot: gitRoot,
+        basename: path.basename(gitRoot ?? cwd),
+        localPathHash: hmacProjectValue(store.deviceSaltId, gitRoot ?? cwd)
+      },
+      ...gitRoot ? {
+        git: {
+          rootHash: hmacProjectValue(store.deviceSaltId, gitRoot),
+          remotes,
+          branch,
+          headCommit,
+          isWorktree,
+          worktreeHash: isWorktree ? hmacProjectValue(store.deviceSaltId, gitRoot) : null
+        }
+      } : {},
+      repository,
+      packages,
+      ...input.aiClientSource ? {
+        aiClient: {
+          cwdHash: hmacProjectValue(store.deviceSaltId, cwd),
+          cwdBasename: path.basename(cwd),
+          source: input.aiClientSource
+        }
+      } : {}
+    };
+    const projects = [
+      ...store.projects.filter((entry) => entry.localProjectId !== localProjectId),
+      project
+    ].sort((left, right) => left.displayName.localeCompare(right.displayName));
+    store.updatedAt = now;
+    store.projects = projects;
+    return {
+      ok: true,
+      state: "discovered",
+      message: "Project metadata discovered.",
+      gitProbe: {
+        status: observation.status,
+        failedCommands: observation.failedCommands
+      },
+      project
+    };
+  });
+};
+var listProjectMetadata = (paths, depsInput = {}) => {
+  const store = readStore(paths, depsWithDefaults(depsInput));
+  return {
+    ok: true,
+    state: "listed",
+    message: `Found ${store.projects.length} Project metadata record(s).`,
+    projects: store.projects
+  };
+};
+var listNamedProjects = (paths, depsInput = {}) => readStore(paths, depsWithDefaults(depsInput)).namedProjects;
+var createNamedProject = (paths, name, depsInput = {}) => {
+  const trimmed = name.trim();
+  if (!trimmed || trimmed.length > 160)
+    throw new Error("Enter a Project name of 1 to 160 characters.");
+  const deps = depsWithDefaults(depsInput);
+  return updateStore(paths, deps, (store) => {
+    if (store.namedProjects.length >= 500)
+      throw new Error("The local Project catalog is full.");
+    const id = `project_${deps.randomId()}`;
+    const project = {
+      id,
+      name: trimmed,
+      createdAt: deps.now().toISOString(),
+      repository: {
+        kind: "local_project",
+        key: id,
+        reason: "manual",
+        originatingDeviceId: store.deviceSaltId,
+        root: null,
+        branch: null,
+        checkoutId: null,
+        selectedRemote: null,
+        anchorDisplay: null
+      }
+    };
+    store.updatedAt = project.createdAt;
+    store.namedProjects.push(project);
+    return project;
+  });
+};
+var getProjectMetadataForCwd = (paths, cwd, depsInput = {}) => {
+  const resolvedCwd = resolve2(cwd);
+  const store = readStore(paths, depsWithDefaults(depsInput));
+  const project = store.projects.find((entry) => entry.path.cwd === resolvedCwd || entry.path.projectRoot === resolvedCwd) ?? null;
+  if (!project) {
+    return {
+      ok: false,
+      state: "missing",
+      message: "Project metadata not found."
+    };
+  }
+  return {
+    ok: true,
+    state: "found",
+    message: "Project metadata found.",
+    project
+  };
+};
+var forgetProjectMetadata = (paths, localProjectId, depsInput = {}) => {
+  const deps = depsWithDefaults(depsInput);
+  return updateStore(paths, deps, (store) => {
+    const project = store.projects.find((entry) => entry.localProjectId === localProjectId);
+    if (!project) {
+      return {
+        ok: false,
+        state: "missing",
+        message: "Project metadata not found."
+      };
+    }
+    const now = deps.now().toISOString();
+    store.updatedAt = now;
+    store.projects = store.projects.filter((entry) => entry.localProjectId !== localProjectId);
+    return {
+      ok: true,
+      state: "forgotten",
+      message: "Project metadata forgotten.",
+      project
+    };
+  });
+};
+var setProjectRepositoryAnchor = async (paths, input, depsInput = {}) => {
+  if (input.remoteName !== null && (!input.remoteName.trim() || input.remoteName.length > 512 || /\s/.test(input.remoteName)))
+    throw new Error("Repository remote name is invalid.");
+  const deps = depsWithDefaults(depsInput);
+  const original = readStore(paths, deps).projects.find((project) => project.localProjectId === input.localProjectId);
+  if (!original)
+    throw new Error("Project metadata not found.");
+  const discovery = await discoverProjectMetadata(paths, { cwd: original.path.projectRoot ?? original.path.cwd }, depsInput);
+  if (discovery.project?.repository?.checkoutId !== input.expectedCheckoutId)
+    throw new Error("Checkout changed. Inspect the Project again before selecting an anchor.");
+  updateStore(paths, deps, (store) => {
+    const checkout = store.checkouts.find((entry) => entry.id === input.expectedCheckoutId);
+    if (!checkout)
+      throw new Error("Checkout provenance is unavailable.");
+    if (input.remoteName === null)
+      delete checkout.selectedRemote;
+    else
+      checkout.selectedRemote = input.remoteName;
+  });
+  return discoverProjectMetadata(paths, { cwd: original.path.projectRoot ?? original.path.cwd }, depsInput);
+};
+var setProjectAssociationLookup = async (paths, input, depsInput = {}) => {
+  const deps = depsWithDefaults(depsInput);
+  const original = readStore(paths, deps).projects.find((entry) => entry.localProjectId === input.localProjectId);
+  if (!original)
+    throw new Error("Local Project is unavailable");
+  const discovery = await discoverProjectMetadata(paths, { cwd: original.path.projectRoot ?? original.path.cwd }, depsInput);
+  if (discovery.project?.repository?.checkoutId !== input.expectedCheckoutId)
+    throw new Error("Checkout changed; inspect the Project again");
+  updateStore(paths, deps, (store) => {
+    const checkout = store.checkouts.find((entry) => entry.id === input.expectedCheckoutId);
+    if (!checkout)
+      throw new Error("Checkout provenance is unavailable");
+    checkout.associationLookupRequired = input.enabled;
+  });
+};
+var refreshProjectAssociations = async (paths, depsInput = {}) => {
+  const store = readStore(paths, depsWithDefaults(depsInput));
+  for (const project of store.projects) {
+    if (!store.checkouts.some((entry) => entry.id === project.repository?.checkoutId && entry.associationLookupRequired))
+      continue;
+    await discoverProjectMetadata(paths, { cwd: project.path.projectRoot ?? project.path.cwd }, depsInput);
+  }
+};
+var listPendingRepositoryChanges = (paths, depsInput = {}) => readStore(paths, depsWithDefaults(depsInput)).repositoryChanges;
+var acknowledgeRepositoryChange = (paths, id, depsInput = {}) => {
+  const deps = depsWithDefaults(depsInput);
+  updateStore(paths, deps, (store) => {
+    store.repositoryChanges = store.repositoryChanges.filter((change) => change.id !== id);
+  });
+};
+export {
+  acknowledgeRepositoryChange,
+  createNamedProject,
+  discoverProjectMetadata,
+  forgetProjectMetadata,
+  getProjectMetadataForCwd,
+  historicalFolderRepositoryIdentity,
+  listNamedProjects,
+  listPendingRepositoryChanges,
+  listProjectMetadata,
+  refreshProjectAssociations,
+  setProjectAssociationLookup,
+  setProjectRepositoryAnchor
+};