@gonrocca/nodd 0.1.0

package/extensions/nodd-gates.test.ts

@@ -0,0 +1,108 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { GATE_IDS } from "../src/gates/registry.ts";
+import { emptyPolicy, resolveFlag } from "../src/gates/policy.ts";
+import { flagsFromCli, runGatesCommand } from "./nodd-gates.ts";
+
+function ctx(config: Record<string, unknown> = {}) {
+  const writes: Array<Record<string, unknown>> = [];
+  return {
+    writes,
+    readConfig: () => config,
+    writeConfig: (next: Record<string, unknown>) => { writes.push(next); },
+  };
+}
+
+test("status is read-only and reports default for an untouched gate", () => {
+  const c = ctx();
+  const out = runGatesCommand("status", c);
+  assert.deepEqual(c.writes, [], "status must write nothing");
+  for (const id of GATE_IDS) {
+    assert.match(out, new RegExp(`${id}\\s+on\\s+default`), `${id} row must report on/default`);
+  }
+});
+
+test("status reports the deciding source when config chose", () => {
+  const out = runGatesCommand("status", ctx({ gates: { track: { enabled: false } } }));
+  assert.match(out, /track\s+off\s+config/);
+  assert.match(out, /classify\s+on\s+default/);
+});
+
+// routing.go:115 — "do not argue, do not work around it, do not propose
+// alternatives first". The one-line confirmation is the whole response.
+test("disable obeys in exactly one line, with no argument and no alternative", () => {
+  const c = ctx();
+  const out = runGatesCommand("disable track", c);
+  assert.equal(out, "nodd: gate track disabled.");
+  assert.equal(out.split("\n").length, 1, "the confirmation is one line");
+
+  const forbidden = ["but ", "however", "instead", "consider", "recommend", "warning",
+    "careful", "risk", "re-enable", "reenable", "you can turn", "alternative"];
+  for (const word of forbidden) {
+    assert.ok(!out.toLowerCase().includes(word), `the confirmation must not contain "${word}"`);
+  }
+});
+
+test("disable flips only that gate's flag", () => {
+  const c = ctx({ models: { implement: "a/b" }, gates: { classify: { enabled: false } } });
+  runGatesCommand("disable track", c);
+  assert.equal(c.writes.length, 1);
+  const written = c.writes[0] as any;
+  assert.equal(written.gates.track.enabled, false);
+  assert.equal(written.gates.classify.enabled, false, "another gate's choice must survive");
+  assert.deepEqual(written.models, { implement: "a/b" }, "unrelated keys must survive");
+});
+
+// routing.go:116 — "do not reactivate it". Nothing but an explicit enable may
+// turn a gate back on: not a session start, not a threshold, not 50 events.
+test("a disabled gate stays disabled across a session start and 50 observations", () => {
+  const config = { gates: { track: { enabled: false } } };
+  let policy = { ...emptyPolicy(), config: { track: { enabled: false } } };
+  assert.deepEqual(resolveFlag("track", policy), { enabled: false, source: "config" });
+
+  for (let i = 0; i < 50; i++) {
+    policy = { ...policy, config: { ...policy.config } };
+  }
+  assert.deepEqual(resolveFlag("track", policy), { enabled: false, source: "config" });
+  // And a real status read after all of it still reports off, from config.
+  const c = ctx(config);
+  assert.match(runGatesCommand("status", c), /track\s+off\s+config/);
+  assert.deepEqual(c.writes, [], "nothing re-enabled it and nothing was written");
+});
+
+test("enable is the only way back on", () => {
+  const c = ctx({ gates: { track: { enabled: false } } });
+  const out = runGatesCommand("enable track", c);
+  assert.equal(out, "nodd: gate track enabled.");
+  assert.equal((c.writes[0] as any).gates.track.enabled, true);
+});
+
+test("an unknown gate id lists the valid ids", () => {
+  const out = runGatesCommand("disable nonsense", ctx());
+  assert.match(out, /nonsense/);
+  for (const id of GATE_IDS) assert.ok(out.includes(id), `must list ${id}`);
+});
+
+test("`enabled: true` is written from exactly one handler", () => {
+  const src = readFileSync(join(dirname(fileURLToPath(import.meta.url)), "nodd-gates.ts"), "utf8");
+  const occurrences = src.match(/enabled:\s*true/g) ?? [];
+  assert.equal(occurrences.length, 1, `expected exactly one 'enabled: true' writer, found ${occurrences.length}`);
+});
+
+test("--nodd-off=<id> disables one gate and --nodd-off=all disables every gate", () => {
+  assert.deepEqual(flagsFromCli("track"), { track: false });
+  assert.deepEqual(flagsFromCli("all"), { all: false });
+  assert.deepEqual(flagsFromCli("nonsense"), {}, "an unknown id disables nothing");
+  assert.deepEqual(flagsFromCli(undefined), {});
+
+  // The flag outranks config, and the status output says so.
+  const one = runGatesCommand("status", ctx(), flagsFromCli("track"));
+  assert.match(one, /track\s+off\s+flag/);
+  assert.match(one, /classify\s+on\s+default/);
+
+  const every = runGatesCommand("status", ctx(), flagsFromCli("all"));
+  for (const id of GATE_IDS) assert.match(every, new RegExp(`${id}\\s+off\\s+flag`));
+});

package/extensions/nodd-gates.ts

@@ -0,0 +1,121 @@
+// `/nodd-gates enable|disable|status [gate]` — the kill switch.
+//
+// The semantics are ODD's, inherited verbatim from `routing.go:106-118`, and
+// the reason ODD gives is the reason NODD adopts them: "a switch the agent
+// cannot name does not exist for the user, who would otherwise ask to stop
+// using receipt-driven development and be argued with instead of obeyed."
+// A gate that resists being turned off is the same product failure as a gate
+// that does not exist — and NODD ships six of them.
+//
+// So: `status` writes nothing and names the deciding source. `disable` obeys in
+// one line, with no counter-argument, no consequence warning and no alternative
+// offered. Nothing re-enables a gate but the explicit `enable` handler, which
+// is why `enabled: true` appears exactly once in this file and a test counts it.
+//
+// The one inversion from ODD is the default: NODD's gates default *on*, because
+// enforcement is the product where RDD is opt-in. Everything else is unchanged.
+
+import { readFileSync, writeFileSync } from "node:fs";
+import { GATE_IDS, isGateId } from "../src/gates/registry.ts";
+import { mergeConfig, noddConfigPath, parseConfig } from "../src/config.ts";
+import { resolveFlag, type Policy } from "../src/gates/policy.ts";
+
+type ConfigIo = {
+  readConfig(): Record<string, unknown>;
+  writeConfig(next: Record<string, unknown>): void;
+};
+
+export function fileConfigIo(path: string = noddConfigPath()): ConfigIo {
+  return {
+    readConfig() {
+      try {
+        return JSON.parse(readFileSync(path, "utf8")) as Record<string, unknown>;
+      } catch {
+        return {};
+      }
+    },
+    writeConfig(next) {
+      writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    },
+  };
+}
+
+function policyFrom(raw: Record<string, unknown>, flags: Record<string, boolean>): Policy {
+  const { config } = parseConfig(JSON.stringify(raw));
+  return { config: config.gates, flags, hatches: {} };
+}
+
+function renderStatus(raw: Record<string, unknown>, flags: Record<string, boolean>): string {
+  const policy = policyFrom(raw, flags);
+  const width = Math.max(...GATE_IDS.map((id) => id.length));
+  const rows = GATE_IDS.map((id) => {
+    const { enabled, source } = resolveFlag(id, policy);
+    return `  ${id.padEnd(width)}  ${(enabled ? "on" : "off").padEnd(3)}  ${source}`;
+  });
+  return [`nodd gates (gate, effective mode, deciding source):`, ...rows].join("\n");
+}
+
+function setEnabled(io: ConfigIo, gate: string, value: boolean): void {
+  const raw = io.readConfig();
+  const gates = { ...(raw.gates as Record<string, unknown> | undefined) };
+  gates[gate] = { enabled: value };
+  io.writeConfig(mergeConfig(raw, { gates }));
+}
+
+export function runGatesCommand(args: string, io: ConfigIo, flags: Record<string, boolean> = {}): string {
+  const [verb, gate] = args.trim().split(/\s+/);
+
+  if (!verb || verb === "status") return renderStatus(io.readConfig(), flags);
+
+  if (verb !== "enable" && verb !== "disable") {
+    return `nodd-gates: usage — /nodd-gates [status|enable <gate>|disable <gate>]`;
+  }
+  if (!gate || !isGateId(gate)) {
+    return `nodd-gates: unknown gate "${gate ?? ""}". Valid gates: ${GATE_IDS.join(", ")}`;
+  }
+
+  if (verb === "disable") {
+    setEnabled(io, gate, false);
+    // One line. No argument, no consequence warning, no alternative, no hint
+    // about turning it back on. This shape is asserted by test because
+    // "do not argue" is a behaviour, and behaviours drift.
+    return `nodd: gate ${gate} disabled.`;
+  }
+
+  // The only place in NODD that turns a gate on. Reached only from an explicit
+  // `/nodd-gates enable` — never from a session start, a threshold or another
+  // gate, and never on the user's behalf.
+  setEnabled(io, gate, true);
+  return `nodd: gate ${gate} enabled.`;
+}
+
+type PiApi = {
+  registerCommand?(name: string, options: { description?: string; handler: (args: string, ctx: unknown) => void }): void;
+  registerFlag?(name: string, options: unknown): void;
+};
+
+export default function register(pi?: PiApi): void {
+  pi?.registerFlag?.("nodd-off", {
+    description: "Disable one NODD gate for this session, or all of them: --nodd-off=track | --nodd-off=all",
+    type: "string",
+  });
+
+  pi?.registerCommand?.("nodd-gates", {
+    description: "Read or set NODD's per-gate switches: /nodd-gates [status|enable <gate>|disable <gate>]",
+    handler: (args: string, ctx: unknown) => {
+      const notify = (ctx as { ui?: { notify?(m: string, t?: string): void } })?.ui?.notify;
+      try {
+        notify?.(runGatesCommand(args ?? "", fileConfigIo()), "info");
+      } catch (err) {
+        notify?.(`nodd-gates: ${err instanceof Error ? err.message : String(err)}`, "error");
+      }
+    },
+  });
+}
+
+/** Parse `--nodd-off=<id|all>` into the policy's flag map. */
+export function flagsFromCli(value: string | undefined): Record<string, boolean> {
+  if (!value) return {};
+  if (value === "all") return { all: false };
+  return isGateId(value) ? { [value]: false } : {};
+}

package/extensions/nodd-kernel.test.ts

@@ -0,0 +1,114 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import register, { createKernel } from "./nodd-kernel.ts";
+
+type Handler = (event: any, ctx?: any) => any;
+
+function fakePi() {
+  const handlers = new Map<string, Handler>();
+  const entries: Array<{ type: string; data: unknown }> = [];
+  return {
+    handlers,
+    entries,
+    on(event: string, handler: Handler) { handlers.set(event, handler); },
+    registerTool() {},
+    appendEntry(type: string, data: unknown) { entries.push({ type, data }); },
+    emit(event: string, payload: any, ctx?: unknown) { return handlers.get(event)?.(payload, ctx); },
+  };
+}
+
+test("a read-only session of read/grep/ls produces zero blocks", () => {
+  const pi = fakePi();
+  register(pi as never);
+  const calls = [
+    { toolName: "read", toolCallId: "c1", input: { path: "a.ts" } },
+    { toolName: "grep", toolCallId: "c2", input: { pattern: "x" } },
+    { toolName: "ls", toolCallId: "c3", input: { path: "." } },
+    { toolName: "read", toolCallId: "c4", input: { path: "b.ts" } },
+  ];
+  for (const call of calls) {
+    const decision = pi.emit("tool_call", call);
+    assert.ok(decision === undefined || decision.block !== true, `${call.toolName} must not be blocked`);
+    pi.emit("tool_result", { ...call, isError: false, content: "" });
+  }
+});
+
+test("tool_call inserts into pending and tool_result moves it into committed", () => {
+  const kernel = createKernel();
+  kernel.onToolCall({ toolName: "write", toolCallId: "c1", input: { path: "a.ts" } });
+  assert.equal(kernel.state.pending.size, 1);
+  assert.equal(kernel.state.committed.filesWritten.size, 0, "a pending write is not a written file");
+
+  kernel.onToolResult({ toolName: "write", toolCallId: "c1", input: { path: "a.ts" }, isError: false, content: "" });
+  assert.equal(kernel.state.pending.size, 0);
+  assert.deepEqual([...kernel.state.committed.filesWritten.keys()], ["a.ts"]);
+});
+
+test("evidence helpers take Committed, so a pending sibling is structurally unreachable", () => {
+  const kernel = createKernel();
+  // Same assistant batch: two siblings preflighted, neither finished.
+  kernel.onToolCall({ toolName: "bash", toolCallId: "c1", input: { command: "npm test" } });
+  kernel.onToolCall({ toolName: "nodd_task", toolCallId: "c2", input: { action: "check", id: "T1" } });
+
+  const evidence = kernel.evidenceView();
+  assert.equal(evidence.commandResults.length, 0, "a pending sibling must not be visible as evidence");
+  assert.ok(!("pending" in evidence), "the evidence view has no pending half at all");
+});
+
+test("session replay is idempotent by toolCallId", () => {
+  const kernel = createKernel();
+  const entry = { toolName: "read", toolCallId: "c1", input: { path: "a.ts" }, isError: false, content: "" };
+  kernel.onToolResult(entry);
+  kernel.onToolResult(entry);
+  assert.equal(kernel.state.committed.toolCalls, 1);
+});
+
+// This test used to emit `{ entries: [...] }` on the event and read
+// `entry.type`. pi's SessionStartEvent has no `entries` field at all
+// (`dist/core/extensions/types.d.ts:416-422`) — the log is reached through
+// `ctx.sessionManager.getEntries()`, and a custom entry is
+// `{ type: "custom", customType, data }` (`dist/core/session-manager.d.ts:69-73`).
+// So the old test passed against a shape production never receives, and the
+// replay path it "covered" was dead code. It now uses pi's real contract.
+test("session_start replays the session log's nodd entries into committed state", () => {
+  const pi = fakePi();
+  const kernel = register(pi as never);
+  const entries = [
+    { type: "custom", customType: "nodd:observation", data: { toolName: "read", toolCallId: "r1", input: { path: "a.ts" }, isError: false, resultText: "", at: "t" } },
+    { type: "custom", customType: "nodd:observation", data: { toolName: "write", toolCallId: "w1", input: { path: "b.ts" }, isError: false, resultText: "", at: "t" } },
+    { type: "custom", customType: "something:else", data: { nope: true } },
+    { type: "message", role: "user" },
+  ];
+  pi.emit("session_start", { type: "session_start", reason: "resume" }, { sessionManager: { getEntries: () => entries } });
+
+  assert.deepEqual([...kernel.state.committed.filesRead], ["a.ts"]);
+  assert.deepEqual([...kernel.state.committed.filesWritten.keys()], ["b.ts"]);
+});
+
+test("replay restores context but never evidence: a run another process saw is not ours", () => {
+  const pi = fakePi();
+  const kernel = register(pi as never);
+  const entries = [
+    { type: "custom", customType: "nodd:observation", data: { toolName: "write", toolCallId: "w1", input: { path: "b.ts" }, isError: false, resultText: "", at: "t" } },
+    { type: "custom", customType: "nodd:observation", data: { toolName: "bash", toolCallId: "b1", input: { command: "npm test" }, isError: false, resultText: "42 passing", at: "t" } },
+  ];
+  pi.emit("session_start", { type: "session_start", reason: "resume" }, { sessionManager: { getEntries: () => entries } });
+
+  assert.deepEqual([...kernel.state.committed.filesWritten.keys()], ["b.ts"], "context comes back");
+  assert.deepEqual(kernel.state.committed.commandResults, [], "evidence does not");
+});
+
+test("a session_start with no session manager never throws", () => {
+  const pi = fakePi();
+  register(pi as never);
+  pi.emit("session_start", { type: "session_start", reason: "startup" });
+  pi.emit("session_start", { type: "session_start", reason: "startup" }, {});
+});
+
+test("terminate is never assigned anywhere in the extension", () => {
+  const src = readFileSync(join(dirname(fileURLToPath(import.meta.url)), "nodd-kernel.ts"), "utf8");
+  assert.ok(!/terminate\s*[:=]/.test(src), "blocking one sibling must never abort the batch");
+});