@stackmemoryai/stackmemory 1.10.5 → 1.14.0

package/dist/src/orchestrators/multimodal/determinism.js

@@ -0,0 +1,244 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { createHash } from "crypto";
+import { estimateTokens } from "../../core/cache/token-estimator.js";
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync
+} from "fs";
+import { join } from "path";
+import { compactPlan } from "./utils.js";
+import { runSpike } from "./harness.js";
+const DETERMINISM_WATCH_PATTERNS = [
+  "src/orchestrators/multimodal",
+  "src/cli/commands/bench.ts",
+  "src/cli/index.ts",
+  "src/core/monitoring/logger.ts"
+];
+const DETERMINISM_WATCH_IGNORE = [
+  ".git/**",
+  "node_modules/**",
+  "dist/**",
+  "build/**",
+  ".next/**",
+  ".turbo/**",
+  "coverage/**",
+  ".stackmemory/**"
+];
+function stableStringify(value) {
+  return JSON.stringify(canonicalize(value));
+}
+function canonicalize(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => canonicalize(item));
+  }
+  if (value && typeof value === "object") {
+    const entries = Object.entries(value).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    return Object.fromEntries(
+      entries.map(([key, entryValue]) => [key, canonicalize(entryValue)])
+    );
+  }
+  return value;
+}
+function hashValue(value) {
+  return createHash("sha256").update(stableStringify(value)).digest("hex");
+}
+function modeAgreement(values) {
+  if (values.length === 0) return 1;
+  const counts = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    counts.set(value, (counts.get(value) || 0) + 1);
+  }
+  const maxCount = Math.max(...counts.values());
+  return maxCount / values.length;
+}
+function normalizeResult(result) {
+  return {
+    plan: compactPlan(result.plan),
+    critique: canonicalize(result.critique),
+    implementation: {
+      success: result.implementation.success,
+      summary: result.implementation.summary,
+      commands: [...result.implementation.commands || []]
+    },
+    iterations: (result.iterations || []).map((iteration) => ({
+      command: iteration.command,
+      ok: iteration.ok,
+      critique: canonicalize(iteration.critique),
+      outputPreviewHash: hashValue(iteration.outputPreview)
+    }))
+  };
+}
+function estimateContextTokens(result) {
+  const normalized = normalizeResult(result);
+  return estimateTokens(stableStringify(normalized));
+}
+function toSnapshot(result, index) {
+  const normalized = normalizeResult(result);
+  return {
+    index,
+    approved: result.critique.approved,
+    iterations: (result.iterations || []).length,
+    planHash: hashValue(compactPlan(result.plan)),
+    critiqueHash: hashValue(canonicalize(result.critique)),
+    commandsHash: hashValue(result.implementation.commands || []),
+    resultHash: hashValue(normalized),
+    contextTokens: estimateContextTokens(result)
+  };
+}
+function computeNumericStability(values) {
+  if (values.length <= 1) return 1;
+  const min = Math.min(...values);
+  const max = Math.max(...values);
+  if (max === min) return 1;
+  return Math.max(0, 1 - (max - min) / Math.max(max, 1));
+}
+function scoreReport(snapshots) {
+  const dimensions = [
+    {
+      name: "result",
+      weight: 40,
+      score: modeAgreement(snapshots.map((item) => item.resultHash)) * 100,
+      details: "Full normalized result hash agreement"
+    },
+    {
+      name: "plan",
+      weight: 20,
+      score: modeAgreement(snapshots.map((item) => item.planHash)) * 100,
+      details: "Plan structure hash agreement"
+    },
+    {
+      name: "critique",
+      weight: 15,
+      score: modeAgreement(snapshots.map((item) => item.critiqueHash)) * 100,
+      details: "Critique hash agreement"
+    },
+    {
+      name: "commands",
+      weight: 10,
+      score: modeAgreement(snapshots.map((item) => item.commandsHash)) * 100,
+      details: "Implementer command sequence agreement"
+    },
+    {
+      name: "iterations",
+      weight: 10,
+      score: modeAgreement(snapshots.map((item) => item.iterations)) * 100,
+      details: "Retry-count agreement"
+    },
+    {
+      name: "context_tokens",
+      weight: 5,
+      score: computeNumericStability(snapshots.map((item) => item.contextTokens)) * 100,
+      details: "Token-footprint stability"
+    }
+  ];
+  const weightedScore = dimensions.reduce((sum, dimension) => {
+    return sum + dimension.score * dimension.weight;
+  }, 0);
+  const totalWeight = dimensions.reduce(
+    (sum, dimension) => sum + dimension.weight,
+    0
+  );
+  const score = totalWeight > 0 ? weightedScore / totalWeight : 0;
+  const recommendations = [];
+  if (dimensions[0].score < 100) {
+    recommendations.push(
+      "Pin planner/critic outputs behind deterministic fixtures or replay traces."
+    );
+  }
+  if (dimensions[1].score < 100) {
+    recommendations.push(
+      "Canonicalize plan generation further and remove any model-dependent fields from smoke checks."
+    );
+  }
+  if (dimensions[4].score < 100) {
+    recommendations.push(
+      "Tighten retry rules so the same failure mode produces the same iteration count."
+    );
+  }
+  if (dimensions[5].score < 100) {
+    recommendations.push(
+      "Reduce context assembly drift by sorting symbols and fixing token accounting."
+    );
+  }
+  return {
+    runs: snapshots.length,
+    score: Math.round(score * 100) / 100,
+    snapshots,
+    dimensions,
+    recommendations
+  };
+}
+async function runDeterminismSmoke(input, options = {}) {
+  const runs = Math.max(1, options.runs ?? 5);
+  const snapshots = [];
+  for (let index = 0; index < runs; index++) {
+    const result = await runSpike(input, {
+      ...options,
+      dryRun: options.dryRun ?? true,
+      deterministicFixture: options.deterministicFixture ?? true,
+      persistAudit: false,
+      record: false,
+      recordFrame: false
+    });
+    snapshots.push(toSnapshot(result, index + 1));
+  }
+  return scoreReport(snapshots);
+}
+function getDeterminismWatchTargets(repoPath) {
+  const existingTargets = DETERMINISM_WATCH_PATTERNS.filter(
+    (target) => existsSync(join(repoPath, target))
+  );
+  if (existingTargets.length > 0) {
+    return existingTargets;
+  }
+  return ["."];
+}
+function getDeterminismDir(repoPath) {
+  return join(repoPath, ".stackmemory", "determinism");
+}
+function persistDeterminismReport(repoPath, report, meta) {
+  const dir = getDeterminismDir(repoPath);
+  mkdirSync(dir, { recursive: true });
+  const stored = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    task: meta.task,
+    trigger: meta.trigger,
+    changedPaths: meta.changedPaths || [],
+    report
+  };
+  writeFileSync(
+    join(dir, "latest.json"),
+    JSON.stringify(stored, null, 2) + "\n"
+  );
+  appendFileSync(join(dir, "history.jsonl"), JSON.stringify(stored) + "\n");
+  return stored;
+}
+function readLatestDeterminismReport(repoPath) {
+  const latestPath = join(getDeterminismDir(repoPath), "latest.json");
+  if (!existsSync(latestPath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(
+      readFileSync(latestPath, "utf8")
+    );
+  } catch {
+    return null;
+  }
+}
+export {
+  DETERMINISM_WATCH_IGNORE,
+  DETERMINISM_WATCH_PATTERNS,
+  getDeterminismWatchTargets,
+  persistDeterminismReport,
+  readLatestDeterminismReport,
+  runDeterminismSmoke
+};

package/dist/src/orchestrators/multimodal/harness.js

@@ -2,6 +2,7 @@ import { fileURLToPath as __fileURLToPath } from 'url';
 import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
+import { estimateTokens } from "../../core/cache/token-estimator.js";
 import {
   callClaude,
   callCodexCLI,
@@ -51,6 +52,45 @@ function heuristicPlan(input) {
     ]
   };
 }
+function deterministicCritique(args) {
+  const issues = [];
+  const suggestions = [];
+  if (!args.ok) {
+    issues.push("Implementer command failed");
+    suggestions.push("Fix the command invocation before retrying");
+  }
+  if (args.diff.includes("<<<<<<<") || args.diff.includes(">>>>>>>")) {
+    issues.push("Merge conflict markers detected in diff");
+    suggestions.push("Resolve conflict markers before approval");
+  }
+  if (args.checks && !args.checks.lintOk) {
+    issues.push("Lint checks failed");
+    suggestions.push("Address lint failures before approval");
+  }
+  if (args.checks && !args.checks.testsOk) {
+    issues.push("Tests failed");
+    suggestions.push("Fix failing tests before approval");
+  }
+  const failedVerifications = args.checks?.verifications.filter((verification) => !verification.ok) || [];
+  if (failedVerifications.length > 0) {
+    issues.push(
+      `Verification command failed: ${failedVerifications[0]?.command}`
+    );
+    suggestions.push(
+      "Use the verification output as the primary repro signal and fix the root cause"
+    );
+  }
+  if (!args.diff || args.diff.startsWith("(no changes detected)")) {
+    suggestions.push(
+      "No code changes detected; verify the task can be satisfied without edits"
+    );
+  }
+  return {
+    approved: issues.length === 0,
+    issues,
+    suggestions
+  };
+}
 async function runSpike(input, options = {}) {
   const plannerSystem = `You write concise, actionable implementation plans. Output raw JSON only (no markdown code fences). Schema: { "summary": "string", "steps": [{ "id": "step-1", "title": "string", "rationale": "string", "acceptanceCriteria": ["string"] }], "risks": ["string"] }`;
   const contextSummary = getLocalContextSummary(input.repoPath);
@@ -61,23 +101,28 @@ ${contextSummary}
 Constraints: Keep the plan minimal and implementable in a single PR.`;
   const t0 = Date.now();
   let plan;
-  try {
-    const raw = await callClaude(plannerPrompt, {
-      model: options.plannerModel,
-      system: plannerSystem
-    });
+  if (options.deterministicFixture) {
+    plan = heuristicPlan(input);
+  } else {
     try {
-      const cleaned = raw.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
-      plan = JSON.parse(cleaned);
+      const raw = await callClaude(plannerPrompt, {
+        model: options.plannerModel,
+        system: plannerSystem
+      });
+      try {
+        const cleaned = raw.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
+        plan = JSON.parse(cleaned);
+      } catch {
+        plan = heuristicPlan(input);
+      }
     } catch {
       plan = heuristicPlan(input);
     }
-  } catch {
-    plan = heuristicPlan(input);
   }
   const planLatencyMs = Date.now() - t0;
   const implementer = options.implementer || "codex";
   const maxIters = Math.max(1, options.maxIters ?? 2);
+  const verificationCommands = options.verificationCommands || [];
   const iterations = [];
   let approved = false;
   let lastCommand = "";
@@ -89,10 +134,14 @@ Constraints: Keep the plan minimal and implementable in a single PR.`;
   };
   for (let i = 0; i < maxIters; i++) {
     const stepsList = plan.steps.map((s, idx) => `${idx + 1}. ${s.title}`).join("\n");
+    const verificationPrompt = verificationCommands.length > 0 ? `
+
+Verification commands that must pass:
+${verificationCommands.map((command) => `- ${command}`).join("\n")}` : "\n\nIf this task fixes uncertain behavior, first create or identify a deterministic repro/test/trace that fails for the current behavior, then use it to guide the fix.";
     const basePrompt = `Implement the following plan:
 ${stepsList}
 
-Keep changes minimal and focused. Avoid unrelated edits.`;
+Keep changes minimal and focused. Avoid unrelated edits.${verificationPrompt}`;
     const refine = i === 0 ? "" : `
 Incorporate reviewer suggestions: ${lastCritique.suggestions.join("; ")}`;
     const implPrompt = basePrompt + refine;
@@ -116,14 +165,20 @@ Incorporate reviewer suggestions: ${lastCritique.suggestions.join("; ")}`;
       _lastOutput = impl.output;
     }
     const diff = options.dryRun !== false ? "(dry run \u2014 no diff)" : captureGitDiff(input.repoPath);
-    const checks = options.dryRun !== false ? null : runPostImplChecks(input.repoPath);
+    const checks = options.dryRun !== false ? null : runPostImplChecks(input.repoPath, verificationCommands);
+    const verificationSection = checks && checks.verifications.length > 0 ? `
+  Custom verification:
+${checks.verifications.map(
+      (verification) => `  - ${verification.ok ? "PASS" : "FAIL"} ${verification.command}
+${verification.output}`
+    ).join("\n")}` : "";
     const checksSection = checks ? `
 
 Post-implementation checks:
   Lint: ${checks.lintOk ? "PASS" : "FAIL"}
 ${checks.lintOutput}
   Tests: ${checks.testsOk ? "PASS" : "FAIL"}
-${checks.testOutput}` : "";
+${checks.testOutput}${verificationSection}` : "";
     const criticSystem = `You are a strict code reviewer. Review the git diff against the plan. Check for: correctness, missing steps, unrelated changes, bugs, security issues. Also review lint and test results if provided. Return raw JSON only (no markdown fences): { "approved": boolean, "issues": ["string"], "suggestions": ["string"] }`;
     const criticPrompt = `Plan: ${plan.summary}
 Acceptance criteria:
@@ -134,25 +189,35 @@ Implementer exit: ${ok ? "success" : "failed"}
 
 Git diff:
 ${diff}${checksSection}`;
-    try {
-      const raw = await callClaude(criticPrompt, {
-        model: options.reviewerModel,
-        system: criticSystem
+    if (options.deterministicFixture) {
+      lastCritique = deterministicCritique({
+        plan,
+        ok,
+        diff,
+        checks
       });
-      const cleaned = raw.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
-      lastCritique = JSON.parse(cleaned);
-    } catch {
-      lastCritique = {
-        approved: ok,
-        issues: ok ? [] : ["Critique failed"],
-        suggestions: []
-      };
+    } else {
+      try {
+        const raw = await callClaude(criticPrompt, {
+          model: options.reviewerModel,
+          system: criticSystem
+        });
+        const cleaned = raw.replace(/^```(?:json)?\s*\n?/i, "").replace(/\n?```\s*$/i, "").trim();
+        lastCritique = JSON.parse(cleaned);
+      } catch {
+        lastCritique = {
+          approved: ok,
+          issues: ok ? [] : ["Critique failed"],
+          suggestions: []
+        };
+      }
     }
     iterations.push({
       command: lastCommand,
       ok,
       outputPreview: diff.slice(0, 2e3),
-      critique: lastCritique
+      critique: lastCritique,
+      checks
     });
     if (lastCritique.approved) {
       approved = true;
@@ -175,64 +240,66 @@ ${diff}${checksSection}`;
     editAttempts: editMetrics.editAttempts,
     editSuccesses: editMetrics.editSuccesses,
     editFuzzyFallbacks: editMetrics.editFuzzyFallbacks,
-    contextTokens: Math.ceil(finalDiff.length / 4)
+    contextTokens: estimateTokens(finalDiff)
   };
-  try {
-    const dir = options.auditDir || path.join(input.repoPath, ".stackmemory", "build");
-    fs.mkdirSync(dir, { recursive: true });
-    const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-    const file = path.join(dir, `spike-${stamp}.json`);
-    fs.writeFileSync(
-      file,
-      JSON.stringify(
-        {
-          input,
-          options: { ...options, auditDir: void 0 },
-          plan,
-          iterations,
-          metrics: runMetrics
-        },
-        null,
-        2
-      )
-    );
-    const metricsFile = path.join(dir, "harness-metrics.jsonl");
-    fs.appendFileSync(metricsFile, JSON.stringify(runMetrics) + "\n");
+  if (options.persistAudit !== false) {
     try {
-      const lines = fs.readFileSync(metricsFile, "utf-8").split("\n").filter((l) => l.trim());
-      const recent = lines.slice(-10).map((l) => JSON.parse(l));
-      if (recent.length >= 3) {
-        const summary = summarizeRuns(recent);
-        if (summary.approvalRate < HARNESS_TARGETS.firstPassApprovalRate) {
-          feedbackLoops.fire(
-            "harnessRegression",
-            "metrics_append",
-            {
-              metric: "approvalRate",
-              current: summary.approvalRate,
-              target: HARNESS_TARGETS.firstPassApprovalRate,
-              window: recent.length
-            },
-            "regression_alert"
-          );
-        }
-        if (summary.p95TotalLatencyMs > HARNESS_TARGETS.totalLatencyP95Ms) {
-          feedbackLoops.fire(
-            "harnessRegression",
-            "metrics_append",
-            {
-              metric: "totalLatencyP95",
-              current: summary.p95TotalLatencyMs,
-              target: HARNESS_TARGETS.totalLatencyP95Ms,
-              window: recent.length
-            },
-            "regression_alert"
-          );
+      const dir = options.auditDir || path.join(input.repoPath, ".stackmemory", "build");
+      fs.mkdirSync(dir, { recursive: true });
+      const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+      const file = path.join(dir, `spike-${stamp}.json`);
+      fs.writeFileSync(
+        file,
+        JSON.stringify(
+          {
+            input,
+            options: { ...options, auditDir: void 0 },
+            plan,
+            iterations,
+            metrics: runMetrics
+          },
+          null,
+          2
+        )
+      );
+      const metricsFile = path.join(dir, "harness-metrics.jsonl");
+      fs.appendFileSync(metricsFile, JSON.stringify(runMetrics) + "\n");
+      try {
+        const lines = fs.readFileSync(metricsFile, "utf-8").split("\n").filter((l) => l.trim());
+        const recent = lines.slice(-10).map((l) => JSON.parse(l));
+        if (recent.length >= 3) {
+          const summary = summarizeRuns(recent);
+          if (summary.approvalRate < HARNESS_TARGETS.firstPassApprovalRate) {
+            feedbackLoops.fire(
+              "harnessRegression",
+              "metrics_append",
+              {
+                metric: "approvalRate",
+                current: summary.approvalRate,
+                target: HARNESS_TARGETS.firstPassApprovalRate,
+                window: recent.length
+              },
+              "regression_alert"
+            );
+          }
+          if (summary.p95TotalLatencyMs > HARNESS_TARGETS.totalLatencyP95Ms) {
+            feedbackLoops.fire(
+              "harnessRegression",
+              "metrics_append",
+              {
+                metric: "totalLatencyP95",
+                current: summary.p95TotalLatencyMs,
+                target: HARNESS_TARGETS.totalLatencyP95Ms,
+                window: recent.length
+              },
+              "regression_alert"
+            );
+          }
         }
+      } catch {
       }
     } catch {
     }
-  } catch {
   }
   if (options.record) {
     void recordContext(
@@ -265,7 +332,8 @@ ${diff}${checksSection}`;
       commands: iterations.map((it) => it.command)
     },
     critique: lastCritique,
-    iterations
+    iterations,
+    verification: iterations.at(-1)?.checks || null
   };
 }
 const runPlanAndCode = runSpike;
@@ -341,6 +409,9 @@ Repo: ${input.repoPath}
 Notes: ${input.contextNotes || "(none)"}
 ${contextSummary}
 Constraints: Keep the plan minimal and implementable in a single PR.`;
+  if (options.deterministicFixture) {
+    return heuristicPlan(input);
+  }
   try {
     const raw = await callClaude(plannerPrompt, {
       model: options.plannerModel,

package/dist/src/orchestrators/multimodal/providers.js

@@ -115,7 +115,7 @@ ${newFiles.join("\n")}`;
     return "(git diff failed)";
   }
 }
-function runPostImplChecks(cwd) {
+function runPostImplChecks(cwd, verificationCommands = []) {
   const maxOutput = 2e3;
   function truncate(s) {
     if (s.length <= maxOutput) return s;
@@ -152,7 +152,47 @@ function runPostImplChecks(cwd) {
   } catch (e) {
     testOutput = truncate(e instanceof Error ? e.message : String(e));
   }
-  return { lintOk, lintOutput, testsOk, testOutput };
+  return {
+    lintOk,
+    lintOutput,
+    testsOk,
+    testOutput,
+    verifications: runVerificationCommands(cwd, verificationCommands)
+  };
+}
+function runVerificationCommands(cwd, commands, options = {}) {
+  const timeout = options.timeoutMs ?? 12e4;
+  const maxOutput = options.maxOutput ?? 4e3;
+  const truncate = (value) => {
+    if (value.length <= maxOutput) return value;
+    return value.slice(0, maxOutput) + `
+... (truncated, ${value.length} total chars)`;
+  };
+  return commands.map((command) => command.trim()).filter(Boolean).map((command) => {
+    try {
+      const result = spawnSync(command, {
+        cwd,
+        encoding: "utf8",
+        shell: true,
+        timeout,
+        maxBuffer: Math.max(maxOutput * 4, 1024 * 1024)
+      });
+      const output = truncate((result.stdout || "") + (result.stderr || ""));
+      return {
+        command,
+        ok: result.status === 0,
+        output: output || (result.status === 0 ? "(command completed with no output)" : `(command failed with exit ${result.status ?? "unknown"})`)
+      };
+    } catch (error) {
+      return {
+        command,
+        ok: false,
+        output: truncate(
+          error instanceof Error ? error.message : String(error)
+        )
+      };
+    }
+  });
 }
 function parseEditMetrics(diff) {
   if (!diff || diff.startsWith("(")) {
@@ -204,5 +244,6 @@ export {
   captureGitDiff,
   implementWithClaude,
   parseEditMetrics,
-  runPostImplChecks
+  runPostImplChecks,
+  runVerificationCommands
 };

package/dist/src/skills/recursive-agent-orchestrator.js

@@ -5,6 +5,7 @@ const __dirname = __pathDirname(__filename);
 import * as fs from "fs";
 import * as path from "path";
 import { logger } from "../core/monitoring/logger.js";
+import { estimateTokens } from "../core/cache/token-estimator.js";
 import { ParallelExecutor } from "../core/execution/parallel-executor.js";
 import { RecursiveContextManager } from "../core/context/recursive-context-manager.js";
 import { ClaudeCodeSubagentClient } from "../integrations/claude-code/subagent-client.js";
@@ -345,7 +346,7 @@ Rules:
       context: agentContext
     });
     node.result = response.result;
-    node.tokens = response.tokens || this.estimateTokens(JSON.stringify(response));
+    node.tokens = response.tokens || estimateTokens(JSON.stringify(response));
     node.cost = this.calculateNodeCost(node.tokens, agentConfig.model);
     if (options.shareContextRealtime) {
       await this.shareAgentResults(node);
@@ -527,9 +528,6 @@ ${sections.join("\n\n")}` : "";
       `- Output structured JSON when possible`
     ].join("\n");
   }
-  estimateTokens(text) {
-    return Math.ceil(text.length / 4);
-  }
   async shareAgentResults(_node) {
     logger.debug("Sharing agent results", { nodeId: _node.id });
   }

package/dist/src/utils/hook-installer.js

@@ -32,14 +32,6 @@ const CANONICAL_HOOKS = [
     commandPrefix: "node",
     required: true
   },
-  {
-    scriptName: "cord-trace.js",
-    eventType: "PostToolUse",
-    matcher: "mcp__.*__cord_(spawn|fork|complete|ask|tree)",
-    timeout: 2,
-    commandPrefix: "node",
-    required: true
-  },
   {
     scriptName: "theory-capture.js",
     eventType: "PostToolUse",

package/dist/src/utils/process-cleanup.js

@@ -15,13 +15,7 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-const STACKMEMORY_PROCESS_PATTERNS = [
-  "stackmemory",
-  "ralph orchestrate",
-  "ralph swarm",
-  "ralph loop",
-  "hooks start"
-];
+const STACKMEMORY_PROCESS_PATTERNS = ["stackmemory", "hooks start"];
 function getStackmemoryProcesses() {
   const processes = [];
   try {