@nodii/dev 0.6.26 → 0.6.28

package/dist/lanes.js

@@ -182,6 +182,18 @@ export async function laneCommand(action, args, flags, { request = devRequest, c
   if (action === "heartbeat") {
     return { payload: await request("POST", `/api/v1/lanes/${encode(id)}/heartbeat`, { ...(flags.note !== undefined ? { note: flags.note } : {}), ...via }), human: `${ref}: heartbeat recorded.` };
   }
+  if (action === "subagent-quota") {
+    const raw = need(args[1], "lane subagent-quota needs <key> <n>");
+    const quota = Number(raw);
+    if (!Number.isInteger(quota) || quota < 0 || quota > 100)
+      throw new CliError("USAGE", "Subagent quota must be an integer from 0 to 100.", 2);
+    const payload = await request(
+      "PUT",
+      `/api/v1/lanes/${encode(id)}/subagent-quota`,
+      { quota, ...via },
+    );
+    return { payload, human: `${ref}: subagent quota set to ${quota}.` };
+  }
   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);

package/dist/managed-hooks.js

@@ -11,7 +11,7 @@ export const CODEX_HOOK_EVENTS = [
 ];
 
 export const managedHooksDir = (home = homedir()) => join(home, ".config", "nodii-dev", "codex-managed-hooks");
-export const MANAGED_DISPATCH_MIN_VERSION = "0.6.26";
+export const MANAGED_DISPATCH_MIN_VERSION = "0.6.27";
 
 /** Only a single nodii-dev invocation is allowed; shell composition is never accepted. */
 export function nodiiCommandArgs(command) {
@@ -110,33 +110,36 @@ function responseOf(stdout) {
 
 /** Execute the current generated hook set behind the stable managed dispatcher. */
 export async function dispatchManagedHook(event, payloadText, deps = {}) {
-  if (!CODEX_HOOK_EVENTS.includes(event)) throw new CliError("USAGE", `Unknown managed Codex hook event: ${event}`, 2);
-  const env = deps.env ?? process.env;
-  if (!laneConfig(env)) return emptyResponse(event);
-  const dir = deps.dir ?? env.NODII_DEV_MANAGED_HOOKS_DIR ?? managedHooksDir();
-  let config;
-  try { config = JSON.parse(await (deps.read ?? readFile)(join(dir, "hooks.json"), "utf8")); }
-  catch (error) { throw new CliError("HARNESS_SETTINGS_INVALID", `Cannot read managed Codex hooks: ${error.message}`, 2); }
-  validateManagedHooks(config.hooks ?? {});
-  const payload = JSON.parse(payloadText);
-  const target = matchTarget(event, payload);
-  const handlers = (config.hooks?.[event] ?? []).filter((entry) => {
-    try { return new RegExp(entry.matcher || ".*").test(target); } catch { return false; }
-  }).flatMap((entry) => entry.hooks ?? []);
-  const results = await Promise.all(handlers.map((handler) => (deps.run ?? runHandler)(nodiiCommandArgs(handler.command), payloadText, deps)));
-  const messages = results.map((result) => responseOf(result.stdout)).filter(Boolean);
-  const errors = results.filter((result) => result.status !== 0).map((result) => result.stderr.trim() || result.stdout.trim()).filter(Boolean);
-  if (["PreToolUse", "PermissionRequest"].includes(event)) {
-    const denied = messages.find((message) => message.hookSpecificOutput?.permissionDecision === "deny");
-    if (denied) return `${JSON.stringify(denied)}\n`;
-    if (errors.length) return `${JSON.stringify({ hookSpecificOutput: { hookEventName: event, permissionDecision: "deny", permissionDecisionReason: errors.join("\n") } })}\n`;
-    const contexts = messages.map((message) => message.hookSpecificOutput?.additionalContext).filter(Boolean);
-    return contexts.length ? `${JSON.stringify({ hookSpecificOutput: { hookEventName: event, additionalContext: contexts.join("\n") } })}\n` : "";
+  try {
+    if (!CODEX_HOOK_EVENTS.includes(event)) return emptyResponse(event);
+    const env = deps.env ?? process.env;
+    if (!laneConfig(env)) return emptyResponse(event);
+    const dir = deps.dir ?? env.NODII_DEV_MANAGED_HOOKS_DIR ?? managedHooksDir();
+    const config = JSON.parse(await (deps.read ?? readFile)(join(dir, "hooks.json"), "utf8"));
+    validateManagedHooks(config.hooks ?? {});
+    const payload = JSON.parse(payloadText);
+    const target = matchTarget(event, payload);
+    const handlers = (config.hooks?.[event] ?? []).filter((entry) => {
+      try { return new RegExp(entry.matcher || ".*").test(target); } catch { return false; }
+    }).flatMap((entry) => entry.hooks ?? []);
+    const results = await Promise.all(handlers.map((handler) => (deps.run ?? runHandler)(nodiiCommandArgs(handler.command), payloadText, deps)));
+    // A failed handler is unavailable policy, not a denial. Ignore both its
+    // output and stderr; doctor is where hook health remains visible.
+    const successful = results.filter((result) => result.status === 0);
+    const messages = successful.map((result) => responseOf(result.stdout)).filter(Boolean);
+    if (["PreToolUse", "PermissionRequest"].includes(event)) {
+      const denied = messages.find((message) => message.hookSpecificOutput?.permissionDecision === "deny");
+      if (denied) return `${JSON.stringify(denied)}\n`;
+      const contexts = messages.map((message) => message.hookSpecificOutput?.additionalContext).filter(Boolean);
+      return contexts.length ? `${JSON.stringify({ hookSpecificOutput: { hookEventName: event, additionalContext: contexts.join("\n") } })}\n` : "";
+    }
+    const structured = messages.map((message) => message.hookSpecificOutput?.additionalContext).filter(Boolean);
+    const plain = successful.map((result) => responseOf(result.stdout) ? "" : result.stdout.trim()).filter(Boolean);
+    if (["Stop", "SubagentStop"].includes(event)) return "{}\n";
+    return [...structured, ...plain].join("\n") + ([...structured, ...plain].length ? "\n" : "");
+  } catch {
+    return emptyResponse(event);
   }
-  const structured = messages.map((message) => message.hookSpecificOutput?.additionalContext).filter(Boolean);
-  const plain = results.map((result) => responseOf(result.stdout) ? "" : result.stdout.trim()).filter(Boolean);
-  if (["Stop", "SubagentStop"].includes(event)) return "{}\n";
-  return [...structured, ...plain, ...errors].join("\n") + ([...structured, ...plain, ...errors].length ? "\n" : "");
 }
 
 const versionParts = (value) => String(value ?? "").split(".").map((part) => Number.parseInt(part, 10));

package/dist/nodii-dev.js

@@ -1,4 +1,16 @@
 #!/usr/bin/env node
 import { fail, main } from "./cli.js";
 
-main().catch(fail);
+// Hooks run in the agent's environment, which may be incomplete or may not be
+// a git worktree. An unavailable hook must never turn into a refused tool call.
+// Intentional policy denials are handled inside the hook command before they
+// reach this boundary.
+main().catch((error) => {
+  const denial = String(error?.code ?? "").startsWith("SAFETY_") ||
+    ["FIGMA_FILE_KEY_MISSING", "FIGMA_LOCK_DENIED", "WRITE_OUT_OF_SCOPE"].includes(error?.code);
+  if (process.argv[2] === "hook" && !denial) {
+    process.exitCode = 0;
+    return;
+  }
+  fail(error);
+});

package/dist/runs.js

@@ -0,0 +1,341 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { basename } from "node:path";
+import { CliError, devRequest, encode } from "./core.js";
+
+export const RUN_ID_ENV = "NODII_DEV_RUN_ID";
+const DEFAULT_HEARTBEAT_MS = 60_000;
+const DEFAULT_TAIL_BYTES = 8 * 1024;
+const RUN_KINDS = new Set(["build", "test_run", "subagent", "deploy"]);
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+
+export function redactRunText(value) {
+  return String(value)
+    .replace(/-----BEGIN [^-\r\n]*PRIVATE KEY-----[\s\S]*?-----END [^-\r\n]*PRIVATE KEY-----/gi, "[REDACTED PRIVATE KEY]")
+    .replace(/\b(Bearer\s+)[A-Za-z0-9._~+/=-]+/gi, "$1[REDACTED]")
+    .replace(/\b(?:github_pat_|gh[pousr]_|sk-)[A-Za-z0-9_-]{12,}\b/g, "[REDACTED]")
+    .replace(
+      /\b((?=[A-Za-z0-9_-]*(?:token|secret|password|passwd|pwd|api[_-]?key|access[_-]?key))[A-Za-z][A-Za-z0-9_-]*\s*[:=]\s*)[^\s,;]+/gi,
+      "$1[REDACTED]",
+    )
+    .replace(/([a-z][a-z0-9+.-]*:\/\/[^\s:/]+:)[^@\s]+@/gi, "$1[REDACTED]@");
+}
+
+function appendTail(current, chunk, maxBytes) {
+  const next = Buffer.concat([current, Buffer.from(chunk)]);
+  return next.length <= maxBytes ? next : next.subarray(next.length - maxBytes);
+}
+
+function writeSafe(write, value) {
+  try {
+    write(value);
+    return true;
+  } catch (error) {
+    if (error?.code !== "EPIPE") throw error;
+    return false;
+  }
+}
+
+function currentRunId(runId = process.env[RUN_ID_ENV]) {
+  if (runId === undefined || runId === "") return null;
+  if (!UUID.test(runId))
+    throw new CliError(
+      "RUN_CONTEXT_INVALID",
+      `${RUN_ID_ENV} must be the UUID of this lane, subagent, or coordinator run.`,
+      2,
+    );
+  return runId;
+}
+
+function evidenceText(evidence) {
+  return (evidence ?? [])
+    .map((item) => {
+      const head = `  ${redactRunText(item.kind)}: ${redactRunText(item.ref)}`;
+      if (!item.note) return head;
+      return `${head}\n${redactRunText(item.note)
+        .split("\n")
+        .map((line) => `    ${line}`)
+        .join("\n")}`;
+    })
+    .join("\n");
+}
+
+function resultText(result) {
+  const lines = [
+    `Result ${redactRunText(result.id)} · ${redactRunText(result.outcome)} · run ${redactRunText(result.sourceRunId)}`,
+  ];
+  if (result.failureReason)
+    lines.push(`  reason: ${redactRunText(result.failureReason)}`);
+  if (result.handoff) lines.push(`  handoff: ${redactRunText(result.handoff)}`);
+  const evidence = evidenceText(result.evidence);
+  if (evidence) lines.push(evidence);
+  return lines.join("\n");
+}
+
+export async function showWaitingResults({
+  runId = process.env[RUN_ID_ENV],
+  request = devRequest,
+  write = (value) => process.stderr.write(value),
+  acknowledge = true,
+} = {}) {
+  const waiterRunId = currentRunId(runId);
+  if (!waiterRunId) return [];
+  const payload = await request(
+    "GET",
+    `/api/v1/runs/${encode(waiterRunId)}/results`,
+  );
+  const results = payload.data ?? [];
+  if (!results.length) return [];
+
+  const rendered = writeSafe(
+    write,
+    `${results.map(resultText).join("\n\n")}\n`,
+  );
+  if (!rendered || !acknowledge) return results;
+  for (const result of results) {
+    try {
+      await request(
+        "POST",
+        `/api/v1/results/${encode(result.id)}/acknowledge`,
+        { waiterRunId },
+      );
+    } catch (error) {
+      writeSafe(
+        write,
+        `Result ${redactRunText(result.id)} remains waiting: acknowledgement failed (${redactRunText(error?.code ?? error?.message ?? "error")}).\n`,
+      );
+    }
+  }
+  return results;
+}
+
+function commandLabel(command) {
+  return basename(command[0] ?? "command").slice(0, 240) || "command";
+}
+
+function runKind(value) {
+  const kind = value ?? "build";
+  if (!RUN_KINDS.has(kind))
+    throw new CliError(
+      "USAGE",
+      `run --kind must be one of ${[...RUN_KINDS].join(", ")}.`,
+      2,
+    );
+  return kind;
+}
+
+function runEvidence(command, exitCode, signal, tail) {
+  const evidence = [
+    { kind: "command", ref: commandLabel(command) },
+    { kind: "exit_code", ref: String(exitCode ?? -1) },
+    {
+      kind: "log_tail",
+      ref: "combined stdout/stderr",
+      note: redactRunText(tail.toString("utf8")) || "(no output)",
+    },
+  ];
+  if (signal) evidence.push({ kind: "signal", ref: signal });
+  return evidence;
+}
+
+async function endRun(request, runId, body, attempts = 3) {
+  let error;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    try {
+      return await request("POST", `/api/v1/runs/${encode(runId)}/end`, body);
+    } catch (caught) {
+      error = caught;
+      if (attempt + 1 < attempts)
+        await new Promise((resolve) => setTimeout(resolve, 250 * (attempt + 1)));
+    }
+  }
+  throw error;
+}
+
+export async function superviseRun({
+  command,
+  waiterRunId = process.env[RUN_ID_ENV],
+  kind,
+  name,
+  expectedHeartbeatSeconds = 60,
+  heartbeatIntervalMs = DEFAULT_HEARTBEAT_MS,
+  tailBytes = DEFAULT_TAIL_BYTES,
+  request = devRequest,
+  spawn = nodeSpawn,
+  stdoutWrite = (value) => process.stdout.write(value),
+  stderrWrite = (value) => process.stderr.write(value),
+} = {}) {
+  const waiter = currentRunId(waiterRunId);
+  if (!waiter)
+    throw new CliError(
+      "RUN_CONTEXT_REQUIRED",
+      `nodii-dev run needs ${RUN_ID_ENV}, supplied by the harness launcher for the current waiter run.`,
+      2,
+    );
+  if (!Array.isArray(command) || !command.length || !command[0])
+    throw new CliError("USAGE", "run needs a command after `--`.", 2);
+  const selectedKind = runKind(kind);
+  const label = redactRunText(String(name ?? commandLabel(command)))
+    .trim()
+    .slice(0, 300);
+  if (!label) throw new CliError("USAGE", "run --name cannot be empty.", 2);
+  const registered = await request("POST", "/api/v1/runs", {
+    kind: selectedKind,
+    name: label,
+    externalRef: `pid:${process.pid}`,
+    waiterRunId: waiter,
+    expectedHeartbeatSeconds,
+    metadata: { executable: redactRunText(commandLabel(command)) },
+  });
+  const runId = registered.data?.id;
+  if (!runId) throw new CliError("RUN_REGISTER_INVALID", "Dev registered a run without an id.", 1);
+
+  let tail = Buffer.alloc(0);
+  let spawnError = null;
+  let heartbeatInFlight = false;
+  let child;
+  let timer;
+  const forwardSignals = new Map();
+  for (const signal of SIGNALS) {
+    const forward = () => {
+      if (child?.pid && child.exitCode === null && child.signalCode === null)
+        child.kill(signal);
+    };
+    forwardSignals.set(signal, forward);
+    process.on(signal, forward);
+  }
+
+  try {
+    try {
+      child = spawn(command[0], command.slice(1), {
+        shell: false,
+        stdio: ["inherit", "pipe", "pipe"],
+      });
+    } catch (error) {
+      const evidence = runEvidence(command, 1, null, tail);
+      await endRun(request, runId, {
+        status: "failed",
+        reason: `Command could not start: ${redactRunText(error?.code ?? error?.message ?? "error")}`,
+        evidence,
+      });
+      return {
+        runId,
+        exitCode: 1,
+        signal: null,
+        tail: "",
+      };
+    }
+    child.stdout?.on("data", (chunk) => {
+      tail = appendTail(tail, chunk, tailBytes);
+      writeSafe(stdoutWrite, chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      tail = appendTail(tail, chunk, tailBytes);
+      writeSafe(stderrWrite, chunk);
+    });
+
+    const heartbeat = async () => {
+      if (heartbeatInFlight) return;
+      heartbeatInFlight = true;
+      try {
+        await request("POST", `/api/v1/runs/${encode(runId)}/heartbeat`, {
+          note: `command pid ${child.pid ?? "starting"}`,
+        });
+      } catch (error) {
+        writeSafe(
+          stderrWrite,
+          `nodii-dev run heartbeat failed (${redactRunText(error?.code ?? error?.message ?? "error")}); retrying.\n`,
+        );
+      } finally {
+        heartbeatInFlight = false;
+      }
+    };
+    timer = setInterval(heartbeat, heartbeatIntervalMs);
+    const outcome = await new Promise((resolve) => {
+      child.once("error", (error) => {
+        spawnError = error;
+      });
+      child.once("close", (exitCode, signal) => resolve({ exitCode, signal }));
+    });
+    clearInterval(timer);
+    timer = undefined;
+    while (heartbeatInFlight)
+      await new Promise((resolve) => setTimeout(resolve, 5));
+
+    const evidence = runEvidence(
+      command,
+      outcome.exitCode,
+      outcome.signal,
+      tail,
+    );
+    const succeeded = outcome.exitCode === 0 && !outcome.signal && !spawnError;
+    const reason = spawnError
+      ? `Command could not start: ${redactRunText(spawnError.code ?? spawnError.message)}`
+      : outcome.signal
+        ? `Command ended by signal ${outcome.signal}`
+        : `Command exited with code ${outcome.exitCode ?? -1}`;
+    await endRun(
+      request,
+      runId,
+      succeeded
+        ? { status: "done", evidence }
+        : { status: "failed", reason, evidence },
+    );
+    return {
+      runId,
+      exitCode: succeeded ? 0 : (outcome.exitCode ?? 1),
+      signal: outcome.signal,
+      tail: redactRunText(tail.toString("utf8")),
+    };
+  } finally {
+    if (timer) clearInterval(timer);
+    for (const [signal, forward] of forwardSignals)
+      process.off(signal, forward);
+  }
+}
+
+export async function launchRunSupervisor(
+  command,
+  {
+    entrypoint = process.argv[1],
+    spawn = nodeSpawn,
+    env = process.env,
+    kind,
+    name,
+  } = {},
+) {
+  if (!entrypoint)
+    throw new CliError("RUN_SUPERVISOR_UNAVAILABLE", "Cannot locate the nodii-dev entrypoint.", 1);
+  const args = [entrypoint, "__run-supervisor"];
+  if (kind) args.push("--kind", kind);
+  if (name) args.push("--name", name);
+  args.push("--", ...command);
+  const supervisor = spawn(process.execPath, args, {
+    detached: true,
+    shell: false,
+    stdio: "inherit",
+    env,
+  });
+  const forwardSignals = new Map();
+  for (const signal of SIGNALS) {
+    const forward = () => {
+      if (
+        supervisor.pid &&
+        supervisor.exitCode === null &&
+        supervisor.signalCode === null
+      )
+        supervisor.kill(signal);
+    };
+    forwardSignals.set(signal, forward);
+    process.on(signal, forward);
+  }
+  try {
+    return await new Promise((resolve, reject) => {
+      supervisor.once("error", reject);
+      supervisor.once("close", (code, signal) => resolve(code ?? (signal ? 1 : 0)));
+    });
+  } finally {
+    for (const [signal, forward] of forwardSignals)
+      process.off(signal, forward);
+  }
+}

package/dist/upload.js

@@ -168,6 +168,7 @@ const uploadBody = (docs, cls, flags, decision) => ({
     ...(flags["meaning-unchanged"] && cls === "editorial" ? { meaningUnchangedReason: String(flags["meaning-unchanged"]) } : {}),
   })),
   ...(decision ? { decision } : {}),
+  ...(flags.pending ? { pending: true } : {}),
 });
 
 export async function docsCommand(action, args, flags, { request = devRequest, log = console.error, cwd = process.cwd(), waitInterval } = {}) {
@@ -185,6 +186,12 @@ export async function docsCommand(action, args, flags, { request = devRequest, l
 
   if (action === "validate" || action === "upload") {
     const cls = changeClass(flags);
+    if (flags.pending !== undefined && flags.pending !== true)
+      throw new CliError("USAGE", "--pending is a switch and takes no value.", 2);
+    if (flags.pending && action !== "upload")
+      throw new CliError("USAGE", "--pending is valid only with docs upload.", 2);
+    if (flags.pending && cls !== "ruling")
+      throw new CliError("USAGE", "--pending requires --class ruling and --decision FILE.", 2);
     const decision = await readJsonFile(flags.decision, "decision");
     if (cls === "ruling" && !decision) throw new CliError("RULING_NEEDS_DECISION", "A ruling write needs its decision: --decision DECISION.json (title, context, options, ruling, consequences, provenance, amends).", 2);
     if (cls !== "ruling" && decision) throw new CliError("DECISION_NEEDS_RULING", "--decision goes with --class ruling only.", 2);
@@ -220,7 +227,9 @@ export async function docsCommand(action, args, flags, { request = devRequest, l
       payload: { data: result },
       human: [
         ...result.documents.map((d) => `${d.created ? "+" : "~"} ${d.code} ${d.version}\t${d.changeNote}`),
-        ...(result.decision ? [`Locked ${result.decision.id}: ${result.decision.title}`] : []),
+        ...(result.decision
+          ? [`${result.decision.status === "pending" ? "Drafted" : "Locked"} ${result.decision.id}: ${result.decision.title}`]
+          : []),
         `Uploaded ${result.documents.length} document${result.documents.length === 1 ? "" : "s"} (${cls}).`,
       ].join("\n"),
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nodii/dev",
-  "version": "0.6.26",
+  "version": "0.6.28",
   "description": "Agent CLI for Nodii Dev, reached through the platform edge",
   "type": "module",
   "bin": {