@nodii/dev 0.6.28 → 0.6.29

package/README.md

@@ -97,6 +97,8 @@ nodii-dev agent heartbeat
 nodii-dev agents spawn SERVICE [--repo-root DIR]
 nodii-dev agents cowork-tick [--json]
 nodii-dev agents cowork-tick --plist [--interval SECONDS]
+nodii-dev watchdog install [--interval SECONDS]
+nodii-dev watchdog sweep
 
 nodii-dev issues list [--service ID] [--project KEY] [--status STATUS]
                        [--kind KIND] [--priority PRIORITY] [--claimed true|false]
@@ -312,6 +314,7 @@ nodii-dev lane step KEY --side backend|frontend --start|--done|--block STEP [--r
 nodii-dev lane evidence KEY --pr|--commit|--figma|--deploy|--dev-check REF
 nodii-dev lane subagent-quota KEY N
 nodii-dev lane heartbeat KEY [--note TEXT]
+nodii-dev lane resume KEY
 nodii-dev lane review KEY --file REVIEW.json
 nodii-dev lane reviews KEY
 nodii-dev lane land KEY
@@ -358,8 +361,22 @@ nodii-dev harness install [--include-drafts] [--adopt PATH,...] [--dry-run] [--s
 nodii-dev harness update [--include-drafts] [--adopt PATH,...] [--dry-run] [--system]
 nodii-dev harness check [--json]               # 0 current, 1 differs from Dev, 2 no harness
 nodii-dev harness update --check               # the same check
+nodii-dev watchdog install [--interval SECONDS] # install/update com.nodii.watchdog in ~/Library/LaunchAgents
+nodii-dev watchdog sweep                        # launchd entrypoint; normally not run by hand
 ```
 
+The per-Mac watchdog runs outside agent sessions. Run `watchdog install` once
+with the machine coordinator's config; it refuses a lane or unassigned agent.
+Every sweep reports three host facts to Dev: watched run processes that exited
+without ending their run, `/tmp/cc-socks/<pid>.sock` sockets whose process is
+gone, and watched worktrees whose HEAD has commits absent from its configured
+remote branch. Each observation is posted to the watched run by the machine
+coordinator; `process_dead` transitions it to explicit `orphan` immediately.
+Run launchers and wrappers persist one owner-only record per process under
+`~/.config/nodii-dev/watchdog/runs/`; the plist itself contains only absolute
+command/config paths, its schedule, and log paths, while OAuth credentials
+remain in the machine keychain.
+
 `harness install` and `harness update` merge the safety hooks into both
 `.claude/settings.json` and `.codex/hooks.json`; every installed hook invokes
 only `nodii-dev`. The
@@ -718,6 +735,35 @@ from AGENT-HARNESS-14 is available.
 
 ## Build lanes and repository setup
 
+`coordinator start --machine NAME` registers the machine's one watched
+coordinator run and shows its running lanes, orphaned runs and unclaimed
+results. A live second coordinator is refused; a coordinator whose heartbeat
+watchdog has recorded it orphaned is recorded as the predecessor of the
+takeover.
+
+`lane launch KEY` replaces the manual worktree/start/process sequence. It
+requires the issue (whose title supplies both lane title and objective), done
+check, build kind and side, runtime profile and model, subagent quota, and
+repeated `--repo NAME=/SOURCE` plus
+`--branch NAME=BRANCH` pairs. The Hub preflight checks the coordinator waiter,
+target agent and machine, fresh account-capacity telemetry, repository grants,
+lane limit, open issues and (when `--figma` is present) the authenticated Figma
+account. Only after that passes does the CLI create one worktree per repository,
+atomically register the lane and watched run, and launch the runtime with the
+single-line brief `You are lane KEY. Run nodii-dev lane gather.`. Ordinary
+notes use `--notes`; a scope-narrowing note uses `--narrowing-note` and must
+also name the remainder's destination with `--narrowing-remainder`.
+The launched process uses the already-provisioned lowercase identity (for
+example `~/.config/nodii-dev/agents/lane-ah-12.json`), never the coordinator's
+Dev identity.
+
+Objective, scope and rule changes are durable `lane amend` records, never chat
+messages. Every CLI call from a launched worktree checks the current watched
+run's acknowledgement version. A pending change is printed and blocks the
+call until `lane gather --delta` serves the current rules and acknowledges the
+newest displayed version. `NODII_DEV_RUN_ID` makes this check per subagent run,
+so one child cannot acknowledge for its siblings.
+
 `lane start` creates and starts a lane. It infers the repository (by short
 name, as Dev compares it), branch and worktree from git unless overridden, and resolves `--issue` keys to the UUIDs
 required by Dev. Lane keys are passed directly to every lane and Built
@@ -733,6 +779,17 @@ slot; Dev refuses another registration with `SUBAGENT_QUOTA_REACHED` when the
 lane is full. A `done`, `handed_off`, or `failed` subagent run no longer counts,
 so the watchdog marking a killed process failed frees the slot.
 
+`lane resume` asks Dev to reserve a fresh run for an orphaned lane, then launches
+the allowlisted Codex or Claude runtime as a detached headless process in the
+same worktree. Dev keeps the lane's finished steps intact and returns the next
+unfinished step together with its bounded recovery packet. The CLI sends that
+packet over the new process's stdin (never its argv), saves its exact PID and
+append-only log under `~/.config/nodii-dev/runs/<run-id>/`, and reports a local
+spawn failure back to Dev so the reservation is not left running. Human output
+identifies the replacement run, PID, step and last pushed commit without
+echoing the dead run's log tail; `--json` retains the complete server response.
+Dev refuses a third attempt after two identical deaths.
+
 `setup` installs the Claude Code and Codex workflow harnesses in the current repository.
 It writes `.claude/skills/nodii-build-workflow/SKILL.md`, merges SessionStart,
 Stop and tool hooks into `.claude/settings.json` and `.codex/hooks.json`, and maintains one

package/dist/api.js

@@ -99,7 +99,8 @@ export const GROUPS = {
   "approval-kinds": "ApprovalKinds", "notification-registry": "Notification registry", skills: "Skills", "open-questions": "OpenQuestions",
   decisions: "Decisions", drift: "Drift", requests: "Requests", pipelines: "Pipelines", slices: "Slices", "sql-lookups": "SqlLookups",
   runners: "Runners", routing: "Routing", usage: "Usage", audit: "AuditLog", reconciliation: "Reconciliation", cron: "Cron", health: "Health",
-  composite: "Composite", "service-edges": "ServiceEdges", lanes: "Lanes",
+  composite: "Composite", "service-edges": "ServiceEdges", lanes: "Lanes", runs: "Runs",
+  releases: "Releases", operate: "Operate",
   swaps: "Swaps", ideas: "Ideas", terminology: "Terminology", credentials: "Credentials",
   rulebook: "ad-documents", "ad-decisions": "ad-decisions", domains: "ad-domains", standardizations: "standardizations",
   archive: "archive", harness: "harness", utils: "utils",
@@ -154,6 +155,8 @@ export const ALIASES = {
   "standardizations:list": "listStandardizations", "standardizations:show": "getStandardization", "standardizations:update": "updateStandardization",
   "archive:search": "searchPreDevArchive", "archive:resolve": "resolvePreCitation",
   "harness:show": "generateHarness", "harness:methodology": "getHarnessMethodologyVersion",
+  "runs:register": "registerRun", "runs:show": "getRun", "runs:heartbeat": "heartbeatRun", "runs:end": "endRun",
+  "runs:results": "listRunResults", "runs:acknowledge": "acknowledgeResult",
   "terminology:list": "listTerminology", "terminology:show": "getTerminologyTerm", "terminology:create": "createTerminologyTerm", "terminology:update": "updateTerminologyTerm",
 };
 

package/dist/cli.js

@@ -53,6 +53,7 @@ export { figmaLock, submitMode } from "./figma.js";
 import { docsCommand, rulebookCommand, rulesCommand } from "./upload.js";
 import { changeSetCommand, guidelineCommand } from "./guidelines.js";
 import { designCheck, designCheckText, designRoles, designRolesText } from "./design.js";
+import { watchdogCommand } from "./watchdog.js";
 import {
   ALIASES,
   GROUPS,
@@ -74,6 +75,13 @@ import {
   nextCommand,
   peopleCommand,
 } from "./lanes.js";
+import {
+  amendmentGuard,
+  amendLaneCommand,
+  coordinatorCommand,
+  gatherLaneCommand,
+  launchLaneCommand,
+} from "./starting.js";
 import {
   launchRunSupervisor,
   showWaitingResults,
@@ -132,6 +140,8 @@ Usage: nodii-dev <command> [options] [--json]
                                         # --system stages managed hooks and only prints operator-reviewed sudo commands
   harness check                         # 0 current, 1 differs from Dev, 2 not installed
   harness update --check                # the same check
+  watchdog install [--interval SECONDS] # install/update the per-Mac launchd liveness sweep (default 60s)
+  watchdog sweep                        # launchd entrypoint: report dead runs, stale sockets, unpushed worktrees
   docs check|validate|upload <path...> --class ruling|conformance|editorial
        [--base CODE=VERSION] [--decision FILE] [--pending] [--conformance-ref REF]
        [--meaning-unchanged REASON] [--wait]
@@ -142,6 +152,17 @@ Usage: nodii-dev <command> [options] [--json]
   rules report [--section S] [--lane KEY]   # delivery totals per document; rules served per lane
   rules cap TOKENS                      # operator: set the core token cap (default 3000)
 
+  coordinator start --machine NAME       # register this machine's one watched coordinator; refuses a live second
+  lane launch <key> --done-check TEXT --kind KIND --side SIDE
+              --issue KEY --repo NAME=/SOURCE --branch NAME=BRANCH [--repo ... --branch ...]
+              --machine NAME --runtime claude|codex --profile PATH --model MODEL --subagents N
+              [--base NAME=REF] [--worktree NAME=PATH] [--owned-path NAME=PATH]
+              [--figma FILE[=COMPONENT_SET[,SET]]] [--notes TEXT]
+              [--narrowing-note TEXT --narrowing-remainder DESTINATION]
+                                        # authoritative preflight, one worktree per repo, watched launch
+                                        # uses the provisioned agents/lane-<key>.json Dev identity
+  lane amend <key> --objective|--scope|--rules TEXT --reason TEXT
+  lane gather [<key>] [--delta]         # infers a launched worktree; Delta required after an amendment
   run [--kind build|test_run|subagent|deploy] [--name TEXT] -- <command> [args...]
                                         # watched command: registers with NODII_DEV_RUN_ID,
                                         # heartbeats, and records exit code + redacted log tail
@@ -151,7 +172,7 @@ Usage: nodii-dev <command> [options] [--json]
                                         # --block --reason on a blocked step records its new reason
   lane evidence <key> --pr|--commit|--figma|--deploy|--dev-check REF
   lane subagent-quota <key> <n>          # coordinator assigns 0-100 subagent slots
-  lane heartbeat|land|verify|prioritize|deprioritize|stop <key>
+  lane heartbeat|resume|land|verify|prioritize|deprioritize|stop <key>
   lane review <key> --file REVIEW.json  # base/head, outcome and clause-cited findings
   lane reviews <key>                    # stored review history for the lane
   lane non-issue <key> --reason TEXT --evidence TEXT --reroute KEY[,KEY]|none
@@ -412,8 +433,12 @@ export async function figmaFileAdd(value, flags, { request = devRequest } = {})
 }
 
 export async function main(argv = process.argv.slice(2)) {
-  if (argv[0] !== "__run-supervisor")
+  // Amendment acknowledgement is a lane-wide backstop, including otherwise
+  // local commands such as help and version.
+  if (argv[0] !== "__run-supervisor") {
+    await amendmentGuard(argv);
     await showWaitingResults({ acknowledge: argv[0] !== "hook" });
+  }
   if (argv.length === 1 && ["--version", "-v"].includes(argv[0]))
     return console.log(VERSION);
   if (argv.length === 1 && ["--help", "-h"].includes(argv[0]))
@@ -523,6 +548,10 @@ export async function main(argv = process.argv.slice(2)) {
     if (rest.length) throw new CliError("USAGE", `harness ${action} takes no arguments, got: ${rest.join(" ")}. Write a flag value as --include-drafts=false.`, 2);
     return emitCommand(await harnessCommand(action, f));
   }
+  if (command === "watchdog") {
+    if (rest.length) throw new CliError("USAGE", `watchdog ${action ?? ""} takes no arguments, got: ${rest.join(" ")}.`, 2);
+    return emitCommand(await watchdogCommand(action, f));
+  }
   if (command === "docs") return emitCommand(await docsCommand(action, rest, f));
   if (command === "rulebook" && ["list", "show", "diff"].includes(action)) return emitCommand(await rulebookCommand(action, rest, f));
   if (command === "rules") return emitCommand(await rulesCommand(action, rest, f));
@@ -541,6 +570,10 @@ export async function main(argv = process.argv.slice(2)) {
     }
     return;
   }
+  if (command === "coordinator") return emitCommand(await coordinatorCommand(action, f));
+  if (command === "lane" && action === "launch") return emitCommand(await launchLaneCommand(rest[0], f));
+  if (command === "lane" && action === "amend") return emitCommand(await amendLaneCommand(rest[0], f));
+  if (command === "lane" && action === "gather") return emitCommand(await gatherLaneCommand(rest[0], f));
   if (command === "lane") return emitCommand(await laneCommand(action, rest, f));
   if (command === "next") return emitCommand(await nextCommand(action, f));
   if (command === "built") return emitCommand(await builtCommand(action, rest, f));

package/dist/core.js

@@ -4,7 +4,7 @@ import { chmod, mkdir, readFile, rm, writeFile } from "node:fs/promises";
 import { homedir, platform } from "node:os";
 import { dirname, join } from "node:path";
 
-export const VERSION = "0.6.28";
+export const VERSION = "0.6.29";
 export const configPath = () =>
   process.env.NODII_DEV_CONFIG_PATH ??
   join(homedir(), ".config/nodii-dev/config.json");
@@ -199,7 +199,7 @@ export async function checkLogin() {
 export const encode = (value) => encodeURIComponent(value);
 // Switches never take the next token as their value, so
 // `docs upload --wait rulebook/` keeps rulebook/ as a path.
-const SWITCHES = new Set(["json", "wait", "pending", "dry-run", "check", "all", "fleet", "help", "yes", "mine", "no-browser", "include-drafts", "drafted", "library", "async", "sync", "force", "system"]);
+const SWITCHES = new Set(["json", "wait", "pending", "dry-run", "check", "all", "fleet", "help", "yes", "mine", "no-browser", "include-drafts", "drafted", "library", "async", "sync", "force", "system", "delta"]);
 export function parseArgs(argv) {
   const flags = {};
   const args = [];

package/dist/doctor.js

@@ -19,7 +19,7 @@ export const LANE_PERMISSIONS = [
   { key: "devops.issues.read", for: "issues list|show" },
   { key: "devops.issues.write", for: "issues create|update|claim|release|transition" },
   { key: "devops.lanes.read", for: "lane show|list, next" },
-  { key: "devops.lanes.write", for: "lane start|step|evidence|heartbeat|review|land|verify" },
+  { key: "devops.lanes.write", for: "lane launch|amend|start|step|evidence|heartbeat|review|land|verify" },
   { key: "devops.agents.read", for: "whoami, reading this agent" },
   { key: "devops.agents.write", for: "agent register|heartbeat" },
   { key: "devops.machines.manage", for: "machine show (this agent's machine and coordinator)" },

package/dist/hooks.js

@@ -1,7 +1,7 @@
 import { CliError, devRequest, readConfig } from "./core.js";
 import { FOUNDATIONS_ID, figmaLockCheck, outOfScopeText } from "./figma.js";
 import { execFile } from "node:child_process";
-import { realpath } from "node:fs/promises";
+import { readFile, realpath } from "node:fs/promises";
 import { resolve } from "node:path";
 import { promisify } from "node:util";
 import { safetySettingsSnippet } from "./safety.js";
@@ -209,6 +209,15 @@ export async function heartbeatCurrentLane(request = devRequest) {
   try { branch = (await execFileAsync("git", ["branch", "--show-current"], { encoding: "utf8" })).stdout.trim(); }
   catch { return { heartbeated: false, reason: "not a git worktree" }; }
   if (!branch) return { heartbeated: false, reason: "detached HEAD" };
+  try {
+    const markerPath = (await execFileAsync("git", ["rev-parse", "--path-format=absolute", "--git-path", "nodii-lane.json"], { encoding: "utf8" })).stdout.trim();
+    const marker = JSON.parse(await readFile(markerPath, "utf8"));
+    const lane = (await request("GET", `/api/v1/lanes/${encodeURIComponent(marker.laneKey)}`)).data;
+    if (lane.repositories?.some((repository) => repository.branch === branch)) {
+      await request("POST", `/api/v1/lanes/${encodeURIComponent(lane.id)}/heartbeat`, { via: "nodii-dev" });
+      return { heartbeated: true, key: lane.key };
+    }
+  } catch {}
   const lanes = (await request("GET", "/api/v1/lanes?limit=200")).data ?? [];
   const lane = lanes.find((x) => x.branch === branch && !["on_dev", "stopped"].includes(x.status));
   if (!lane) return { heartbeated: false, reason: "no lane for current branch" };
@@ -226,6 +235,23 @@ export async function sessionStartContext(payload, { request = devRequest, confi
     const rootText = (await execFileAsync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8" })).stdout.trim();
     const root = await realpath(rootText).catch(() => resolve(rootText));
     const current = await config(false);
+    try {
+      const markerPath = (await execFileAsync("git", ["rev-parse", "--path-format=absolute", "--git-path", "nodii-lane.json"], { cwd, encoding: "utf8" })).stdout.trim();
+      const marker = JSON.parse(await readFile(markerPath, "utf8"));
+      const marked = (await request("GET", `/api/v1/lanes/${encodeURIComponent(marker.laneKey)}`)).data;
+      const repository = marked.repositories?.find((item) => item.branch === branch && resolve(item.worktree) === root);
+      if (marked.agentId === current.agentId && repository && !["on_dev", "stopped"].includes(marked.status)) lane = marked;
+    } catch {}
+    if (lane) {
+      const freeze = lane.freeze ?? {};
+      return [
+        `Freeze re-grounding for ${lane.key}:`,
+        `title: ${lane.title ?? "(untitled)"}`,
+        `status: ${lane.status}`,
+        `boundaries: ${JSON.stringify(freeze.boundaries ?? {})}`,
+        `rules: ${JSON.stringify(freeze.rules ?? freeze.ruleRefs ?? [])}`,
+      ].join("\n");
+    }
     const lanes = (await request("GET", "/api/v1/lanes?limit=200")).data ?? [];
     for (const item of lanes) {
       if (item.agentId !== current.agentId || item.branch !== branch || ["on_dev", "stopped"].includes(item.status)) continue;

package/dist/lanes.js

@@ -2,6 +2,7 @@ import { execFile } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { promisify } from "node:util";
 import { CliError, encode, devRequest, query, readConfig, requireFlag } from "./core.js";
+import { launchRecovery } from "./runtime-launcher.js";
 import { recordReviewReceipt, reviewCommitContext } from "./safety.js";
 
 const execFileAsync = promisify(execFile);
@@ -106,14 +107,18 @@ const MAX_COMMITS = 200;
 /** The lane's branch commits not on origin/main (as last fetched), from its recorded worktree. */
 export async function branchCommits(lane) {
   try {
-    const out = (await execFileAsync("git", ["-C", lane.worktree, "rev-list", `origin/main..${lane.branch}`], { encoding: "utf8" })).stdout.trim();
-    return out ? out.split("\n") : [];
+    const repositories = lane.repositories?.length ? lane.repositories : [{ worktree: lane.worktree, branch: lane.branch, baseRef: "origin/main" }];
+    const commits = await Promise.all(repositories.map(async (repository) => {
+      const out = (await execFileAsync("git", ["-C", repository.worktree, "rev-list", `${repository.baseRef ?? "origin/main"}..${repository.branch}`], { encoding: "utf8" })).stdout.trim();
+      return out ? out.split("\n") : [];
+    }));
+    return [...new Set(commits.flat())];
   } catch {
-    throw new CliError("GIT_REQUIRED", `Cannot read the commits of ${lane.branch} in ${lane.worktree}. Pass --commits SHA[,SHA], or --branch dropped:REASON.`, 2);
+    throw new CliError("GIT_REQUIRED", `Cannot read every repository branch for this lane. Pass --commits SHA[,SHA], or --branch dropped:REASON.`, 2);
   }
 }
 
-export async function laneCommand(action, args, flags, { request = devRequest, config = readConfig, gitContext = inferGitContext, commitsOf = branchCommits, read = (path) => readFile(path, "utf8"), reviewContext = reviewCommitContext, reviewReceipt = recordReviewReceipt } = {}) {
+export async function laneCommand(action, args, flags, { request = devRequest, config = readConfig, gitContext = inferGitContext, commitsOf = branchCommits, read = (path) => readFile(path, "utf8"), reviewContext = reviewCommitContext, reviewReceipt = recordReviewReceipt, launch = launchRecovery } = {}) {
   if (action === "list") {
     const c = flags.mine ? await config() : null;
     const payload = await request("GET", `/api/v1/lanes${query({ kind: flags.kind, status: flags.status, machine: flags.machine, agent: flags.mine ? c.agentId : flags.agent, "waiting-on": flags["waiting-on"], stuck: flags.stuck, cursor: flags.cursor, limit: flags.limit })}`);
@@ -194,6 +199,40 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
     );
     return { payload, human: `${ref}: subagent quota set to ${quota}.` };
   }
+  if (action === "resume") {
+    const payload = await request(
+      "POST",
+      `/api/v1/lanes/${encode(id)}/resume`,
+      via,
+    );
+    let launched;
+    try {
+      launched = await launch(payload);
+    } catch (error) {
+      const reason = `local recovery launch failed: ${error instanceof Error ? error.message : String(error)}`.slice(0, 2_000);
+      const runId = payload?.data?.run?.id;
+      if (runId) {
+        await request(
+          "POST",
+          `/api/v1/lanes/${encode(id)}/resume/${encode(runId)}/launch-failed`,
+          { reason, ...via },
+        ).catch(() => {});
+      }
+      throw new CliError("RECOVERY_LAUNCH_FAILED", reason, 1);
+    }
+    return {
+      payload,
+      human: (response) => {
+        const runId = response.data.run.id;
+        const next = response.data.lane.next?.[0];
+        const checkpoint = response.data.recovery.lastPushedCommit;
+        const continuation = next
+          ? `${next.side}/${next.step}`
+          : "the lane's next unfinished step";
+        return `${ref}: resumed fresh run ${runId} as PID ${launched.pid}; continuing ${continuation} from ${checkpoint}.`;
+      },
+    };
+  }
   if (action === "land") return { payload: await request("POST", `/api/v1/lanes/${encode(id)}/land`, via), human: `${ref}: recorded on main.` };
   if (action === "review") {
     const body = await reviewBody(flags, read);
@@ -269,11 +308,15 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
  */
 export async function laneChangedPaths(lane) {
   try {
-    const run = async (...args) => (await execFileAsync("git", ["-C", lane.worktree, ...args], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024 })).stdout;
-    const base = (await run("merge-base", "origin/main", "HEAD")).trim();
-    const changed = (await run("diff", "--name-only", base)).split("\n");
-    const untracked = (await run("ls-files", "--others", "--exclude-standard")).split("\n");
-    return [...new Set([...changed, ...untracked].map((x) => x.trim()).filter(Boolean))].slice(0, 5000);
+    const repositories = lane.repositories?.length ? lane.repositories : [{ repo: lane.repos?.[0], worktree: lane.worktree, baseRef: "origin/main" }];
+    const changed = await Promise.all(repositories.map(async (repository) => {
+      const run = async (...args) => (await execFileAsync("git", ["-C", repository.worktree, ...args], { encoding: "utf8", maxBuffer: 16 * 1024 * 1024 })).stdout;
+      const base = (await run("merge-base", repository.baseRef ?? "origin/main", "HEAD")).trim();
+      const tracked = (await run("diff", "--name-only", base)).split("\n");
+      const untracked = (await run("ls-files", "--others", "--exclude-standard")).split("\n");
+      return [...tracked, ...untracked].map((path) => path.trim()).filter(Boolean);
+    }));
+    return [...new Set(changed.flat())].slice(0, 5000);
   } catch {
     return null;
   }
@@ -295,11 +338,14 @@ export async function nextCommand(ref, flags, { request = devRequest, changedPat
   const data = steps.map((step) => ({ side: step.side, step: step.stepKey, label: step.label, state: step.state, command: `nodii-dev lane step ${lane.key} --side ${step.side} --${step.state === "current" ? "done" : "start"} ${step.stepKey}` }));
   // M05-32: the clauses Dev serves for this step. A failure here never hides the next step.
   let rules = null;
-  if (data.length) {
+  if (data.length || flags.deltaContext) {
     const paths = flags.paths ? list(flags.paths) : await changedPaths(lane);
-    const body = { ...(paths ? { paths } : {}), ...(flags.components ? { components: list(flags.components) } : {}), ...(flags.role ? { role: String(flags.role) } : {}) };
+    const body = { ...(paths ? { paths } : {}), ...(flags.components ? { components: list(flags.components) } : {}), ...(flags.role ? { role: String(flags.role) } : {}), ...(flags.deltaContext && typeof flags.deltaContext === "object" ? { delta: flags.deltaContext } : {}) };
     try { rules = (await request("POST", `/api/v1/lanes/${encode(lane.key)}/rules`, body)).data; }
-    catch (error) { rules = { error: error.code ?? error.message }; }
+    catch (error) {
+      if (flags.deltaContext) throw error;
+      rules = { error: error.code ?? error.message };
+    }
   }
   const human = data.length
     ? [...data.map((x) => `${x.side}: ${x.label}\n  ${x.command}`), ...rulesLines(rules, lane.key)].join("\n")