@stackmemoryai/stackmemory 1.4.0 → 1.5.0

package/README.md

@@ -22,6 +22,9 @@ StackMemory is a **production-ready memory runtime** for AI coding tools that pr
 - **Multi-wrapper support** — `claude-sm`, `codex-sm`, `opencode-sm` with auto context loading
 - **Skills system** with `/spec` and `/linear-run` for Claude Code
 - **Automatic hooks** for task tracking, Linear sync, and spec progress
+- **Snapshot capture** — post-run context snapshots for session handoff (`snapshot save`)
+- **Pre-flight overlap check** — predict file conflicts before parallel task dispatch (`preflight`)
+- **Conductor orchestrator** — polls Linear, creates worktrees, spawns agents with bounded concurrency
 - **Memory monitor daemon** with automatic capture/clear on RAM pressure
 - **Auto-save service** for periodic context persistence
 - **Comprehensive test coverage** across all core modules
@@ -63,6 +66,8 @@ Tools forget decisions and constraints between sessions. StackMemory makes conte
 - **Hooks**: automatic context save, task tracking, Linear sync, PROMPT_PLAN updates, cord tracing
 - **Prompt Forge**: watches CLAUDE.md and AGENTS.md for prompt optimization (GEPA)
 - **Safe branches**: worktree isolation with `--worktree` or `-w`
+- **Snapshot**: post-run context capture — records what changed, commits, and decisions (`stackmemory snapshot`)
+- **Pre-flight check**: file overlap prediction before parallel task dispatch (`stackmemory preflight`)
 - **Persistent context**: frames, anchors, decisions, retrieval
 - **Integrations**: Linear (API key + OAuth), DiffMem, Browser MCP, log-mcp (log analysis)
 
@@ -351,6 +356,39 @@ npm run mcp:dev
 
 See [docs/cli.md](https://github.com/stackmemoryai/stackmemory/blob/main/docs/cli.md) for the full command reference.
 
+### Snapshot (`snapshot` / `snap`)
+
+Capture a point-in-time snapshot of what changed on your branch — files modified, commits, and key decisions. Useful for session handoff and post-task review.
+
+```bash
+# Save a snapshot of current branch state
+stackmemory snapshot save --task "add auth middleware"
+
+# Save with explicit decisions
+stackmemory snap save -d "chose JWT over session cookies" -d "switched to argon2"
+
+# List recent snapshots
+stackmemory snap list
+
+# Show latest snapshot (or by branch)
+stackmemory snap show feature/auth
+```
+
+### Pre-flight Check (`preflight` / `pf`)
+
+Predict file overlaps before running parallel tasks. Uses git history, import graphs, and keyword matching to flag conflicts.
+
+```bash
+# Check if two tasks can safely run in parallel
+stackmemory preflight "add user auth" "refactor database layer"
+
+# With explicit file hints
+stackmemory pf "auth work" "db migration" -f "task1:src/auth.ts;task2:src/db.ts"
+
+# JSON output for programmatic use
+stackmemory pf "task A" "task B" "task C" --json
+```
+
 ---
 
 ## Documentation

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

@@ -0,0 +1,123 @@
+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 { execSync } from "child_process";
+import chalk from "chalk";
+function parseSeconds(value) {
+  const match = value.match(/^(\d+)(s|m|h)?$/);
+  if (!match) return parseInt(value, 10) || 10;
+  const num = parseInt(match[1], 10);
+  switch (match[2]) {
+    case "h":
+      return num * 3600;
+    case "m":
+      return num * 60;
+    default:
+      return num;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function checkCondition(output, exitCode, opts) {
+  if (opts.untilExit) return exitCode === 0;
+  if (opts.untilEmpty) return output.trim().length === 0;
+  if (opts.untilNonEmpty) return output.trim().length > 0;
+  if (opts.until) return output.includes(opts.until);
+  if (opts.untilNot) return !output.includes(opts.untilNot);
+  return exitCode === 0;
+}
+function createLoopCommand() {
+  return new Command("loop").alias("watch").description(
+    "Run a command repeatedly until a condition is met (monitor CI, deploys, logs)"
+  ).argument("<command>", "Shell command to run on each iteration").option("--until <pattern>", "Stop when output contains this string").option(
+    "--until-not <pattern>",
+    "Stop when output no longer contains this string"
+  ).option("--until-empty", "Stop when output is empty", false).option("--until-non-empty", "Stop when output is non-empty", false).option(
+    "--until-exit",
+    "Stop when command exits with code 0 (ignore output)",
+    false
+  ).option("-i, --interval <duration>", "Check interval (e.g. 10s, 1m)", "10s").option("-t, --timeout <duration>", "Max wait time (e.g. 30m, 1h)", "30m").option("-q, --quiet", "Only show final result", false).option("--json", "Output result as JSON", false).option("-l, --label <name>", "Label for this loop (shown in output)").option("--shell <path>", "Shell to use", "/bin/sh").action(async (command, opts) => {
+    const intervalSec = parseSeconds(opts.interval);
+    const timeoutSec = parseSeconds(opts.timeout);
+    const label = opts.label || command.slice(0, 40);
+    const startTime = Date.now();
+    const deadline = startTime + timeoutSec * 1e3;
+    let iterations = 0;
+    let lastOutput = "";
+    if (!opts.quiet && !opts.json) {
+      console.log(
+        chalk.cyan(`[loop] ${label}`) + chalk.gray(` (every ${intervalSec}s, timeout ${timeoutSec}s)`)
+      );
+    }
+    while (Date.now() < deadline) {
+      iterations++;
+      let output = "";
+      let exitCode = 0;
+      try {
+        output = execSync(command, {
+          encoding: "utf8",
+          timeout: Math.min(intervalSec * 1e3, 6e4),
+          shell: opts.shell,
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } catch (error) {
+        const e = error;
+        exitCode = e.status ?? 1;
+        output = (e.stdout || "") + (e.stderr || "");
+      }
+      lastOutput = output;
+      if (!opts.quiet && !opts.json) {
+        const elapsed = Math.round((Date.now() - startTime) / 1e3);
+        const preview = output.trim().split("\n").slice(-3).join("\n");
+        console.log(
+          chalk.gray(`[${elapsed}s #${iterations}]`) + (preview ? `
+${preview}` : chalk.gray(" (no output)"))
+        );
+      }
+      if (checkCondition(output, exitCode, opts)) {
+        const result2 = {
+          ok: true,
+          reason: "matched",
+          iterations,
+          elapsed: Date.now() - startTime,
+          lastOutput: lastOutput.trim()
+        };
+        if (opts.json) {
+          console.log(JSON.stringify(result2));
+        } else if (!opts.quiet) {
+          console.log(
+            chalk.green(`[loop] Condition met after ${iterations} iterations`)
+          );
+        }
+        return;
+      }
+      const remaining = deadline - Date.now();
+      if (remaining > 0) {
+        await sleep(Math.min(intervalSec * 1e3, remaining));
+      }
+    }
+    const result = {
+      ok: false,
+      reason: "timeout",
+      iterations,
+      elapsed: Date.now() - startTime,
+      lastOutput: lastOutput.trim()
+    };
+    if (opts.json) {
+      console.log(JSON.stringify(result));
+    } else {
+      console.log(
+        chalk.yellow(
+          `[loop] Timed out after ${timeoutSec}s (${iterations} iterations)`
+        )
+      );
+    }
+    process.exit(1);
+  });
+}
+export {
+  createLoopCommand
+};

package/dist/src/cli/index.js

@@ -60,6 +60,7 @@ import { createDesiresCommands } from "./commands/desires.js";
 import { createConductorCommands } from "./commands/orchestrate.js";
 import { createPreflightCommand } from "./commands/preflight.js";
 import { createSnapshotCommand } from "./commands/snapshot.js";
+import { createLoopCommand } from "./commands/loop.js";
 import chalk from "chalk";
 import * as fs from "fs";
 import * as path from "path";
@@ -513,6 +514,7 @@ program.addCommand(createDesiresCommands());
 program.addCommand(createConductorCommands());
 program.addCommand(createPreflightCommand());
 program.addCommand(createSnapshotCommand());
+program.addCommand(createLoopCommand());
 registerSetupCommands(program);
 program.command("mm-spike").description(
   "Run multi-agent planning/implementation spike (planner/implementer/critic)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackmemoryai/stackmemory",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Project-scoped memory for AI coding tools. Durable context across sessions with 56 MCP tools, FTS5 search, Claude/Codex/OpenCode wrappers, Linear sync, automatic hooks, and log analysis.",
   "engines": {
     "node": ">=20.0.0",

package/templates/claude-hooks/skill-eval.cjs

@@ -350,6 +350,12 @@ function evaluate(prompt) {
     if (config.showMatchReasons && match.reasons.length > 0) {
       output += `   Matched: ${match.reasons.slice(0, 3).join(', ')}\n`;
     }
+
+    // Show suggestion if the skill defines one (e.g. loop-monitor)
+    const skillDef = skills[match.name];
+    if (skillDef?.suggestion) {
+      output += `   Suggestion: ${skillDef.suggestion}\n`;
+    }
   }
 
   if (relatedSkills.length > 0) {

package/templates/claude-hooks/skill-rules.json

@@ -255,6 +255,22 @@
       },
       "relatedSkills": ["linear-task-runner"]
     },
+    "loop-monitor": {
+      "description": "Monitor CI, deploys, logs, or external state with stackmemory loop",
+      "priority": 9,
+      "triggers": {
+        "keywords": ["monitor", "watch", "poll", "wait for", "check status", "loop", "keep checking", "deploy status", "ci status", "action status", "run status"],
+        "keywordPatterns": ["\\b(?:monitor|watch|poll|loop)\\b", "wait\\s+(?:for|until)", "keep\\s+checking", "check.*(?:status|state|progress)", "(?:gh|github)\\s+(?:run|action|check)", "deploy.*(?:status|log|done)", "\\buntil\\b.*(?:done|complete|pass|success|fail)"],
+        "intentPatterns": [
+          "(?:monitor|watch|poll|check).*(?:ci|deploy|action|run|build|status|log|inbox)",
+          "(?:wait|loop).*(?:until|for).*(?:done|complete|pass|success|finish)",
+          "(?:keep|continue).*(?:checking|monitoring|watching)",
+          "(?:let me know|notify|alert).*(?:when|if).*(?:done|complete|ready|fail)"
+        ]
+      },
+      "suggestion": "Use `stackmemory loop` to poll a command until a condition is met:\n  stackmemory loop \"<command>\" --until \"<pattern>\" -i 10s -t 30m\n  stackmemory loop \"gh run view <id> --json status -q .status\" --until \"completed\"\n  stackmemory loop \"curl -s http://localhost/health\" --until \"ok\" --json",
+      "relatedSkills": ["github-actions"]
+    },
     "linear-task-runner": {
       "description": "Execute Linear tasks via RLM orchestrator",
       "priority": 8,