@mnemonik/cli 7.104.11 → 7.105.0

package/dist/router.js

@@ -517,17 +517,311 @@ var init_repositoryFingerprint = __esm({
 });
 
 // packages/shared/dist/projectIdentityFile.js
+import { lstat, readFile } from "node:fs/promises";
+import { join as join2 } from "node:path";
+function parseIdentityFile(text) {
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch (error) {
+    return { kind: "malformed", detail: `unparseable JSON: ${error.message}` };
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return { kind: "malformed", detail: "identity file must contain a JSON object" };
+  }
+  const record = value;
+  if (record.schemaVersion !== 1) {
+    return { kind: "unknown_version", version: record.schemaVersion };
+  }
+  const unknownKey = Object.keys(record).find((key) => !IDENTITY_KEYS.has(key));
+  if (unknownKey)
+    return { kind: "malformed", detail: `unknown key "${unknownKey}"` };
+  if (!isCanonicalUuid(record.projectId)) {
+    return { kind: "malformed", detail: '"projectId" must be a canonical RFC 4122 UUID string' };
+  }
+  if ("projectName" in record && typeof record.projectName !== "string") {
+    return { kind: "malformed", detail: '"projectName" must be a string when present' };
+  }
+  if ("repositoryFingerprint" in record && (!record.repositoryFingerprint || typeof record.repositoryFingerprint !== "object" || Array.isArray(record.repositoryFingerprint))) {
+    return { kind: "malformed", detail: '"repositoryFingerprint" must be an object when present' };
+  }
+  const fingerprint = record.repositoryFingerprint;
+  const unknownFingerprintKey = fingerprint ? Object.keys(fingerprint).find((key) => !FINGERPRINT_KEYS.has(key)) : void 0;
+  if (unknownFingerprintKey) {
+    return {
+      kind: "malformed",
+      detail: `unknown repositoryFingerprint key "${unknownFingerprintKey}"`
+    };
+  }
+  if (fingerprint && (fingerprint.algorithmVersion !== 1 || typeof fingerprint.hash !== "string")) {
+    return {
+      kind: "malformed",
+      detail: '"repositoryFingerprint" must contain algorithmVersion 1 and a string hash'
+    };
+  }
+  const repositoryFingerprint = fingerprint ? { algorithmVersion: 1, hash: fingerprint.hash } : void 0;
+  return {
+    kind: "ok",
+    identity: {
+      schemaVersion: 1,
+      projectId: record.projectId,
+      ...record.projectName === void 0 ? {} : { projectName: record.projectName },
+      ...repositoryFingerprint ? { repositoryFingerprint } : {}
+    }
+  };
+}
+async function readIdentityFile(dir, options = {}) {
+  const path = join2(dir, ".mnemonik.json");
+  try {
+    const stat = await lstat(path);
+    if (stat.isSymbolicLink())
+      return { kind: "malformed", detail: "symlink" };
+    if (!stat.isFile())
+      return { kind: "malformed", detail: "identity path is not a regular file" };
+    const text = await readFile(path, "utf8");
+    if (options.selectedRoot) {
+      try {
+        const value = JSON.parse(text);
+        if (value && typeof value === "object" && !Array.isArray(value) && !("projectId" in value))
+          return { kind: "absent" };
+      } catch {
+      }
+    }
+    return parseIdentityFile(text);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { kind: "absent" };
+    return { kind: "malformed", detail: `cannot read identity file: ${error.message}` };
+  }
+}
+var CANONICAL_UUID, isCanonicalUuid, IDENTITY_KEYS, FINGERPRINT_KEYS;
 var init_projectIdentityFile = __esm({
   "packages/shared/dist/projectIdentityFile.js"() {
     "use strict";
+    CANONICAL_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+    isCanonicalUuid = (value) => typeof value === "string" && CANONICAL_UUID.test(value);
+    IDENTITY_KEYS = /* @__PURE__ */ new Set([
+      "schemaVersion",
+      "projectId",
+      "projectName",
+      "repositoryFingerprint"
+    ]);
+    FINGERPRINT_KEYS = /* @__PURE__ */ new Set(["algorithmVersion", "hash"]);
   }
 });
 
 // packages/shared/dist/repositoryRoot.js
+import { lstat as lstat2, readFile as readFile2 } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join3, resolve } from "node:path";
+function gitEnvironment() {
+  const env = {};
+  for (const key of GIT_ENV_KEYS) {
+    if (process.env[key] !== void 0)
+      env[key] = process.env[key];
+  }
+  env.LC_ALL = "C";
+  return env;
+}
+function runGit(cwd, args2) {
+  return new Promise((resolvePromise, reject) => {
+    execFile("git", args2, { cwd, timeout: GIT_TIMEOUT_MS, encoding: "utf8", env: gitEnvironment() }, (error, stdout, stderr) => {
+      if (error)
+        reject(Object.assign(error, { stdout, stderr }));
+      else
+        resolvePromise({ stdout, stderr });
+    });
+  });
+}
+async function boundaryAt(path) {
+  try {
+    const stat = await lstat2(join3(path, ".git"));
+    if (stat.isDirectory())
+      return { path, kind: "directory" };
+    if (stat.isFile())
+      return { path, kind: "file" };
+  } catch (error) {
+    const code = error.code;
+    if (code !== "ENOENT" && code !== "ENOTDIR")
+      throw error;
+  }
+  return void 0;
+}
+async function confirmedBoundaryAt(path) {
+  const boundary = await boundaryAt(path);
+  if (!boundary)
+    return void 0;
+  try {
+    const { stdout } = await runGit(path, ["rev-parse", "--git-dir"]);
+    return stdout.trim() ? boundary : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function boundariesBetween(cwd, root) {
+  const boundaries = [];
+  let directory = cwd;
+  while (directory !== root) {
+    const boundary = await confirmedBoundaryAt(directory);
+    if (boundary)
+      boundaries.push(boundary);
+    const parent = dirname2(directory);
+    if (parent === directory)
+      break;
+    directory = parent;
+  }
+  return boundaries;
+}
+async function containingRepository(root) {
+  let directory = dirname2(root);
+  while (true) {
+    const boundary = await confirmedBoundaryAt(directory);
+    if (boundary)
+      return boundary;
+    const parent = dirname2(directory);
+    if (parent === directory)
+      return void 0;
+    directory = parent;
+  }
+}
+async function canonicalBoundaryRoot(boundary) {
+  if (boundary.kind === "directory")
+    return boundary.path;
+  const pointer = /^gitdir:\s*(.+)\s*$/im.exec(await readFile2(join3(boundary.path, ".git"), "utf8"))?.[1];
+  if (!pointer)
+    return boundary.path;
+  const gitDir = resolve(boundary.path, pointer);
+  try {
+    const commonDir = resolve(gitDir, (await readFile2(join3(gitDir, "commondir"), "utf8")).trim());
+    return dirname2(commonDir);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return boundary.path;
+    throw error;
+  }
+}
+async function resolveRepositoryRoot(cwd) {
+  const absoluteCwd = resolve(cwd);
+  try {
+    const { stdout } = await runGit(absoluteCwd, [
+      "rev-parse",
+      "--show-toplevel",
+      "--git-common-dir"
+    ]);
+    const [rootLine, commonLine, ...extra] = stdout.trim().split(/\r?\n/);
+    if (!rootLine || !commonLine || extra.length) {
+      return { kind: "git_unavailable", detail: "git rev-parse returned an unexpected response" };
+    }
+    const root = resolve(rootLine);
+    const commonDir = resolve(root, commonLine);
+    const isLinkedWorktree = commonDir !== join3(root, ".git");
+    const nested = await boundariesBetween(absoluteCwd, root);
+    if (!isLinkedWorktree && await containingRepository(root)) {
+      const boundary = await boundaryAt(root);
+      if (boundary)
+        nested.push(boundary);
+    }
+    return {
+      kind: "git",
+      root,
+      commonDir,
+      isLinkedWorktree,
+      nested
+    };
+  } catch (error) {
+    const failure = error;
+    if (failure.code === 128 && /not a git repository/i.test(failure.stderr ?? failure.message)) {
+      return { kind: "plain", root: absoluteCwd };
+    }
+    return { kind: "git_unavailable", detail: failure.message };
+  }
+}
+async function readPlainIdentity(start2) {
+  const home = resolve(homedir());
+  let directory = start2;
+  while (true) {
+    const result = await readIdentityFile(directory);
+    if (result.kind !== "absent")
+      return { root: directory, result };
+    if (directory === home)
+      break;
+    const parent = dirname2(directory);
+    if (parent === directory)
+      break;
+    directory = parent;
+  }
+  return { root: start2, result: { kind: "absent" } };
+}
+function withBase(repository, root, nested) {
+  return { root, repository, nested };
+}
+async function resolveProjectIdentity(cwd, options = {}) {
+  const resolved = await resolveRepositoryRoot(cwd);
+  const repository = resolved.kind === "git_unavailable" ? { kind: "plain", root: resolve(cwd) } : resolved;
+  if (repository.kind === "plain") {
+    const { root, result } = options.selectedRoot ? { root: repository.root, result: await readIdentityFile(repository.root, options) } : await readPlainIdentity(repository.root);
+    const base2 = withBase(repository, root, []);
+    if (result.kind === "ok")
+      return { ...base2, ...result };
+    if (result.kind === "unknown_version")
+      return { ...base2, ...result, path: root };
+    if (result.kind === "malformed")
+      return { ...base2, ...result, path: root };
+    return { ...base2, kind: "absent" };
+  }
+  const ownRoot = repository.isLinkedWorktree ? dirname2(repository.commonDir) : repository.root;
+  const outer = repository.isLinkedWorktree ? void 0 : await containingRepository(repository.root);
+  const own = await readIdentityFile(ownRoot, options);
+  if (!outer || options.selectedRoot || own.kind === "ok") {
+    const base2 = withBase(repository, ownRoot, repository.nested);
+    if (own.kind === "ok")
+      return { ...base2, ...own };
+    if (own.kind === "unknown_version")
+      return { ...base2, ...own, path: ownRoot };
+    if (own.kind === "malformed")
+      return { ...base2, ...own, path: ownRoot };
+    return { ...base2, kind: "absent" };
+  }
+  const nested = repository.nested;
+  const parentRoot = await canonicalBoundaryRoot(outer);
+  const parent = await readIdentityFile(parentRoot);
+  const base = withBase(repository, parentRoot, nested);
+  if (own.kind === "unknown_version")
+    return { ...base, ...own, path: ownRoot };
+  if (own.kind === "malformed")
+    return { ...base, ...own, path: ownRoot };
+  if (parent.kind === "unknown_version")
+    return { ...base, ...parent, path: parentRoot };
+  if (parent.kind === "malformed")
+    return { ...base, ...parent, path: parentRoot };
+  if (!options.allowNestedInherit) {
+    return {
+      ...base,
+      kind: "nested",
+      ...parent.kind === "ok" ? { parentIdentity: parent.identity } : {}
+    };
+  }
+  if (parent.kind === "ok")
+    return { ...base, kind: "ok", identity: parent.identity };
+  return { ...base, kind: "absent" };
+}
+var GIT_TIMEOUT_MS, GIT_ENV_KEYS;
 var init_repositoryRoot = __esm({
   "packages/shared/dist/repositoryRoot.js"() {
     "use strict";
     init_projectIdentityFile();
+    GIT_TIMEOUT_MS = 2e3;
+    GIT_ENV_KEYS = [
+      "PATH",
+      "HOME",
+      "LANG",
+      "LC_ALL",
+      "SYSTEMROOT",
+      "TEMP",
+      "TMP",
+      "USERPROFILE"
+    ];
   }
 });
 
@@ -2183,13 +2477,13 @@ async function Module2(moduleArg = {}) {
       }
       readAsync = /* @__PURE__ */ __name(async (url) => {
         if (isFileURI(url)) {
-          return new Promise((resolve, reject) => {
+          return new Promise((resolve2, reject) => {
             var xhr = new XMLHttpRequest();
             xhr.open("GET", url, true);
             xhr.responseType = "arraybuffer";
             xhr.onload = () => {
               if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                resolve(xhr.response);
+                resolve2(xhr.response);
                 return;
               }
               reject(xhr.status);
@@ -2385,9 +2679,9 @@ async function Module2(moduleArg = {}) {
     __name(receiveInstantiationResult, "receiveInstantiationResult");
     var info22 = getWasmImports();
     if (Module["instantiateWasm"]) {
-      return new Promise((resolve, reject) => {
+      return new Promise((resolve2, reject) => {
         Module["instantiateWasm"](info22, (mod, inst) => {
-          resolve(receiveInstance(mod, inst));
+          resolve2(receiveInstance(mod, inst));
         });
       });
     }
@@ -3718,8 +4012,8 @@ async function Module2(moduleArg = {}) {
   if (runtimeInitialized) {
     moduleRtn = Module;
   } else {
-    moduleRtn = new Promise((resolve, reject) => {
-      readyPromiseResolve = resolve;
+    moduleRtn = new Promise((resolve2, reject) => {
+      readyPromiseResolve = resolve2;
       readyPromiseReject = reject;
     });
   }
@@ -4866,10 +5160,10 @@ function apiOrigin(env = process.env) {
 
 // packages/local-setup/dist/storage.js
 init_hookRuntime();
-import { homedir } from "node:os";
-import { dirname as dirname2, join as join2, win32, posix } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname3, join as join4, win32, posix } from "node:path";
 init_hookRuntime();
-function stateDirectory(platform = process.platform, env = process.env, home = homedir()) {
+function stateDirectory(platform = process.platform, env = process.env, home = homedir2()) {
   if (env.MNEMONIK_STATE_DIR)
     return env.MNEMONIK_STATE_DIR;
   if (platform === "win32")
@@ -4956,12 +5250,12 @@ import {
 import { hostOrder, launchHostLabels } from "./install/adapters.js";
 import { readInstallVersions } from "./install/ownership.js";
 import { ensureLauncher, removeLauncher, LauncherError } from "./launcher.js";
-import { readFile, realpath } from "node:fs/promises";
+import { readFile as readFile3, realpath } from "node:fs/promises";
 import { createInterface } from "node:readline";
 import { RuntimeStore, updateRuntime } from "./runtime/store.js";
 import { updateCli, cliUpdateHint } from "./runtime/selfUpdate.js";
-import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+import { join as join5 } from "node:path";
 import { Output } from "./output.js";
 import { SCANNER_RESTART_MESSAGE } from "./scanner/service.js";
 import { SCANNER_FAILURE_MESSAGE, SCANNER_RETRY_MESSAGE } from "./screens/journey.js";
@@ -4978,6 +5272,7 @@ import {
 import { evaluateRoot } from "./project/eligibility.js";
 import { grantTransport, grantHost } from "./auth/status.js";
 import { createCliAuth } from "./auth/index.js";
+import { runEditorLogin } from "./auth/pkce.js";
 import { currentInstallSession, ensureInstallSession } from "./auth/installSession.js";
 import { runIdentityMigration } from "./identity/migrate.js";
 import { renderScannerStatus } from "./scanner/picker.js";
@@ -5005,7 +5300,14 @@ import {
 var connectFolderPrompt = (name2) => `Connect ${name2} to Mnemonik? [Y/n]`;
 var removeFolderPrompt = (name2) => `Stop indexing ${name2}? Its memories stay in your account. [y/N]`;
 var connectedFolderLine = (name2) => `  \u2713 Connected ${name2}.`;
+var alreadyConnectedFolderLine = (name2) => `  \u2713 ${name2} is already connected and watched.`;
 var removedFolderLine = (name2) => `  \u2713 ${name2} is no longer connected.`;
+var projectDeletionWarning = (name2) => `Deleting ${name2} removes its memories, code index and summaries for everyone. This cannot be undone.`;
+var projectDeletedLine = (name2) => `Deleted ${name2}.`;
+var stillWatchedLine = (root) => `The folder is still being indexed. Run mnemonik remove ${root} to stop that.`;
+var identityFileKeptLine = "This folder's .mnemonik.json still points at the deleted project. Connecting the folder again creates a new project.";
+var CODEX_SIGNED_IN_MESSAGE = "Codex is signed in to Mnemonik.";
+var CONNECT_NOT_APPROVED_MESSAGE = "Sign-in timed out. Run mnemonik connect codex to try again.";
 function maintenanceExitCode(results) {
   if (results.some((result) => result.status === "FAILED")) return 1;
   return results.every((result) => result.status === "READY") ? 0 : 3;
@@ -5064,7 +5366,7 @@ Commands:
   install
   status
   connect <${hostOrder.join("|")}>
-  project <init|setup|status|link|ensure>
+  project <init|setup|status|link|ensure|delete>
   add <folder>
   remove <folder>
   data delete --project <id>
@@ -5083,6 +5385,7 @@ Install consent: --accept-indexing --accept-limited --apply`;
 function parse(args2) {
   const positionals = [];
   const flags2 = /* @__PURE__ */ new Map();
+  const namedConfirm = args2[0] === "project" && args2[1] === "delete";
   for (let index = 0; index < args2.length; index++) {
     const argument = args2[index] ?? "";
     if (!argument.startsWith("--")) {
@@ -5096,8 +5399,17 @@ function parse(args2) {
       continue;
     }
     if (booleans.has(name2)) {
-      if (inline !== void 0) return { positionals, flags: flags2, error: `Unknown flag: ${argument}` };
-      flags2.set(name2 === "accept-scanner" ? "accept-indexing" : name2, true);
+      const takesName = name2 === "confirm" && namedConfirm;
+      if (inline !== void 0 && !takesName)
+        return { positionals, flags: flags2, error: `Unknown flag: ${argument}` };
+      const next = args2[index + 1];
+      let value = true;
+      if (takesName && inline !== void 0) value = inline;
+      else if (takesName && next !== void 0 && !next.startsWith("--")) {
+        value = next;
+        index++;
+      }
+      flags2.set(name2 === "accept-scanner" ? "accept-indexing" : name2, value);
       continue;
     }
     if (values.has(name2)) {
@@ -5179,7 +5491,7 @@ async function hostDependencies(deps, output, state) {
   if (!cliAuth.accountEmail) throw new Error("account_identity_failed");
   const email = await cliAuth.accountEmail(bearer);
   const installation = JSON.parse(
-    await readFile(join3(state, "installation.json"), "utf8").catch(() => "{}")
+    await readFile3(join5(state, "installation.json"), "utf8").catch(() => "{}")
   );
   return {
     stateDir: state,
@@ -5196,7 +5508,7 @@ async function hostDependencies(deps, output, state) {
 async function updateHostDependencies(deps, state) {
   if (deps.hostManagement) return { ...deps.hostManagement, stateDir: state };
   const installation = JSON.parse(
-    await readFile(join3(state, "installation.json"), "utf8").catch(() => "{}")
+    await readFile3(join5(state, "installation.json"), "utf8").catch(() => "{}")
   );
   return {
     stateDir: state,
@@ -5204,7 +5516,7 @@ async function updateHostDependencies(deps, state) {
   };
 }
 async function packageVersion() {
-  const contents = await readFile(new URL("../package.json", import.meta.url), "utf8");
+  const contents = await readFile3(new URL("../package.json", import.meta.url), "utf8");
   return JSON.parse(contents).version;
 }
 async function runHostCommand(command, parsed, deps, output, scannerSelected = false) {
@@ -5236,7 +5548,7 @@ async function runHostCommand(command, parsed, deps, output, scannerSelected = f
         component: component2,
         host: name2,
         scope: "user",
-        home: deps.home ?? homedir2(),
+        home: deps.home ?? homedir3(),
         projectRoot: deps.cwd ?? process.cwd()
       }))
     );
@@ -5305,7 +5617,7 @@ async function runHostCommand(command, parsed, deps, output, scannerSelected = f
         noBrowser: parsed.flags.has("no-browser"),
         source: dependencies.source ?? (updatedCli ? (host2) => hostSource(
           host2,
-          join3(updatedCli.directory, "node_modules/@mnemonik/cli/package.json")
+          join5(updatedCli.directory, "node_modules/@mnemonik/cli/package.json")
         ) : void 0),
         instruction: json ? void 0 : (text) => output.line(text),
         apply: parsed.flags.has("apply")
@@ -5316,7 +5628,7 @@ async function runHostCommand(command, parsed, deps, output, scannerSelected = f
     let scanner;
     let launcher;
     let scannerRecovery;
-    if (all && await readFile(`${state}/scanner/state.json`).then(
+    if (all && await readFile3(`${state}/scanner/state.json`).then(
       () => true,
       () => false
     )) {
@@ -5358,7 +5670,7 @@ async function runHostCommand(command, parsed, deps, output, scannerSelected = f
     if (fullUninstall && hostExit === 0) {
       const installed = await Promise.all(
         [new RuntimeStore(state).pointerPath("scanner"), `${state}/scanner/state.json`].map(
-          (path) => readFile(path).then(
+          (path) => readFile3(path).then(
             () => true,
             () => false
           )
@@ -5402,18 +5714,29 @@ async function runHostCommand(command, parsed, deps, output, scannerSelected = f
         ...remaining ? { remaining } : {}
       });
     else if (command === "update") {
-      if (failed || hostsFailed) output.error(updateFailureMessage);
-      else if (codexTrustPending) {
+      if (failed || hostsFailed) {
+        if (cli?.status === "UPDATED") output.line("The mnemonik command updated.");
+        if (result.reports.length > 0 && !hostsFailed) output.line("Your editors updated.");
+        if (scanner?.status === "UPDATED") output.line("The scanner updated.");
+        if (cli?.status === "FAILED") {
+          output.error("The mnemonik command could not update.");
+          output.error("Run npx -y @mnemonik/cli@latest install to update it.");
+        }
+        if (hostsFailed) {
+          output.error("Your editors could not update.");
+          output.error("Run mnemonik repair, then start a new session in each editor.");
+        }
+        if (scanner?.status === "FAILED") {
+          output.error(scannerRecovery?.message ?? "The scanner could not update.");
+          output.error(scannerRecovery?.action ?? SCANNER_RETRY_MESSAGE);
+        }
+      } else if (codexTrustPending) {
         output.line("Mnemonik updated.");
         output.line(CODEX_TRUST_MESSAGE.sentence);
         output.line(CODEX_TRUST_MESSAGE.nextStep);
       } else if (cli?.status === "UPDATED" || result.reports.length > 0 || scanner?.status === "UPDATED")
         output.line("Mnemonik updated.");
       else output.line("Mnemonik is up to date.");
-      if (scannerRecovery) {
-        output.error(scannerRecovery.message);
-        if (scannerRecovery.action) output.error(scannerRecovery.action);
-      }
     } else {
       for (const target of result.results)
         output.line(target.status === "READY" ? "Done." : humanReason(target.reason));
@@ -5591,7 +5914,7 @@ async function doctorCommand(parsed, deps, output) {
   const invalid = allowed(parsed, []);
   if (invalid) return output.error(invalid), 2;
   const result = await runPreflight({ cwd: deps.cwd, home: deps.home, ...deps.preflight });
-  output.setContext({ home: deps.home ?? homedir2(), projectRoot: result.project.root });
+  output.setContext({ home: deps.home ?? homedir3(), projectRoot: result.project.root });
   const document = await collectStatusDocument({
     preflight: result,
     cwd: deps.cwd ?? process.cwd(),
@@ -5628,10 +5951,10 @@ async function collectCurrentInstallation(deps, output) {
     ...deps.preflight,
     fetch: async () => new Response(null, { status: 204 })
   });
-  output.setContext({ home: deps.home ?? homedir2(), projectRoot: result.project.root });
+  output.setContext({ home: deps.home ?? homedir3(), projectRoot: result.project.root });
   const hostStateDir = deps.hostManagement?.stateDir ?? deps.installStateDir ?? stateDirectory(process.platform, process.env, deps.home);
   const localConditions = deps.projectHookConditions ? [] : [
-    ...await localInstallationConditions(deps.home ?? homedir2(), hostStateDir, deps.launcher),
+    ...await localInstallationConditions(deps.home ?? homedir3(), hostStateDir, deps.launcher),
     // Installed Codex hooks that Codex has not trusted cannot run.
     ...await (deps.codexTrustConditions ?? (() => codexTrustConditions({
       stateDir: hostStateDir,
@@ -5675,6 +5998,96 @@ async function reportCurrentInstallation(deps, output, document) {
   ).catch(() => {
   });
 }
+async function deleteProjectCommand(parsed, rest, deps, output) {
+  const json = parsed.flags.has("json");
+  const cwd = deps.cwd ?? process.cwd();
+  const resolve2 = deps.projectResolver?.resolveProjectIdentity ?? resolveProjectIdentity;
+  const here = await resolve2(cwd, { allowNestedInherit: false });
+  const hereId = here.kind === "ok" ? here.identity.projectId : void 0;
+  const root = "root" in here ? here.root : cwd;
+  const target = rest[0] ?? hereId;
+  if (!target) {
+    output.error(
+      "This folder is not connected to a project. Run mnemonik project delete <name> instead."
+    );
+    return 3;
+  }
+  const bearer = await ensureCliAuth(deps, output, parsed.flags.has("no-browser"), false);
+  const send = deps.grantFetch ?? fetch;
+  const listed = await send(`${apiOrigin()}/api/v1/users/me/projects?days=0&limit=200`, {
+    headers: { Authorization: `Bearer ${bearer}` }
+  });
+  if (!listed.ok) {
+    output.error("Mnemonik could not be reached from this machine.");
+    return 3;
+  }
+  const listing = await listed.json().catch(() => []);
+  const projects = Array.isArray(listing) ? listing : [];
+  const project = projects.find(
+    (candidate) => candidate.id === target || candidate.name?.toLowerCase() === target.toLowerCase()
+  );
+  if (!project) {
+    output.error(`There is no project called ${target} in your account.`);
+    return 3;
+  }
+  const supplied = parsed.flags.get("confirm");
+  let typed = typeof supplied === "string" ? supplied : "";
+  if (typeof supplied !== "string") {
+    if (parsed.flags.has("non-interactive") || json) {
+      output.error(
+        `To skip this check, run mnemonik project delete ${project.name} --confirm "${project.name}".`
+      );
+      return 3;
+    }
+    output.line(projectDeletionWarning(project.name));
+    output.line("Type the project name to confirm.");
+    const readline = createInterface({ input: deps.input ?? process.stdin, terminal: false });
+    typed = String((await readline[Symbol.asyncIterator]().next()).value ?? "").trim();
+    readline.close();
+    if (typed.toLowerCase() !== project.name.toLowerCase()) {
+      output.line("Nothing was deleted.");
+      return 130;
+    }
+  }
+  if (typed.toLowerCase() !== project.name.toLowerCase()) {
+    output.error("That is not the project name. Nothing was deleted.");
+    return 3;
+  }
+  const response = await send(`${apiOrigin()}/api/v1/projects/${encodeURIComponent(project.id)}`, {
+    method: "DELETE",
+    headers: { Authorization: `Bearer ${bearer}`, "content-type": "application/json" },
+    body: JSON.stringify({ confirmProjectName: typed })
+  });
+  if (!response.ok) {
+    output.error(
+      response.status === 403 ? `Only the owner of ${project.name} can delete it.` : response.status === 404 ? `There is no project called ${target} in your account.` : `${project.name} could not be deleted. Try again in a moment.`
+    );
+    return 3;
+  }
+  const result = await response.json().catch(() => ({ success: true }));
+  const stateDir = deps.installStateDir ?? stateDirectory(process.platform, process.env, deps.home);
+  const saved = JSON.parse(
+    await readFile3(`${stateDir}/scanner/state.json`, "utf8").catch(() => "null")
+  );
+  let stillWatched = false;
+  if (hereId === project.id && saved?.config.roots.includes(root)) {
+    const update = await updateScannerRoots({
+      stateDir,
+      bearer,
+      add: [],
+      remove: [root],
+      fetch: deps.grantFetch
+    }).catch(() => void 0);
+    stillWatched = update?.status !== "updated";
+  }
+  if (json) output.json(result);
+  else {
+    output.line(projectDeletedLine(project.name));
+    if (stillWatched) output.line(stillWatchedLine(root));
+    if (hereId === project.id) output.line(identityFileKeptLine);
+  }
+  return 0;
+}
 async function runCli(args2, deps = {}) {
   const parsed = parse(args2);
   const silent = parsed.flags.has("automatic");
@@ -5683,7 +6096,7 @@ async function runCli(args2, deps = {}) {
   const stdout = silent ? discard : deps.stdout ?? process.stdout;
   const stderr = silent ? discard : deps.stderr ?? process.stderr;
   const output = new Output(stdout, stderr, {
-    home: deps.home ?? homedir2()
+    home: deps.home ?? homedir3()
   });
   if (process.env.MNEMONIK_DEV_RELEASE_DIR && !silent)
     stderr.write(
@@ -5715,7 +6128,7 @@ async function runCli(args2, deps = {}) {
       return output.error(invalid ?? "Usage: mnemonik add <folder> or mnemonik remove <folder>"), 2;
     const stateDir = deps.installStateDir ?? stateDirectory(process.platform, process.env, deps.home);
     const saved = JSON.parse(
-      await readFile(`${stateDir}/scanner/state.json`, "utf8").catch(() => "null")
+      await readFile3(`${stateDir}/scanner/state.json`, "utf8").catch(() => "null")
     );
     if (!saved) return actionRequired2(output, parsed.flags.has("json"), "mnemonik install");
     if (action === "list") {
@@ -5728,6 +6141,11 @@ async function runCli(args2, deps = {}) {
     const pathArgument = actionArguments[0] ?? "";
     const requested = action === "add" ? await realpath(pathArgument) : saved.config.roots.find((root) => root === pathArgument) ?? pathArgument;
     const name2 = requested.split(/[\\/]/u).filter(Boolean).at(-1) ?? requested;
+    if (action === "add" && saved.config.roots.includes(requested)) {
+      if (parsed.flags.has("json")) output.json(saved.config.roots);
+      else output.line(alreadyConnectedFolderLine(name2));
+      return 0;
+    }
     if (!parsed.flags.has("non-interactive") && !parsed.flags.has("json")) {
       output.line(action === "add" ? connectFolderPrompt(name2) : removeFolderPrompt(name2));
       const readline = createInterface({ input: deps.input ?? process.stdin, terminal: false });
@@ -5793,7 +6211,7 @@ async function runCli(args2, deps = {}) {
     if (invalid || rest.length) return output.error(invalid ?? "Unexpected argument"), 2;
     try {
       const stateDir = deps.installStateDir ?? stateDirectory(process.platform, process.env, deps.home);
-      const saved = JSON.parse(await readFile(`${stateDir}/scanner/state.json`, "utf8"));
+      const saved = JSON.parse(await readFile3(`${stateDir}/scanner/state.json`, "utf8"));
       const bearer = await ensureCliAuth(deps, output, false);
       const response = await (deps.grantFetch ?? fetch)(
         `${apiOrigin()}/api/v1/component-credentials/${encodeURIComponent(saved.config.credentialFamilyId)}/revoke`,
@@ -6030,9 +6448,25 @@ Preview: ${preview.path}
     if (!subcommand || rest.length || !hostOrder.includes(subcommand))
       return output.error(`Usage: mnemonik connect <${hostOrder.join("|")}>`), 2;
     const host = subcommand;
-    const editor = (await localEditorStatus(deps.home ?? homedir2())).find(
+    const editor = (await localEditorStatus(deps.home ?? homedir3())).find(
       (candidate) => candidate.host === host
     );
+    if (host === "codex" && editor?.mcp === "ready" && !parsed.flags.has("json")) {
+      const bearer = await auth(deps, output, false).getCliBearer().catch(() => void 0);
+      if (typeof bearer === "string") {
+        const outcome = await runEditorLogin({
+          command: ["codex", "mcp", "login", "mnemonik"],
+          apiOrigin: apiOrigin(),
+          issuer: process.env.MNEMONIK_OAUTH_ISSUER ?? "https://auth.mnemonik.ai",
+          bearer: () => Promise.resolve(bearer),
+          print: (line) => void output.line(line),
+          fetch: deps.grantFetch,
+          ...deps.editorLogin
+        });
+        if (outcome === "signed_in") return output.line(CODEX_SIGNED_IN_MESSAGE), 0;
+        if (outcome === "not_approved") return output.line(CONNECT_NOT_APPROVED_MESSAGE), 1;
+      }
+    }
     const reason = editor?.mcp === "disabled" ? `${editor.name} connection is turned off.` : editor?.mcp === "ready" ? "Finish signing in to Mnemonik in the editor." : `${launchHostLabels[host]} connection is missing.`;
     const actions = editor?.mcp === "ready" ? editorAuthorizationRows([host]) : [
       editor?.mcp === "disabled" ? mcpTurnOnAction[host] : "Run mnemonik install to set it up again."
@@ -6045,8 +6479,14 @@ Preview: ${preview.path}
     return 3;
   }
   if (command === "project") {
-    if (!subcommand || !["init", "setup", "status", "link", "ensure"].includes(subcommand))
-      return output.error("Usage: mnemonik project <init|setup|status|link|ensure>"), 2;
+    if (!subcommand || !["init", "setup", "status", "link", "ensure", "delete"].includes(subcommand))
+      return output.error("Usage: mnemonik project <init|setup|status|link|ensure|delete>"), 2;
+    if (subcommand === "delete") {
+      const unknown = allowed(parsed, ["confirm"]);
+      if (unknown || rest.length > 1)
+        return output.error(unknown ?? "Usage: mnemonik project delete [<project id or name>]"), 2;
+      return deleteProjectCommand(parsed, rest, deps, output);
+    }
     const invalid = allowed(
       parsed,
       subcommand === "ensure" ? ["agent"] : subcommand === "status" ? [] : subcommand === "link" ? ["apply", "non-git", "confirm-mismatch", "replace", "owner"] : ["apply", "non-git", "owner"]
@@ -6393,11 +6833,18 @@ Preview: ${preview.path}
 }
 var serializeReadiness2 = (input) => devReadiness(serializeReadiness(input));
 export {
+  CODEX_SIGNED_IN_MESSAGE,
+  CONNECT_NOT_APPROVED_MESSAGE,
+  alreadyConnectedFolderLine,
   connectFolderPrompt,
   connectedFolderLine,
   help,
+  identityFileKeptLine,
   maintenanceExitCode,
+  projectDeletedLine,
+  projectDeletionWarning,
   removeFolderPrompt,
   removedFolderLine,
-  runCli
+  runCli,
+  stillWatchedLine
 };