@stackmemoryai/stackmemory 1.12.0 → 1.14.0

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

@@ -0,0 +1,161 @@
+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 { networkInterfaces } from "os";
+import {
+  PortalServer,
+  ensureToken,
+  readStatus,
+  stopRunning
+} from "../../features/portal/index.js";
+import { DEFAULT_PORTAL_CONFIG } from "../../features/portal/types.js";
+function tailscaleIp() {
+  const nets = networkInterfaces();
+  for (const addrs of Object.values(nets)) {
+    for (const a of addrs ?? []) {
+      if (a.family === "IPv4" && a.address.startsWith("100.")) {
+        return a.address;
+      }
+    }
+  }
+  return void 0;
+}
+function printAccessUrls(host, port, token) {
+  const path = token ? `/?token=${token}` : "/";
+  const ts = tailscaleIp();
+  console.log(chalk.cyan("\nAccess your agent:"));
+  if (ts) {
+    console.log(
+      chalk.green(`  http://${ts}:${port}${path}`) + chalk.gray("  (tailnet)")
+    );
+  }
+  console.log(chalk.gray(`  http://localhost:${port}${path}`));
+  if (!ts && host === "0.0.0.0") {
+    console.log(
+      chalk.gray(
+        "  Tip: connect this machine to Tailscale, then use its 100.x address."
+      )
+    );
+  }
+}
+function createPortalCommand() {
+  const cmd = new Command("portal").description("Browser terminal into a persistent tmux Claude Code session").addHelpText(
+    "after",
+    `
+Examples:
+  stackmemory portal start                 Start the portal (foreground)
+  stackmemory portal start --port 8080     Use a custom port
+  stackmemory portal start --command "claude --resume"
+  stackmemory portal start --no-auth       Disable token (Tailscale-only)
+  stackmemory portal status                Show running status + access URL
+  stackmemory portal stop                  Stop a backgrounded portal
+  stackmemory portal token                 Print the access token
+
+Run it on a VPS behind Tailscale for 24/7 agents. See docs/guides/PORTAL.md.
+`
+  );
+  cmd.command("start").description("Start the portal server (runs in the foreground)").option(
+    "--port <number>",
+    "Port to listen on",
+    String(DEFAULT_PORTAL_CONFIG.port)
+  ).option("--host <host>", "Interface to bind", DEFAULT_PORTAL_CONFIG.host).option(
+    "--session <name>",
+    "tmux session name",
+    DEFAULT_PORTAL_CONFIG.session
+  ).option(
+    "--command <cmd>",
+    "Command tmux runs in the session",
+    DEFAULT_PORTAL_CONFIG.command
+  ).option("--cwd <dir>", "Working directory for the session").option("--no-auth", "Disable token auth (rely on Tailscale)").action(async (options) => {
+    const server = new PortalServer({
+      port: parseInt(options.port, 10),
+      host: options.host,
+      session: options.session,
+      command: options.command,
+      cwd: options.cwd,
+      noAuth: options.auth === false
+    });
+    try {
+      const status = await server.start();
+      const cfg = server.getConfig();
+      console.log(chalk.green("\u2713 StackMemory Portal started"));
+      console.log(
+        chalk.gray(
+          `  Session: ${cfg.session}  (tmux new-session -A -s ${cfg.session})`
+        )
+      );
+      console.log(chalk.gray(`  Command: ${cfg.command}`));
+      console.log(chalk.gray(`  Listening: ${cfg.host}:${status.port}`));
+      if (cfg.noAuth) {
+        console.log(
+          chalk.yellow("  Auth: disabled (anyone on the network can connect)")
+        );
+      }
+      printAccessUrls(cfg.host, cfg.port, cfg.token);
+      console.log(
+        chalk.gray(
+          "\nPress Ctrl+C to stop the portal (your tmux session keeps running)."
+        )
+      );
+    } catch (error) {
+      console.error(
+        chalk.red("Failed to start portal:"),
+        error.message
+      );
+      process.exit(1);
+    }
+    const shutdown = async () => {
+      console.log(chalk.gray("\nShutting down portal\u2026"));
+      await server.stop();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  });
+  cmd.command("status").description("Show portal status and access URL").action(() => {
+    const status = readStatus();
+    if (!status.running) {
+      console.log(chalk.yellow("Portal is not running"));
+      console.log(chalk.gray("  Start with: stackmemory portal start"));
+      return;
+    }
+    console.log(chalk.green("Portal is running"));
+    console.log(chalk.gray(`  PID: ${status.pid}`));
+    console.log(chalk.gray(`  Session: ${status.session}`));
+    console.log(chalk.gray(`  Listening: ${status.host}:${status.port}`));
+    if (status.startedAt) {
+      const up = Math.floor((Date.now() - status.startedAt) / 1e3);
+      console.log(chalk.gray(`  Uptime: ${formatUptime(up)}`));
+    }
+    const token = ensureToken();
+    if (status.port)
+      printAccessUrls(status.host ?? "0.0.0.0", status.port, token);
+  });
+  cmd.command("stop").description("Stop a running portal server").action(() => {
+    if (stopRunning()) {
+      console.log(chalk.green("\u2713 Portal stopped"));
+    } else {
+      console.log(chalk.yellow("Portal is not running"));
+    }
+  });
+  cmd.command("token").description("Print the portal access token (auto-generated on first use)").action(() => {
+    console.log(ensureToken());
+  });
+  return cmd;
+}
+function formatUptime(seconds) {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  if (seconds < 86400) {
+    const h = Math.floor(seconds / 3600);
+    return `${h}h ${Math.floor(seconds % 3600 / 60)}m`;
+  }
+  const d = Math.floor(seconds / 86400);
+  return `${d}d ${Math.floor(seconds % 86400 / 3600)}h`;
+}
+export {
+  createPortalCommand
+};

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

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+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 * as fs from "fs";
+import * as path from "path";
+const DIRS = ["company", "wiki", "skills", "clients", "raw", ".stackmemory"];
+const TEMPLATES = {
+  "company/voice.md": "---\nname: Voice Guide\ndescription: How we write and communicate\n---\n\n# Voice Guide\n\n## Tone\n- [Your tone descriptors here]\n\n## Words we use\n- [Preferred terms]\n\n## Words we avoid\n- [Banned terms]\n",
+  "company/team.md": "---\nname: Team Directory\ndescription: Who works here and what they do\n---\n\n# Team\n\n| Name | Role | Contact |\n|------|------|---------||\n",
+  "company/design.md": "---\nname: Design System\ndescription: Logos, colors, components\n---\n\n# Design System\n\n## Colors\n- Primary:\n- Secondary:\n\n## Logos\n- [paths or URLs]\n",
+  "wiki/README.md": "# Wiki \u2014 SOPs & Playbooks\n\nAdd markdown files here. Files with skill frontmatter become Claude skills.\n\nSOPs should follow the Company OS schema:\n\n- `## Objective`\n- `## Procedure`\n- `## Verification`\n- `## Non-compliance`\n\nEach SOP must reference a PROSE Expectation from `docs/specs/COMPANY-OS-PROSE.md`.\n",
+  "wiki/SOP-301-onboarding.md": "# SOP-301 New Hire Onboarding\n\n**Owner:** People Ops  \n**Status:** Active  \n**Related PROSE Expectation:** [E.1 Onboarding completeness](../docs/specs/COMPANY-OS-PROSE.md#e1-onboarding-completeness)\n\n## Objective\nEnsure every new hire has accounts, hardware, and access documented before their start date.\n\n## Procedure\n\n1. **Pre-start checklist (5 days before)**\n   - Hiring manager opens an onboarding ticket.\n   - People Ops confirms laptop requirement and shipping address.\n\n2. **Account provisioning (3 days before)**\n   - IT creates SSO account and adds the hire to default groups.\n   - People Ops sends welcome email with first-week schedule.\n\n3. **Access verification (1 day before)**\n   - Hiring manager verifies the hire can log in to primary systems.\n\n## Verification\n\n- Run audit: `stackmemory company-os audit onboarding`\n- Expected result: 100% of hires in last 30 days have completed checklist.\n\n## Non-compliance\n\nOnboarding missing SSO access or hardware assignment on start date is non-compliant.\n",
+  "skills/README.md": '# Skills\n\nClaude skill-packs. Each file is a markdown instruction set with frontmatter.\n\n```yaml\n---\nname: skill-name\ndescription: What this skill does\nactivates_on: [keyword1, keyword2]\nversion: "1.0"\n---\n```\n',
+  "clients/README.md": "# Clients\n\nEach client gets a subfolder with icp.md, voice.md, campaigns/, context/.\n",
+  "raw/README.md": "# Raw\n\nUnstructured data: transcripts, research, scrapes.\n",
+  ".stackmemory/config.yml": `# StackMemory Company OS Configuration
+
+sources:
+  - path: ./company
+    type: reference
+  - path: ./wiki
+    type: sop
+  - path: ./skills
+    type: skill
+  - path: ./raw
+    type: raw
+
+tenants: {}
+
+freshness_threshold_hours: 24
+
+skill_rot:
+  enabled: true
+  stale_days: 90
+  correction_threshold: 5
+`
+};
+function createScaffoldCommand() {
+  const cmd = new Command("scaffold").alias("os-init").description(
+    "Scaffold a Company OS folder structure for local context management"
+  ).option("--force", "Overwrite existing template files").option("--dir <path>", "Target directory (default: current directory)").action(async (options) => {
+    const targetDir = path.resolve(options.dir || process.cwd());
+    const created = [];
+    const skipped = [];
+    for (const dir of DIRS) {
+      const fullPath = path.join(targetDir, dir);
+      if (!fs.existsSync(fullPath)) {
+        fs.mkdirSync(fullPath, { recursive: true });
+        created.push(dir + "/");
+      }
+    }
+    for (const [relPath, content] of Object.entries(TEMPLATES)) {
+      const fullPath = path.join(targetDir, relPath);
+      const dir = path.dirname(fullPath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      if (fs.existsSync(fullPath) && !options.force) {
+        skipped.push(relPath);
+        continue;
+      }
+      fs.writeFileSync(fullPath, content, "utf-8");
+      created.push(relPath);
+    }
+    console.log(chalk.cyan("\n  Company OS scaffolded\n"));
+    if (created.length) {
+      console.log(chalk.green(`  Created: ${created.length} files/dirs`));
+      for (const f of created) {
+        console.log(chalk.gray(`    + ${f}`));
+      }
+    }
+    if (skipped.length) {
+      console.log(chalk.gray(`  Skipped: ${skipped.length} (already exist)`));
+    }
+    console.log();
+    console.log(chalk.gray("  Next steps:"));
+    console.log(
+      chalk.gray("    1. Edit company/voice.md with your tone and brand")
+    );
+    console.log(chalk.gray("    2. Add skills to skills/ as markdown files"));
+    console.log(
+      chalk.gray("    3. Set COMPANY_OS_ROOT=. in .env for MCP auto-indexing")
+    );
+    console.log();
+  });
+  return cmd;
+}
+export {
+  createScaffoldCommand
+};

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

@@ -678,7 +678,6 @@ function createSetupPluginsCommand() {
     }
     console.log(chalk.gray(`Source: ${sourcePluginsDir}
 `));
-    const plugins = ["stackmemory", "ralph-wiggum"];
     let installed = 0;
     for (const plugin of plugins) {
       const sourcePath = join(sourcePluginsDir, plugin);
@@ -735,9 +734,7 @@ function createSetupPluginsCommand() {
       console.log(
         chalk.white("  /sm-help      ") + chalk.gray("Show all commands")
       );
-      console.log(
-        chalk.white("  /ralph-loop   ") + chalk.gray("Start Ralph iteration loop")
-      );
+      console.log(chalk.gray("Start Ralph iteration loop"));
     } else {
       console.log(chalk.yellow("No plugins installed"));
     }

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

@@ -0,0 +1,253 @@
+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 { homedir, hostname } from "os";
+import { join } from "path";
+import { existsSync, readFileSync } from "fs";
+import { createHash } from "crypto";
+import Database from "better-sqlite3";
+import { CloudSyncEngine } from "../../core/storage/cloud-sync.js";
+const DEFAULT_ENDPOINT = "https://provenant-api.jpwu03.workers.dev";
+function loadSyncConfig(projectDir) {
+  const envKey = process.env["PROVENANT_API_KEY"];
+  const envProject = process.env["PROVENANT_PROJECT_ID"];
+  if (envKey) {
+    return buildConfig(
+      envKey,
+      envProject || createHash("sha256").update(projectDir).digest("hex").slice(0, 16),
+      process.env["PROVENANT_API_URL"] || DEFAULT_ENDPOINT,
+      projectDir
+    );
+  }
+  const cfgPath = join(homedir(), ".stackmemory", "config.json");
+  if (!existsSync(cfgPath)) return null;
+  try {
+    const cfg = JSON.parse(readFileSync(cfgPath, "utf8"));
+    if (!cfg.auth?.apiKey) return null;
+    return buildConfig(
+      cfg.auth.apiKey,
+      cfg.auth.projectId || createHash("sha256").update(projectDir).digest("hex").slice(0, 16),
+      cfg.auth.apiUrl || DEFAULT_ENDPOINT,
+      projectDir
+    );
+  } catch {
+    return null;
+  }
+}
+function buildConfig(apiKey, projectId, endpoint, projectDir) {
+  return {
+    enabled: true,
+    endpoint,
+    apiKey,
+    projectId,
+    clientId: createHash("sha256").update(hostname() + projectDir).digest("hex").slice(0, 16),
+    batchSize: 100,
+    conflictResolution: "newest_wins",
+    generationalPolicy: {
+      youngMaxAgeDays: 1,
+      matureMaxAgeDays: 7
+    },
+    timeoutMs: 3e4,
+    retryAttempts: 3,
+    retryBaseDelayMs: 1e3
+  };
+}
+function getDbPath(projectDir) {
+  const contextDb = join(projectDir, ".stackmemory", "context.db");
+  if (existsSync(contextDb)) return contextDb;
+  const localDb = join(projectDir, ".stackmemory", "stackmemory.db");
+  if (existsSync(localDb)) return localDb;
+  const globalDb = join(homedir(), ".stackmemory", "stackmemory.db");
+  if (existsSync(globalDb)) return globalDb;
+  return contextDb;
+}
+function createLoginCommand() {
+  const cmd = new Command("login").description("Connect to Provenant cloud sync").argument("<email>", "Your email address").option("--workspace <name>", "Workspace name (for new accounts)").option("--reset", "Reset API key (revokes existing keys)").action(
+    async (email, options) => {
+      const endpoint = process.env["PROVENANT_API_URL"] || DEFAULT_ENDPOINT;
+      try {
+        const path = options.reset ? "/v1/setup/reset" : "/v1/setup";
+        const body = { email };
+        if (!options.reset) {
+          body["workspaceName"] = options.workspace ?? email.split("@")[0];
+        }
+        const res = await fetch(`${endpoint}${path}`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(body)
+        });
+        const data = await res.json();
+        if (res.status === 409 && !options.reset) {
+          console.log(
+            chalk.yellow("Workspace already exists for this email.")
+          );
+          console.log(chalk.dim("  Run: stackmemory login <email> --reset"));
+          console.log(chalk.dim(`  Workspace ID: ${data.workspaceId}`));
+          console.log(chalk.dim(`  Project ID:   ${data.projectId}`));
+          return;
+        }
+        if (!res.ok || !data.apiKey) {
+          console.error(
+            chalk.red(`Login failed: ${data.error || res.statusText}`)
+          );
+          process.exit(1);
+        }
+        const smDir = join(homedir(), ".stackmemory");
+        const cfgPath = join(smDir, "config.json");
+        let cfg = {};
+        if (existsSync(cfgPath)) {
+          try {
+            cfg = JSON.parse(readFileSync(cfgPath, "utf8"));
+          } catch {
+          }
+        }
+        cfg["auth"] = {
+          apiKey: data.apiKey,
+          apiUrl: endpoint,
+          projectId: data.projectId,
+          workspaceId: data.workspaceId,
+          email
+        };
+        const { writeFileSync, mkdirSync } = await import("fs");
+        mkdirSync(smDir, { recursive: true });
+        writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n");
+        console.log(chalk.green("Logged in to Provenant cloud sync."));
+        console.log(chalk.dim(`  Workspace: ${data.workspaceId}`));
+        console.log(chalk.dim(`  Project:   ${data.projectId}`));
+        console.log(chalk.dim(`  Config:    ${cfgPath}`));
+      } catch (err) {
+        console.error(
+          chalk.red(
+            `Login failed: ${err instanceof Error ? err.message : err}`
+          )
+        );
+        process.exit(1);
+      }
+    }
+  );
+  return cmd;
+}
+function createSyncCommand() {
+  const cmd = new Command("sync").description(
+    "Provenant cloud sync operations"
+  );
+  cmd.command("push").description("Push local changes to Provenant cloud").option("--force", "Push all data, ignoring cursors").option("--json", "Output as JSON").action(async (options) => {
+    const projectDir = process.cwd();
+    const config = loadSyncConfig(projectDir);
+    if (!config) {
+      console.error(
+        chalk.yellow(
+          "Cloud sync not configured. Run `stackmemory login` to connect."
+        )
+      );
+      process.exit(1);
+    }
+    const dbPath = getDbPath(projectDir);
+    if (!existsSync(dbPath)) {
+      console.error(chalk.red("No StackMemory database found."));
+      process.exit(1);
+    }
+    const db = new Database(dbPath);
+    const engine = new CloudSyncEngine(db, config);
+    try {
+      const result = await engine.push();
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else if (result.success) {
+        console.log(
+          chalk.green(`Pushed ${result.pushed} entities.`) + (result.conflicts > 0 ? chalk.yellow(` ${result.conflicts} conflicts.`) : "")
+        );
+      } else {
+        console.error(chalk.red(`Push failed: ${result.error}`));
+      }
+    } finally {
+      db.close();
+    }
+  });
+  cmd.command("pull").description("Pull changes from Provenant cloud").option("--tables <tables...>", "Only pull specific tables").option("--json", "Output as JSON").action(async (options) => {
+    const projectDir = process.cwd();
+    const config = loadSyncConfig(projectDir);
+    if (!config) {
+      console.error(
+        chalk.yellow(
+          "Cloud sync not configured. Run `stackmemory login` to connect."
+        )
+      );
+      process.exit(1);
+    }
+    const dbPath = getDbPath(projectDir);
+    if (!existsSync(dbPath)) {
+      console.error(chalk.red("No StackMemory database found."));
+      process.exit(1);
+    }
+    const db = new Database(dbPath);
+    const engine = new CloudSyncEngine(db, config);
+    try {
+      const result = await engine.pull(options.tables);
+      if (options.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else if (result.success) {
+        console.log(
+          chalk.green(
+            `Pulled ${result.pulled} entities, applied ${result.applied}.`
+          ) + (result.conflicts > 0 ? chalk.yellow(` ${result.conflicts} conflicts.`) : "")
+        );
+      } else {
+        console.error(chalk.red(`Pull failed: ${result.error}`));
+      }
+    } finally {
+      db.close();
+    }
+  });
+  cmd.command("status").description("Show cloud sync status").option("--json", "Output as JSON").action(async (options) => {
+    const projectDir = process.cwd();
+    const config = loadSyncConfig(projectDir);
+    if (!config) {
+      if (options.json) {
+        console.log(
+          JSON.stringify({ connected: false, message: "Not configured" })
+        );
+      } else {
+        console.log(
+          chalk.dim("Cloud sync not configured. Run `stackmemory login`.")
+        );
+      }
+      return;
+    }
+    const dbPath = getDbPath(projectDir);
+    if (!existsSync(dbPath)) {
+      console.log(chalk.dim("No StackMemory database found."));
+      return;
+    }
+    const db = new Database(dbPath);
+    const engine = new CloudSyncEngine(db, config);
+    try {
+      const status = engine.status();
+      if (options.json) {
+        console.log(JSON.stringify(status, null, 2));
+      } else {
+        console.log(chalk.bold("Cloud Sync Status"));
+        console.log(
+          `  Connected:  ${status.connected ? chalk.green("yes") : chalk.red("no")}`
+        );
+        console.log(`  Endpoint:   ${status.endpoint ?? "none"}`);
+        console.log(`  Last push:  ${status.lastPushAt ?? "never"}`);
+        console.log(`  Last pull:  ${status.lastPullAt ?? "never"}`);
+        console.log(`  Pending:    ${status.pendingPushCount} items`);
+        console.log(
+          `  Conflicts:  ${status.conflictCount > 0 ? chalk.yellow(String(status.conflictCount)) : "0"}`
+        );
+      }
+    } finally {
+      db.close();
+    }
+  });
+  return cmd;
+}
+export {
+  createLoginCommand,
+  createSyncCommand
+};

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

@@ -5,10 +5,20 @@ const __dirname = __pathDirname(__filename);
 import { Command } from "commander";
 import Database from "better-sqlite3";
 import { join } from "path";
-import { existsSync } from "fs";
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
 import {
   LinearTaskManager
 } from "../../features/tasks/linear-task-manager.js";
+import {
+  parseMasterTasks,
+  getNextTask,
+  addTaskToFile,
+  updateTaskInFile
+} from "../../core/tasks/md-task-parser.js";
+import {
+  MASTER_TASKS_TEMPLATE,
+  TASKS_CONFIG_TEMPLATE
+} from "../../core/tasks/master-tasks-template.js";
 function getTaskStore(projectRoot) {
   const dbPath = join(projectRoot, ".stackmemory", "context.db");
   if (!existsSync(dbPath)) {
@@ -191,8 +201,127 @@ Tags: ${tags.join(", ")}`);
       console.error("\u274C Failed to show task:", error.message);
     }
   });
+  tasks.command("init").description("Scaffold .stackmemory/tasks/master-tasks.md").action(() => {
+    const projectRoot = process.cwd();
+    const tasksDir = join(projectRoot, ".stackmemory", "tasks");
+    const mdPath = join(tasksDir, "master-tasks.md");
+    const configPath = join(tasksDir, "config.json");
+    if (existsSync(mdPath)) {
+      console.log(`Already exists: ${mdPath}`);
+      return;
+    }
+    mkdirSync(tasksDir, { recursive: true });
+    writeFileSync(mdPath, MASTER_TASKS_TEMPLATE, "utf-8");
+    writeFileSync(
+      configPath,
+      JSON.stringify(TASKS_CONFIG_TEMPLATE, null, 2),
+      "utf-8"
+    );
+    console.log(`Created: ${mdPath}`);
+    console.log(`Created: ${configPath}`);
+  });
+  const md = new Command("md").description(
+    "Local-first task management via master-tasks.md"
+  );
+  md.command("list").alias("ls").description("List tasks from master-tasks.md").option("-p, --priority <P>", "Filter by priority (P0, P1, P2, P3)").option(
+    "-s, --status <status>",
+    "Filter by status (todo, active, done, blocked, cut)"
+  ).option("-o, --owner <owner>", "Filter by owner (@me, @agent, @defer)").option("--json", "Output as JSON").action((options) => {
+    const mdPath = resolveMdPath();
+    if (!mdPath) return;
+    let tasks2 = parseMasterTasks(readFileSync(mdPath, "utf-8"));
+    if (options.priority)
+      tasks2 = tasks2.filter((t) => t.priority === options.priority);
+    if (options.status)
+      tasks2 = tasks2.filter((t) => t.status === options.status);
+    if (options.owner) tasks2 = tasks2.filter((t) => t.owner === options.owner);
+    if (options.json) {
+      console.log(JSON.stringify(tasks2, null, 2));
+      return;
+    }
+    if (tasks2.length === 0) {
+      console.log("No tasks found");
+      return;
+    }
+    console.log(`
+Tasks (${tasks2.length})
+`);
+    for (const t of tasks2) {
+      const pColor = t.priority === "P0" ? "\x1B[31m" : t.priority === "P1" ? "\x1B[33m" : "\x1B[90m";
+      const sIcon = t.status === "done" ? "[x]" : t.status === "active" ? "[>]" : t.status === "blocked" ? "[!]" : "[ ]";
+      console.log(
+        `${sIcon} ${pColor}${t.priority}\x1B[0m ${t.id} ${t.task} ${t.owner} ${t.branchPr ? `(${t.branchPr})` : ""}`
+      );
+    }
+    console.log("");
+  });
+  md.command("next").description("Show the next task to work on").option("--json", "Output as JSON").action((options) => {
+    const mdPath = resolveMdPath();
+    if (!mdPath) return;
+    const tasks2 = parseMasterTasks(readFileSync(mdPath, "utf-8"));
+    const next = getNextTask(tasks2);
+    if (!next) {
+      console.log("No actionable tasks");
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(next));
+      return;
+    }
+    console.log(`
+Next: ${next.id} [${next.priority}] ${next.task}`);
+    console.log(`  Owner: ${next.owner} | Sync: ${next.sync}`);
+    if (next.notes) console.log(`  Notes: ${next.notes}`);
+    console.log("");
+  });
+  md.command("add <description>").description("Add a task to master-tasks.md").option("-p, --priority <P>", "Priority (P0-P3)", "P1").option("-o, --owner <owner>", "Owner (@me, @agent, @defer)", "@me").option("-s, --sync <sync>", "Sync target (local, linear, gh)", "local").option("-b, --branch <branch>", "Branch or PR").option("-n, --notes <notes>", "Notes").action((description, options) => {
+    const mdPath = resolveMdPath();
+    if (!mdPath) return;
+    const id = addTaskToFile(mdPath, {
+      priority: options.priority,
+      status: "todo",
+      owner: options.owner,
+      sync: options.sync,
+      task: description,
+      branchPr: options.branch || "",
+      notes: options.notes || ""
+    });
+    console.log(`Added: ${id} ${description}`);
+  });
+  md.command("update <taskId>").description("Update a task in master-tasks.md").option(
+    "-s, --status <status>",
+    "New status (todo, active, done, blocked, cut)"
+  ).option("-p, --priority <P>", "New priority (P0-P3)").option("-o, --owner <owner>", "New owner").option("-b, --branch <branch>", "Branch or PR").option("-n, --notes <notes>", "Notes").option("--sync <sync>", "Sync target (local, linear, gh)").action((taskId, options) => {
+    const mdPath = resolveMdPath();
+    if (!mdPath) return;
+    try {
+      const updates = {};
+      if (options.status) updates.status = options.status;
+      if (options.priority) updates.priority = options.priority;
+      if (options.owner) updates.owner = options.owner;
+      if (options.branch) updates.branchPr = options.branch;
+      if (options.notes) updates.notes = options.notes;
+      if (options.sync) updates.sync = options.sync;
+      updateTaskInFile(mdPath, taskId.toUpperCase(), updates);
+      console.log(`Updated: ${taskId.toUpperCase()}`);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+    }
+  });
+  tasks.addCommand(md);
   return tasks;
 }
+function resolveMdPath() {
+  const projectRoot = process.cwd();
+  const smPath = join(projectRoot, ".stackmemory", "tasks", "master-tasks.md");
+  if (existsSync(smPath)) return smPath;
+  const rootPath = join(projectRoot, "master-tasks.md");
+  if (existsSync(rootPath)) return rootPath;
+  console.error(
+    'No master-tasks.md found. Run "stackmemory tasks init" first.'
+  );
+  return null;
+}
 function findTaskByPartialId(projectRoot, partialId) {
   const dbPath = join(projectRoot, ".stackmemory", "context.db");
   if (!existsSync(dbPath)) return null;