@stackmemoryai/stackmemory 1.10.4 → 1.12.0

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

@@ -0,0 +1,265 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+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 {
+  canonicalStateStore
+} from "../../core/shared-state/canonical-store.js";
+import {
+  getCurrentRepoGitHubInfo,
+  refreshCurrentRepoPullRequestState
+} from "../../integrations/github/pr-state.js";
+function parseJsonObject(input) {
+  if (!input) {
+    return {};
+  }
+  const parsed = JSON.parse(input);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Expected a JSON object");
+  }
+  return parsed;
+}
+function createStateCommand() {
+  const cmd = new Command("state").description(
+    "Manage canonical user-scoped shared state across instances and sessions"
+  );
+  const instance = cmd.command("instance").description("Manage instance state");
+  instance.command("upsert").requiredOption("--id <id>", "Instance identifier").requiredOption(
+    "--tool <tool>",
+    "Tool name (claude|codex|opencode|stackmemory)"
+  ).option("--session <id>", "Session identifier").option("--project <id>", "Project identifier").option("--project-path <path>", "Project path").option("--branch <branch>", "Git branch").option("--worktree-path <path>", "Worktree path").option("--pid <pid>", "Process id").option("--status <status>", "Status", "active").option("--metadata <json>", "Metadata JSON object").action(async (options) => {
+    const record = await canonicalStateStore.upsertInstance({
+      instanceId: options.id,
+      tool: options.tool,
+      sessionId: options.session,
+      projectId: options.project,
+      projectPath: options.projectPath,
+      branch: options.branch,
+      worktreePath: options.worktreePath,
+      pid: options.pid ? Number(options.pid) : void 0,
+      status: options.status,
+      metadata: parseJsonObject(options.metadata)
+    });
+    console.log(JSON.stringify(record, null, 2));
+  });
+  instance.command("end").requiredOption("--id <id>", "Instance identifier").action(async (options) => {
+    await canonicalStateStore.endInstance(options.id);
+    console.log(chalk.green(`Ended instance ${options.id}`));
+  });
+  const session = cmd.command("session").description("Manage session state");
+  session.command("upsert").requiredOption("--id <id>", "Session identifier").requiredOption(
+    "--tool <tool>",
+    "Tool name (claude|codex|opencode|stackmemory)"
+  ).option("--project <id>", "Project identifier").option("--project-path <path>", "Project path").option("--branch <branch>", "Git branch").option("--instance <id>", "Associated instance identifier").option("--status <status>", "Status", "active").option("--metadata <json>", "Metadata JSON object").action(async (options) => {
+    const record = await canonicalStateStore.upsertSession({
+      sessionId: options.id,
+      tool: options.tool,
+      projectId: options.project,
+      projectPath: options.projectPath,
+      branch: options.branch,
+      instanceId: options.instance,
+      status: options.status,
+      metadata: parseJsonObject(options.metadata)
+    });
+    console.log(JSON.stringify(record, null, 2));
+  });
+  session.command("end").requiredOption("--id <id>", "Session identifier").option("--status <status>", "Status", "closed").action(async (options) => {
+    await canonicalStateStore.endSession(options.id, options.status);
+    console.log(chalk.green(`Ended session ${options.id}`));
+  });
+  cmd.command("event").description("Append a shared-state event").requiredOption("--type <type>", "Event type").option("--tool <tool>", "Tool name (claude|codex|opencode|stackmemory)").option("--instance <id>", "Instance identifier").option("--session <id>", "Session identifier").option("--project <id>", "Project identifier").option("--project-path <path>", "Project path").option("--branch <branch>", "Git branch").option("--payload <json>", "Payload JSON object").action(async (options) => {
+    const event = await canonicalStateStore.appendEvent({
+      type: options.type,
+      tool: options.tool,
+      instanceId: options.instance,
+      sessionId: options.session,
+      projectId: options.project,
+      projectPath: options.projectPath,
+      branch: options.branch,
+      payload: parseJsonObject(options.payload)
+    });
+    console.log(JSON.stringify(event, null, 2));
+  });
+  cmd.command("show").description("Show canonical shared state for a project").option("--project <id>", "Project identifier").option("--project-path <path>", "Project path").option("--limit <count>", "Recent event limit", "10").option("--json", "Emit JSON output").action(async (options) => {
+    const summary = await canonicalStateStore.getProjectSummary({
+      projectId: options.project,
+      projectPath: options.projectPath,
+      eventLimit: Number(options.limit)
+    });
+    if (options.json) {
+      console.log(JSON.stringify(summary, null, 2));
+      return;
+    }
+    console.log(chalk.bold("Canonical Shared State"));
+    console.log(
+      `  Active sessions: ${summary.activeSessions.length} | Active instances: ${summary.activeInstances.length} | Active claims: ${summary.activeClaims.length}`
+    );
+    if (summary.projectId) {
+      console.log(`  Project: ${summary.projectId}`);
+    }
+    if (summary.activeSessions.length > 0) {
+      console.log(chalk.bold("\nSessions"));
+      for (const record of summary.activeSessions) {
+        console.log(
+          `  ${record.sessionId.slice(0, 8)} ${record.tool} ${record.branch || ""}`.trim()
+        );
+      }
+    }
+    if (summary.activeInstances.length > 0) {
+      console.log(chalk.bold("\nInstances"));
+      for (const record of summary.activeInstances) {
+        console.log(
+          `  ${record.instanceId} ${record.tool} ${record.branch || ""}`.trim()
+        );
+      }
+    }
+    if (summary.activeClaims.length > 0) {
+      console.log(chalk.bold("\nClaims"));
+      for (const claim of summary.activeClaims) {
+        const scopes = [
+          claim.branch ? `branch:${claim.branch}` : "",
+          ...claim.paths.map((item) => `path:${item}`)
+        ].filter(Boolean).join(", ");
+        console.log(
+          `  ${claim.claimId.slice(0, 8)} ${claim.tool} ${scopes || "(no scope)"}`.trim()
+        );
+      }
+    }
+    if (summary.recentEvents.length > 0) {
+      console.log(chalk.bold("\nRecent events"));
+      for (const event of summary.recentEvents) {
+        console.log(
+          `  ${event.type} ${new Date(event.timestamp).toISOString()}`
+        );
+      }
+    }
+  });
+  const claims = cmd.command("claims").description("Manage shared ownership claims");
+  claims.command("claim").requiredOption(
+    "--tool <tool>",
+    "Tool name (claude|codex|opencode|stackmemory)"
+  ).option("--session <id>", "Session identifier").option("--instance <id>", "Instance identifier").option("--project <id>", "Project identifier").option("--project-path <path>", "Project path").option("--branch <branch>", "Git branch").option("--path <path...>", "Claimed file or directory path(s)").option("--ttl-ms <ttl>", "Time to live in milliseconds", "86400000").option("--metadata <json>", "Metadata JSON object").option("--json", "Emit JSON output").action(async (options) => {
+    const result = await canonicalStateStore.claimPaths({
+      tool: options.tool,
+      sessionId: options.session,
+      instanceId: options.instance,
+      projectId: options.project,
+      projectPath: options.projectPath,
+      branch: options.branch,
+      paths: options.path || [],
+      ttlMs: Number(options.ttlMs),
+      metadata: parseJsonObject(options.metadata)
+    });
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(chalk.green(`Claimed ${result.record.claimId.slice(0, 8)}`));
+    if (result.conflicts.length > 0) {
+      console.log(chalk.yellow(`Conflicts: ${result.conflicts.length}`));
+      for (const conflict of result.conflicts) {
+        console.log(
+          `  ${conflict.claimId.slice(0, 8)} ${conflict.branch || ""} ${conflict.paths.join(", ")}`.trim()
+        );
+      }
+    }
+  });
+  claims.command("release").option("--claim <id>", "Claim identifier").option("--session <id>", "Session identifier").option("--instance <id>", "Instance identifier").option("--project <id>", "Project identifier").option("--project-path <path>", "Project path").option("--branch <branch>", "Git branch").option("--reason <reason>", "Release reason").action(async (options) => {
+    const released = await canonicalStateStore.releaseClaims({
+      claimId: options.claim,
+      sessionId: options.session,
+      instanceId: options.instance,
+      projectId: options.project,
+      projectPath: options.projectPath,
+      branch: options.branch,
+      reason: options.reason
+    });
+    console.log(chalk.green(`Released ${released} claim(s)`));
+  });
+  claims.command("show").option("--project <id>", "Project identifier").option("--project-path <path>", "Project path").option("--all", "Show released and expired claims too").option("--json", "Emit JSON output").action(async (options) => {
+    const records = await canonicalStateStore.listPathClaims({
+      projectId: options.project,
+      projectPath: options.projectPath,
+      activeOnly: !options.all
+    });
+    if (options.json) {
+      console.log(JSON.stringify(records, null, 2));
+      return;
+    }
+    if (records.length === 0) {
+      console.log(chalk.yellow("No claims found"));
+      return;
+    }
+    for (const claim of records) {
+      const scopes = [
+        claim.branch ? `branch:${claim.branch}` : "",
+        ...claim.paths.map((item) => `path:${item}`)
+      ].filter(Boolean).join(", ");
+      console.log(
+        `${claim.claimId.slice(0, 8)} ${claim.status} ${claim.tool} ${scopes || "(no scope)"}`
+      );
+    }
+  });
+  const github = cmd.command("github").description("GitHub projection state");
+  github.command("refresh").description("Refresh current repo branch PR state from GitHub CLI").option("--json", "Emit JSON output").action(async (options) => {
+    const projection = await refreshCurrentRepoPullRequestState();
+    if (!projection) {
+      console.log(
+        chalk.yellow(
+          "No GitHub PR projection available for current repo/branch"
+        )
+      );
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(projection, null, 2));
+      return;
+    }
+    console.log(chalk.green(`Refreshed PR #${projection.prNumber}`));
+    console.log(`${projection.state} ${projection.title}`);
+    console.log(projection.url);
+  });
+  github.command("show").description("Show cached current repo branch PR projection").option("--json", "Emit JSON output").action(async (options) => {
+    const info = getCurrentRepoGitHubInfo();
+    if (!info) {
+      console.log(chalk.yellow("Not in a GitHub repository"));
+      return;
+    }
+    const projection = await canonicalStateStore.getGitHubPullRequest({
+      repo: info.repo,
+      branch: info.branch
+    });
+    if (!projection) {
+      console.log(
+        chalk.yellow("No cached GitHub PR projection for current branch")
+      );
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(projection, null, 2));
+      return;
+    }
+    console.log(chalk.bold(`PR #${projection.prNumber}`));
+    console.log(`${projection.state} ${projection.title}`);
+    console.log(`Repo: ${projection.repo}`);
+    console.log(
+      `Branch: ${projection.headRefName} -> ${projection.baseRefName}`
+    );
+    if (projection.reviewDecision) {
+      console.log(`Review: ${projection.reviewDecision}`);
+    }
+    if (projection.statusCheckRollup) {
+      console.log(`Checks: ${projection.statusCheckRollup}`);
+    }
+    console.log(`Synced: ${new Date(projection.lastSyncedAt).toISOString()}`);
+    console.log(projection.url);
+  });
+  return cmd;
+}
+var state_default = createStateCommand;
+export {
+  createStateCommand,
+  state_default as default
+};

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

@@ -173,6 +173,39 @@ function createWikiCommand() {
     console.log(chalk.gray(`  Articles updated:  ${result.updated.length}`));
     console.log(chalk.gray(`  Total articles:    ${result.totalArticles}`));
   });
+  cmd.command("ingest <source>").description("Ingest a URL or local path into the wiki").option("--wiki-dir <path>", "Override wiki directory").option("-n, --max-pages <n>", "Max pages to crawl for URLs", "20").option("--json", "Output as JSON").action(async (source, options) => {
+    const compiler = getCompiler(options.wikiDir);
+    await compiler.initialize();
+    const isUrl = source.startsWith("http://") || source.startsWith("https://");
+    let result;
+    if (isUrl) {
+      console.log(
+        chalk.cyan(`Crawling ${source} (max ${options.maxPages} pages)...`)
+      );
+      result = await compiler.ingestUrl(source, {
+        maxPages: parseInt(options.maxPages)
+      });
+    } else {
+      console.log(chalk.cyan(`Ingesting ${source}...`));
+      result = await compiler.ingestPath(source);
+    }
+    if (options.json) {
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    console.log(chalk.green("\nIngested."));
+    console.log(chalk.gray(`  Articles created: ${result.created.length}`));
+    console.log(chalk.gray(`  Total articles:   ${result.totalArticles}`));
+    if (result.created.length > 0) {
+      console.log(chalk.gray("\n  Created:"));
+      result.created.slice(0, 10).forEach((p) => console.log(chalk.gray(`    - ${p}`)));
+      if (result.created.length > 10) {
+        console.log(
+          chalk.gray(`    ...and ${result.created.length - 10} more`)
+        );
+      }
+    }
+  });
   cmd.command("lint").description("Health check the wiki for issues").option("--wiki-dir <path>", "Override wiki directory").option("--json", "Output as JSON").action(async (options) => {
     const compiler = getCompiler(options.wikiDir);
     await compiler.initialize();

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

@@ -13,6 +13,7 @@ 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";
 const DEFAULT_SM_CONFIG = {
   defaultWorktree: false,
   defaultTracing: true
@@ -125,35 +126,24 @@ class GeminiSM {
     }
   }
   resolveGeminiBin() {
-    if (this.config.geminiBin && this.config.geminiBin.trim()) {
-      return this.config.geminiBin.trim();
-    }
-    const envBin = process.env["GEMINI_BIN"];
-    if (envBin && envBin.trim()) return envBin.trim();
-    const possiblePaths = [
-      path.join(
-        os.homedir(),
-        ".nvm",
-        "versions",
-        "node",
-        "v22.22.0",
-        "bin",
-        "gemini"
-      ),
-      "/usr/local/bin/gemini",
-      "/opt/homebrew/bin/gemini"
-    ];
-    for (const binPath of possiblePaths) {
-      if (fs.existsSync(binPath)) {
-        return binPath;
-      }
-    }
-    try {
-      execSync("which gemini", { stdio: "ignore" });
-      return "gemini";
-    } catch {
-    }
-    return null;
+    return resolveRealCliBin({
+      explicitBin: this.config.geminiBin,
+      envBin: process.env["GEMINI_BIN"],
+      preferredPaths: [
+        path.join(
+          os.homedir(),
+          ".nvm",
+          "versions",
+          "node",
+          "v22.22.0",
+          "bin",
+          "gemini"
+        ),
+        "/usr/local/bin/gemini",
+        "/opt/homebrew/bin/gemini"
+      ],
+      pathCommands: ["gemini"]
+    });
   }
   setupWorktree() {
     if (!this.config.useWorktree || !this.isGitRepo()) {

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";
@@ -54,8 +56,9 @@ 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 { createPreflightCommand } from "./commands/preflight.js";
@@ -64,11 +67,18 @@ 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 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 +115,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 +211,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 +280,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 +316,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}`);
@@ -571,8 +608,9 @@ 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(createPreflightCommand());
@@ -581,6 +619,8 @@ program.addCommand(createWikiCommand());
 program.addCommand(createLoopCommand());
 program.addCommand(createRulesCommand());
 program.addCommand(createSkillCommand());
+program.addCommand(createPackCommand());
+program.addCommand(createCacheCommand());
 registerSetupCommands(program);
 program.command("mm-spike").description(
   "Run multi-agent planning/implementation spike (planner/implementer/critic)"
@@ -600,7 +640,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 +668,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 +728,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 +772,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) {