@stackmemoryai/stackmemory 1.5.2 → 1.5.4

package/README.md

@@ -24,7 +24,8 @@ StackMemory is a **production-ready memory runtime** for AI coding tools that pr
 - **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
+- **Conductor orchestrator** — polls Linear, creates worktrees, spawns agents with bounded concurrency and auto team detection
+- **Loop/Watch command** — poll any shell command until a condition is met (monitor CI, deploys, logs)
 - **Memory monitor daemon** with automatic capture/clear on RAM pressure
 - **Auto-save service** for periodic context persistence
 - **Comprehensive test coverage** across all core modules
@@ -68,6 +69,8 @@ Tools forget decisions and constraints between sessions. StackMemory makes conte
 - **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`)
+- **Loop/Watch**: poll shell commands until conditions are met — monitor CI, deploys, logs (`stackmemory loop`)
+- **Conductor**: autonomous orchestrator — polls Linear, creates worktrees, spawns agents with auto team detection
 - **Persistent context**: frames, anchors, decisions, retrieval
 - **Integrations**: Linear (API key + OAuth), DiffMem, Browser MCP, log-mcp (log analysis)
 
@@ -389,6 +392,26 @@ stackmemory pf "auth work" "db migration" -f "task1:src/auth.ts;task2:src/db.ts"
 stackmemory pf "task A" "task B" "task C" --json
 ```
 
+### Loop / Watch (`loop` / `watch`)
+
+Poll a shell command until a condition is met. Useful for monitoring CI runs, deploy logs, inboxes, or any external state.
+
+```bash
+# Monitor GitHub Actions until complete
+stackmemory loop "gh run view <id> --json status -q .status" --until "completed"
+
+# Watch deploy logs for success
+stackmemory watch "railway logs --latest" --until "deployed" -i 5s
+
+# Wait for health check to pass
+stackmemory loop "curl -s http://localhost:3000/health" --until "ok" -i 3s -t 5m
+
+# JSON output for programmatic use
+stackmemory loop "gh pr checks 42 --json state -q '.[0].state'" --until "SUCCESS" --json
+```
+
+Options: `--until`, `--until-not`, `--until-empty`, `--until-non-empty`, `--until-exit`, `-i/--interval` (default 10s), `-t/--timeout` (default 30m), `--json`, `-q/--quiet`
+
 ---
 
 ## Documentation

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

@@ -8,7 +8,7 @@ import Table from "cli-table3";
 import { SessionManager } from "../../core/session/session-manager.js";
 import Database from "better-sqlite3";
 import { join } from "path";
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { getModelTokenLimit } from "../../core/models/model-router.js";
 const dashboardCommand = {
   command: "dashboard",
@@ -150,6 +150,52 @@ const dashboardCommand = {
       console.log(chalk.yellow.bold("\u{1F4BE} Context Usage"));
       console.log(`${usageBar} ${contextUsage}%`);
       console.log();
+      const conductorStatusPath = join(
+        projectRoot,
+        ".stackmemory",
+        "conductor-status.json"
+      );
+      if (existsSync(conductorStatusPath)) {
+        try {
+          const raw = readFileSync(conductorStatusPath, "utf-8");
+          const conductorStatus = JSON.parse(raw);
+          const stale = Date.now() - conductorStatus.updatedAt > 12e4;
+          const header = stale ? chalk.gray.bold("\u2699 Conductor (stale)") : chalk.yellow.bold("\u2699 Conductor");
+          console.log(header);
+          if (conductorStatus.running.length > 0) {
+            const conductorTable = new Table({
+              head: [
+                chalk.white("Issue"),
+                chalk.white("Status"),
+                chalk.white("Title"),
+                chalk.white("Runtime")
+              ],
+              style: { head: [], border: [] },
+              colWidths: [12, 14, 36, 10]
+            });
+            conductorStatus.running.forEach((r) => {
+              const mins = Math.round(r.runtime / 6e4);
+              const statusColor = r.status === "running" ? chalk.green : r.status === "completed" ? chalk.cyan : chalk.red;
+              conductorTable.push([
+                r.identifier,
+                statusColor(r.status),
+                r.title.slice(0, 34),
+                `${mins}m`
+              ]);
+            });
+            console.log(conductorTable.toString());
+          } else {
+            console.log(chalk.gray("  No agents running"));
+          }
+          console.log(
+            chalk.gray(
+              `  Completed: ${conductorStatus.completed}  Failed: ${conductorStatus.failed}  Max: ${conductorStatus.maxConcurrent}`
+            )
+          );
+          console.log();
+        } catch {
+        }
+      }
       db.close();
       if (argv.watch) {
         console.log(

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

@@ -3,13 +3,20 @@ 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 { existsSync, mkdirSync, writeFileSync } from "fs";
+import { execSync, spawn as cpSpawn } from "child_process";
+import {
+  existsSync,
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  readdirSync
+} from "fs";
 import { join } from "path";
 import { homedir, tmpdir } from "os";
 import Database from "better-sqlite3";
 import { logger } from "../../core/monitoring/logger.js";
 import { Conductor } from "./orchestrator.js";
+import { getAgentStatusDir } from "./orchestrator.js";
 function getGlobalStorePath() {
   const dir = join(homedir(), ".stackmemory", "conductor");
   if (!existsSync(dir)) {
@@ -43,6 +50,16 @@ function getGlobalDb() {
   `);
   return db;
 }
+function formatElapsed(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
 function createConductorCommands() {
   const cmd = new Command("conductor");
   cmd.description("Conductor \u2014 autonomous agent orchestration via Linear");
@@ -263,6 +280,60 @@ function createConductorCommands() {
     }
     globalDb.close();
   });
+  cmd.command("status").description("Show running agent status table").action(async () => {
+    const agentsDir = join(homedir(), ".stackmemory", "conductor", "agents");
+    if (!existsSync(agentsDir)) {
+      console.log("No agent status files found");
+      return;
+    }
+    const entries = readdirSync(agentsDir, { withFileTypes: true });
+    const statuses = [];
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const statusPath = join(agentsDir, entry.name, "status.json");
+      if (!existsSync(statusPath)) continue;
+      try {
+        const data = JSON.parse(readFileSync(statusPath, "utf-8"));
+        statuses.push(data);
+      } catch {
+      }
+    }
+    if (statuses.length === 0) {
+      console.log("No agent status files found");
+      return;
+    }
+    statuses.sort(
+      (a, b) => new Date(b.lastUpdate).getTime() - new Date(a.lastUpdate).getTime()
+    );
+    const header = `${"Issue".padEnd(12)}${"Phase".padEnd(16)}${"Tools".padStart(7)}${"Files".padStart(7)}${"Tokens".padStart(9)}   Last Update`;
+    console.log(header);
+    for (const s of statuses) {
+      const elapsed = Date.now() - new Date(s.lastUpdate).getTime();
+      const lastUpdate = formatElapsed(elapsed);
+      const line = `${s.issue.padEnd(12)}${s.phase.padEnd(16)}${String(s.toolCalls).padStart(7)}${String(s.filesModified).padStart(7)}${String(s.tokensUsed).padStart(9)}   ${lastUpdate}`;
+      console.log(line);
+    }
+  });
+  cmd.command("logs").description("Tail agent output log").argument("<issue-id>", "Issue identifier (e.g., STA-499)").option("-f, --follow", "Follow the log (tail -f)", false).option("-n, --lines <n>", "Number of lines to show", "50").action(async (issueId, options) => {
+    const logPath = join(getAgentStatusDir(issueId), "output.log");
+    if (!existsSync(logPath)) {
+      console.error(`No log file found for ${issueId} at ${logPath}`);
+      return;
+    }
+    const lines = parseInt(options.lines, 10);
+    const args = options.follow ? ["-f", "-n", String(lines), logPath] : ["-n", String(lines), logPath];
+    const tail = cpSpawn("tail", args, { stdio: "inherit" });
+    await new Promise((resolve) => {
+      tail.on("close", () => {
+        resolve();
+      });
+      const forward = () => {
+        tail.kill("SIGTERM");
+      };
+      process.on("SIGINT", forward);
+      process.on("SIGTERM", forward);
+    });
+  });
   cmd.command("start").description("Start the orchestrator daemon").option("--team <id>", "Linear team ID").option(
     "--states <states>",
     "Comma-separated issue states to pick up",
@@ -275,7 +346,11 @@ function createConductorCommands() {
     "--in-review <state>",
     "State name for completed review",
     "In Review"
-  ).option("--poll <ms>", "Polling interval in milliseconds", "30000").option("--concurrency <n>", "Max concurrent agents", "3").option("--workspace-root <path>", "Workspace root directory").option("--repo <path>", "Git repo root for worktrees", process.cwd()).option("--branch <name>", "Base branch for worktrees", "main").option("--retries <n>", "Max retries per issue", "1").option("--turn-timeout <ms>", "Agent turn timeout in ms", "3600000").action(async (options) => {
+  ).option("--poll <ms>", "Polling interval in milliseconds", "30000").option("--concurrency <n>", "Max concurrent agents", "3").option("--workspace-root <path>", "Workspace root directory").option("--repo <path>", "Git repo root for worktrees", process.cwd()).option("--branch <name>", "Base branch for worktrees", "main").option("--retries <n>", "Max retries per issue", "1").option("--turn-timeout <ms>", "Agent turn timeout in ms", "3600000").option(
+    "--mode <mode>",
+    'Agent mode: "cli" (claude -p, session auth) or "adapter" (JSON-RPC, API key)',
+    "cli"
+  ).action(async (options) => {
     const conductor = new Conductor({
       teamId: options.team,
       activeStates: options.states.split(",").map((s) => s.trim()),
@@ -287,12 +362,14 @@ function createConductorCommands() {
       repoRoot: options.repo,
       baseBranch: options.branch,
       maxRetries: parseInt(options.retries, 10),
-      turnTimeoutMs: parseInt(options.turnTimeout, 10)
+      turnTimeoutMs: parseInt(options.turnTimeout, 10),
+      agentMode: options.mode === "adapter" ? "adapter" : "cli"
     });
     await conductor.start();
   });
   return cmd;
 }
 export {
-  createConductorCommands
+  createConductorCommands,
+  formatElapsed
 };