nccgs 2.0.0 → 2.1.1

package/tests/returned-handoff-notices.test.mjs

@@ -0,0 +1,170 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { captureReturnedHandoff } from "../.claude/nccgs/tools/returned-handoff.mjs";
+import { nativeCompletion } from "../.claude/nccgs/tools/native-completion.mjs";
+
+const REL = ".nccgs/evidence/analysis/handoff.md";
+const GREP = "<tools-used-before-summary>Grep</tools-used-before-summary>";
+const text = value => ({ type: "text", text: value });
+const BODY = "NCCGS-HANDOFF: COMPLETE\n\n## Outcome\nDone.\n";
+
+function fixture() {
+  const project = fs.mkdtempSync(path.join(os.tmpdir(), "nccgs-returned-handoff-"));
+  const dispatch = { handoffTransport: "native-result", status: "running", kind: "analysis", sessionId: "S1",
+    toolUseId: "T1", agentId: "A1", agent: "nccgs-engine-programmer", snapshot: "snap1", handoffPaths: [REL] };
+  const input = response => ({ hook_event_name: "PostToolUse", tool_name: "Agent", session_id: "S1", tool_use_id: "T1",
+    tool_input: { subagent_type: "nccgs-engine-programmer" }, tool_response: response });
+  const file = path.join(project, REL);
+  // Real hook path: completion comes from the authoritative classifier.
+  const capture = (response, { completion, d = dispatch, snapshot = "snap1", inp } = {}) =>
+    captureReturnedHandoff(project, d, inp ?? input(response), completion ?? nativeCompletion(response), snapshot);
+  const resp = (content, extra = {}) => ({ agentId: "A1", status: "completed", content, ...extra });
+  return { project, dispatch, input, file, capture, resp, dispose: () => fs.rmSync(project, { recursive: true, force: true }) };
+}
+function withFixture(fn) { const f = fixture(); try { fn(f); } finally { f.dispose(); } }
+const rejected = (f, result) => { assert.equal(result?.status, "rejected", JSON.stringify(result)); assert.ok(!fs.existsSync(f.file)); };
+const captured = (f, result, expected) => {
+  assert.equal(result?.status, "captured", JSON.stringify(result));
+  assert.equal(fs.readFileSync(f.file, "utf8"), expected);
+};
+
+test("no-note response is captured verbatim", () => withFixture(f => {
+  captured(f, f.capture(f.resp([text(BODY)])), BODY);
+}));
+
+test("observed Grep leading header plus one handoff", () => withFixture(f => {
+  captured(f, f.capture(f.resp([text(GREP), text(BODY)], { harnessNoteCount: 1 })), BODY);
+}));
+
+test("designated tail block is stripped", () => withFixture(f => {
+  captured(f, f.capture(f.resp([text(BODY), text(GREP)], { harnessTailCount: 1 })), BODY);
+}));
+
+test("leading plus tail blocks are stripped", () => withFixture(f => {
+  captured(f, f.capture(f.resp([text(GREP), text(BODY), text("<tools-used-before-summary>Read,Edit</tools-used-before-summary>")],
+    { harnessNoteCount: 1, harnessTailCount: 1 })), BODY);
+}));
+
+test("multiple recognized notes are stripped", () => withFixture(f => {
+  const notes = [text(GREP), text("<tools-used-before-summary>Read</tools-used-before-summary>")];
+  captured(f, f.capture(f.resp([...notes, text(BODY), text(GREP)], { harnessNoteCount: 2, harnessTailCount: 1 })), BODY);
+}));
+
+test("model text is preserved byte for byte", () => {
+  const bodies = [
+    `  \n${BODY}  \n`,
+    "NCCGS-HANDOFF: COMPLETE\r\nline\r\n\r\n",
+    "NCCGS-HANDOFF: COMPLETE\nUnicode: é中文 \u{1F600}\n",
+    `${BODY}\n\`\`\`nccgs-review\n{"schemaVersion":1,"verdict":"PASS","criteriaMet":true,"findings":[{"id":"F-1"}],"conditions":[{"id":"C-1"}]}\n\`\`\`\n`,
+  ];
+  for (const body of bodies) withFixture(f => {
+    captured(f, f.capture(f.resp([text(GREP), text(body)], { harnessNoteCount: 1 })), body);
+  });
+});
+
+test("marker-like text inside the model body is preserved verbatim", () => withFixture(f => {
+  const body = `${BODY}\nQuote: ${GREP}\n<system-reminder>kept</system-reminder>\n`;
+  captured(f, f.capture(f.resp([text(GREP), text(body)], { harnessNoteCount: 1 })), body);
+}));
+
+test("undesignated lookalike block counts as a model block and is ambiguous", () => withFixture(f => {
+  rejected(f, f.capture(f.resp([text(GREP), text(BODY)])));
+  rejected(f, f.capture(f.resp([text(BODY), text(GREP)], { harnessNoteCount: 0 })));
+}));
+
+test("unknown, mixed, turn-limit and non-completed responses reject with a COMPLETE body", () => {
+  const cases = [
+    f => f.resp([text("<harness-advisory>something new</harness-advisory>"), text(BODY)], { harnessNoteCount: 1 }),
+    f => f.resp([text(`${GREP}\nextra prose`), text(BODY)], { harnessNoteCount: 1 }),
+    f => f.resp([text("Note: this agent stopped at its 30-turn limit before finishing"), text(BODY)], { harnessNoteCount: 1 }),
+    f => f.resp([text(BODY), text("this agent stopped at its 12-turn limit before finishing")], { harnessTailCount: 1 }),
+    f => f.resp([text(BODY)], { status: "failed" }),
+    f => f.resp([text(BODY)], { status: "async_launched" }),
+    f => ({ agentId: "A1", content: [text(BODY)] }),
+  ];
+  for (const make of cases) withFixture(f => rejected(f, f.capture(make(f))));
+});
+
+test("invalid, negative, non-integer, overlapping and too-large counts reject", () => {
+  const counts = [
+    { harnessNoteCount: -1 }, { harnessTailCount: -1 }, { harnessNoteCount: 1.5 }, { harnessTailCount: "1" },
+    { harnessNoteCount: 2, harnessTailCount: 1 }, { harnessNoteCount: 3 }, { harnessTailCount: 5 },
+    { harnessNoteCount: Number.NaN }, { harnessNoteCount: Number.MAX_SAFE_INTEGER + 2 },
+  ];
+  for (const extra of counts) withFixture(f => {
+    rejected(f, f.capture(f.resp([text(GREP), text(BODY)], extra)));
+    // Even with a forged supplied completion the raw response is re-evaluated.
+    rejected(f, f.capture(f.resp([text(GREP), text(BODY)], extra), { completion: { status: "completed" } }));
+  });
+});
+
+test("count equal to all blocks leaves no model block and rejects", () => withFixture(f => {
+  rejected(f, f.capture(f.resp([text(GREP)], { harnessNoteCount: 1 })));
+}));
+
+test("absent, non-text, empty, whitespace-only and oversized model content reject", () => {
+  const big = "x".repeat(262145), exact = "y".repeat(262144);
+  const cases = [
+    undefined, "str", [], [{ type: "image", text: BODY }], [{ type: "text" }], [{ type: "text", text: 5 }],
+    [text("")], [text(" \r\n\t ")], [text(big)], [text("é".repeat(131073))],
+  ];
+  for (const content of cases) withFixture(f => rejected(f, f.capture(f.resp(content))));
+  for (const content of cases.filter(Array.isArray)) withFixture(f =>
+    rejected(f, f.capture(f.resp([text(GREP), ...content], { harnessNoteCount: 1 }))));
+  withFixture(f => captured(f, f.capture(f.resp([text(exact)])), exact));
+});
+
+test("multiple model blocks are ambiguous", () => withFixture(f => {
+  rejected(f, f.capture(f.resp([text(BODY), text("second")])));
+  rejected(f, f.capture(f.resp([text(GREP), text(BODY), text("second")], { harnessNoteCount: 1 })));
+  rejected(f, f.capture(f.resp([text(GREP), text(BODY), text("second"), text(GREP)], { harnessNoteCount: 1, harnessTailCount: 1 })));
+}));
+
+test("forged supplied completion with invalid or turn-limited raw response rejects", () => withFixture(f => {
+  const forged = { status: "completed" };
+  rejected(f, f.capture(f.resp([text("<unknown>x</unknown>"), text(BODY)], { harnessNoteCount: 1 }), { completion: forged }));
+  rejected(f, f.capture(f.resp([text("this agent stopped at its 5-turn limit before finishing"), text(BODY)], { harnessNoteCount: 1 }), { completion: forged }));
+  rejected(f, f.capture(f.resp([text(BODY)], { status: "failed" }), { completion: forged }));
+  rejected(f, f.capture(f.resp([text(BODY)], { harnessNoteCount: 7 }), { completion: forged }));
+}));
+
+test("failures indicated by the supplied completion are preserved", () => withFixture(f => {
+  const response = f.resp([text(BODY)]);
+  rejected(f, f.capture(response, { completion: { status: "failed" } }));
+  rejected(f, f.capture(response, { completion: { status: "completed", reason: "turn-limit" } }));
+  rejected(f, f.capture(response, { completion: { reason: "x" } }));
+}));
+
+test("identity and snapshot mismatches reject", () => withFixture(f => {
+  const response = f.resp([text(GREP), text(BODY)], { harnessNoteCount: 1 });
+  const base = f.input(response);
+  for (const field of ["session_id", "tool_use_id", "hook_event_name", "tool_name"])
+    rejected(f, f.capture(response, { inp: { ...base, [field]: "incorrect" } }));
+  rejected(f, f.capture(response, { inp: { ...base, tool_input: { subagent_type: "wrong" } } }));
+  rejected(f, f.capture({ ...response, agentId: "wrong" }));
+  rejected(f, f.capture(response, { snapshot: "other" }));
+  rejected(f, f.capture(response, { d: { ...f.dispatch, status: "completed" } }));
+  rejected(f, f.capture(response, { d: { ...f.dispatch, kind: "implementation" } }));
+  rejected(f, f.capture(response, { d: { ...f.dispatch, handoffPaths: [REL, "other.md"] } }));
+  assert.equal(f.capture(response, { d: { ...f.dispatch, handoffTransport: undefined } }), null);
+  assert.ok(!fs.existsSync(f.file));
+}));
+
+test("an existing handoff is never overwritten", () => withFixture(f => {
+  fs.mkdirSync(path.dirname(f.file), { recursive: true });
+  fs.writeFileSync(f.file, "ORIGINAL DRAFT");
+  const result = f.capture(f.resp([text(GREP), text(BODY)], { harnessNoteCount: 1 }));
+  assert.equal(result.status, "rejected");
+  assert.equal(result.reason, "handoff-already-exists");
+  assert.equal(fs.readFileSync(f.file, "utf8"), "ORIGINAL DRAFT");
+}));
+
+test("paths escaping the project reject without writing", () => withFixture(f => {
+  const response = f.resp([text(BODY)]);
+  const result = f.capture(response, { d: { ...f.dispatch, handoffPaths: ["../escape.md"] } });
+  assert.equal(result.status, "rejected");
+  assert.ok(!fs.existsSync(path.join(f.project, "..", "escape.md")));
+}));