bosun 0.40.21 → 0.41.1

package/cli.mjs

@@ -28,6 +28,7 @@ import { fileURLToPath } from "node:url";
 import { execFileSync, execSync, fork, spawn } from "node:child_process";
 import os from "node:os";
 import { createDaemonCrashTracker } from "./infra/daemon-restart-policy.mjs";
+import { ensureTestRuntimeSandbox } from "./infra/test-runtime.mjs";
 import {
   applyAllCompatibility,
   detectLegacySetup,
@@ -76,12 +77,14 @@ function showHelp() {
     bosun [options]
 
   COMMANDS
-    audit <command> [options]   Codebase annotation audit workflows (scan/generate/warn/manifest/index/trim/conformity/migrate)
-    --setup                     Launch the web-based setup wizard (default)
+    workflow list              List declarative pipeline workflows
+    workflow run <name>        Run a declarative pipeline workflow
+    --setup                    Launch the web-based setup wizard (default)
     --setup-terminal            Run the legacy terminal setup wizard
     --where                     Show the resolved bosun config directory
     --doctor                    Validate bosun .env/config setup
     --tool-log <ID|list|prune>  Retrieve/list/prune cached tool outputs
+    node:create <name>          Scaffold a custom workflow node in custom-nodes/
     --context-index [mode]      Run context index workflow (run|status|search)
     --context-index-query <text> Query text for context index search mode
     --context-index-limit <n>   Max results for context index search (default: 25)
@@ -140,6 +143,12 @@ function showHelp() {
     --workspace-switch <id>     Switch active workspace
     --workspace-add-repo        Add repo to workspace (interactive)
     --workspace-health          Run workspace health diagnostics
+    --workspace-pause <id>      Pause a workspace (no new workflows)
+    --workspace-resume <id>     Resume a paused workspace
+    --workspace-disable <id>    Disable a workspace entirely
+    --workspace-status          Show state summary of all workspaces
+    --workspace-executors <id>  Show/set executor config for workspace
+                                  [--max-concurrent N] [--pool shared|dedicated] [--weight N]
 
   TASK MANAGEMENT
     task list [--status s] [--json]  List tasks with optional filters
@@ -152,6 +161,12 @@ function showHelp() {
 
     Run 'bosun task --help' for complete task CLI documentation and examples.
 
+  WORKFLOWS
+    workflow list               List built-in and configured workflows
+    workflow run <name>         Run a declarative fresh-context workflow
+
+    Run 'bosun workflow --help' for workflow CLI examples.
+
   VIBE-KANBAN
     --no-vk-spawn               Don't auto-spawn Vibe-Kanban
     --vk-ensure-interval <ms>   VK health check interval (default: 60000)
@@ -252,6 +267,9 @@ function resolveConfigDirForCli() {
   const repoLocalConfigDir = resolveRepoLocalBosunDir(repoRoot);
   if (repoLocalConfigDir) return repoLocalConfigDir;
 
+  const sandbox = ensureTestRuntimeSandbox();
+  if (sandbox?.configDir) return sandbox.configDir;
+
   const preferWindowsDirs =
     process.platform === "win32" && !isWslInteropRuntime();
   const baseDir = preferWindowsDirs
@@ -368,10 +386,21 @@ function uniqueResolvedPaths(paths) {
   return results;
 }
 
+function getWorkspaceScopedCacheDirCandidate(repoRootPath) {
+  const bosunDir = process.env.BOSUN_DIR || resolveConfigDirForCli();
+  if (!bosunDir || !repoRootPath) return null;
+  const parts = String(repoRootPath).replace(/\\/g, "/").split("/").filter(Boolean);
+  const repoName = parts.at(-1);
+  const workspaceName = parts.at(-2);
+  if (!repoName || !workspaceName) return null;
+  return resolve(bosunDir, "workspaces", workspaceName, repoName, ".cache");
+}
+
 function getRuntimeCacheDirCandidates(extraCacheDirs = []) {
   return uniqueResolvedPaths([
     ...extraCacheDirs,
     runtimeCacheDir,
+    getWorkspaceScopedCacheDirCandidate(runtimeRepoRoot),
     process.env.BOSUN_DIR ? resolve(process.env.BOSUN_DIR, ".cache") : null,
     resolve(__dirname, ".cache"),
     resolve(process.cwd(), ".cache"),
@@ -625,6 +654,42 @@ function findGhostDaemonPids() {
   }
 }
 
+function findGhostSentinelPids() {
+  if (process.platform === "win32") {
+    try {
+      const out = execFileSync(
+        "powershell",
+        [
+          "-NoProfile",
+          "-Command",
+          "Get-CimInstance Win32_Process | Where-Object { $_.Name -match '^(node|electron)(\\.exe)?$' -and $_.CommandLine -match 'telegram-sentinel\\.mjs' } | Select-Object -ExpandProperty ProcessId",
+        ],
+        { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 3000 },
+      ).trim();
+      if (!out) return [];
+      return out
+        .split(/\r?\n/)
+        .map((s) => parseInt(String(s).trim(), 10))
+        .filter((n) => Number.isFinite(n) && n > 0 && n !== process.pid);
+    } catch {
+      return [];
+    }
+  }
+  try {
+    const out = execFileSync(
+      "pgrep",
+      ["-f", "telegram-sentinel\\.mjs"],
+      { encoding: "utf8", stdio: ["pipe", "pipe", "pipe"], timeout: 3000 },
+    ).trim();
+    return out
+      .split("\n")
+      .map((s) => parseInt(s.trim(), 10))
+      .filter((n) => Number.isFinite(n) && n > 0 && n !== process.pid);
+  } catch {
+    return [];
+  }
+}
+
 function writePidFile(pid) {
   try {
     mkdirSync(dirname(DAEMON_PID_FILE), { recursive: true });
@@ -852,11 +917,28 @@ function daemonStatus() {
   } else {
     // Check for ghost daemon-child processes (alive but no PID file)
     const ghosts = findGhostDaemonPids();
+    const ghostSentinels = findGhostSentinelPids();
     if (ghosts.length > 0) {
       console.log(`  :alert:  bosun daemon is NOT tracked (no PID file), but ${ghosts.length} ghost process(es) found: ${ghosts.join(", ")}`);
       console.log(`  The daemon is likely running but its PID file was lost.`);
-      console.log(`  Run --stop-daemon to clean up, then --daemon to restart.`);
+      if (ghostSentinels.length > 0) {
+        console.log(`  Ghost sentinel restart owner(s) detected: ${ghostSentinels.join(", ")}`);
+      }
+      console.log(`  Run --terminate to stop restart owners, then --daemon to restart.`);
     } else {
+      const existingMonitorOwner = detectExistingMonitorLockOwner();
+      if (existingMonitorOwner) {
+        console.log(
+          `  bosun daemon is not running in daemon mode, but bosun monitor is active (PID ${existingMonitorOwner.pid}).`,
+        );
+        console.log(
+          `  Bosun is running in monitor mode with lock file ${existingMonitorOwner.pidFile}.`,
+        );
+        console.log(
+          `  Use 'bosun --terminate' to stop it, or 'bosun --daemon' only after it is fully stopped.`,
+        );
+        process.exit(0);
+      }
       // Broader scan: portal, monitor, ui-server, etc. (non-daemon bosun processes)
       const allPids = findAllBosunProcessPids();
       if (allPids.length > 0) {
@@ -1108,6 +1190,7 @@ async function terminateBosun() {
     ]).map((pidFile) => readAlivePid(pidFile)),
     readSentinelPid(),
   ].filter((pid) => Number.isFinite(pid) && pid > 0);
+  const sentinelGhostPids = findGhostSentinelPids();
   const manualStopHoldMs =
     Math.max(
       0,
@@ -1119,9 +1202,17 @@ async function terminateBosun() {
     ...daemonPids,
     ...monitorPids,
     ...sentinelPids,
+    ...sentinelGhostPids,
+    ...ghosts,
   ]);
   const restartOwnerPids = Array.from(
-    new Set([...ancestorPids, ...sentinelPids, ...daemonPids, ...ghosts]),
+    new Set([
+      ...ancestorPids,
+      ...sentinelPids,
+      ...sentinelGhostPids,
+      ...daemonPids,
+      ...ghosts,
+    ]),
   ).filter((pid) => pid !== process.pid);
   const tracked = [...restartOwnerPids, ...monitorPids];
   const trackedPids = Array.from(new Set([...tracked, ...ghosts])).filter(
@@ -1251,7 +1342,21 @@ async function main() {
     process.exit(0);
   }
 
-  // Handle 'audit' subcommand before --help so command-specific help works.
+  const workflowFlagIndex = args.indexOf("--workflow");
+  const workflowCommandIndex =
+    args[0] === "workflow"
+      ? 0
+      : args[0]?.startsWith("--")
+        ? args.indexOf("workflow")
+        : -1;
+  if (workflowCommandIndex >= 0 || workflowFlagIndex >= 0) {
+    const { runWorkflowCli } = await import("./workflow/workflow-cli.mjs");
+    const commandStartIndex = workflowCommandIndex >= 0 ? workflowCommandIndex : workflowFlagIndex;
+    const workflowArgs = args.slice(commandStartIndex + 1);
+    await runWorkflowCli(workflowArgs);
+    process.exit(0);
+  }
+
   const auditFlagIndex = args.indexOf("--audit");
   const auditCommandIndex =
     args[0] === "audit"
@@ -1263,8 +1368,27 @@ async function main() {
     const { runAuditCli } = await import("./lib/codebase-audit.mjs");
     const commandStartIndex = auditCommandIndex >= 0 ? auditCommandIndex : auditFlagIndex;
     const auditArgs = args.slice(commandStartIndex + 1);
-    const result = await runAuditCli(auditArgs);
-    process.exit(Number.isInteger(result?.exitCode) ? result.exitCode : 0);
+    await runAuditCli(auditArgs);
+    process.exit(0);
+  }
+
+  if (args[0] === "node:create" || (args[0] === "node" && args[1] === "create")) {
+    const name = args[0] === "node:create" ? args[1] : args[2];
+    if (!name) {
+      console.error("Usage: bosun node:create <name>");
+      process.exit(1);
+    }
+    const { scaffoldCustomNodeFile } = await import("./workflow/workflow-nodes.mjs");
+    try {
+      const result = scaffoldCustomNodeFile(name, { repoRoot: runtimeRepoRoot });
+      console.log(`\n  ✓ Created custom node \"${result.type}\"`);
+      console.log(`    File: ${result.filePath}`);
+      console.log("");
+    } catch (err) {
+      console.error(`  Error: ${err.message}`);
+      process.exit(1);
+    }
+    process.exit(0);
   }
 
   // Handle --help
@@ -1742,7 +1866,11 @@ async function main() {
       console.log("\n  Workspaces:");
       for (const ws of workspaces) {
         const marker = ws.id === active?.id ? " ← active" : "";
-        console.log(`    ${ws.name} (${ws.id})${marker}`);
+        const stateIcon = ws.state === "active" ? "●" : ws.state === "paused" ? "◐" : "○";
+        const stateLabel = ws.state !== "active" ? ` [${ws.state}]` : "";
+        console.log(`    ${stateIcon} ${ws.name} (${ws.id})${stateLabel}${marker}`);
+        const ex = ws.executors;
+        console.log(`      executors: max=${ex.maxConcurrent}, pool=${ex.pool}, weight=${ex.weight}`);
         for (const repo of ws.repos || []) {
           const primary = repo.primary ? " [primary]" : "";
           const exists = repo.exists ? "✓" : "✗";
@@ -1831,6 +1959,137 @@ async function main() {
     process.exit(result.ok ? 0 : 1);
   }
 
+  // Handle --workspace-pause
+  if (args.includes("--workspace-pause") || args.includes("workspace-pause")) {
+    const { pauseWorkspace, getWorkspace } = await import("./workspace/workspace-manager.mjs");
+    const configDirArg = getArgValue("--config-dir");
+    const configDir = configDirArg || process.env.BOSUN_DIR || resolveConfigDirForCli();
+    const wsId = getArgValue("--workspace-pause") || getArgValue("workspace-pause");
+    if (!wsId) {
+      console.error("  Error: workspace ID required. Usage: bosun --workspace-pause <id>");
+      process.exit(1);
+    }
+    try {
+      pauseWorkspace(configDir, wsId);
+      const ws = getWorkspace(configDir, wsId);
+      console.log(`\n  ⏸  Workspace "${ws?.name || wsId}" paused — no new workflows will start\n`);
+    } catch (err) {
+      console.error(`  Error: ${err.message}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
+  // Handle --workspace-resume
+  if (args.includes("--workspace-resume") || args.includes("workspace-resume")) {
+    const { resumeWorkspace, getWorkspace } = await import("./workspace/workspace-manager.mjs");
+    const configDirArg = getArgValue("--config-dir");
+    const configDir = configDirArg || process.env.BOSUN_DIR || resolveConfigDirForCli();
+    const wsId = getArgValue("--workspace-resume") || getArgValue("workspace-resume");
+    if (!wsId) {
+      console.error("  Error: workspace ID required. Usage: bosun --workspace-resume <id>");
+      process.exit(1);
+    }
+    try {
+      resumeWorkspace(configDir, wsId);
+      const ws = getWorkspace(configDir, wsId);
+      console.log(`\n  ▶  Workspace "${ws?.name || wsId}" resumed — workflows will trigger normally\n`);
+    } catch (err) {
+      console.error(`  Error: ${err.message}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
+  // Handle --workspace-disable
+  if (args.includes("--workspace-disable") || args.includes("workspace-disable")) {
+    const { disableWorkspace, getWorkspace } = await import("./workspace/workspace-manager.mjs");
+    const configDirArg = getArgValue("--config-dir");
+    const configDir = configDirArg || process.env.BOSUN_DIR || resolveConfigDirForCli();
+    const wsId = getArgValue("--workspace-disable") || getArgValue("workspace-disable");
+    if (!wsId) {
+      console.error("  Error: workspace ID required. Usage: bosun --workspace-disable <id>");
+      process.exit(1);
+    }
+    try {
+      disableWorkspace(configDir, wsId);
+      const ws = getWorkspace(configDir, wsId);
+      console.log(`\n  ⏹  Workspace "${ws?.name || wsId}" disabled — no workflows, no executors\n`);
+    } catch (err) {
+      console.error(`  Error: ${err.message}`);
+      process.exit(1);
+    }
+    process.exit(0);
+  }
+
+  // Handle --workspace-status
+  if (args.includes("--workspace-status") || args.includes("workspace-status")) {
+    const { getWorkspaceStateSummary } = await import("./workspace/workspace-manager.mjs");
+    const configDirArg = getArgValue("--config-dir");
+    const configDir = configDirArg || process.env.BOSUN_DIR || resolveConfigDirForCli();
+    const summary = getWorkspaceStateSummary(configDir);
+    if (summary.length === 0) {
+      console.log("\n  No workspaces configured.\n");
+    } else {
+      console.log("\n  Workspace Status:");
+      for (const ws of summary) {
+        const stateIcon = ws.state === "active" ? "●" : ws.state === "paused" ? "◐" : "○";
+        const current = ws.isCurrent ? " ← current" : "";
+        console.log(`    ${stateIcon} ${ws.name} (${ws.id}) — ${ws.state}${current}`);
+        const ex = ws.executors;
+        console.log(`      executors: max=${ex.maxConcurrent}, pool=${ex.pool}, weight=${ex.weight}`);
+        if (ws.disabledWorkflows.length > 0) {
+          console.log(`      disabled workflows: ${ws.disabledWorkflows.join(", ")}`);
+        }
+        if (ws.enabledWorkflows.length > 0) {
+          console.log(`      enabled workflows: ${ws.enabledWorkflows.join(", ")}`);
+        }
+      }
+      console.log("");
+    }
+    process.exit(0);
+  }
+
+  // Handle --workspace-executors
+  if (args.includes("--workspace-executors") || args.includes("workspace-executors")) {
+    const { setWorkspaceExecutors, getWorkspace } = await import("./workspace/workspace-manager.mjs");
+    const configDirArg = getArgValue("--config-dir");
+    const configDir = configDirArg || process.env.BOSUN_DIR || resolveConfigDirForCli();
+    const wsId = getArgValue("--workspace-executors") || getArgValue("workspace-executors");
+    if (!wsId) {
+      console.error("  Error: workspace ID required. Usage: bosun --workspace-executors <id> [--max-concurrent N] [--pool shared|dedicated] [--weight N]");
+      process.exit(1);
+    }
+    const maxConcurrent = getArgValue("--max-concurrent");
+    const pool = getArgValue("--pool");
+    const weight = getArgValue("--weight");
+    const hasUpdate = maxConcurrent || pool || weight;
+    if (hasUpdate) {
+      try {
+        const opts = {};
+        if (maxConcurrent) opts.maxConcurrent = Number(maxConcurrent);
+        if (pool) opts.pool = pool;
+        if (weight) opts.weight = Number(weight);
+        const result = setWorkspaceExecutors(configDir, wsId, opts);
+        console.log(`\n  ✓ Executor config updated for "${wsId}":`, JSON.stringify(result), "\n");
+      } catch (err) {
+        console.error(`  Error: ${err.message}`);
+        process.exit(1);
+      }
+    } else {
+      const ws = getWorkspace(configDir, wsId);
+      if (!ws) {
+        console.error(`  Error: workspace "${wsId}" not found`);
+        process.exit(1);
+      }
+      console.log(`\n  Executor config for "${ws.name}":`);
+      console.log(`    maxConcurrent: ${ws.executors.maxConcurrent}`);
+      console.log(`    pool: ${ws.executors.pool}`);
+      console.log(`    weight: ${ws.executors.weight}\n`);
+    }
+    process.exit(0);
+  }
+
   // Handle --setup-terminal (legacy terminal wizard)
   if (args.includes("--setup-terminal")) {
     const configDirArg = getArgValue("--config-dir");

package/config/config-doctor.mjs

@@ -1,8 +1,10 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { resolve, dirname, isAbsolute, relative, join } from "node:path";
 import { execSync, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
+import { ensureTestRuntimeSandbox } from "../infra/test-runtime.mjs";
+import { getWorkflowContract } from "../workflow/workflow-contract.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const CONFIG_FILES = [
@@ -10,6 +12,10 @@ const CONFIG_FILES = [
   ".bosun.json",
   "bosun.json",
 ];
+const WORKFLOW_CONTRACT_NODE_TYPES = Object.freeze({
+  read: new Set(["read-workflow-contract", "action.read_workflow_contract"]),
+  validate: new Set(["workflow-contract-validation", "action.workflow_contract_validation"]),
+});
 
 function parseBool(value) {
   return ["1", "true", "yes", "on"].includes(
@@ -92,6 +98,9 @@ function resolveConfigDir(repoRoot) {
     return packageDir;
   }
 
+  const sandbox = ensureTestRuntimeSandbox();
+  if (sandbox?.configDir) return sandbox.configDir;
+
   const preferWindowsDirs =
     process.platform === "win32" && !isWslInteropRuntime();
   const baseDir =
@@ -166,6 +175,36 @@ function findConfigFile(configDir) {
   return null;
 }
 
+function workflowHasContractNodes(definition) {
+  const nodes = Array.isArray(definition?.nodes) ? definition.nodes : [];
+  let hasRead = false;
+  let hasValidate = false;
+  for (const node of nodes) {
+    const type = String(node?.type || "").trim();
+    if (WORKFLOW_CONTRACT_NODE_TYPES.read.has(type)) hasRead = true;
+    if (WORKFLOW_CONTRACT_NODE_TYPES.validate.has(type)) hasValidate = true;
+  }
+  return hasRead && hasValidate;
+}
+
+function hasEnabledWorkflowContractStep(repoRoot) {
+  const workflowDir = resolve(repoRoot, ".bosun", "workflows");
+  if (!existsSync(workflowDir)) return false;
+
+  for (const file of readdirSync(workflowDir)) {
+    if (!file.endsWith(".json")) continue;
+    try {
+      const definition = JSON.parse(readFileSync(resolve(workflowDir, file), "utf8"));
+      if (definition?.enabled === false) continue;
+      if (workflowHasContractNodes(definition)) return true;
+    } catch {
+      /* ignore malformed workflow files here; other checks can catch them */
+    }
+  }
+
+  return false;
+}
+
 function validateExecutors(raw, issues) {
   if (!raw) return;
   const entries = String(raw)
@@ -671,6 +710,17 @@ export function runConfigDoctor(options = {}) {
     });
   }
 
+  const workflowContract = getWorkflowContract(repoRoot);
+  if (workflowContract.found && !hasEnabledWorkflowContractStep(repoRoot)) {
+    issues.warnings.push({
+      code: "WORKFLOW_CONTRACT_STEP_DISABLED",
+      message:
+        "WORKFLOW.md exists but no enabled workflow includes the read/validate workflow-contract steps.",
+      fix:
+        "Install or update the session-start workflow (for example template-task-lifecycle) so it includes `read-workflow-contract` and `workflow-contract-validation`.",
+    });
+  }
+
   issues.infos.push({
     code: "PATHS",
     message: `Config directory: ${configDir}`,
@@ -988,4 +1038,3 @@ export function formatWorkspaceHealthReport(result) {
   return lines.join("\n");
 }
 
-