@event4u/agent-config 14.6.0 → 14.8.0

package/src/scripts/hooks/py_json_dumps.ts

@@ -0,0 +1,103 @@
+/**
+ * `json.dumps(obj, indent=n)` byte-for-byte, extracted from `dispatch_hook.ts`.
+ *
+ * Pure and self-contained: it recurses into itself and calls nothing else, which
+ * is what made it safe to move out of a dispatcher that runs on every tool call.
+ * Extracted because dispatch_hook.ts sits at the 1500-line source ceiling.
+ *
+ * For anyone tempted to share it: mcp_telemetry_store, mcp_telemetry_query and
+ * mcp_telemetry_health each define their OWN `_py_json_dumps`. They were left
+ * alone — unifying four copies is a change with its own risk, not a merge-time
+ * side effect.
+ */
+// Python json.dumps(record, indent=2) byte-for-byte (ensure_ascii=True).
+export function _py_json_dumps(value: unknown, indent: number): string {
+  const pad = " ".repeat(indent);
+  const escapeString = (s: string): string => {
+    let out = '"';
+    for (const ch of s) {
+      const code = ch.codePointAt(0) as number;
+      switch (ch) {
+        case '"':
+          out += '\\"';
+          break;
+        case "\\":
+          out += "\\\\";
+          break;
+        case "\n":
+          out += "\\n";
+          break;
+        case "\r":
+          out += "\\r";
+          break;
+        case "\t":
+          out += "\\t";
+          break;
+        case "\b":
+          out += "\\b";
+          break;
+        case "\f":
+          out += "\\f";
+          break;
+        default:
+          if (code < 0x20 || code > 0x7e) {
+            if (code > 0xffff) {
+              const c = code - 0x10000;
+              const hi = 0xd800 + (c >> 10);
+              const lo = 0xdc00 + (c & 0x3ff);
+              out +=
+                "\\u" +
+                hi.toString(16).padStart(4, "0") +
+                "\\u" +
+                lo.toString(16).padStart(4, "0");
+            } else {
+              out += "\\u" + code.toString(16).padStart(4, "0");
+            }
+          } else {
+            out += ch;
+          }
+      }
+    }
+    return out + '"';
+  };
+  const render = (v: unknown, depth: number): string => {
+    if (v === null || v === undefined) return "null";
+    if (typeof v === "boolean") return v ? "true" : "false";
+    if (typeof v === "number") {
+      if (!Number.isFinite(v)) {
+        if (Number.isNaN(v)) return "NaN";
+        return v > 0 ? "Infinity" : "-Infinity";
+      }
+      return String(v);
+    }
+    if (typeof v === "string") return escapeString(v);
+    const curPad = pad.repeat(depth + 1);
+    const closePad = pad.repeat(depth);
+    if (Array.isArray(v)) {
+      if (v.length === 0) return "[]";
+      return (
+        "[\n" +
+        v.map((item) => curPad + render(item, depth + 1)).join(",\n") +
+        "\n" +
+        closePad +
+        "]"
+      );
+    }
+    if (typeof v === "object") {
+      const obj = v as Record<string, unknown>;
+      const keys = Object.keys(obj);
+      if (keys.length === 0) return "{}";
+      return (
+        "{\n" +
+        keys
+          .map((k) => curPad + escapeString(k) + ": " + render(obj[k], depth + 1))
+          .join(",\n") +
+        "\n" +
+        closePad +
+        "}"
+      );
+    }
+    throw new TypeError(`Object of type ${typeof v} is not JSON serializable`);
+  };
+  return render(value, 0);
+}

package/src/scripts/hooks/rtk_wrap_hook.ts

@@ -155,14 +155,19 @@ export function classify(command: string): Eligibility {
 
   let tokens: string[];
   try {
-    tokens = shlexSplit(cmd);
+    tokens = shlexSplit(cmd, true);
   } catch (e) {
     if (e instanceof ShlexError) return { eligible: false, reason_skip: "parse-error" };
     throw e;
   }
 
   // Compound / piped → don't wrap (rtk wraps a single command). `_split_subcommands`
-  // splits on && || ; | — more than one group means a pipeline/chain.
+  // splits on && || ; | & — more than one group means a pipeline/chain.
+  // `splitOperators` is REQUIRED here: POSIX shlex leaves a separator attached
+  // to the preceding word, so `foo; bar` tokenised to one group and read as a
+  // single command. Same construct as the block_no_verify defect measured
+  // 2026-08-20; found by the sibling search for that fix, 2 call sites, both
+  // in this file.
   const groups = _split_subcommands(tokens);
   if (groups.length !== 1) return { eligible: false, reason_skip: "compound-or-piped" };
 
@@ -256,7 +261,7 @@ export function classifyCap(
   if (!cmd) return null;
   let tokens: string[];
   try {
-    tokens = shlexSplit(cmd);
+    tokens = shlexSplit(cmd, true);
   } catch (e) {
     if (e instanceof ShlexError) return null;
     throw e;

package/src/scripts/hooks/run_continuation_hook.ts

@@ -72,12 +72,15 @@
  *                                duplicate, whatever the counts say.
  *   scope complete (0 open,
  *   none blocked)              → allow            (event: complete; state cleared)
- *   runnable work exhausted
- *   (0 open, ≥1 blocked)       → allow  (event: blocked, ONCE per run, guarded by
+ *   remaining work externally
+ *   impossible (0 open, ≥1
+ *   blocked)                   → allow  (event: blocked, ONCE per run, guarded by
  *                                the LEDGER: the state is cleared like `complete`,
- *                                so no field there outlives the event. ADR-235's
- *                                terminal outcome — not a sixth halt, never in
- *                                `HALT_ACTIONS`, never stamped into `halted`)
+ *                                so no field there outlives the event. A terminal
+ *                                outcome — not a sixth halt, never in
+ *                                `HALT_ACTIONS`, never stamped into `halted`.
+ *                                ADR-237 narrows what may legally wear a
+ *                                `blocked-by:` marker; semantics unchanged.)
  *   iterations ≥ MAX (25)      → allow            (event: halt-max-iterations)
  *   wall clock ≥ cap (4 h)     → allow            (event: halt-wall-clock)
  *   stall (3 engagements, no

package/src/scripts/hooks/ship_diff_volume_hook.ts

@@ -33,6 +33,7 @@ import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 import { readHookStdin } from './hook_stdin.js';
+import { isPayloadStub } from './payload_stub.js';
 import { atomic_write_json } from './state_io.js';
 
 export const STATE_FILE = path.join('agents', 'state', 'ship-diff-volume.json');
@@ -89,31 +90,96 @@ export function correctedVolume(numstat: string): { volume: number; excluded: nu
     return { volume, excluded, files };
 }
 
-function extractCommand(envelope: Record<string, unknown>): string {
-    const ti = envelope['tool_input'];
-    if (ti !== null && typeof ti === 'object') {
-        const c = (ti as Record<string, unknown>)['command'];
+/**
+ * Tools that carry a shell command. Mirrors `block_unauthorized_git`'s set.
+ *
+ * `SHIP_PATTERNS` are unanchored, so without this gate a `grep` for the string
+ * `git push` spawns two `git` subprocesses on a blocking slot. ALLOW-list: a
+ * named tool outside it is declined, so an unlisted host shell goes dark until
+ * added — the trade that sibling already makes while BLOCKING. A payload naming
+ * no tool still reads; that is the bare-host shape, with nothing to gate on.
+ */
+const COMMAND_TOOLS: ReadonlySet<string> = new Set([
+    'launch-process',
+    'launch_process',
+    'Bash',
+    'BashTool',
+    'run-process',
+    'runProcess',
+    'shell',
+    'execute_shell',
+    'RunShellCommand',
+]);
+
+function isObj(v: unknown): v is Record<string, unknown> {
+    return typeof v === 'object' && v !== null && !Array.isArray(v);
+}
+
+/**
+ * Descend to the platform payload.
+ *
+ * The dispatcher nests the host-shaped tool fields under `payload`
+ * (`_build_envelope`); a bare host invocation puts them at the top level. This
+ * concern shipped reading the top level ONLY, so under the real dispatcher it
+ * found nothing and returned `''` every time — it ran, cost a dispatch, and
+ * could never fire.
+ *
+ * Deliberately NOT `envelope.ts`'s shared `unwrap`, which descends only when all
+ * four `ENVELOPE_KEYS` are present: a partial envelope would return this concern
+ * to its pre-fix dead state with no test noticing. `design-slop` and
+ * `ui-route-nudge` each carry their own local descent for the same reason.
+ */
+function payloadOf(root: Record<string, unknown>): Record<string, unknown> {
+    const inner = root['payload'];
+    return isObj(inner) ? inner : root;
+}
+
+/** The ship command, or `''` when this payload does not carry one. */
+function shipCommandFrom(payload: Record<string, unknown>): string {
+    const toolRaw = payload['tool_name'] ?? payload['toolName'] ?? payload['tool'];
+    if (typeof toolRaw === 'string' && !COMMAND_TOOLS.has(toolRaw)) return '';
+
+    const ti = payload['tool_input'] ?? payload['toolInput'];
+    if (isPayloadStub(ti)) {
+        // Body omitted despite `needs_payload_bodies: [input]`. A bare '' here is
+        // indistinguishable from "no ship verb" — the silent death this file was
+        // fixed to remove — so say so instead of dying quietly again.
+        process.stderr.write(
+            'ship-diff-volume: tool_input arrived stubbed; the concern declares ' +
+                'needs_payload_bodies: [input] and cannot read a command without it.\n',
+        );
+        return '';
+    }
+    if (isObj(ti)) {
+        const c = ti['command'];
         if (typeof c === 'string') return c;
     }
-    const c = envelope['command'];
+    const c = payload['command'];
     return typeof c === 'string' ? c : '';
 }
 
+/**
+ * The stdin boundary: raw concern stdin → the ship command. Exported so a
+ * regression drives the boundary rather than the extractor. Never throws.
+ */
+export function commandFromStdin(raw: string): string {
+    if (!raw.trim()) return '';
+    let root: unknown;
+    try {
+        root = JSON.parse(raw);
+    } catch {
+        return '';
+    }
+    if (!isObj(root)) return '';
+    return shipCommandFrom(payloadOf(root));
+}
+
 export function main(argv?: string[]): number {
     const args = argv ?? process.argv.slice(2);
     const idx = args.indexOf('--command');
     let cmd = idx >= 0 && args[idx + 1] !== undefined ? args[idx + 1]! : '';
     if (!cmd) {
-        const raw = readHookStdin();
-        let envelope: Record<string, unknown> = {};
-        if (raw.trim()) {
-            try {
-                envelope = JSON.parse(raw) as Record<string, unknown>;
-            } catch {
-                envelope = {};
-            }
-        }
-        cmd = extractCommand(envelope);
+        cmd = commandFromStdin(readHookStdin());
     }
     if (!isShipCommand(cmd)) return 0;