@stackmemoryai/stackmemory 1.10.5 → 1.14.0

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

@@ -11,9 +11,26 @@ import { program } from "commander";
 import { v4 as uuidv4 } from "uuid";
 import chalk from "chalk";
 import { initializeTracing, trace } from "../core/trace/index.js";
+import {
+  resolveRealCliBin,
+  resolveNativeCodexBin,
+  resolveNvmBin
+} from "./utils/real-cli-bin.js";
+import {
+  startDeterminismWatcher,
+  stopDeterminismWatcher
+} from "./utils/determinism-watcher.js";
+import {
+  canonicalStateStore,
+  projectIdFromIdentifier
+} from "../core/shared-state/canonical-store.js";
 class CodexSM {
   config;
   stackmemoryPath;
+  sessionId;
+  ownsSession;
+  sessionEnded;
+  determinismWatcher;
   constructor() {
     this.config = {
       instanceId: this.generateInstanceId(),
@@ -23,6 +40,10 @@ class CodexSM {
       verboseTracing: false
     };
     this.stackmemoryPath = this.findStackMemory();
+    this.sessionId = process.env["STACKMEMORY_SESSION"] || uuidv4();
+    this.ownsSession = !process.env["STACKMEMORY_SESSION"];
+    this.sessionEnded = false;
+    this.determinismWatcher = null;
   }
   getRepoRoot() {
     try {
@@ -87,6 +108,20 @@ class CodexSM {
       return "main";
     }
   }
+  getProjectId() {
+    const root = this.getRepoRoot() || process.cwd();
+    try {
+      const remote = execSync("git config --get remote.origin.url", {
+        cwd: root,
+        encoding: "utf8"
+      }).trim();
+      if (remote) {
+        return projectIdFromIdentifier(remote);
+      }
+    } catch {
+    }
+    return projectIdFromIdentifier(root);
+  }
   hasUncommittedChanges() {
     try {
       const status = execSync("git status --porcelain", { encoding: "utf8" });
@@ -96,24 +131,21 @@ class CodexSM {
     }
   }
   resolveCodexBin() {
-    if (this.config.codexBin && this.config.codexBin.trim()) {
-      return this.config.codexBin.trim();
-    }
-    const envBin = process.env["CODEX_BIN"];
-    if (envBin && envBin.trim()) {
-      return envBin.trim();
-    }
-    try {
-      execSync("which codex", { stdio: "ignore" });
-      return "codex";
-    } catch {
-    }
-    try {
-      execSync("which codex-cli", { stdio: "ignore" });
-      return "codex-cli";
-    } catch {
-    }
-    return null;
+    return resolveRealCliBin({
+      explicitBin: this.config.codexBin,
+      envBin: process.env["CODEX_BIN"],
+      preferredPaths: [
+        ...resolveNativeCodexBin(),
+        // native binary first (no wrapper overhead)
+        resolveNvmBin("codex"),
+        // dynamic nvm/fnm/volta path
+        "/usr/local/bin/codex",
+        "/opt/homebrew/bin/codex",
+        "/usr/local/bin/codex-cli",
+        "/opt/homebrew/bin/codex-cli"
+      ].filter((p) => !!p),
+      pathCommands: ["codex", "codex-cli"]
+    });
   }
   setupWorktree() {
     if (!this.config.useWorktree || !this.isGitRepo()) return null;
@@ -169,22 +201,58 @@ class CodexSM {
     } catch {
     }
   }
+  /**
+   * Emit context budget advice based on tool-call count from checkpoint state.
+   * Mirrors the Claude Code context-budget.js hook.
+   */
+  emitContextBudgetAdvice() {
+    const COMPACT_SUGGEST = 50;
+    const COMPACT_STRONG = 65;
+    const RESTART_RECOMMEND = 80;
+    try {
+      const stateFile = path.join(
+        os.homedir(),
+        ".stackmemory",
+        `checkpoint-state-${this.config.instanceId}.json`
+      );
+      if (!fs.existsSync(stateFile)) return;
+      const state = JSON.parse(fs.readFileSync(stateFile, "utf-8"));
+      const cwd = process.cwd();
+      const toolCount = state.projects?.[cwd]?.toolCount || 0;
+      if (toolCount >= RESTART_RECOMMEND) {
+        console.log(
+          chalk.yellow(
+            `[CONTEXT_BUDGET] ${toolCount} tool calls (~150K+ tokens). Recommend: save context then start fresh session.`
+          )
+        );
+      } else if (toolCount >= COMPACT_STRONG) {
+        console.log(
+          chalk.yellow(
+            `[CONTEXT_BUDGET] ${toolCount} tool calls (~100-130K tokens). Context heavy \u2014 consider compacting or restarting.`
+          )
+        );
+      } else if (toolCount >= COMPACT_SUGGEST) {
+        console.log(
+          chalk.gray(
+            `[CONTEXT_BUDGET] ${toolCount} tool calls (~80-100K tokens). Context getting heavy.`
+          )
+        );
+      }
+    } catch {
+    }
+  }
   loadContext() {
     if (!this.config.contextEnabled) return;
     try {
       console.log(chalk.blue("\u{1F4DA} Loading previous context..."));
-      const cmd = `${this.stackmemoryPath} context list --limit 5 --format json`;
-      const output = execSync(cmd, { encoding: "utf8" });
-      const contexts = JSON.parse(output);
-      if (Array.isArray(contexts) && contexts.length > 0) {
-        console.log(chalk.gray("Recent context loaded:"));
-        contexts.forEach(
-          (ctx) => {
-            console.log(
-              chalk.gray(`  - ${ctx.message} (${ctx.metadata?.timestamp})`)
-            );
-          }
-        );
+      const cmd = `${this.stackmemoryPath} context show`;
+      const output = execSync(cmd, {
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const lines = output.trim().split("\n").filter((line) => line.trim());
+      if (lines.length > 3) {
+        console.log(chalk.gray("Context stack loaded"));
       }
     } catch {
     }
@@ -197,6 +265,117 @@ class CodexSM {
       );
     }
   }
+  async publishSessionStart() {
+    const projectPath = process.cwd();
+    const projectId = this.getProjectId();
+    const branch = this.isGitRepo() ? this.getCurrentBranch() : void 0;
+    await canonicalStateStore.upsertSession({
+      sessionId: this.sessionId,
+      tool: "codex",
+      projectId,
+      projectPath,
+      branch,
+      instanceId: this.config.instanceId,
+      metadata: {
+        task: this.config.task
+      }
+    });
+    await canonicalStateStore.upsertInstance({
+      instanceId: this.config.instanceId,
+      tool: "codex",
+      sessionId: this.sessionId,
+      projectId,
+      projectPath,
+      branch,
+      worktreePath: this.config.worktreePath,
+      pid: process.pid,
+      status: "active",
+      metadata: {
+        task: this.config.task
+      }
+    });
+    await canonicalStateStore.appendEvent({
+      type: "session_start",
+      tool: "codex",
+      sessionId: this.sessionId,
+      instanceId: this.config.instanceId,
+      projectId,
+      projectPath,
+      branch,
+      payload: {
+        task: this.config.task,
+        worktreePath: this.config.worktreePath
+      }
+    });
+    const claimResult = await canonicalStateStore.claimPaths({
+      tool: "codex",
+      sessionId: this.sessionId,
+      instanceId: this.config.instanceId,
+      projectId,
+      projectPath,
+      branch,
+      paths: [],
+      metadata: {
+        task: this.config.task,
+        scope: "branch"
+      }
+    });
+    if (claimResult.conflicts.length > 0) {
+      console.log(chalk.yellow("\u26A0\uFE0F  Shared state conflict detected"));
+      for (const conflict of claimResult.conflicts.slice(0, 3)) {
+        console.log(
+          chalk.gray(
+            `   Claim ${conflict.claimId.slice(0, 8)} already owns ${conflict.branch || "overlapping work"}`
+          )
+        );
+      }
+    }
+  }
+  async publishSessionEnd(eventType, payload = {}) {
+    if (this.sessionEnded) {
+      return;
+    }
+    this.sessionEnded = true;
+    const projectPath = process.cwd();
+    const projectId = this.getProjectId();
+    const branch = this.isGitRepo() ? this.getCurrentBranch() : void 0;
+    await canonicalStateStore.appendEvent({
+      type: eventType,
+      tool: "codex",
+      sessionId: this.sessionId,
+      instanceId: this.config.instanceId,
+      projectId,
+      projectPath,
+      branch,
+      payload
+    });
+    await canonicalStateStore.releaseClaims({
+      instanceId: this.config.instanceId,
+      reason: eventType
+    });
+    await canonicalStateStore.endInstance(this.config.instanceId);
+    if (this.ownsSession) {
+      await canonicalStateStore.endSession(this.sessionId);
+    }
+  }
+  startDeterminismWatcher() {
+    this.determinismWatcher = startDeterminismWatcher({
+      stackmemoryBin: this.stackmemoryPath,
+      cwd: process.cwd(),
+      task: this.config.task,
+      instanceId: this.config.instanceId,
+      sessionId: this.sessionId,
+      tool: "codex"
+    });
+    if (this.determinismWatcher) {
+      const modeLabel = this.determinismWatcher.mode === "targeted" ? "targeted" : "repo-root fallback";
+      console.log(chalk.gray(`\u{1F9EA} Determinism: ${modeLabel}`));
+    }
+  }
+  stopDeterminismWatcher() {
+    stopDeterminismWatcher(this.determinismWatcher);
+    this.determinismWatcher = null;
+  }
   async run(args) {
     const codexArgs = [];
     let i = 0;
@@ -293,9 +472,13 @@ class CodexSM {
     }
     this.loadContext();
     process.env["CODEX_INSTANCE_ID"] = this.config.instanceId;
+    process.env["STACKMEMORY_SESSION"] = this.sessionId;
     if (this.config.worktreePath)
       process.env["CODEX_WORKTREE_PATH"] = this.config.worktreePath;
+    await this.publishSessionStart();
+    this.startDeterminismWatcher();
     console.log(chalk.gray(`\u{1F916} Instance ID: ${this.config.instanceId}`));
+    console.log(chalk.gray(`\u{1F9E0} Session ID: ${this.sessionId.slice(0, 8)}`));
     console.log(chalk.gray(`\u{1F4C1} Working in: ${process.cwd()}`));
     console.log();
     console.log(chalk.gray("Starting Codex..."));
@@ -334,11 +517,15 @@ class CodexSM {
       }
       process.exit(1);
     });
-    child.on("exit", (code) => {
+    child.on("exit", async (code) => {
+      this.stopDeterminismWatcher();
       this.saveContext("Codex session ended", {
         action: "session_end",
         exitCode: code
       });
+      await this.publishSessionEnd("session_end", {
+        exitCode: code
+      });
       try {
         execSync("stackmemory linear sync", {
           stdio: "ignore",
@@ -346,6 +533,7 @@ class CodexSM {
         });
       } catch {
       }
+      this.emitContextBudgetAdvice();
       if (this.config.tracingEnabled) {
         const summary = trace.getExecutionSummary();
         console.log();
@@ -361,16 +549,20 @@ class CodexSM {
       }
       process.exit(code || 0);
     });
-    process.on("SIGINT", () => {
+    process.on("SIGINT", async () => {
+      this.stopDeterminismWatcher();
       this.saveContext("Codex session interrupted", {
         action: "session_interrupt"
       });
+      await this.publishSessionEnd("session_interrupt");
       child.kill("SIGINT");
     });
-    process.on("SIGTERM", () => {
+    process.on("SIGTERM", async () => {
+      this.stopDeterminismWatcher();
       this.saveContext("Codex session terminated", {
         action: "session_terminate"
       });
+      await this.publishSessionEnd("session_terminate");
       child.kill("SIGTERM");
     });
   }

package/dist/src/cli/commands/bench.js

@@ -3,6 +3,7 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 import { Command } from "commander";
+import chalk from "chalk";
 import { existsSync, readFileSync, readdirSync } from "fs";
 import { join } from "path";
 import {
@@ -13,6 +14,13 @@ import {
 import {
   feedbackLoops
 } from "../../core/monitoring/feedback-loops.js";
+import {
+  DETERMINISM_WATCH_IGNORE,
+  getDeterminismWatchTargets,
+  persistDeterminismReport,
+  readLatestDeterminismReport,
+  runDeterminismSmoke
+} from "../../orchestrators/multimodal/determinism.js";
 function loadRunMetrics(projectRoot) {
   const metricsFile = join(
     projectRoot,
@@ -45,6 +53,56 @@ function loadSpikeAudits(projectRoot) {
     }
   }).filter(Boolean);
 }
+function printDeterminismReport(task, requestedRuns, report) {
+  console.log("\nHarness Determinism Smoke");
+  console.log("\u2550".repeat(60));
+  console.log(`Task:                 ${task}`);
+  console.log(`Runs:                 ${report.runs}`);
+  console.log(`Determinism score:    ${report.score.toFixed(2)}/100`);
+  console.log("\nDimension Scores:");
+  for (const dimension of report.dimensions) {
+    console.log(
+      `  ${dimension.name.padEnd(14)} ${dimension.score.toFixed(2).padStart(6)}/100  ${dimension.details}`
+    );
+  }
+  if (report.recommendations.length > 0) {
+    console.log("\nRecommended Tightening:");
+    for (const recommendation of report.recommendations) {
+      console.log(`  - ${recommendation}`);
+    }
+  } else {
+    console.log("\nNo drift detected in deterministic fixture mode.");
+  }
+  const sample = report.snapshots[0];
+  if (sample) {
+    console.log("\nReference Snapshot:");
+    console.log(`  resultHash:         ${sample.resultHash.slice(0, 16)}`);
+    console.log(`  planHash:           ${sample.planHash.slice(0, 16)}`);
+    console.log(`  critiqueHash:       ${sample.critiqueHash.slice(0, 16)}`);
+    console.log(`  commandsHash:       ${sample.commandsHash.slice(0, 16)}`);
+    console.log(`  iterations:         ${sample.iterations}`);
+    console.log(`  contextTokens:      ${sample.contextTokens}`);
+  }
+  if (report.runs !== requestedRuns) {
+    console.log(
+      `
+Note: requested ${requestedRuns} runs, completed ${report.runs}.`
+    );
+  }
+  console.log("");
+}
+function printStoredDeterminismReport(stored) {
+  console.log("\nCached Determinism Result");
+  console.log("\u2550".repeat(60));
+  console.log(`Task:                 ${stored.task}`);
+  console.log(`Trigger:              ${stored.trigger}`);
+  console.log(`Timestamp:            ${stored.timestamp}`);
+  console.log(`Determinism score:    ${stored.report.score.toFixed(2)}/100`);
+  if (stored.changedPaths.length > 0) {
+    console.log(`Changed paths:        ${stored.changedPaths.join(", ")}`);
+  }
+  console.log("");
+}
 function createBenchCommand() {
   const bench = new Command("bench").description(
     "Harness benchmarks \u2014 compare local runs against SWE-bench baselines"
@@ -197,11 +255,160 @@ Recent Spike Audits (${audits.length}):`);
     }
     console.log("");
   });
-  bench.command("loops").description("Show feedback loop configuration, status, and recent events").option("--json", "Output as JSON", false).action((options) => {
+  bench.command("determinism").description(
+    "Run deterministic fixture smoke checks for the multimodal harness"
+  ).option(
+    "-t, --task <desc>",
+    "Task description to run through the harness",
+    "Add a small auth guard"
+  ).option("--runs <n>", "Number of repeated runs", "5").option(
+    "--planner-model <name>",
+    "Planner model label to include in the run config",
+    "claude-sonnet-4-20250514"
+  ).option(
+    "--reviewer-model <name>",
+    "Reviewer model label to include in the run config",
+    "claude-sonnet-4-20250514"
+  ).option("--implementer <name>", "codex|claude", "codex").option("--max-iters <n>", "Retry loop iterations", "2").option(
+    "--watch",
+    "Watch harness-critical files and rerun on changes",
+    false
+  ).option(
+    "--debounce-ms <n>",
+    "Debounce window for write completion in watch mode",
+    "3000"
+  ).option("--latest", "Show the latest cached determinism result", false).option("--json", "Output as JSON", false).action(async function() {
+    const command = this;
+    const options = command.opts();
+    const json = Boolean(options.json || command.parent?.opts().json);
+    const projectRoot = process.cwd();
+    const runs = Math.max(1, parseInt(options.runs, 10) || 5);
+    const debounceMs = Math.max(
+      250,
+      parseInt(options.debounceMs, 10) || 3e3
+    );
+    if (options.latest) {
+      const stored = readLatestDeterminismReport(projectRoot);
+      if (!stored) {
+        console.error("No cached determinism result found.");
+        process.exitCode = 1;
+        return;
+      }
+      if (json) {
+        console.log(JSON.stringify(stored, null, 2));
+        return;
+      }
+      printStoredDeterminismReport(stored);
+      return;
+    }
+    const runCheck = async (trigger, changedPaths = []) => {
+      const report = await runDeterminismSmoke(
+        {
+          task: options.task,
+          repoPath: projectRoot
+        },
+        {
+          runs,
+          plannerModel: options.plannerModel,
+          reviewerModel: options.reviewerModel,
+          implementer: options.implementer,
+          maxIters: parseInt(options.maxIters, 10) || 2
+        }
+      );
+      const stored = persistDeterminismReport(projectRoot, report, {
+        task: options.task,
+        trigger,
+        changedPaths
+      });
+      if (json) {
+        console.log(JSON.stringify(stored, null, 2));
+      } else {
+        printDeterminismReport(options.task, runs, report);
+      }
+      return stored;
+    };
+    if (options.watch) {
+      const chokidar = await import("chokidar");
+      const watchTargets = getDeterminismWatchTargets(projectRoot);
+      const watchPatterns = watchTargets.map(
+        (pattern) => join(projectRoot, pattern)
+      );
+      const watcher = chokidar.watch(watchPatterns, {
+        ignoreInitial: true,
+        ignored: DETERMINISM_WATCH_IGNORE.map(
+          (pattern) => join(projectRoot, pattern)
+        ),
+        awaitWriteFinish: {
+          stabilityThreshold: debounceMs,
+          pollInterval: 100
+        }
+      });
+      let running = false;
+      let rerunRequested = false;
+      const pendingPaths = /* @__PURE__ */ new Set();
+      const maybeRun = async (trigger) => {
+        if (running) {
+          rerunRequested = true;
+          return;
+        }
+        running = true;
+        const changedPaths = Array.from(pendingPaths).sort();
+        pendingPaths.clear();
+        try {
+          await runCheck(trigger, changedPaths);
+        } finally {
+          running = false;
+          if (rerunRequested) {
+            rerunRequested = false;
+            await maybeRun("watch:debounced-rerun");
+          }
+        }
+      };
+      const onFileEvent = async (trigger, filePath) => {
+        const relativePath = filePath.startsWith(projectRoot) ? filePath.slice(projectRoot.length + 1) : filePath;
+        pendingPaths.add(relativePath);
+        if (!json) {
+          console.log(
+            chalk.gray(`determinism watcher: ${trigger} ${relativePath}`)
+          );
+        }
+        await maybeRun(`watch:${trigger}`);
+      };
+      watcher.on("all", async (eventName, filePath) => {
+        if (eventName !== "add" && eventName !== "change") {
+          return;
+        }
+        await onFileEvent(eventName, filePath);
+      });
+      if (!json) {
+        console.log("\nHarness Determinism Watch");
+        console.log("\u2550".repeat(60));
+        console.log(`Task:                 ${options.task}`);
+        console.log(`Watching:             ${watchTargets.join(", ")}`);
+        console.log(`Debounce:             ${debounceMs}ms`);
+        console.log(chalk.gray("Press Ctrl+C to stop.\n"));
+      }
+      await runCheck("watch:initial");
+      await new Promise((resolve) => {
+        const stop = () => {
+          void watcher.close();
+          resolve();
+        };
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+      });
+      return;
+    }
+    await runCheck("manual");
+  });
+  bench.command("loops").description("Show feedback loop configuration, status, and recent events").option("--json", "Output as JSON", false).action(function() {
+    const command = this;
+    const options = command.opts();
+    const json = Boolean(options.json || command.parent?.opts().json);
     const config = feedbackLoops.getConfig();
     const stats = feedbackLoops.getStats();
     const history = feedbackLoops.getHistory(void 0, 20);
-    if (options.json) {
+    if (json) {
       console.log(JSON.stringify({ config, stats, history }, null, 2));
       return;
     }