balladeer 1.0.15 → 1.0.17

package/dist/guidance-hook.mjs

@@ -16,9 +16,9 @@ var __commonJS = (cb, mod) => function __require2() {
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to;
 };
@@ -366,9 +366,9 @@ var require_toml_parser = __commonJS({
     var hasOwnProperty = Object.prototype.hasOwnProperty;
     var defineProperty = Object.defineProperty;
     var descriptor = { configurable: true, enumerable: true, writable: true, value: void 0 };
-    function hasKey(obj, key) {
-      if (hasOwnProperty.call(obj, key)) return true;
-      if (key === "__proto__") defineProperty(obj, "__proto__", descriptor);
+    function hasKey(obj, key2) {
+      if (hasOwnProperty.call(obj, key2)) return true;
+      if (key2 === "__proto__") defineProperty(obj, "__proto__", descriptor);
       return false;
     }
     var INLINE_TABLE = Symbol("inline-table");
@@ -570,11 +570,11 @@ var require_toml_parser = __commonJS({
         parseAssign() {
           return this.callNow(this.parseKeyword, this.recordAssignKeyword);
         }
-        recordAssignKeyword(key) {
+        recordAssignKeyword(key2) {
           if (this.state.resultTable) {
-            this.state.resultTable.push(key);
+            this.state.resultTable.push(key2);
           } else {
-            this.state.resultTable = [key];
+            this.state.resultTable = [key2];
           }
           return this.goto(this.parseAssignKeywordPreDot);
         }
@@ -1779,10 +1779,10 @@ var require_stringify = __commonJS({
       return new Error("Array values can't have mixed types");
     }
     function getInlineKeys(obj) {
-      return Object.keys(obj).filter((key) => isInline(obj[key]));
+      return Object.keys(obj).filter((key2) => isInline(obj[key2]));
     }
     function getComplexKeys(obj) {
-      return Object.keys(obj).filter((key) => !isInline(obj[key]));
+      return Object.keys(obj).filter((key2) => !isInline(obj[key2]));
     }
     function toJSON(obj) {
       let nobj = Array.isArray(obj) ? [] : Object.prototype.hasOwnProperty.call(obj, "__proto__") ? { ["__proto__"]: void 0 } : {};
@@ -1803,16 +1803,16 @@ var require_stringify = __commonJS({
       complexKeys = getComplexKeys(obj);
       var result = [];
       var inlineIndent = indent || "";
-      inlineKeys.forEach((key) => {
-        var type = tomlType2(obj[key]);
+      inlineKeys.forEach((key2) => {
+        var type = tomlType2(obj[key2]);
         if (type !== "undefined" && type !== "null") {
-          result.push(inlineIndent + stringifyKey(key) + " = " + stringifyAnyInline(obj[key], true));
+          result.push(inlineIndent + stringifyKey(key2) + " = " + stringifyAnyInline(obj[key2], true));
         }
       });
       if (result.length > 0) result.push("");
       var complexIndent = prefix && inlineKeys.length > 0 ? indent + "  " : "";
-      complexKeys.forEach((key) => {
-        result.push(stringifyComplex(prefix, complexIndent, key, obj[key]));
+      complexKeys.forEach((key2) => {
+        result.push(stringifyComplex(prefix, complexIndent, key2, obj[key2]));
       });
       return result.join("\n");
     }
@@ -1857,8 +1857,8 @@ var require_stringify = __commonJS({
         return "table";
       }
     }
-    function stringifyKey(key) {
-      var keyStr = String(key);
+    function stringifyKey(key2) {
+      var keyStr = String(key2);
       if (/^[-A-Za-z0-9_]+$/.test(keyStr)) {
         return keyStr;
       } else {
@@ -1977,27 +1977,27 @@ var require_stringify = __commonJS({
     function stringifyInlineTable(value) {
       value = toJSON(value);
       var result = [];
-      Object.keys(value).forEach((key) => {
-        result.push(stringifyKey(key) + " = " + stringifyAnyInline(value[key], false));
+      Object.keys(value).forEach((key2) => {
+        result.push(stringifyKey(key2) + " = " + stringifyAnyInline(value[key2], false));
       });
       return "{ " + result.join(", ") + (result.length > 0 ? " " : "") + "}";
     }
-    function stringifyComplex(prefix, indent, key, value) {
+    function stringifyComplex(prefix, indent, key2, value) {
       var valueType = tomlType2(value);
       if (valueType === "array") {
-        return stringifyArrayOfTables(prefix, indent, key, value);
+        return stringifyArrayOfTables(prefix, indent, key2, value);
       } else if (valueType === "table") {
-        return stringifyComplexTable(prefix, indent, key, value);
+        return stringifyComplexTable(prefix, indent, key2, value);
       } else {
         throw typeError(valueType);
       }
     }
-    function stringifyArrayOfTables(prefix, indent, key, values) {
+    function stringifyArrayOfTables(prefix, indent, key2, values) {
       values = toJSON(values);
       validateArray(values);
       var firstValueType = tomlType2(values[0]);
       if (firstValueType !== "table") throw typeError(firstValueType);
-      var fullKey = prefix + stringifyKey(key);
+      var fullKey = prefix + stringifyKey(key2);
       var result = "";
       values.forEach((table) => {
         if (result.length > 0) result += "\n";
@@ -2006,8 +2006,8 @@ var require_stringify = __commonJS({
       });
       return result;
     }
-    function stringifyComplexTable(prefix, indent, key, value) {
-      var fullKey = prefix + stringifyKey(key);
+    function stringifyComplexTable(prefix, indent, key2, value) {
+      var fullKey = prefix + stringifyKey(key2);
       var result = "";
       if (getInlineKeys(value).length > 0) {
         result += indent + "[" + fullKey + "]\n";
@@ -2026,8 +2026,133 @@ var require_toml = __commonJS({
   }
 });
 
+// src/relay.ts
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+var RELAY_FIELD = "forThePerson";
+var MAX_SENTENCE = 400;
+var MAX_SUBJECT = 200;
+var MAX_PENDING = 8;
+function clean(value, limit) {
+  if (typeof value !== "string") return void 0;
+  const text = value.replace(/[\u0000-\u001f\u007f]/g, " ").trim();
+  return text ? text.slice(0, limit) : void 0;
+}
+function noticeFrom(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  const sentence = clean(record.sentence, MAX_SENTENCE);
+  if (!sentence) return void 0;
+  const subjects = (Array.isArray(record.subjects) ? record.subjects : []).map((s) => clean(s, MAX_SUBJECT)).filter((s) => s !== void 0).slice(0, 4);
+  return { sentence, subjects };
+}
+function noticeFromToolResponse(response) {
+  const visit = (value, depth) => {
+    if (depth > 4 || value === null || value === void 0) return void 0;
+    if (typeof value === "string") {
+      if (!value.includes(RELAY_FIELD)) return void 0;
+      try {
+        return visit(JSON.parse(value), depth + 1);
+      } catch {
+        return void 0;
+      }
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        const found = visit(item, depth + 1);
+        if (found) return found;
+      }
+      return void 0;
+    }
+    if (typeof value !== "object") return void 0;
+    const record = value;
+    if (RELAY_FIELD in record) return noticeFrom(record[RELAY_FIELD]);
+    for (const key2 of ["structuredContent", "content", "text", "result", "tool_response"]) {
+      const found = visit(record[key2], depth + 1);
+      if (found) return found;
+    }
+    return void 0;
+  };
+  return visit(response, 0);
+}
+function relayNote(notice2) {
+  return `Balladeer just acted on the person's behalf: ${notice2.sentence} Make sure your reply tells them this, in your own words and in about one line.`;
+}
+var WORD = /[a-z0-9]+/g;
+var QUIET = new Set(
+  "a an the and or of to in on for with is are be by as at from that this it its not no".split(" ")
+);
+function words(text) {
+  return (text.toLowerCase().match(WORD) ?? []).filter((w) => w.length > 2 && !QUIET.has(w));
+}
+function mentions(reply, subject) {
+  const wanted = [...new Set(words(subject))];
+  if (!wanted.length) return true;
+  const said = new Set(words(reply));
+  const found = wanted.filter((w) => said.has(w) || said.has(w.replace(/s$/, ""))).length;
+  return found / wanted.length >= 0.5;
+}
+function relayed(reply, notice2) {
+  return notice2.subjects.length === 0 || notice2.subjects.some((s) => mentions(reply, s));
+}
+function reminder(notices) {
+  const told = notices.map((n) => n.sentence).join(" ");
+  return `Your reply does not yet tell the person what Balladeer did: ${told} Add it in your own words, in about one line.`;
+}
+function pendingPath(directory, sessionId) {
+  return join(directory, `${createHash("sha256").update(sessionId).digest("hex")}.relay.json`);
+}
+function readPending(directory, sessionId) {
+  try {
+    const parsed = JSON.parse(readFileSync(pendingPath(directory, sessionId), "utf8"));
+    return parsed.schemaVersion === 1 && Array.isArray(parsed.notices) ? parsed.notices.map(noticeFrom).filter((n) => n !== void 0) : [];
+  } catch {
+    return [];
+  }
+}
+function writePending(directory, sessionId, notices) {
+  mkdirSync(directory, { recursive: true, mode: 448 });
+  const path = pendingPath(directory, sessionId);
+  const temporary = `${path}.${process.pid}.tmp`;
+  const body = { schemaVersion: 1, notices: notices.slice(-MAX_PENDING) };
+  writeFileSync(temporary, JSON.stringify(body), { mode: 384 });
+  renameSync(temporary, path);
+}
+function isBalladeerTool(name) {
+  return typeof name === "string" && /^mcp__balladeer[a-z0-9_-]*__/i.test(name);
+}
+function relayHook(input, directory) {
+  try {
+    const sessionId = typeof input.session_id === "string" ? input.session_id : void 0;
+    if (input.hook_event_name === "PostToolUse") {
+      if (!isBalladeerTool(input.tool_name)) return void 0;
+      const notice2 = noticeFromToolResponse(input.tool_response ?? input.tool_output);
+      if (!notice2) return void 0;
+      if (sessionId && directory)
+        writePending(directory, sessionId, [...readPending(directory, sessionId), notice2]);
+      return JSON.stringify({
+        hookSpecificOutput: { hookEventName: "PostToolUse", additionalContext: relayNote(notice2) }
+      });
+    }
+    if (input.hook_event_name === "Stop") {
+      if (!sessionId || !directory) return void 0;
+      const pending = readPending(directory, sessionId);
+      if (!pending.length) return void 0;
+      const reply = typeof input.last_assistant_message === "string" ? input.last_assistant_message : "";
+      const missing = pending.filter((n) => !relayed(reply, n));
+      writePending(directory, sessionId, []);
+      if (!missing.length || input.stop_hook_active === true) return void 0;
+      return JSON.stringify({ decision: "block", reason: reminder(missing) });
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+
 // src/wire.ts
-var CLI_VERSION = "1.0.15";
+var CLI_VERSION = "1.0.17";
 var CLIENT_HEADER = "x-balladeer-client";
 var UPDATE_STATE_HEADER = "x-balladeer-update-state";
 var HOOK_HOST_HEADER = "x-balladeer-hook";
@@ -2040,15 +2165,15 @@ import {
   fchmodSync,
   fsyncSync,
   lstatSync,
-  mkdirSync,
+  mkdirSync as mkdirSync2,
   openSync,
-  readFileSync,
-  renameSync,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
   unlinkSync,
   writeSync
 } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, join, parse, resolve } from "node:path";
+import { dirname, join as join2, parse, resolve } from "node:path";
 var StoreError = class extends Error {
   code;
   constructor(code, message, options) {
@@ -2062,11 +2187,11 @@ function configHome(environment = process.env) {
   const explicit = environment.BALLADEER_CONFIG_HOME?.trim();
   if (explicit) return resolve(explicit);
   const xdg = environment.XDG_CONFIG_HOME?.trim();
-  if (xdg) return resolve(join(xdg, "balladeer"));
-  return resolve(join(homedir(), ".config", "balladeer"));
+  if (xdg) return resolve(join2(xdg, "balladeer"));
+  return resolve(join2(homedir(), ".config", "balladeer"));
 }
 function credentialsPath(environment = process.env) {
-  return join(configHome(environment), "credentials.json");
+  return join2(configHome(environment), "credentials.json");
 }
 function assertPrivate(path, kind) {
   const stats = lstatSync(path);
@@ -2098,7 +2223,7 @@ function readCredentials(environment = process.env) {
   let raw;
   try {
     assertPrivate(path, "file");
-    raw = readFileSync(path, "utf8");
+    raw = readFileSync2(path, "utf8");
   } catch (error) {
     if (error?.code === "ENOENT") {
       return { ...EMPTY, pendingPairings: [], sessions: [], agents: [] };
@@ -2154,8 +2279,8 @@ function newerVersionPublished() {
 
 // src/self-update.ts
 import { spawn } from "node:child_process";
-import { existsSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync } from "node:fs";
-import { delimiter, dirname as dirname2, join as join2 } from "node:path";
+import { existsSync, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { delimiter, dirname as dirname2, join as join3 } from "node:path";
 
 // src/release.ts
 var HOOK_SPECIFIER = "balladeer@1";
@@ -2167,24 +2292,24 @@ var DAY_MS = 24 * 60 * 60 * 1e3;
 var SELF_UPDATE_ENVIRONMENT = "BALLADEER_SELF_UPDATE";
 var STATE_PATTERN = /^(?:started|unstartable|installed|failed):[A-Za-z0-9._-]{1,40}$/;
 function stampPath(environment) {
-  return join2(configHome(environment), STAMP);
+  return join3(configHome(environment), STAMP);
 }
 function statePath(environment) {
-  return join2(configHome(environment), STATE);
+  return join3(configHome(environment), STATE);
 }
 function lastStarted(environment) {
   const path = stampPath(environment);
   if (!existsSync(path)) return 0;
   try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
     return typeof parsed.startedAt === "number" ? parsed.startedAt : 0;
   } catch {
     return 0;
   }
 }
 function writePrivate(path, value, environment) {
-  mkdirSync2(configHome(environment), { recursive: true, mode: 448 });
-  writeFileSync(path, JSON.stringify(value) + "\n", { mode: 384 });
+  mkdirSync3(configHome(environment), { recursive: true, mode: 448 });
+  writeFileSync2(path, JSON.stringify(value) + "\n", { mode: 384 });
 }
 function recordSelfUpdateState(environment, state, at) {
   if (!STATE_PATTERN.test(state)) return;
@@ -2195,7 +2320,7 @@ function recordSelfUpdateState(environment, state, at) {
 }
 function selfUpdateState(environment) {
   try {
-    const parsed = JSON.parse(readFileSync2(statePath(environment), "utf8"));
+    const parsed = JSON.parse(readFileSync3(statePath(environment), "utf8"));
     return typeof parsed.state === "string" && STATE_PATTERN.test(parsed.state) ? parsed.state : void 0;
   } catch {
     return void 0;
@@ -2209,9 +2334,9 @@ function resolveLaunch(specifier, environment, execPath = process.execPath, exis
     PATH: [bin, environment.PATH ?? ""].filter((part) => part.length > 0).join(delimiter),
     [SELF_UPDATE_ENVIRONMENT]: "1"
   };
-  const script = join2(bin, "..", "lib", "node_modules", "npm", "bin", "npx-cli.js");
+  const script = join3(bin, "..", "lib", "node_modules", "npm", "bin", "npx-cli.js");
   if (exists(script)) return { command: execPath, args: [script, ...tail], environment: child };
-  const shim = join2(bin, process.platform === "win32" ? "npx.cmd" : "npx");
+  const shim = join3(bin, process.platform === "win32" ? "npx.cmd" : "npx");
   if (exists(shim)) return { command: shim, args: tail, environment: child };
   return { command: "npx", args: tail, environment: child };
 }
@@ -2249,25 +2374,25 @@ function startSelfUpdateIfDue(newer, deps) {
 }
 
 // src/guidance.ts
-import { createHash, randomBytes } from "node:crypto";
+import { createHash as createHash2, randomBytes } from "node:crypto";
 import {
   constants,
   closeSync as closeSync2,
   fstatSync,
   lstatSync as lstatSync2,
-  mkdirSync as mkdirSync3,
+  mkdirSync as mkdirSync4,
   openSync as openSync2,
-  readFileSync as readFileSync3,
-  renameSync as renameSync2,
+  readFileSync as readFileSync4,
+  renameSync as renameSync3,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync2
+  writeFileSync as writeFileSync3
 } from "node:fs";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 var GUIDANCE_UNAVAILABLE = "Balladeer could not verify the current workspace guidance and capture mode. Continue the user's authorized work, but do not make unsolicited capture offers or file inferred promises. Do not reuse earlier Quiet/Thorough permission or cached instructions as current. An explicit request to record still requires current Balladeer tool checks and named-human agreement to meaning; never invent approval. Retry current guidance at the next hook boundary.";
 var HEX = /^[a-f0-9]{64}$/;
 var UUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/i;
 var MAX_BYTES = 4e4;
-var sha = (value) => createHash("sha256").update(value).digest("hex");
+var sha = (value) => createHash2("sha256").update(value).digest("hex");
 function object(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -2282,13 +2407,13 @@ function guidanceEndpoint(agent) {
   const expected = new URL(agent.controlPlane);
   if (url.origin !== expected.origin || url.protocol !== "https:" || url.pathname !== "/api/mcp" || url.username || url.password || url.hash || !UUID.test(agent.workspaceId) || !UUID.test(agent.repositoryId))
     throw new Error("invalid_guidance_scope");
-  for (const [key, value] of [
+  for (const [key2, value] of [
     ["workspaceId", agent.workspaceId],
     ["repositoryId", agent.repositoryId]
   ]) {
-    if (url.searchParams.getAll(key).length > 1 || url.searchParams.has(key) && url.searchParams.get(key) !== value)
+    if (url.searchParams.getAll(key2).length > 1 || url.searchParams.has(key2) && url.searchParams.get(key2) !== value)
       throw new Error("invalid_guidance_scope");
-    url.searchParams.set(key, value);
+    url.searchParams.set(key2, value);
   }
   url.pathname = "/api/agent-guidance";
   return url;
@@ -2299,7 +2424,7 @@ function readJson(path) {
     fd = openSync2(path, constants.O_RDONLY | constants.O_NOFOLLOW);
     const stat = fstatSync(fd);
     if (!stat.isFile() || stat.size > MAX_BYTES || (stat.mode & 63) !== 0) return void 0;
-    return JSON.parse(readFileSync3(fd, "utf8"));
+    return JSON.parse(readFileSync4(fd, "utf8"));
   } catch {
     return void 0;
   } finally {
@@ -2308,7 +2433,7 @@ function readJson(path) {
 }
 function privateDirectory(path) {
   try {
-    mkdirSync3(path, { mode: 448 });
+    mkdirSync4(path, { mode: 448 });
   } catch {
   }
   const stat = lstatSync2(path);
@@ -2318,9 +2443,9 @@ function privateDirectory(path) {
 function atomicJson(path, value) {
   const temporary = `${path}.${randomBytes(8).toString("hex")}.tmp`;
   try {
-    writeFileSync2(temporary, `${JSON.stringify(value)}
+    writeFileSync3(temporary, `${JSON.stringify(value)}
 `, { flag: "wx", mode: 384 });
-    renameSync2(temporary, path);
+    renameSync3(temporary, path);
   } finally {
     try {
       unlinkSync2(temporary);
@@ -2342,16 +2467,16 @@ function guidanceScopeKey(agent) {
 function cacheDirectory(environment) {
   const home = configHome(environment);
   privateDirectory(home);
-  const directory = join3(home, "guidance-v1");
+  const directory = join4(home, "guidance-v1");
   privateDirectory(directory);
   return directory;
 }
 function cached(directory, scopeKey, agent) {
   try {
-    const pointer = readJson(join3(directory, `${scopeKey}.current.json`));
+    const pointer = readJson(join4(directory, `${scopeKey}.current.json`));
     if (!object(pointer) || typeof pointer.key !== "string" || !HEX.test(pointer.key))
       return void 0;
-    const body = readJson(join3(directory, `${pointer.key}.body.json`));
+    const body = readJson(join4(directory, `${pointer.key}.body.json`));
     if (!object(body) || typeof body.etag !== "string" || !/^"[a-f0-9]{64}"$/.test(body.etag))
       return void 0;
     const document = parseGuidance(body.document, agent);
@@ -2427,12 +2552,12 @@ async function loadGuidance(input) {
       if (abort.signal.aborted) throw new Error("guidance_deadline");
       if (directory) {
         try {
-          const key = sha(JSON.stringify([scopeKey, document.revision]));
-          atomicJson(join3(directory, `${key}.body.json`), { document, etag });
-          atomicJson(join3(directory, `${scopeKey}.current.json`), { key });
-          if (previous && previous.key !== key) {
+          const key2 = sha(JSON.stringify([scopeKey, document.revision]));
+          atomicJson(join4(directory, `${key2}.body.json`), { document, etag });
+          atomicJson(join4(directory, `${scopeKey}.current.json`), { key: key2 });
+          if (previous && previous.key !== key2) {
             try {
-              unlinkSync2(join3(directory, `${previous.key}.body.json`));
+              unlinkSync2(join4(directory, `${previous.key}.body.json`));
             } catch {
             }
           }
@@ -2474,7 +2599,7 @@ function recordGuidanceContext(input, write2) {
   let path;
   let emitted = true;
   try {
-    path = join3(cacheDirectory(input.environment), `${contextKey}.context.json`);
+    path = join4(cacheDirectory(input.environment), `${contextKey}.context.json`);
     const previous = readJson(path);
     emitted = always || !object(previous) || previous.status === "unavailable" || previous.digest !== document?.digest || previous.revision !== document?.revision || (previous.runtimeGeneration ?? null) !== (input.runtimeGeneration ?? null);
   } catch {
@@ -2510,14 +2635,14 @@ import {
   existsSync as existsSync3,
   lstatSync as lstatSync4,
   linkSync,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync6,
-  renameSync as renameSync5,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync7,
+  renameSync as renameSync6,
   unlinkSync as unlinkSync5,
-  writeFileSync as writeFileSync3
+  writeFileSync as writeFileSync4
 } from "node:fs";
 var import_toml2 = __toESM(require_toml(), 1);
-import { dirname as dirname4, join as join6, relative } from "node:path";
+import { dirname as dirname4, join as join7, relative } from "node:path";
 
 // src/codex-config.ts
 var import_toml = __toESM(require_toml(), 1);
@@ -2526,26 +2651,26 @@ import {
   existsSync as existsSync2,
   fsyncSync as fsyncSync3,
   lstatSync as lstatSync3,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync5,
   openSync as openSync4,
-  readFileSync as readFileSync5,
-  renameSync as renameSync4,
+  readFileSync as readFileSync6,
+  renameSync as renameSync5,
   unlinkSync as unlinkSync4,
   writeSync as writeSync3
 } from "node:fs";
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 
 // src/mcp-config.ts
 import {
   closeSync as closeSync3,
   fsyncSync as fsyncSync2,
   openSync as openSync3,
-  readFileSync as readFileSync4,
-  renameSync as renameSync3,
+  readFileSync as readFileSync5,
+  renameSync as renameSync4,
   unlinkSync as unlinkSync3,
   writeSync as writeSync2
 } from "node:fs";
-import { basename, dirname as dirname3, isAbsolute, join as join4 } from "node:path";
+import { basename, dirname as dirname3, isAbsolute, join as join5 } from "node:path";
 var MCP_CONFIG_FILE = ".mcp.json";
 function sameOrigin(left, right) {
   try {
@@ -2588,7 +2713,7 @@ function currentEntry(parsed) {
 }
 function readMcpConfig(repositoryRoot) {
   try {
-    return JSON.parse(readFileSync4(join4(repositoryRoot, MCP_CONFIG_FILE), "utf8"));
+    return JSON.parse(readFileSync5(join5(repositoryRoot, MCP_CONFIG_FILE), "utf8"));
   } catch {
     return void 0;
   }
@@ -2598,7 +2723,7 @@ function readMcpConfig(repositoryRoot) {
 var CODEX_CONFIG_FILE = ".codex/config.toml";
 function readCodexEntry(root) {
   try {
-    const config = (0, import_toml.parse)(readFileSync5(join5(root, CODEX_CONFIG_FILE), "utf8"));
+    const config = (0, import_toml.parse)(readFileSync6(join6(root, CODEX_CONFIG_FILE), "utf8"));
     const servers = config.mcp_servers;
     return servers && typeof servers === "object" && !Array.isArray(servers) && !(servers instanceof Date) ? servers.balladeer : void 0;
   } catch {
@@ -2607,7 +2732,7 @@ function readCodexEntry(root) {
 }
 function hasManagedCodexEntry(root, controlPlane) {
   try {
-    const text = readFileSync5(join5(root, CODEX_CONFIG_FILE), "utf8");
+    const text = readFileSync6(join6(root, CODEX_CONFIG_FILE), "utf8");
     const starts = [...text.matchAll(/^# balladeer:mcp:start\r?$/gm)];
     const ends = [...text.matchAll(/^# balladeer:mcp:end\r?$/gm)];
     if (starts.length !== 1 || ends.length !== 1 || !starts[0] || !ends[0] || starts[0].index >= ends[0].index)
@@ -2740,6 +2865,72 @@ Balladeer only keeps promises a check can catch. If a customer would notice some
 slips, say that and I will keep that instead."
 
 Then take the customer-visible half if they give you one, and file that instead.`;
+var VERIFIER_SHAPE = `### The shape of a check that lasts
+
+Write a test only when the promise is easily testable: the repository's own test runner reaches the
+behavior in the ordinary way, its existing fixtures set the situation up, no outside system is
+needed, and the assertion is one of the promise's cases. Put it in the team's own suite, under the
+team's runner, with a comment naming the promise id, so a later judge can find it, read it and run
+it first. If reaching the behavior would mean stand-in modules, a scenario repository or a copy of
+the product's logic, the promise is not easily testable: write nothing and say so. The pre-push
+judge below covers it.
+
+A check exists to catch the failure its owner named, and to keep catching it after the code
+underneath has been rewritten by people who never read the promise. So build it against the
+behavior, at the boundary the promise names: the request a caller sends, the command a person runs,
+the row that ends up written, the page that renders. Reach the product through the entry point its
+users reach it through, never through a helper you found while reading the source, and never through
+a copy of the product's logic written into the check. A copy passes forever while the product drifts
+underneath it.
+
+Assert what the promise's cases say and nothing more. Each passing case states a property; check
+that property. Each failing case names an outcome that must not happen; make the check refuse
+exactly that. Do not pin whole outputs, orderings the promise lets vary, or values the owner never
+mentioned: every one of those becomes a red the owner is told to act on when the behavior has not
+broken.
+
+The refactor control is where a brittle check shows itself. It must be a genuine restructuring of
+the same behavior, moved, renamed or reimplemented, with the same observable outcome, reached
+through the same interface the check uses to reach the product. If you cannot write it without also
+editing the check, the check is bound to an implementation rather than to the promise, and what
+needs fixing is the check. The known-bad control must be the failure the owner wrote down, not the
+check sabotaging itself.
+
+Where the repository's own test runner already reaches the behavior, run it through the declared
+result protocol rather than writing a second harness: the existing suite is the one the team will
+keep maintaining. And when a check cannot reach a verdict, say so. A check that could not run reads
+Unknown, which is honest, and never as a pass, which is not.`;
+var PRE_PUSH_JUDGE = `### Before you push, try to break it
+
+The sealed check runs in CI, after the fact. The cheapest moment to catch a broken promise is before
+the push, on the machine where the change can still be fixed, and the way to catch it is not to
+reread your own diff. Find the promises the change touches: balladeer affected <paths> where this
+repository has a touch map, otherwise the leads discover_intent gave you for those paths. For each
+one that has a linked test or a sealed check, run it first; a test named for the promise is the
+fastest verdict there is, and the runner's run-one-target command prints the four facts a red check
+carries.
+
+Then, for every promise the change touches, checked or not, spawn a fresh agent that has not seen
+your change or your reasoning, however your host spawns one, and hand it three things and nothing
+else: the promise as get_promise returns it, the changed files, and the brief below. Not the
+pull-request description and not your notes. One agent per promise; a judge handed six promises at
+once holds none of them. If your host cannot spawn one, work through the brief yourself in a fresh
+context after the work is finished, and say that you did.
+
+The brief, verbatim: "You are checking one promise against one change. Read the promise's cases
+first. Then find out, by running things, whether the change keeps it. You may report broken only
+with a reproduction: a command or test that fails with this change and passes without it, which
+you have run both ways. You may report kept only after you have exercised each of the promise's
+passing cases against the changed code. Anything else you report as could not tell, with what
+stopped you. Do not take the author's word for anything, read code rather than descriptions, and
+name the promise, never the person."
+
+What to do with the answer. Broken, with a reproduction: fix the behavior before pushing, keep the
+reproduction, and offer to carry it into the sealed check as a failing case, which means re-sealing
+and re-qualifying, so ask before you do. Kept: say so in one line, naming the promise. Could not
+tell: say that, in those words; it is not a pass. None of this is protection, and none of it reaches
+Balladeer on its own. Protection is the sealed check qualifying in CI. This is the check you run so
+that CI has nothing to find.`;
 var SETTLING_QUESTIONS = `### When somebody says "tell me about" one
 
 An id is how a person points at something here. Expand a promise id with get_promise and a proposal
@@ -2888,6 +3079,10 @@ especially: it is Balladeer's word for a proposal, so it reads as jargon whateve
 
 ${SESSION_BEHAVIORS}
 
+${VERIFIER_SHAPE}
+
+${PRE_PUSH_JUDGE}
+
 ${SETTLING_QUESTIONS}
 
 ${SEALED_FILES}
@@ -2962,7 +3157,7 @@ function readRegular(path, allowMissing = false, writable = true) {
   const stat = lstatSync4(path);
   if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_FILE || writable && (stat.mode & 146) === 0)
     throw new Error("file_not_safely_writable");
-  return readFileSync6(path, "utf8");
+  return readFileSync7(path, "utf8");
 }
 function safeParent(root, path) {
   let at = dirname4(path);
@@ -2984,7 +3179,7 @@ function validateProjectGuidanceScope(options) {
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 1e3
     }).trim();
-    const path = join6(root, options.hook === "codex" ? ".codex/config.toml" : ".mcp.json");
+    const path = join7(root, options.hook === "codex" ? ".codex/config.toml" : ".mcp.json");
     safeParent(root, path);
     readRegular(path, false, false);
     const entry = options.hook === "codex" ? readCodexEntry(root) : currentEntry(readMcpConfig(root));
@@ -3098,31 +3293,52 @@ function repositoryHints(cwd = process.cwd()) {
 }
 
 // src/hook-trust.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "node:fs";
-import { join as join7 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync8, rmSync, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join8 } from "node:path";
+var HOSTS_REQUIRING_TRUST = ["codex"];
 var FILE = "hook-trust.json";
+var key = (host, set) => set === "guidance" ? host : `${host}:${set}`;
 function read(environment) {
   try {
-    const parsed = JSON.parse(readFileSync7(join7(configHome(environment), FILE), "utf8"));
+    const parsed = JSON.parse(readFileSync8(join8(configHome(environment), FILE), "utf8"));
     return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
   }
 }
+function pushCheckAwaitingFile(environment, host) {
+  return join8(configHome(environment), `${host}-push-check-awaiting-first-run`);
+}
+function forget(path) {
+  try {
+    rmSync(path, { force: true });
+  } catch {
+  }
+}
 function write(environment, marks) {
   try {
-    mkdirSync6(configHome(environment), { recursive: true, mode: 448 });
-    writeFileSync4(join7(configHome(environment), FILE), JSON.stringify(marks) + "\n", {
+    mkdirSync7(configHome(environment), { recursive: true, mode: 448 });
+    writeFileSync5(join8(configHome(environment), FILE), JSON.stringify(marks) + "\n", {
       mode: 384
     });
+    for (const host of HOSTS_REQUIRING_TRUST) {
+      const file = pushCheckAwaitingFile(environment, host);
+      if (awaiting(marks[key(host, "push-check")])) writeFileSync5(file, "", { mode: 384 });
+      else forget(file);
+    }
   } catch {
   }
 }
-function noteHookFired(environment, host, now = Date.now()) {
+function noteHookFired(environment, host, now = Date.now(), set = "guidance") {
+  if (set === "push-check") forget(pushCheckAwaitingFile(environment, host));
   const marks = read(environment);
-  const mark = marks[host];
+  const mark = marks[key(host, set)];
   if (mark?.firedAt !== void 0 && mark.firedAt >= (mark.writtenAt ?? 0)) return;
-  write(environment, { ...marks, [host]: { ...mark, firedAt: now } });
+  write(environment, { ...marks, [key(host, set)]: { ...mark, firedAt: now } });
+}
+function awaiting(mark) {
+  if (mark?.writtenAt === void 0) return false;
+  return mark.firedAt === void 0 || mark.firedAt < mark.writtenAt;
 }
 
 // src/commands/guidance.ts
@@ -3167,7 +3383,45 @@ function eventFrom(input) {
 function identifier(input) {
   return typeof input === "string" && input.length > 0 && input.length <= 256 ? input : void 0;
 }
+async function runRelayNote(options) {
+  const input = await new Promise((resolve2) => {
+    const chunks = [];
+    let bytes = 0;
+    let settled = false;
+    const done = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      options.stdin.removeListener("data", data);
+      resolve2(value);
+    };
+    const data = (chunk) => {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      bytes += buffer.length;
+      if (bytes > 1048576) done(void 0);
+      else chunks.push(buffer);
+    };
+    const timer = setTimeout(() => done(void 0), 1e3);
+    options.stdin.on("data", data);
+    options.stdin.once("end", () => {
+      try {
+        done(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+      } catch {
+        done(void 0);
+      }
+    });
+    options.stdin.once("error", () => done(void 0));
+  });
+  if (!input || typeof input !== "object" || Array.isArray(input)) return 0;
+  const record = input;
+  if (record.hook_event_name !== "PostToolUse") return 0;
+  const out = relayHook(record);
+  if (out) options.write(`${out}
+`);
+  return 0;
+}
 async function runGuidance(options) {
+  if (options.event === "PostToolUse") return runRelayNote(options);
   const projectScoped = options.repositoryId !== void 0;
   if (projectScoped && !validateProjectGuidanceScope({
     cwd: options.cwd,