@stackmemoryai/stackmemory 1.10.5 → 1.14.0

package/dist/src/cli/index.js

@@ -4,6 +4,9 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 process.env["STACKMEMORY_CLI"] = "true";
+if (!process.env["STACKMEMORY_LOG_LEVEL"] && process.argv.includes("--json")) {
+  process.env["STACKMEMORY_LOG_LEVEL"] = "ERROR";
+}
 import { config as loadDotenv } from "dotenv";
 loadDotenv({ quiet: true });
 import { initializeTracing, trace } from "../core/trace/index.js";
@@ -12,7 +15,6 @@ import { program } from "commander";
 import { logger } from "../core/monitoring/logger.js";
 import { FrameManager } from "../core/context/index.js";
 import { sessionManager, FrameQueryMode } from "../core/session/index.js";
-import { sharedContextLayer } from "../core/context/shared-context-layer.js";
 import { UpdateChecker } from "../core/utils/update-checker.js";
 import { ProgressTracker } from "../core/monitoring/progress-tracker.js";
 import { registerProjectCommands } from "./commands/projects.js";
@@ -36,12 +38,14 @@ import {
 } from "./commands/decision.js";
 import clearCommand from "./commands/clear.js";
 import serviceCommand from "./commands/service.js";
-import { registerLoginCommand } from "./commands/login.js";
 import { registerSignupCommand } from "./commands/signup.js";
+import { createSyncCommand, createLoginCommand } from "./commands/sync.js";
 import { registerLogoutCommand, registerDbCommands } from "./commands/db.js";
 import { createHooksCommand } from "./commands/hooks.js";
 import { createDaemonCommand } from "./commands/daemon.js";
 import { createSweepCommand } from "./commands/sweep.js";
+import { createPortalCommand } from "./commands/portal.js";
+import { createBrainCommand } from "./commands/brain.js";
 import { createShellCommand } from "./commands/shell.js";
 import { createAPICommand } from "./commands/api.js";
 import { createCleanupProcessesCommand } from "./commands/cleanup-processes.js";
@@ -54,21 +58,33 @@ import { createPingCommand } from "./commands/ping.js";
 import { createAuditCommand } from "./commands/audit.js";
 import { createStatsCommand } from "./commands/stats.js";
 import { createBenchCommand } from "./commands/bench.js";
+import { createOptimizeCommand } from "./commands/optimize.js";
+import { createStateCommand } from "./commands/state.js";
 import { createDigestCommands } from "./commands/digest.js";
-import { createTeamCommands } from "./commands/team.js";
 import { createDesiresCommands } from "./commands/desires.js";
 import { createConductorCommands } from "./commands/orchestrate.js";
+import { createOperatorCommands } from "./commands/operator.js";
+import { createPatternsCommand } from "./commands/patterns.js";
 import { createPreflightCommand } from "./commands/preflight.js";
 import { createRulesCommand } from "./commands/rules.js";
 import { createSnapshotCommand } from "./commands/snapshot.js";
 import { createWikiCommand } from "./commands/wiki.js";
 import { createLoopCommand } from "./commands/loop.js";
 import { createSkillCommand } from "./commands/skill.js";
+import { createPackCommand } from "./commands/pack.js";
+import { createCacheCommand } from "./commands/cache.js";
+import { createScaffoldCommand } from "./commands/scaffold.js";
+import { createCompanyOsCommand } from "./commands/company-os.js";
 import chalk from "chalk";
 import * as fs from "fs";
 import * as path from "path";
 import { filterPending } from "../integrations/mcp/pending-utils.js";
+import {
+  getCurrentRepoGitHubInfo,
+  refreshCurrentRepoPullRequestState
+} from "../integrations/github/pr-state.js";
 import { ProjectManager } from "../core/projects/project-manager.js";
+import { canonicalStateStore } from "../core/shared-state/canonical-store.js";
 import { join } from "path";
 import { existsSync, mkdirSync } from "fs";
 import { createRequire } from "module";
@@ -105,10 +121,13 @@ async function openDatabase(dbPath) {
 function isTestEnv() {
   return process.env["VITEST"] === "true" || process.env["NODE_ENV"] === "test" || process.env["STACKMEMORY_TEST_SKIP_DB"] === "1";
 }
+function collectRepeatedOption(value, previous = []) {
+  return [...previous, value];
+}
 UpdateChecker.checkForUpdates(VERSION, true).catch(() => {
 });
 program.name("stackmemory").description(
-  "Lossless memory runtime for AI coding tools - organizes context as a call stack instead of linear chat logs, with team collaboration and infinite retention"
+  "Lossless memory runtime for AI coding tools - organizes context as a call stack instead of linear chat logs, with infinite retention"
 ).version(VERSION);
 program.command("init").description(
   "Initialize StackMemory in current project (zero-config by default)"
@@ -198,33 +217,24 @@ program.command("status").description("Show current StackMemory status").option(
       }
       await UpdateChecker.checkForUpdates(VERSION);
       await sessionManager.initialize();
-      await sharedContextLayer.initialize();
       const { initObsidianVault } = await import("../core/storage/obsidian-vault-adapter.js");
       await initObsidianVault();
       const session = await sessionManager.getOrCreateSession({
         projectPath: projectRoot,
         sessionId: options.session
       });
-      const contextDiscovery = await sharedContextLayer.autoDiscoverContext();
-      if (contextDiscovery.hasSharedContext && contextDiscovery.sessionCount > 1) {
-        console.log(`
-\u{1F4A1} Shared Context Available:`);
-        console.log(
-          `   ${contextDiscovery.sessionCount} sessions with shared context`
-        );
-        if (contextDiscovery.recentPatterns.length > 0) {
-          console.log(`   Recent patterns:`);
-          contextDiscovery.recentPatterns.slice(0, 3).forEach((p) => {
-            console.log(
-              `     \u2022 ${p.type}: ${p.pattern.slice(0, 50)} (${p.frequency}x)`
-            );
-          });
-        }
-        if (contextDiscovery.lastDecisions.length > 0) {
-          console.log(
-            `   Last decision: ${contextDiscovery.lastDecisions[0].decision.slice(0, 60)}`
-          );
-        }
+      const sharedProjectState = await canonicalStateStore.getProjectSummary({
+        projectId: session.projectId,
+        projectPath: projectRoot,
+        eventLimit: 5
+      });
+      const githubInfo = getCurrentRepoGitHubInfo(projectRoot);
+      let githubProjection = githubInfo && await canonicalStateStore.getGitHubPullRequest({
+        repo: githubInfo.repo,
+        branch: githubInfo.branch
+      });
+      if (githubInfo && (!githubProjection || Date.now() - githubProjection.lastSyncedAt > 2 * 60 * 1e3)) {
+        githubProjection = await refreshCurrentRepoPullRequestState(projectRoot) || githubProjection;
       }
       const db = await openDatabase(dbPath);
       const frameManager = new FrameManager(db, session.projectId);
@@ -276,6 +286,23 @@ program.command("status").description("Show current StackMemory status").option(
       console.log(
         `     Cached contexts: ${contextCount.count || 0} (global)`
       );
+      console.log(
+        `     Shared sessions: ${sharedProjectState.activeSessions.length}`
+      );
+      console.log(
+        `     Shared instances: ${sharedProjectState.activeInstances.length}`
+      );
+      console.log(
+        `     Shared claims: ${sharedProjectState.activeClaims.length}`
+      );
+      const branchClaim = sharedProjectState.activeClaims.find(
+        (claim) => claim.branch && claim.branch === session.branch
+      );
+      if (branchClaim) {
+        console.log(
+          `     Branch owner: ${branchClaim.tool} ${branchClaim.instanceId || branchClaim.sessionId || branchClaim.claimId.slice(0, 8)}`
+        );
+      }
       const recentFrames = db.prepare(
         `
         SELECT name, type, state, datetime(created_at, 'unixepoch') as created
@@ -295,6 +322,22 @@ program.command("status").description("Show current StackMemory status").option(
           );
         });
       }
+      if (githubProjection) {
+        console.log(`
+   GitHub PR:`);
+        console.log(
+          `     #${githubProjection.prNumber} ${githubProjection.state} ${githubProjection.title}`
+        );
+        console.log(
+          `     ${githubProjection.headRefName} -> ${githubProjection.baseRefName}`
+        );
+        if (githubProjection.reviewDecision) {
+          console.log(`     Review: ${githubProjection.reviewDecision}`);
+        }
+        if (githubProjection.statusCheckRollup) {
+          console.log(`     Checks: ${githubProjection.statusCheckRollup}`);
+        }
+      }
       console.log(`
    Current Session:`);
       console.log(`     Stack depth: ${stackDepth}`);
@@ -460,7 +503,7 @@ program.command("context:test").description("Test context persistence by creatin
 });
 registerOnboardingCommand(program);
 registerSignupCommand(program);
-registerLoginCommand(program);
+program.addCommand(createLoginCommand());
 registerLogoutCommand(program);
 registerDbCommands(program);
 registerProjectCommands(program);
@@ -478,6 +521,7 @@ program.addCommand(createConfigCommand());
 program.addCommand(createCaptureCommand());
 program.addCommand(createRestoreCommand());
 program.addCommand(createAutoCaptureCommand());
+program.addCommand(createSyncCommand());
 program.addCommand(createDecisionCommand());
 program.addCommand(createMemoryCommand());
 program.addCommand(clearCommand);
@@ -550,16 +594,10 @@ if (isFeatureEnabled("skills")) {
     })
   );
 }
-if (isFeatureEnabled("ralph")) {
-  lazyCommands.push(
-    import("./commands/ralph.js").then(
-      ({ default: createRalphCommand }) => program.addCommand(createRalphCommand())
-    ).catch(() => {
-    })
-  );
-}
 program.addCommand(createDaemonCommand());
 program.addCommand(createSweepCommand());
+program.addCommand(createPortalCommand());
+program.addCommand(createBrainCommand());
 program.addCommand(createShellCommand());
 program.addCommand(createAPICommand());
 program.addCommand(createCleanupProcessesCommand());
@@ -571,16 +609,23 @@ program.addCommand(createModelCommand());
 program.addCommand(createAuditCommand());
 program.addCommand(createStatsCommand());
 program.addCommand(createBenchCommand());
+program.addCommand(createOptimizeCommand());
+program.addCommand(createStateCommand());
 program.addCommand(createDigestCommands());
-program.addCommand(createTeamCommands());
 program.addCommand(createDesiresCommands());
 program.addCommand(createConductorCommands());
+program.addCommand(createOperatorCommands());
+program.addCommand(createPatternsCommand());
 program.addCommand(createPreflightCommand());
 program.addCommand(createSnapshotCommand());
 program.addCommand(createWikiCommand());
 program.addCommand(createLoopCommand());
 program.addCommand(createRulesCommand());
 program.addCommand(createSkillCommand());
+program.addCommand(createPackCommand());
+program.addCommand(createCacheCommand());
+program.addCommand(createScaffoldCommand());
+program.addCommand(createCompanyOsCommand());
 registerSetupCommands(program);
 program.command("mm-spike").description(
   "Run multi-agent planning/implementation spike (planner/implementer/critic)"
@@ -600,7 +645,16 @@ program.command("mm-spike").description(
   "--execute",
   "Execute implementer (codex-sm) instead of dry-run",
   false
-).option("--implementer <name>", "codex|claude", "codex").option("--max-iters <n>", "Retry loop iterations", "2").option("--audit-dir <path>", "Persist spike results to directory").option("--record-frame", "Record as real frame with anchors", false).option("--record", "Record plan & critique into StackMemory context", false).option("--json", "Emit single JSON result (UI-friendly)", false).option("--quiet", "Minimal output (default)", true).option("--verbose", "Verbose sectioned output", false).option(
+).option("--implementer <name>", "codex|claude", "codex").option("--max-iters <n>", "Retry loop iterations", "2").option("--audit-dir <path>", "Persist spike results to directory").option(
+  "--verify <cmd>",
+  "Verification command to run after each implementation attempt; repeatable",
+  collectRepeatedOption,
+  []
+).option("--record-frame", "Record as real frame with anchors", false).option("--record", "Record plan & critique into StackMemory context", false).option(
+  "--deterministic-fixture",
+  "Use deterministic fixture planner/critic for replayable smoke runs",
+  false
+).option("--json", "Emit single JSON result (UI-friendly)", false).option("--quiet", "Minimal output (default)", true).option("--verbose", "Verbose sectioned output", false).option(
   "--log",
   "Pretty print interaction log (planner/implementer/critic)",
   false
@@ -619,8 +673,10 @@ program.command("mm-spike").description(
         maxIters: parseInt(opts.maxIters),
         dryRun: !opts.execute,
         auditDir: opts.auditDir,
+        verificationCommands: opts.verify,
         recordFrame: Boolean(opts.recordFrame),
-        record: Boolean(opts.record)
+        record: Boolean(opts.record),
+        deterministicFixture: Boolean(opts.deterministicFixture)
       }
     );
     if (opts.log) {
@@ -677,7 +733,15 @@ program.command("build").description(
   "--reviewer-model <name>",
   "Claude model for review",
   "claude-sonnet-4-20250514"
-).option("--execute", "Execute implementer (default: true)", true).option("--dry-run", "Skip execution, show commands only").option("--implementer <name>", "codex|claude", "codex").option("--max-iters <n>", "Retry loop iterations", "2").option("--audit-dir <path>", "Persist spike results to directory").option("--record-frame", "Record as real frame with anchors").option("--record", "Record plan & critique into StackMemory context").option("--json", "Emit single JSON result (UI-friendly)").option("--quiet", "Minimal output").option("--verbose", "Verbose sectioned output").option("--log", "Pretty print interaction log (default: true)", true).option("-C, --cwd <path>", "Working directory for implementation").action(async (taskArg, opts) => {
+).option("--execute", "Execute implementer (default: true)", true).option("--dry-run", "Skip execution, show commands only").option("--implementer <name>", "codex|claude", "codex").option("--max-iters <n>", "Retry loop iterations", "2").option("--audit-dir <path>", "Persist spike results to directory").option(
+  "--verify <cmd>",
+  "Verification command to run after each implementation attempt; repeatable",
+  collectRepeatedOption,
+  []
+).option("--record-frame", "Record as real frame with anchors").option("--record", "Record plan & critique into StackMemory context").option(
+  "--deterministic-fixture",
+  "Use deterministic fixture planner/critic for replayable smoke runs"
+).option("--json", "Emit single JSON result (UI-friendly)").option("--quiet", "Minimal output").option("--verbose", "Verbose sectioned output").option("--log", "Pretty print interaction log (default: true)", true).option("-C, --cwd <path>", "Working directory for implementation").action(async (taskArg, opts) => {
   try {
     const task = typeof taskArg === "string" && taskArg.length > 0 ? taskArg : opts.task;
     if (!task) {
@@ -713,8 +777,10 @@ program.command("build").description(
         maxIters: parseInt(opts.maxIters),
         dryRun,
         auditDir: opts.auditDir,
+        verificationCommands: opts.verify,
         recordFrame: Boolean(opts.recordFrame),
-        record: Boolean(opts.record)
+        record: Boolean(opts.record),
+        deterministicFixture: Boolean(opts.deterministicFixture)
       }
     );
     if (opts.log) {

package/dist/src/cli/opencode-sm.js

@@ -13,6 +13,11 @@ import { program } from "commander";
 import { v4 as uuidv4 } from "uuid";
 import chalk from "chalk";
 import { initializeTracing, trace } from "../core/trace/index.js";
+import { resolveRealCliBin } from "./utils/real-cli-bin.js";
+import {
+  startDeterminismWatcher,
+  stopDeterminismWatcher
+} from "./utils/determinism-watcher.js";
 const DEFAULT_SM_CONFIG = {
   defaultWorktree: false,
   defaultTracing: true
@@ -43,6 +48,7 @@ class OpencodeSM {
   config;
   stackmemoryPath;
   smConfig;
+  determinismWatcher;
   constructor() {
     this.smConfig = loadSMConfig();
     this.config = {
@@ -54,6 +60,7 @@ class OpencodeSM {
       sessionStartTime: Date.now()
     };
     this.stackmemoryPath = this.findStackMemory();
+    this.determinismWatcher = null;
   }
   getRepoRoot() {
     try {
@@ -127,27 +134,16 @@ class OpencodeSM {
     }
   }
   resolveOpencodeBin() {
-    if (this.config.opencodeBin && this.config.opencodeBin.trim()) {
-      return this.config.opencodeBin.trim();
-    }
-    const envBin = process.env["OPENCODE_BIN"];
-    if (envBin && envBin.trim()) return envBin.trim();
-    const possiblePaths = [
-      path.join(os.homedir(), ".opencode", "bin", "opencode"),
-      "/usr/local/bin/opencode",
-      "/opt/homebrew/bin/opencode"
-    ];
-    for (const binPath of possiblePaths) {
-      if (fs.existsSync(binPath)) {
-        return binPath;
-      }
-    }
-    try {
-      execSync("which opencode", { stdio: "ignore" });
-      return "opencode";
-    } catch {
-    }
-    return null;
+    return resolveRealCliBin({
+      explicitBin: this.config.opencodeBin,
+      envBin: process.env["OPENCODE_BIN"],
+      preferredPaths: [
+        path.join(os.homedir(), ".opencode", "bin", "opencode"),
+        "/usr/local/bin/opencode",
+        "/opt/homebrew/bin/opencode"
+      ],
+      pathCommands: ["opencode"]
+    });
   }
   setupWorktree() {
     if (!this.config.useWorktree || !this.isGitRepo()) {
@@ -251,6 +247,23 @@ class OpencodeSM {
       );
     }
   }
+  startDeterminismWatcher() {
+    this.determinismWatcher = startDeterminismWatcher({
+      stackmemoryBin: this.stackmemoryPath,
+      cwd: process.cwd(),
+      task: this.config.task,
+      instanceId: this.config.instanceId,
+      tool: "opencode"
+    });
+    if (this.determinismWatcher) {
+      const modeLabel = this.determinismWatcher.mode === "targeted" ? "targeted" : "repo-root fallback";
+      console.log(chalk.gray(`Determinism: ${modeLabel}`));
+    }
+  }
+  stopDeterminismWatcher() {
+    stopDeterminismWatcher(this.determinismWatcher);
+    this.determinismWatcher = null;
+  }
   async run(args) {
     const opencodeArgs = [];
     let i = 0;
@@ -354,6 +367,7 @@ class OpencodeSM {
     if (this.config.worktreePath) {
       process.env["OPENCODE_WORKTREE_PATH"] = this.config.worktreePath;
     }
+    this.startDeterminismWatcher();
     console.log(chalk.gray(`Instance: ${this.config.instanceId}`));
     console.log(chalk.gray(`Working in: ${process.cwd()}`));
     if (this.config.tracingEnabled) {
@@ -391,6 +405,7 @@ class OpencodeSM {
       process.exit(1);
     });
     opencode.on("exit", async (code) => {
+      this.stopDeterminismWatcher();
       this.saveContext("OpenCode session ended", {
         action: "session_end",
         exitCode: code
@@ -411,12 +426,14 @@ class OpencodeSM {
       process.exit(code || 0);
     });
     process.on("SIGINT", () => {
+      this.stopDeterminismWatcher();
       this.saveContext("OpenCode session interrupted", {
         action: "session_interrupt"
       });
       opencode.kill("SIGINT");
     });
     process.on("SIGTERM", () => {
+      this.stopDeterminismWatcher();
       this.saveContext("OpenCode session terminated", {
         action: "session_terminate"
       });

package/dist/src/cli/utils/determinism-watcher.js

@@ -0,0 +1,66 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { getDeterminismWatchTargets } from "../../orchestrators/multimodal/determinism.js";
+function shouldAutoStartDeterminismWatcher(cwd) {
+  if (process.env["STACKMEMORY_DETERMINISM_AUTO"] === "0") {
+    return false;
+  }
+  return fs.existsSync(path.join(cwd, ".git"));
+}
+function startDeterminismWatcher(options) {
+  if (!shouldAutoStartDeterminismWatcher(options.cwd)) {
+    return null;
+  }
+  const runs = process.env["STACKMEMORY_DETERMINISM_RUNS"] || "3";
+  const task = options.task || process.env["STACKMEMORY_DETERMINISM_TASK"] || "Determinism probe";
+  const targets = getDeterminismWatchTargets(options.cwd);
+  const mode = targets.length === 1 && targets[0] === "." ? "repo-root" : "targeted";
+  const child = spawn(
+    options.stackmemoryBin,
+    [
+      "bench",
+      "determinism",
+      "--task",
+      task,
+      "--runs",
+      runs,
+      "--watch",
+      "--json"
+    ],
+    {
+      cwd: options.cwd,
+      stdio: "ignore",
+      env: {
+        ...process.env,
+        STACKMEMORY_DETERMINISM_PARENT_TOOL: options.tool,
+        STACKMEMORY_DETERMINISM_PARENT_INSTANCE: options.instanceId || "",
+        STACKMEMORY_DETERMINISM_PARENT_SESSION: options.sessionId || ""
+      }
+    }
+  );
+  return {
+    child,
+    mode,
+    targets
+  };
+}
+function stopDeterminismWatcher(handle) {
+  const child = handle?.child ?? null;
+  if (!child || child.killed) {
+    return;
+  }
+  try {
+    child.kill("SIGTERM");
+  } catch {
+  }
+}
+export {
+  shouldAutoStartDeterminismWatcher,
+  startDeterminismWatcher,
+  stopDeterminismWatcher
+};

package/dist/src/cli/utils/real-cli-bin.js

@@ -0,0 +1,116 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { execSync } from "child_process";
+import { createRequire } from "node:module";
+import * as fs from "fs";
+import * as path from "path";
+const DEFAULT_WRAPPER_PATH_SNIPPETS = [
+  "/Applications/cmux.app/Contents/Resources/bin/"
+];
+function isWrapperPath(candidate, wrapperPathSnippets) {
+  const normalized = candidate.trim();
+  return wrapperPathSnippets.some((snippet) => normalized.includes(snippet));
+}
+function resolveRealCliBin(options) {
+  if (options.explicitBin?.trim()) {
+    return options.explicitBin.trim();
+  }
+  if (options.envBin?.trim()) {
+    return options.envBin.trim();
+  }
+  const wrapperPathSnippets = options.wrapperPathSnippets || DEFAULT_WRAPPER_PATH_SNIPPETS;
+  for (const candidate of options.preferredPaths || []) {
+    if (fs.existsSync(candidate) && !isWrapperPath(candidate, wrapperPathSnippets)) {
+      return candidate;
+    }
+  }
+  for (const command of options.pathCommands) {
+    try {
+      const output = execSync(`which -a ${command}`, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      const resolved = output.split("\n").map((line) => line.trim()).filter(Boolean).find((candidate) => !isWrapperPath(candidate, wrapperPathSnippets));
+      if (resolved) {
+        return resolved;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+const CODEX_PLATFORM_TRIPLES = {
+  darwin: { x64: "x86_64-apple-darwin", arm64: "aarch64-apple-darwin" },
+  linux: {
+    x64: "x86_64-unknown-linux-musl",
+    arm64: "aarch64-unknown-linux-musl"
+  },
+  win32: { x64: "x86_64-pc-windows-msvc", arm64: "aarch64-pc-windows-msvc" }
+};
+function resolveNativeCodexBin() {
+  const triple = CODEX_PLATFORM_TRIPLES[process.platform]?.[process.arch];
+  if (!triple) return [];
+  const binaryName = process.platform === "win32" ? "codex.exe" : "codex";
+  const platformPkg = `@openai/codex-${process.platform}-${process.arch === "arm64" ? "arm64" : "x64"}`;
+  const candidates = [];
+  try {
+    const req = createRequire(
+      path.join(
+        process.execPath,
+        "..",
+        "..",
+        "lib",
+        "node_modules",
+        "@openai",
+        "codex",
+        "package.json"
+      )
+    );
+    const pkgJson = req.resolve(`${platformPkg}/package.json`);
+    const vendorBin = path.join(
+      path.dirname(pkgJson),
+      "vendor",
+      triple,
+      "bin",
+      binaryName
+    );
+    if (fs.existsSync(vendorBin)) candidates.push(vendorBin);
+  } catch {
+  }
+  try {
+    const nodeDir = path.dirname(process.execPath);
+    const globalModules = path.join(nodeDir, "..", "lib", "node_modules");
+    const vendorBin = path.join(
+      globalModules,
+      "@openai",
+      "codex",
+      "node_modules",
+      platformPkg,
+      "vendor",
+      triple,
+      "bin",
+      binaryName
+    );
+    if (fs.existsSync(vendorBin) && !candidates.includes(vendorBin)) {
+      candidates.push(vendorBin);
+    }
+  } catch {
+  }
+  return candidates;
+}
+function resolveNvmBin(name) {
+  try {
+    const nodeDir = path.dirname(process.execPath);
+    const candidate = path.join(nodeDir, name);
+    if (fs.existsSync(candidate)) return candidate;
+  } catch {
+  }
+  return void 0;
+}
+export {
+  resolveNativeCodexBin,
+  resolveNvmBin,
+  resolveRealCliBin
+};