balladeer 1.0.16 → 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.16";
+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)
@@ -3032,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);
@@ -3054,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));
@@ -3168,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
@@ -3237,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,