@jstn-sdk/ma 0.14.0 → 0.14.1

package/src/runtime/autonomous-tasks.js

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { Worker } from "node:worker_threads";
 import { getAgentInvocation } from "../agents.js";
 import { readJson, withRuntimeStateLock, writeFileIfMissing, writeJson } from "../fs-utils.js";
 import { getRuntimeSubsystemPath } from "../paths.js";
@@ -16,11 +17,16 @@ import { createTaskContract, validateTaskContract } from "./task-contracts.js";
 export const autonomousTaskSchemaVersion = "0.1.0";
 const statuses = new Set(["queued", "running", "completed", "failed", "blocked", "cancelled"]);
 const priorities = new Set(["low", "normal", "high", "critical"]);
+const runnerLeaseMaxAgeMs = 30_000;
 
 export function getAutonomousTaskQueuePath() {
   return getRuntimeSubsystemPath("tasks", "autonomous-queue.json");
 }
 
+export function getRunnerLeasePath(runnerId) {
+  return getRuntimeSubsystemPath("tasks", "leases", `${encodeURIComponent(runnerId)}.json`);
+}
+
 export function createTaskQueue() {
   return {
     schemaVersion: autonomousTaskSchemaVersion,
@@ -87,6 +93,8 @@ function normalizeTask(input) {
     completedAt: input?.completedAt ?? null,
     error: input?.error ?? null,
     blocker: input?.blocker ?? null,
+    runnerPid: Number.isInteger(input?.runnerPid) ? input.runnerPid : null,
+    runnerId: typeof input?.runnerId === "string" ? input.runnerId : null,
     evidence: Array.isArray(input?.evidence) ? [...input.evidence] : [],
     selectedCapabilities: Array.isArray(input?.selectedCapabilities)
       ? input.selectedCapabilities
@@ -136,15 +144,40 @@ function byId(tasks) {
   return new Map(tasks.map((task) => [task.id, task]));
 }
 
+async function runnerIsAlive(task) {
+  if (!Number.isInteger(task.runnerPid) || task.runnerPid < 1 || !task.runnerId) return false;
+  try {
+    const lease = await readJson(getRunnerLeasePath(task.runnerId));
+    const heartbeatAt = Date.parse(lease.heartbeatAt);
+    if (
+      lease.runnerId !== task.runnerId ||
+      lease.runnerPid !== task.runnerPid ||
+      !Number.isFinite(heartbeatAt) ||
+      Date.now() - heartbeatAt > runnerLeaseMaxAgeMs
+    ) {
+      return false;
+    }
+    process.kill(task.runnerPid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 async function loadTaskQueueUnlocked() {
   try {
     const queue = validateTaskQueue(await readJson(getAutonomousTaskQueuePath()));
-    const interrupted = queue.tasks.filter((task) => task.status === "running");
+    const interrupted = [];
+    for (const task of queue.tasks) {
+      if (task.status === "running" && !(await runnerIsAlive(task))) interrupted.push(task);
+    }
     if (interrupted.length === 0) return queue;
     const recoveredAt = new Date().toISOString();
     for (const task of interrupted) {
       task.status = "queued";
       task.error = "Recovered after the previous process exited while the task was running";
+      task.runnerPid = null;
+      task.runnerId = null;
       task.updatedAt = recoveredAt;
     }
     await writeJsonAtomically(getAutonomousTaskQueuePath(), queue);
@@ -164,6 +197,80 @@ export async function saveTaskQueue(queue) {
   return writeJson(getAutonomousTaskQueuePath(), validateTaskQueue(queue));
 }
 
+async function updateTaskQueueTask(taskId, update) {
+  return withRuntimeStateLock(
+    getAutonomousTaskQueuePath(),
+    async () => {
+      const queue = await loadTaskQueueUnlocked();
+      const task = queue.tasks.find((entry) => entry.id === taskId);
+      if (!task) return null;
+      const changed = (await update(task, queue)) !== false;
+      if (changed) {
+        task.updatedAt = new Date().toISOString();
+        await writeJsonAtomically(getAutonomousTaskQueuePath(), validateTaskQueue(queue));
+      }
+      return { task, changed };
+    },
+    { wait: true },
+  );
+}
+
+async function createRunnerLease(runnerId) {
+  await writeJsonAtomically(getRunnerLeasePath(runnerId), {
+    schemaVersion: autonomousTaskSchemaVersion,
+    runnerId,
+    runnerPid: process.pid,
+    heartbeatAt: new Date().toISOString(),
+  });
+}
+
+function startRunnerLeaseHeartbeat(runnerId) {
+  const leasePath = getRunnerLeasePath(runnerId);
+  const worker = new Worker(
+    `const { parentPort, workerData } = require("node:worker_threads");
+     const fs = require("node:fs");
+     const path = require("node:path");
+     let active = true;
+     const beat = () => {
+       if (!active) return;
+       const temporary = workerData.leasePath + ".heartbeat-" + process.pid;
+       fs.writeFile(temporary, JSON.stringify({
+         schemaVersion: workerData.schemaVersion,
+         runnerId: workerData.runnerId,
+         runnerPid: workerData.runnerPid,
+         heartbeatAt: new Date().toISOString()
+       }) + "\\n", { mode: 0o600 }, (writeError) => {
+         if (writeError) return;
+         fs.rename(temporary, workerData.leasePath, () => {});
+       });
+     };
+     const timer = setInterval(beat, workerData.intervalMs);
+     timer.unref();
+     parentPort.on("message", (message) => {
+       if (message === "stop") {
+         active = false;
+         clearInterval(timer);
+         process.exit(0);
+       }
+     });`,
+    {
+      eval: true,
+      workerData: {
+        leasePath,
+        runnerId,
+        runnerPid: process.pid,
+        schemaVersion: autonomousTaskSchemaVersion,
+        intervalMs: runnerLeaseMaxAgeMs / 3,
+      },
+    },
+  );
+  worker.on("error", () => {});
+  return async () => {
+    worker.postMessage("stop");
+    await worker.terminate();
+  };
+}
+
 export async function enqueueAutonomousTasks(inputs) {
   return withRuntimeStateLock(
     getAutonomousTaskQueuePath(),
@@ -227,7 +334,7 @@ export async function runAutonomousTasks({
   if (!Number.isInteger(concurrency) || concurrency < 1)
     throw new Error("concurrency must be a positive integer");
   const queue = await loadTaskQueue();
-  const byId = new Map(queue.tasks.map((task) => [task.id, task]));
+  const taskById = new Map(queue.tasks.map((task) => [task.id, task]));
   const capabilities = createDefaultEnvironmentAwarenessCore({
     capabilities: await discoverEnvironmentCapabilities({ cwd, includeGlobal }),
   });
@@ -269,7 +376,7 @@ export async function runAutonomousTasks({
     const now = Date.now();
     const eligible = queue.tasks
       .filter((task) => task.status === "queued" && !running.has(task.id))
-      .filter((task) => !isExpired(task, now) && dependenciesReady(task, byId))
+      .filter((task) => !isExpired(task, now) && dependenciesReady(task, taskById))
       .sort(
         (a, b) =>
           (priorities.has(b.priority)
@@ -289,40 +396,103 @@ export async function runAutonomousTasks({
       ).selected;
       task.invocation = task.vendor ? getAgentInvocation(task.vendor, "maestro") : null;
       if (hasUnsafeAction(task)) {
-        task.status = "blocked";
-        task.blocker =
-          "Explicit approval required for destructive, production, credential, or external mutation task";
-        task.updatedAt = new Date().toISOString();
-        await emit({ taskId: task.id, status: task.status, blocker: task.blocker });
+        const transition = await updateTaskQueueTask(task.id, (current) => {
+          if (current.status !== "queued") return false;
+          current.status = "blocked";
+          current.blocker =
+            "Explicit approval required for destructive, production, credential, or external mutation task";
+          return true;
+        });
+        if (transition?.changed) {
+          Object.assign(task, transition.task);
+          await emit({ taskId: task.id, status: task.status, blocker: task.blocker });
+        }
         processed++;
         continue;
       }
-      task.status = "running";
-      task.attempts++;
-      task.startedAt ??= new Date().toISOString();
-      task.updatedAt = new Date().toISOString();
+      const runnerId = randomUUID();
+      try {
+        await createRunnerLease(runnerId);
+      } catch (error) {
+        await emit({
+          taskId: task.id,
+          status: "queued",
+          error: `Unable to establish task runner lease: ${error.message}`,
+        });
+        continue;
+      }
+      const claim = await updateTaskQueueTask(task.id, (current) => {
+        if (current.status !== "queued") return false;
+        current.status = "running";
+        current.attempts++;
+        current.startedAt ??= new Date().toISOString();
+        current.runnerPid = process.pid;
+        current.runnerId = runnerId;
+        current.selectedCapabilities = task.selectedCapabilities;
+        current.invocation = task.invocation;
+        return true;
+      });
+      if (!claim?.changed) {
+        await fs.rm(getRunnerLeasePath(runnerId), { force: true });
+        continue;
+      }
+      Object.assign(task, claim.task);
       const promise = (async () => {
+        const stopHeartbeat = startRunnerLeaseHeartbeat(runnerId);
         try {
           const result = await runner(task);
+          const patch = { runnerPid: null, runnerId: null };
           if (result?.status === "blocked") {
-            task.status = "blocked";
-            task.blocker = result.reason ?? "Runner reported a blocker";
+            Object.assign(patch, {
+              status: "blocked",
+              blocker: result.reason ?? "Runner reported a blocker",
+            });
           } else if (result?.status === "failed" && task.attempts < task.maxAttempts) {
-            task.status = "queued";
-            task.error = result.reason ?? "Runner failed; task queued for retry";
+            Object.assign(patch, {
+              status: "queued",
+              error: result.reason ?? "Runner failed; task queued for retry",
+            });
           } else if (result?.status === "failed") {
-            task.status = "failed";
-            task.error = result.reason ?? "Runner failed after maximum attempts";
+            Object.assign(patch, {
+              status: "failed",
+              error: result.reason ?? "Runner failed after maximum attempts",
+            });
           } else {
-            task.status = "completed";
-            task.completedAt = new Date().toISOString();
-            task.evidence.push(...(Array.isArray(result?.evidence) ? result.evidence : []));
+            Object.assign(patch, {
+              status: "completed",
+              completedAt: new Date().toISOString(),
+              evidence: [
+                ...task.evidence,
+                ...(Array.isArray(result?.evidence) ? result.evidence : []),
+              ],
+            });
           }
+          const transition = await updateTaskQueueTask(task.id, (current) => {
+            if (current.status === "cancelled") return false;
+            Object.assign(current, patch);
+            return true;
+          });
+          if (transition) Object.assign(task, transition.task);
         } catch (error) {
           task.error = error instanceof Error ? error.message : String(error);
           task.status = task.attempts < task.maxAttempts ? "queued" : "failed";
+          task.runnerPid = null;
+          task.runnerId = null;
+          const transition = await updateTaskQueueTask(task.id, (current) => {
+            if (current.status === "cancelled") return false;
+            Object.assign(current, {
+              status: task.status,
+              error: task.error,
+              runnerPid: null,
+              runnerId: null,
+            });
+            return true;
+          });
+          if (transition) Object.assign(task, transition.task);
+        } finally {
+          await stopHeartbeat();
+          await fs.rm(getRunnerLeasePath(runnerId), { force: true });
         }
-        task.updatedAt = new Date().toISOString();
         await emit({
           taskId: task.id,
           status: task.status,
@@ -330,37 +500,44 @@ export async function runAutonomousTasks({
           error: task.error,
           blocker: task.blocker,
         });
-        await saveTaskQueue(queue);
         running.delete(promise);
         processed++;
       })();
       running.add(promise);
-      await saveTaskQueue(queue);
     }
   }
   await Promise.all(running);
-  for (const task of queue.tasks) {
-    if (task.status !== "queued") continue;
-    const failedDependency = task.dependencies.find((id) =>
-      ["failed", "blocked", "cancelled"].includes(byId.get(id)?.status),
-    );
-    if (failedDependency) {
-      task.status = "blocked";
-      task.blocker = `Dependency ${failedDependency} is ${byId.get(failedDependency).status}`;
-    } else if (isExpired(task, Date.now())) {
-      task.status = "blocked";
-      task.blocker = "Task deadline expired";
-    } else if (!dependenciesReady(task, byId)) {
-      task.blocker = "Waiting for dependencies";
-    }
-    task.updatedAt = new Date().toISOString();
-  }
-  await saveTaskQueue(queue);
+  await withRuntimeStateLock(
+    getAutonomousTaskQueuePath(),
+    async () => {
+      const latestQueue = await loadTaskQueueUnlocked();
+      const latestById = byId(latestQueue.tasks);
+      for (const task of latestQueue.tasks) {
+        if (task.status !== "queued") continue;
+        const failedDependency = task.dependencies.find((id) =>
+          ["failed", "blocked", "cancelled"].includes(latestById.get(id)?.status),
+        );
+        if (failedDependency) {
+          task.status = "blocked";
+          task.blocker = `Dependency ${failedDependency} is ${latestById.get(failedDependency).status}`;
+        } else if (isExpired(task, Date.now())) {
+          task.status = "blocked";
+          task.blocker = "Task deadline expired";
+        } else if (!dependenciesReady(task, latestById)) {
+          task.blocker = "Waiting for dependencies";
+        }
+        task.updatedAt = new Date().toISOString();
+      }
+      await writeJsonAtomically(getAutonomousTaskQueuePath(), validateTaskQueue(latestQueue));
+    },
+    { wait: true },
+  );
+  const finalQueue = await loadTaskQueue();
   return {
     schemaVersion: autonomousTaskSchemaVersion,
-    tasks: queue.tasks,
+    tasks: finalQueue.tasks,
     events,
-    summary: summarizeTasks(queue.tasks),
+    summary: summarizeTasks(finalQueue.tasks),
   };
 }
 

package/src/runtime/codeburn-core.js

@@ -1,9 +1,9 @@
-import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import { ensureDir, readJson, writeFileIfMissing, writeJson } from "../fs-utils.js";
 import { getRuntimeSubsystemPath } from "../paths.js";
+import { assertSafeExecutable, safeExecFile } from "../process-utils.js";
 
-const execFileAsync = promisify(execFile);
+const execFileAsync = promisify(safeExecFile);
 export const codeburnSchemaVersion = "0.1.0";
 
 export function getCodeburnRoot() {
@@ -87,8 +87,14 @@ export async function syncCodeburnUsage({
   const existing = await loadCodeburnUsage();
   const executable = command ?? process.env.MA_CODEBURN_BIN ?? "npx";
   const commandArgs = args ?? ["--yes", "codeburn", "usage", "--json"];
+  assertSafeExecutable(executable, "Codeburn executable");
   try {
-    const result = await exec(executable, commandArgs, { cwd, encoding: "utf8", timeout: 15_000 });
+    const result = await exec(executable, commandArgs, {
+      cwd,
+      encoding: "utf8",
+      timeout: 15_000,
+      shell: false,
+    });
     const entries = parseCodeburnOutput(result.stdout ?? result);
     const normalized = entries
       .filter((entry) => entry && typeof entry === "object")

package/src/runtime/core-source-ingest.js

@@ -1,9 +1,9 @@
-import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { ensureDir, readJson, writeFileIfMissing, writeJson } from "../fs-utils.js";
 import { getRepoRoot, getRuntimeSubsystemPath, getRuntimeWritePath } from "../paths.js";
+import { safeSpawn } from "../process-utils.js";
 
 export const coreSourceIngestSchemaVersion = "0.1.0";
 
@@ -153,7 +153,7 @@ export async function loadCoreSourceIngest() {
 export async function ingestCoreSources({
   definitions = coreSourceDefinitions,
   refresh = false,
-  spawnImpl = spawn,
+  spawnImpl = safeSpawn,
 } = {}) {
   await ensureDir(getCoreSourcesRootPath());
   const sources = [];

package/src/runtime/detached-provider.js

@@ -1,8 +1,8 @@
-import { spawnSync } from "node:child_process";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { ensureDir } from "../fs-utils.js";
 import { getRuntimeSubsystemPath } from "../paths.js";
+import { assertSafeExecutable, safeSpawnSync } from "../process-utils.js";
 
 export function getRuntimeLogsRoot() {
   return getRuntimeSubsystemPath("logs");
@@ -11,7 +11,7 @@ export function getRuntimeLogsRoot() {
 export function resolveDetachedProvider() {
   const preferred = process.env.MA_DETACHED_PROVIDER ?? "";
   if (preferred === "tmux" || process.env.MA_TMUX_PROVIDER === "1") {
-    const probe = spawnSync("tmux", ["ls"], {
+    const probe = safeSpawnSync("tmux", ["ls"], {
       encoding: "utf8",
       env: buildDetachedEnv(),
     });
@@ -24,6 +24,10 @@ export function resolveDetachedProvider() {
 }
 
 export async function launchDetachedTrack({ trackId, title, command, args = [] }) {
+  assertSafeExecutable(command, "Detached provider command");
+  if (!Array.isArray(args) || args.some((arg) => typeof arg !== "string" || arg.includes("\0"))) {
+    throw new Error("Detached provider arguments must be strings without NUL bytes");
+  }
   const provider = resolveDetachedProvider();
   await ensureDir(getRuntimeLogsRoot());
   const safeTrackId = sanitizeTrackId(trackId);
@@ -43,10 +47,15 @@ export async function launchDetachedTrack({ trackId, title, command, args = [] }
 
   const sessionName = `ma_${safeTrackId}`;
   await fs.writeFile(logPath, `provider=tmux\n${metadata}`, "utf8");
-  const started = spawnSync("tmux", ["new-session", "-d", "-s", sessionName, command, ...args], {
-    encoding: "utf8",
-    env: buildDetachedEnv(),
-  });
+  const tmuxCommand = [command, ...args].map(quoteForShell).join(" ");
+  const started = safeSpawnSync(
+    "tmux",
+    ["new-session", "-d", "-s", sessionName, "--", tmuxCommand],
+    {
+      encoding: "utf8",
+      env: buildDetachedEnv(),
+    },
+  );
 
   if (started.status !== 0) {
     await fs.writeFile(
@@ -64,13 +73,13 @@ export async function launchDetachedTrack({ trackId, title, command, args = [] }
     };
   }
 
-  const piped = spawnSync(
+  const piped = safeSpawnSync(
     "tmux",
     ["pipe-pane", "-t", sessionName, "-o", `cat >> ${quoteForShell(logPath)}`],
     { encoding: "utf8", env: buildDetachedEnv() },
   );
   if (piped.status !== 0) {
-    spawnSync("tmux", ["kill-session", "-t", sessionName], {
+    safeSpawnSync("tmux", ["kill-session", "-t", sessionName], {
       encoding: "utf8",
       env: buildDetachedEnv(),
     });

package/src/runtime/live-agent-verification.js

@@ -1,8 +1,8 @@
-import { spawn } from "node:child_process";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { agentRegistry as executableAgents, resolveAgentCommand } from "../agents.js";
+import { safeSpawn } from "../process-utils.js";
 import {
   agentRegistry,
   createSkillCompatibilityPayload,
@@ -13,7 +13,7 @@ const defaultTimeoutMs = 5000;
 
 function runVersionProbe(command, timeoutMs, args = ["--version"]) {
   return new Promise((resolve) => {
-    const child = spawn(command, args, {
+    const child = safeSpawn(command, args, {
       shell: false,
       stdio: ["ignore", "pipe", "pipe"],
     });

package/src/runtime/project-context.js

@@ -1,14 +1,14 @@
-import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { promisify } from "node:util";
 import { readJson, writeJson } from "../fs-utils.js";
 import { getRepoRoot } from "../paths.js";
+import { safeExecFile } from "../process-utils.js";
 import { createFreshness } from "./context-authority.js";
 import { createManagedMarkdownBlock, replaceManagedMarkdownBlock } from "./managed-markdown.js";
 
-const execFileAsync = promisify(execFile);
+const execFileAsync = promisify(safeExecFile);
 export const projectIndexSchemaVersion = "0.1.0";
 const MAX_SOURCE_FILES = 2000;
 const GENERATED_DIRS = [

package/src/runtime/skills-registry-export.js

@@ -440,7 +440,9 @@ export function renderSkillCompatibilitySkillMd(payload, { agentType = "codex" }
     "",
     "## Invocation",
     "",
-    `- Start the umbrella lane with \`${getAgentInvocation(agentType, agentType === "codex" ? "maestro" : payload.name)}\` in this host.`,
+    agentType === "generic"
+      ? "- Start the umbrella lane using this host's native Meta-Architect invocation syntax."
+      : `- Start the umbrella lane with \`${getAgentInvocation(agentType, agentType === "codex" ? "maestro" : payload.name)}\` in this host.`,
     "- Dispatch to the canonical MA runtime as `ma run '$maestro'`.",
     "- Lane aliases: `arch`, `sage`, `flow`, `vet`, `vibe`, and `build`.",
     "",
@@ -562,6 +564,7 @@ export async function writeSkillCompatibilityExport({
   agentRootExists = null,
   createSymlink = fs.symlink,
   lockMetadata = {},
+  renderAgentType = agentType,
 }) {
   const effectiveAgentRootExists =
     agentRootExists ?? (await detectProjectAgentRoot(agentType, cwd));
@@ -573,11 +576,11 @@ export async function writeSkillCompatibilityExport({
     mode,
     agentRootExists: effectiveAgentRootExists,
   });
-  const skillMd = renderSkillCompatibilitySkillMd(payload, { agentType });
+  const skillMd = renderSkillCompatibilitySkillMd(payload, { agentType: renderAgentType });
   const lockEntry = validateSkillLockEntry(
     createSkillLockEntry({
       payload,
-      agentType,
+      agentType: renderAgentType,
       selectedAgentTargets: [agentType],
       ...lockMetadata,
     }),
@@ -729,6 +732,7 @@ export async function verifyCrossAgentInstallMatrix({
     const result = await writeSkillCompatibilityExport({
       payload,
       agentType,
+      renderAgentType: targets.length > 1 ? "generic" : agentType,
       cwd,
       agentRootExists: await detectProjectAgentRoot(agentType, cwd),
       createSymlink: forceFallback

package/src/skills.js

@@ -268,31 +268,31 @@ function chooseMaestroRecommendation(releaseState, idea, buildReadiness = null)
 
   if (releaseState.merge_status !== "MERGED_TO_DEVELOPMENT") {
     return {
-      nextStep: "Finish the implementation slice and merge it into development.",
+      nextStep: "Finish the implementation slice and merge it into dev.",
       why: "The build gate is ready or done, but the branch promotion path has not completed yet.",
       primaryLane: "implementation",
       supportLane: "merge",
       assignments: [
         "Use the current build plan to finish the smallest viable implementation slice.",
-        "When ready, merge feature work into development with `ma merge`.",
+        "When ready, merge feature work into dev with `ma merge`.",
       ],
-      avoid: ["Do not promote directly to prod."],
-      nextTrigger: "`ma merge <feature/*> development`",
+      avoid: ["Do not promote directly to main."],
+      nextTrigger: "`ma merge <feature/*> dev`",
     };
   }
 
   if (releaseState.release_status !== "SHIPPED_TO_PROD") {
     return {
-      nextStep: "Promote the approved release line to prod.",
+      nextStep: "Promote the approved release line to main.",
       why: "Implementation and merge gates are complete, so the remaining step is the controlled release promotion.",
       primaryLane: "release",
       supportLane: "verification",
       assignments: [
-        "Verify the origin branch is development or an approved release branch.",
-        "Run `ma release <origin> prod` when the line is ready.",
+        "Verify the origin branch is dev or an approved release branch.",
+        "Run `ma release <origin> main` when the line is ready.",
       ],
       avoid: ["Do not reopen earlier gates unless a new blocker appears."],
-      nextTrigger: "`ma release <development|release/*> prod`",
+      nextTrigger: "`ma release <dev|release/*> main`",
     };
   }
 
@@ -687,7 +687,7 @@ export async function runBuildLane({ actor = null, reviewMode = null, quorumVote
     allowed: true,
     gateState: "DONE",
     blockers: [],
-    nextTriggers: ["ma merge <feature/*> development"],
+    nextTriggers: ["ma merge <feature/*> dev"],
     suggestedBranches,
     buildSlice,
     verificationPlan,
@@ -708,21 +708,21 @@ export async function runBuildLane({ actor = null, reviewMode = null, quorumVote
       { kind: "ralph-prd", value: ralphContract.prdPath },
     ],
     blockers: [],
-    next_allowed_triggers: ["ma merge <feature/*> development"],
+    next_allowed_triggers: ["ma merge <feature/*> dev"],
   });
   await syncStatusUpdates({ build_status: "DONE" }, { actor: authority.leaderActor });
   await updateMaestroLedgerForBuild({
     buildStatus: "DONE",
     runtimeSummary,
     blockers: [],
-    nextTriggers: ["ma merge <feature/*> development"],
+    nextTriggers: ["ma merge <feature/*> dev"],
     gateState: "COMPLETED",
     trackStatus: "COMPLETED",
     completionEvidence,
   });
   return {
     status: "DONE",
-    nextTrigger: "ma merge <feature/*> development",
+    nextTrigger: "ma merge <feature/*> dev",
     blockers: [],
     suggestedBranches,
   };

package/src/test-fixtures.js

@@ -1,4 +1,3 @@
-import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import {
   chmodSync,
@@ -13,6 +12,7 @@ import {
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { safeSpawn } from "./process-utils.js";
 
 const TEST_ROOT = path.join(os.tmpdir(), "ma-tests");
 const RETENTION_ROOT = path.join(TEST_ROOT, "retained");
@@ -215,7 +215,7 @@ async function copyTree(sourceRoot, targetRoot, { strategy = "copy" } = {}) {
 
 function runCommand(command, args) {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { stdio: "ignore" });
+    const child = safeSpawn(command, args, { stdio: "ignore" });
     child.once("error", reject);
     child.once("close", (code) =>
       code === 0 ? resolve() : reject(new Error(`${command} exited with ${code}`)),
@@ -337,7 +337,7 @@ async function enforceFixtureBudget(root, strategy) {
 
 async function runArchive(args) {
   return new Promise((resolve, reject) => {
-    const child = spawn("tar", args, { stdio: ["ignore", "ignore", "pipe"] });
+    const child = safeSpawn("tar", args, { stdio: ["ignore", "ignore", "pipe"] });
     let stderr = "";
     child.stderr.on("data", (chunk) => {
       stderr += chunk.toString();
@@ -442,7 +442,7 @@ export function runTestWithStreaming(command, args, options) {
   assertNoSymlinkComponentsSync(TEST_ROOT, logFile);
   assertNoSymlinkComponentsSync(TEST_ROOT, summaryFile);
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { stdio: ["inherit", "pipe", "pipe"] });
+    const child = safeSpawn(command, args, { stdio: ["inherit", "pipe", "pipe"] });
     const log = fs.open(logFile, "w");
     const summary = fs.open(summaryFile, "w");
     let summaryBytes = 0;