@pushary/agent-hooks 1.9.72 → 1.9.75

package/dist/{chunk-EEFFP64A.js → chunk-JFVLMWKY.js}

@@ -1,6 +1,6 @@
 import {
   repoKeyFor
-} from "./chunk-ILWEGI4H.js";
+} from "./chunk-DUOBFECC.js";
 import {
   cancelQuestion,
   clientErrorKindOf,
@@ -8,29 +8,33 @@ import {
   reportClientError,
   sendNotification,
   waitForAnswer
-} from "./chunk-DU7L7R4A.js";
+} from "./chunk-EOGVWCLF.js";
 import {
   withRetry
-} from "./chunk-E56VJY23.js";
+} from "./chunk-32JJ5KV3.js";
 import {
   getMachineId
-} from "./chunk-5XYYBB5Z.js";
+} from "./chunk-BGEUAJYL.js";
 import {
   reportedInstallSource
-} from "./chunk-ZWCKS65X.js";
+} from "./chunk-DARPCQPY.js";
 import {
   IDLE_PROMPT_NOTIFICATION,
   NOTIFICATION_PUSH_TYPES,
   POSTTOOLUSE_MIRROR_ONLY_TOOLS,
-  canonicalJson
-} from "./chunk-N4NSX5MB.js";
+  canonicalJson,
+  claudeConfigDir
+} from "./chunk-2J4IVUEA.js";
 import {
-  writeFileAtomic
-} from "./chunk-GUJBS6TK.js";
+  compareVersion,
+  parseVersion,
+  writeFileAtomic,
+  writeJsonAtomicDurable
+} from "./chunk-AUDYAVNM.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-BMVWGPYB.js";
+} from "./chunk-53D6FFVE.js";
 import {
   ACTION_BODY_MAX,
   AGENTS,
@@ -38,25 +42,30 @@ import {
   BLANK_TASK_INPUT_TOOL,
   BLOCKED_ACTION_GRANT_TTL_SECONDS,
   CODEX_SHELL_COMMAND_FLAGS,
+  COMMAND_RECOVERY,
   DECISION_LINE_MAX,
   FILE_TARGET_TOOLS,
   GATE_MAX_TOOL_INPUTS,
   HOOK_COMPATIBLE_PROFILES,
   HOOK_SOURCES,
-  PENDING_COMMAND_PREFIX,
   REPO_AWARE_AGENTS,
   TASK_OUTPUT_TOOL,
   TASK_STOP_TOOL,
   blockedActionIdentity,
+  canCarryPendingCommand,
   canonicalToolName,
+  claudeTurnEndOutput,
   conversationText,
   gateOutputFor,
   hookCompatibleProfileBySource,
   isAutoApprove,
+  isRecord,
   isTokenCount,
   modeStateFromResponse,
+  nativeRecord,
   parseMcpToolName,
   pendingCommandEvents,
+  pendingCommandInstruction,
   questionLimitHandBack,
   redactSecrets,
   redactSecretsDeep,
@@ -66,7 +75,7 @@ import {
   toToolLookup,
   truncateLine,
   unansweredRefusalReason
-} from "./chunk-5XKJH5GD.js";
+} from "./chunk-QRS7FQHE.js";
 
 // ../hook-mapping/src/describe.ts
 import { isAbsolute, relative, resolve } from "path";
@@ -844,7 +853,7 @@ var transcriptUsageRequest = (hook) => {
 import { join } from "path";
 import { homedir, tmpdir } from "os";
 import { createHash } from "crypto";
-import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, renameSync, unlinkSync, rmSync, statSync } from "fs";
+import { openSync, closeSync, fsyncSync, lstatSync, existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync, unlinkSync, rmSync, statSync } from "fs";
 var PENDING_DIR = join(tmpdir(), "pushary-pending");
 var commandRoot = () => process.env.PUSHARY_COMMAND_DIR?.trim() || join(homedir(), ".pushary", "run", "commands");
 var DEFAULT_SESSION = "_no_session";
@@ -860,16 +869,23 @@ var legacyCommandFile = (sessionId, namespace = "") => join(commandDirFor(sessio
 var commandFile = (sessionId, id, namespace = "") => join(commandDirFor(sessionId, namespace), `${createHash("sha256").update(id).digest("hex")}.json`);
 var readCommandFile = (file) => {
   try {
+    if (!lstatSync(file).isFile()) return null;
     const value = JSON.parse(readFileSync(file, "utf-8"));
-    if (typeof value.id !== "string" || typeof value.text !== "string" || typeof value.expiresAtMs !== "number") return null;
-    if (value.expiresAtMs <= Date.now()) {
+    if (!nativeRecord(value) || typeof value.id !== "string" || typeof value.text !== "string" || typeof value.expiresAtMs !== "number" || !Number.isFinite(value.expiresAtMs)) return null;
+    if (value.expiresAtMs + COMMAND_RECOVERY.receiptRetentionMs <= Date.now()) {
       unlinkSync(file);
+      rmSync(`${file}.emission`, { force: true });
       return null;
     }
     return {
-      ...value,
+      id: value.id,
+      text: value.text,
+      expiresAtMs: value.expiresAtMs,
+      ...value.attempted === true ? { attempted: true } : {},
+      ...typeof value.attemptedAtMs === "number" ? { attemptedAtMs: value.attemptedAtMs } : {},
+      ...typeof value.sessionId === "string" ? { sessionId: value.sessionId } : {},
       delivered: value.delivered === true,
-      ...value.failed === true ? { failed: true } : {}
+      ...value.failed === true || !value.delivered && !value.attempted && value.expiresAtMs <= Date.now() ? { failed: true } : {}
     };
   } catch {
     return null;
@@ -915,7 +931,7 @@ var pruneExpiredCommandStore = () => {
 };
 var readPendingCommand = (sessionId, namespace = "") => {
   const commands = pruneExpiredCommands(commandDirFor(sessionId, namespace));
-  return commands.find((command) => !command.delivered && !command.failed) ?? commands[0] ?? null;
+  return commands.find((command) => !command.delivered && !command.failed && !command.attempted) ?? commands[0] ?? null;
 };
 var savePendingCommand = (sessionId, command, namespace = "") => {
   const dir = commandDirFor(sessionId, namespace);
@@ -923,7 +939,21 @@ var savePendingCommand = (sessionId, command, namespace = "") => {
     mkdirSync(dir, { recursive: true, mode: 448 });
     pruneExpiredCommandStore();
     if (readPendingCommandById(sessionId, command.id, namespace)) return false;
-    writeFileSync(commandFile(sessionId, command.id, namespace), JSON.stringify(command), { encoding: "utf-8", mode: 384, flag: "wx" });
+    writeFileSync(commandFile(sessionId, command.id, namespace), JSON.stringify({ ...command, sessionId }), { encoding: "utf-8", mode: 384, flag: "wx" });
+    const descriptor = openSync(commandFile(sessionId, command.id, namespace), "r");
+    try {
+      fsyncSync(descriptor);
+    } finally {
+      closeSync(descriptor);
+    }
+    if (process.platform !== "win32") {
+      const directory = openSync(dir, "r");
+      try {
+        fsyncSync(directory);
+      } finally {
+        closeSync(directory);
+      }
+    }
     return true;
   } catch {
     return false;
@@ -934,19 +964,36 @@ var updatePendingCommand = (sessionId, id, update, namespace = "") => {
   if (!command) return false;
   const currentFile = commandFile(sessionId, id, namespace);
   const file = existsSync(currentFile) ? currentFile : legacyCommandFile(sessionId, namespace);
-  const temporary = `${file}.${process.pid}.tmp`;
   try {
-    writeFileSync(temporary, JSON.stringify({ ...command, ...update, text: "" }), { encoding: "utf-8", mode: 384 });
-    renameSync(temporary, file);
+    writeJsonAtomicDurable(file, { ...command, ...update, text: "" }, 384);
     return true;
   } catch {
+    return false;
+  }
+};
+var markPendingCommandAttempted = (sessionId, id, namespace = "") => {
+  const command = readPendingCommandById(sessionId, id, namespace);
+  if (!command || command.attempted || command.delivered || command.failed) return false;
+  try {
+    const descriptor = openSync(`${commandFile(sessionId, id, namespace)}.emission`, "wx", 384);
     try {
-      unlinkSync(temporary);
-    } catch {
+      fsyncSync(descriptor);
+    } finally {
+      closeSync(descriptor);
     }
+    return updatePendingCommand(sessionId, id, { attempted: true, attemptedAtMs: Date.now() }, namespace);
+  } catch {
     return false;
   }
 };
+var pendingCommandReceipts = (namespace) => {
+  const root = join(commandRoot(), createHash("sha256").update(namespace).digest("hex").slice(0, 16));
+  try {
+    return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => pruneExpiredCommands(join(root, entry.name)).filter((command) => command.delivered || command.failed || command.attempted && Date.now() - (command.attemptedAtMs ?? 0) >= COMMAND_RECOVERY.emissionRecoveryGraceMs).map((command) => ({ sessionId: command.sessionId ?? entry.name, command })));
+  } catch {
+    return [];
+  }
+};
 var markPendingCommandDelivered = (sessionId, id, namespace = "") => updatePendingCommand(sessionId, id, { delivered: true, failed: void 0 }, namespace);
 var markPendingCommandFailed = (sessionId, id, namespace = "") => updatePendingCommand(sessionId, id, { delivered: false, failed: true }, namespace);
 var removePendingCommand = (sessionId, id, namespace = "") => {
@@ -955,6 +1002,10 @@ var removePendingCommand = (sessionId, id, namespace = "") => {
     unlinkSync(commandFile(sessionId, id, namespace));
   } catch {
   }
+  try {
+    rmSync(`${commandFile(sessionId, id, namespace)}.emission`, { force: true });
+  } catch {
+  }
   try {
     if (readCommandFile(legacyCommandFile(sessionId, namespace))?.id === id) {
       unlinkSync(legacyCommandFile(sessionId, namespace));
@@ -1011,6 +1062,48 @@ var removePendingSession = (sessionId) => {
   }
 };
 
+// src/hook-command-delivery.ts
+import { AsyncLocalStorage } from "async_hooks";
+var delivery = new AsyncLocalStorage();
+var stageHookCommand = (command) => {
+  const staged = delivery.getStore();
+  if (!staged) return false;
+  staged.push(command);
+  return true;
+};
+var writeOutput = (output) => new Promise((resolve3, reject) => {
+  process.stdout.write(output, (error) => error ? reject(error) : resolve3());
+});
+var emitHookOutput = async (render, write = writeOutput) => {
+  const staged = [];
+  const output = await delivery.run(staged, render);
+  if (!output) return;
+  for (const command of staged) {
+    if (!markPendingCommandAttempted(
+      command.sessionId,
+      command.commandId,
+      command.namespace
+    )) {
+      throw new Error("Could not persist instruction delivery intent");
+    }
+  }
+  await write(output);
+  for (const command of staged) {
+    if (!markPendingCommandDelivered(
+      command.sessionId,
+      command.commandId,
+      command.namespace
+    ))
+      continue;
+    if (await command.acknowledge())
+      removePendingCommand(
+        command.sessionId,
+        command.commandId,
+        command.namespace
+      );
+  }
+};
+
 // src/policy.ts
 import { createHash as createHash2 } from "crypto";
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
@@ -1155,7 +1248,7 @@ var fetchModeState = async (apiKey, sessionId, reuseWithinMs = 0, signal) => {
 var fetchModeOverride = async (apiKey) => (await fetchModeState(apiKey)).mode;
 
 // src/usage.ts
-import { closeSync, mkdirSync as mkdirSync2, openSync, readFileSync as readFileSync3, readSync, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
+import { closeSync as closeSync2, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync3, readSync, statSync as statSync2, writeFileSync as writeFileSync3 } from "fs";
 import { createHash as createHash3 } from "crypto";
 import { join as join3 } from "path";
 import { tmpdir as tmpdir3 } from "os";
@@ -1191,7 +1284,7 @@ var readState = (path) => {
   return emptyState();
 };
 var readRange = (path, start, end) => {
-  const fd = openSync(path, "r");
+  const fd = openSync2(path, "r");
   try {
     const chunks = [];
     let position = start;
@@ -1205,7 +1298,7 @@ var readRange = (path, start, end) => {
     }
     return Buffer.concat(chunks);
   } finally {
-    closeSync(fd);
+    closeSync2(fd);
   }
 };
 var applyLine = (state, line) => {
@@ -1582,14 +1675,78 @@ var forgetBlockedActionHint = (fingerprint) => {
   }
 };
 
+// src/claude-session-record.ts
+import { readFileSync as readFileSync6, readdirSync as readdirSync4, statSync as statSync6 } from "fs";
+import { join as join7 } from "path";
+var UNREADABLE = { kind: "unreadable" };
+var OTHER_SESSION = { kind: "other_session" };
+var PROCESS_ID = /^[1-9]\d*$/;
+var SESSION_FILE_SUFFIX = ".json";
+var SESSION_FILE_MAX_BYTES = 64 * 1024;
+var isRunning = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error instanceof Error && "code" in error && error.code === "EPERM";
+  }
+};
+var isSmallRegularFile = (path) => {
+  try {
+    const stats = statSync6(path);
+    return stats.isFile() && stats.size <= SESSION_FILE_MAX_BYTES;
+  } catch {
+    return false;
+  }
+};
+var readSessionFile = (path, sessionId) => {
+  if (!isSmallRegularFile(path)) return UNREADABLE;
+  try {
+    const parsed = JSON.parse(readFileSync6(path, "utf-8"));
+    if (!isRecord(parsed) || typeof parsed.sessionId !== "string") return UNREADABLE;
+    if (parsed.sessionId !== sessionId) return OTHER_SESSION;
+    return { kind: "this_session", version: typeof parsed.version === "string" ? parsed.version : null };
+  } catch {
+    return UNREADABLE;
+  }
+};
+var runningSessionFiles = (sessions) => {
+  try {
+    return readdirSync4(sessions).filter((name) => name.endsWith(SESSION_FILE_SUFFIX)).map((name) => name.slice(0, -SESSION_FILE_SUFFIX.length)).filter((pid) => PROCESS_ID.test(pid) && isRunning(Number(pid))).map((pid) => join7(sessions, `${pid}${SESSION_FILE_SUFFIX}`));
+  } catch {
+    return [];
+  }
+};
+var parsedSessionVersion = (version) => {
+  const release = version === null ? null : parseVersion(version);
+  return version === null || release === null ? null : { version, release };
+};
+var isParsed = (entry) => entry !== null;
+var lowerVersion = (lowest, entry) => compareVersion(entry.release, lowest.release) < 0 ? entry : lowest;
+var oldestVersionAcross = (readings) => {
+  if (readings.some((reading) => reading.kind === "unreadable")) return null;
+  const parsed = readings.flatMap((reading) => reading.kind === "this_session" ? [reading.version] : []).map(parsedSessionVersion);
+  if (parsed.length === 0 || !parsed.every(isParsed)) return null;
+  return parsed.filter(isParsed).reduce(lowerVersion).version;
+};
+var claudeSessionVersion = (sessionId, environment = process.env) => {
+  if (!sessionId) return null;
+  try {
+    const sessions = join7(claudeConfigDir(void 0, environment), "sessions");
+    return oldestVersionAcross(runningSessionFiles(sessions).map((path) => readSessionFile(path, sessionId)));
+  } catch {
+    return null;
+  }
+};
+
 // src/background-work.ts
 import { createHash as createHash7 } from "crypto";
-import { mkdirSync as mkdirSync6, rmSync as rmSync5, statSync as statSync6, writeFileSync as writeFileSync6 } from "fs";
+import { mkdirSync as mkdirSync6, rmSync as rmSync5, statSync as statSync7, writeFileSync as writeFileSync6 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 var BACKGROUND_WORK_TTL_MS = 60 * 60 * 1e3;
-var backgroundWorkDir = () => join7(tmpdir7(), "pushary-background-work");
-var markerFor = (sessionKey) => join7(backgroundWorkDir(), createHash7("sha256").update(sessionKey).digest("hex"));
+var backgroundWorkDir = () => join8(tmpdir7(), "pushary-background-work");
+var markerFor = (sessionKey) => join8(backgroundWorkDir(), createHash7("sha256").update(sessionKey).digest("hex"));
 var hasRunningBackgroundTasks = (backgroundTasks) => Array.isArray(backgroundTasks) && backgroundTasks.length > 0;
 var noteBackgroundWork = (sessionKey, running) => {
   try {
@@ -1605,21 +1762,21 @@ var noteBackgroundWork = (sessionKey, running) => {
 };
 var isWaitingOnBackgroundWork = (sessionKey, nowMs = Date.now()) => {
   try {
-    return nowMs - statSync6(markerFor(sessionKey)).mtimeMs < BACKGROUND_WORK_TTL_MS;
+    return nowMs - statSync7(markerFor(sessionKey)).mtimeMs < BACKGROUND_WORK_TTL_MS;
   } catch {
     return false;
   }
 };
 
 // src/events.ts
-import { basename as basename2, join as join8 } from "path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync6, statSync as statSync7, writeFileSync as writeFileSync7 } from "fs";
+import { basename as basename2, join as join9 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync7, statSync as statSync8, writeFileSync as writeFileSync7 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
-var INTENT_DIR = join8(tmpdir8(), "pushary-intent");
+var INTENT_DIR = join9(tmpdir8(), "pushary-intent");
 var INTENT_MAX_BYTES = 2048;
 var INTENT_GRACE_MS = 10 * 60 * 1e3;
 var sanitizeSession = (sessionId) => sessionId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 128) || DEFAULT_SESSION;
-var intentFile = (sessionId) => join8(INTENT_DIR, sanitizeSession(sessionId));
+var intentFile = (sessionId) => join9(INTENT_DIR, sanitizeSession(sessionId));
 var saveLastPrompt = (sessionId, prompt) => {
   try {
     const trimmed = prompt.replace(/\s+/g, " ").trim().slice(0, INTENT_MAX_BYTES);
@@ -1632,8 +1789,8 @@ var saveLastPrompt = (sessionId, prompt) => {
 var readLastPrompt = (sessionId) => {
   try {
     const path = intentFile(sessionId);
-    if (isDefaultSession(sessionId) && statSync7(path).mtimeMs < Date.now() - INTENT_GRACE_MS) return void 0;
-    const value = readFileSync6(path, "utf-8").trim();
+    if (isDefaultSession(sessionId) && statSync8(path).mtimeMs < Date.now() - INTENT_GRACE_MS) return void 0;
+    const value = readFileSync7(path, "utf-8").trim();
     return value.length > 0 ? value : void 0;
   } catch {
     return void 0;
@@ -1698,7 +1855,7 @@ var readFreshCachedPolicy = (apiKey, agentType, sessionId) => {
   const request = policyRequestFor(agentType);
   const path = policyCacheFile(apiKey, request.agent, request.repoAware);
   if (!existsSync6(path)) return null;
-  const cached = JSON.parse(readFileSync6(path, "utf-8"));
+  const cached = JSON.parse(readFileSync7(path, "utf-8"));
   if (!isPolicyConfig(cached)) return null;
   if ((cached._sessionId ?? null) !== (sessionId ?? null)) return null;
   if (!cached._cachedAt || Date.now() - cached._cachedAt >= POLICY_CACHE_TTL_MS) return null;
@@ -1741,8 +1898,9 @@ var deriveAutoDecisionBeacon = (toolName, toolInput, liveMode, agentType, cwd, s
 };
 var AUTO_DECISION_WINDOW_MS = 15 * 60 * 1e3;
 var HOOK_ACTIVE_WINDOW_MS = 30 * 60 * 1e3;
+var hookSourceOfAgentType = (agentType) => HOOK_SOURCES.find((candidate) => AGENT_IDENTITIES[candidate].type === agentType);
 var deriveUsage = (payload, agent, event) => {
-  const source = HOOK_SOURCES.find((candidate) => AGENT_IDENTITIES[candidate].type === agent.type);
+  const source = hookSourceOfAgentType(agent.type);
   const request = source ? transcriptUsageRequest({ source, event, payload, costTracking: process.env[COST_TRACKING_ENV] }) : null;
   if (!request) return void 0;
   try {
@@ -1751,16 +1909,19 @@ var deriveUsage = (payload, agent, event) => {
     return void 0;
   }
 };
-var mergeAdditionalContext = (existing, reported) => {
+var pendingInstructionOf = (reported) => {
   const pendingCommand = reported.status === "fulfilled" ? reported.value?.pendingCommand : void 0;
-  if (typeof pendingCommand !== "string" || pendingCommand.trim().length === 0) return existing;
-  const injected = `${PENDING_COMMAND_PREFIX} ${pendingCommand.trim()}`;
+  return typeof pendingCommand === "string" ? pendingCommandInstruction(pendingCommand) : void 0;
+};
+var mergeAdditionalContext = (existing, reported) => {
+  const injected = pendingInstructionOf(reported);
+  if (injected === void 0) return existing;
   return existing ? `${existing}
 
 ${injected}` : injected;
 };
 var consumesActivityContext = (agentType) => {
-  const source = HOOK_SOURCES.find((candidate) => AGENT_IDENTITIES[candidate].type === agentType);
+  const source = hookSourceOfAgentType(agentType);
   if (!source) return false;
   return pendingCommandEvents(source).some((event) => event !== "Stop");
 };
@@ -1841,6 +2002,13 @@ var reportEvent = async (event, options = {}) => {
       const result = await res.json();
       const withoutPending = () => ({ ...result, pendingCommand: void 0, pendingCommandId: void 0 });
       if (storedCommand) {
+        if (storedCommand.attempted && !storedCommand.delivered && Date.now() - (storedCommand.attemptedAtMs ?? 0) < COMMAND_RECOVERY.emissionRecoveryGraceMs) return withoutPending();
+        if (!storedCommand.delivered && !storedCommand.failed && !storedCommand.attempted && stageHookCommand({
+          sessionId: sessionKey,
+          commandId: storedCommand.id,
+          namespace: receiptNamespace,
+          acknowledge: () => acknowledgePendingCommand(apiKey, baseUrl, storedCommand.id, event.sessionId, machineId, ACK_RESERVE_MS)
+        })) return { ...withoutPending(), pendingCommand: storedCommand.text, pendingCommandId: storedCommand.id };
         const failed = storedCommand.failed === true;
         const acknowledged = await acknowledgePendingCommand(
           apiKey,
@@ -1849,11 +2017,11 @@ var reportEvent = async (event, options = {}) => {
           event.sessionId,
           machineId,
           ackTimeoutMs(options.timeoutMs ?? 1e4),
-          failed ? "failed" : "delivered",
+          failed ? "failed" : storedCommand.attempted && !storedCommand.delivered ? "uncertain" : "delivered",
           options.signal
         );
         if (!acknowledged) return withoutPending();
-        if (storedCommand.delivered || failed) {
+        if (storedCommand.delivered || storedCommand.attempted || failed) {
           removePendingCommand(sessionKey, storedCommand.id, receiptNamespace);
           return withoutPending();
         }
@@ -1868,6 +2036,13 @@ var reportEvent = async (event, options = {}) => {
           delivered: false
         }, receiptNamespace);
         if (!saved) return withoutPending();
+        const commandId = result.pendingCommandId;
+        if (stageHookCommand({
+          sessionId: sessionKey,
+          commandId,
+          namespace: receiptNamespace,
+          acknowledge: () => acknowledgePendingCommand(apiKey, baseUrl, commandId, event.sessionId, machineId, ACK_RESERVE_MS)
+        })) return result;
         const acknowledged = await acknowledgePendingCommand(
           apiKey,
           baseUrl,
@@ -1998,7 +2173,10 @@ var handleUserPrompt = async (input, agent = CLAUDE_CODE_AGENT) => {
   }
 };
 var UNUSED_APPROVAL_INSTRUCTION = "The person allowed, from Pushary, the call auto mode blocked. Send that call again now, exactly as it was with nothing changed, to use their approval. It covers only that exact call.";
-var phoneInstructionOf = (pendingCommand) => typeof pendingCommand === "string" && pendingCommand.trim().length > 0 ? `The user sent a new instruction from their phone via Pushary: ${pendingCommand.trim()}` : null;
+var carriesInstructionAtTurnEnd = (agentType) => {
+  const source = hookSourceOfAgentType(agentType);
+  return source !== void 0 && canCarryPendingCommand(source, "Stop");
+};
 var handleStop = async (input, agent = CLAUDE_CODE_AGENT) => {
   const deadline = Date.now() + HOOK_BUDGET_MS;
   const signal = AbortSignal.timeout(HOOK_BUDGET_MS);
@@ -2007,6 +2185,7 @@ var handleStop = async (input, agent = CLAUDE_CODE_AGENT) => {
     const sessionKey = input.session_id || DEFAULT_SESSION;
     noteBackgroundWork(sessionKey, hasRunningBackgroundTasks(input.background_tasks));
     const late = await reconcilePendingQuestions(sessionKey, void 0, signal);
+    const carriesInstruction = carriesInstructionAtTurnEnd(agent.type);
     const tasks = [
       reportEvent({
         event: "session_end",
@@ -2015,7 +2194,12 @@ var handleStop = async (input, agent = CLAUDE_CODE_AGENT) => {
         action: summarizeStop(input),
         ...sessionIdentityOf(input),
         usage: deriveUsage(input, agent, "Stop")
-      }, { maxAttempts: 1, budgetMs: Math.min(DRAINING_REPORT_BUDGET_MS, Math.max(0, deadline - Date.now())), signal })
+      }, {
+        maxAttempts: 1,
+        budgetMs: Math.min(DRAINING_REPORT_BUDGET_MS, Math.max(0, deadline - Date.now())),
+        signal,
+        skipDrain: !carriesInstruction
+      })
     ];
     if (late.length > 0) {
       tasks.push(notifyLateAnswers(getApiKey(), late, `${agent.label} - ${projectName}`, input.session_id, signal));
@@ -2023,10 +2207,13 @@ var handleStop = async (input, agent = CLAUDE_CODE_AGENT) => {
     }
     if (!isDefaultSession(sessionKey) && listPendingQuestions(sessionKey).length === 0) removePendingSession(sessionKey);
     const [reported] = await Promise.allSettled(tasks);
-    const pendingCommand = reported.status === "fulfilled" ? reported.value?.pendingCommand : void 0;
     const unusedApproval = !input.stop_hook_active && approvalAwaitingRetry(input.session_id) !== null;
-    const instructions = [unusedApproval ? UNUSED_APPROVAL_INSTRUCTION : null, phoneInstructionOf(pendingCommand)].filter((instruction) => instruction !== null);
-    return instructions.length > 0 ? { decision: "block", reason: instructions.join("\n\n") } : void 0;
+    const instruction = carriesInstruction ? pendingInstructionOf(reported) : void 0;
+    return claudeTurnEndOutput({
+      instruction,
+      continueReason: unusedApproval ? UNUSED_APPROVAL_INSTRUCTION : void 0,
+      claudeVersion: instruction === void 0 ? null : claudeSessionVersion(input.session_id)
+    });
   } catch {
     return void 0;
   }
@@ -2217,14 +2404,16 @@ export {
   isCodexGuardianRolloutHead,
   scanCodexGuardianReviews,
   codexReviewerDenialsSince,
-  phoneDrivenEnv,
   DEFAULT_SESSION,
   readPendingCommandById,
   readPendingCommand,
   savePendingCommand,
+  pendingCommandReceipts,
   markPendingCommandDelivered,
   markPendingCommandFailed,
   removePendingCommand,
+  emitHookOutput,
+  phoneDrivenEnv,
   claimThrottle,
   releaseThrottle,
   policyRequestFor,

package/dist/{chunk-5KS3E3T5.js → chunk-JOMG6J64.js}

@@ -7,7 +7,7 @@ import {
   recordSealerFor,
   uploadTranscriptRecords,
   wrapSessionKey
-} from "./chunk-CAUNUTYE.js";
+} from "./chunk-SONZCJY5.js";
 
 // src/live-session.ts
 var MAX_TRANSCRIPT_QUEUE = 100;

package/dist/{chunk-EEQG7VF2.js → chunk-KDUWFGY2.js}

@@ -1,9 +1,9 @@
 import {
   realpath
-} from "./chunk-S6BD346V.js";
+} from "./chunk-QDUDXJAF.js";
 import {
   findNativeClaudeInstall
-} from "./chunk-LFBQ55OO.js";
+} from "./chunk-R7V6BPEV.js";
 import {
   readGlobalPrefixAsync,
   resolveGlobalBinary,
@@ -13,10 +13,10 @@ import {
   resolvePackageVersionFromBinary,
   resolvePathBinary,
   resolvePathBinaryAsync
-} from "./chunk-GUJBS6TK.js";
+} from "./chunk-AUDYAVNM.js";
 import {
   MANAGED_PROVIDERS
-} from "./chunk-5XKJH5GD.js";
+} from "./chunk-QRS7FQHE.js";
 
 // src/live-capabilities.ts
 import { homedir } from "os";

package/dist/{chunk-6YZ72YP3.js → chunk-LIDUPDEY.js}

@@ -1,19 +1,19 @@
 import {
   resolveInstallSourceFor
-} from "./chunk-ZWCKS65X.js";
+} from "./chunk-DARPCQPY.js";
 import {
   backupFile,
   readJsonSafe,
   writeFileAtomic,
   writeJsonAtomic
-} from "./chunk-GUJBS6TK.js";
+} from "./chunk-AUDYAVNM.js";
 import {
   configFilePath
-} from "./chunk-BMVWGPYB.js";
+} from "./chunk-53D6FFVE.js";
 import {
   API_KEY_PREFIX_PATTERN,
   isRecord
-} from "./chunk-5XKJH5GD.js";
+} from "./chunk-QRS7FQHE.js";
 
 // src/shell-alias.ts
 import { homedir } from "os";

package/dist/{chunk-DNCEZWRC.js → chunk-LRYZXY4V.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-KZERVKTD.js";
 import {
   redactSecretsFromContent
-} from "./chunk-5XKJH5GD.js";
+} from "./chunk-QRS7FQHE.js";
 
 // src/cli/json.ts
 var writeStdoutFully = (text) => new Promise((resolve, reject) => {

package/dist/{chunk-L6F62LKX.js → chunk-M7BXAWUC.js}

@@ -3,11 +3,11 @@ import {
 } from "./chunk-POFBE6ZY.js";
 import {
   autoUpdateState
-} from "./chunk-N4NSX5MB.js";
+} from "./chunk-2J4IVUEA.js";
 import {
   readJsonSafe,
   writeJsonAtomic
-} from "./chunk-GUJBS6TK.js";
+} from "./chunk-AUDYAVNM.js";
 import {
   CLI_PACKAGE_NAMES,
   POSIX_GLOBAL_ROOT_SEGMENTS,
@@ -17,7 +17,7 @@ import {
 } from "./chunk-QTOLNRET.js";
 import {
   isAutoUpdateResult
-} from "./chunk-5XKJH5GD.js";
+} from "./chunk-QRS7FQHE.js";
 
 // src/auto-update.ts
 import { spawn } from "child_process";