pushary 1.8.0

package/dist/chunk-XHKBHWLX.js

@@ -0,0 +1,14 @@
+// src/wrapper/spawnClaude.ts
+import { spawn } from "child_process";
+var needsShell = (binary, platform = process.platform) => platform === "win32" && /\.(cmd|bat)$/i.test(binary);
+var spawnClaude = (binary, args, options) => {
+  if (needsShell(binary)) {
+    return spawn(`"${binary}"`, args, { ...options, shell: true });
+  }
+  return spawn(binary, args, options);
+};
+
+export {
+  needsShell,
+  spawnClaude
+};

package/dist/chunk-ZSZSSJCV.js

@@ -0,0 +1,275 @@
+import {
+  pusharyDir
+} from "./chunk-A2A2YTMG.js";
+import {
+  readJsonSafe
+} from "./chunk-T7E75EKA.js";
+
+// src/process-ownership.ts
+import { createHash, randomUUID } from "crypto";
+import { mkdirSync, readdirSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { createConnection, createServer } from "net";
+import { join } from "path";
+var MAX_PROOF_BYTES = 1024;
+var ownershipDir = (options) => options.dir ?? join(pusharyDir(), "processes");
+var proofPath = (dir, sessionId) => join(dir, `${createHash("sha256").update(sessionId).digest("hex")}.json`);
+var isOptionalTimestamp = (value) => value === void 0 || typeof value === "string" && Number.isFinite(Date.parse(value));
+var isProof = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const proof = value;
+  return typeof proof.sessionId === "string" && Number.isInteger(proof.pid) && proof.pid > 1 && Number.isInteger(proof.port) && proof.port > 0 && proof.port <= 65535 && typeof proof.token === "string" && proof.token.length > 0 && (proof.spawnId === void 0 || typeof proof.spawnId === "string") && isOptionalTimestamp(proof.startedAt) && isOptionalTimestamp(proof.heartbeatAt);
+};
+var removeProof = (path, token) => {
+  const current = readJsonSafe(path);
+  if (current.kind !== "ok" || current.value.token !== token) return;
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+};
+var processIsAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
+var fileTimes = (path) => {
+  try {
+    const stat = statSync(path);
+    return { createdAt: stat.birthtimeMs || stat.mtimeMs, modifiedAt: stat.mtimeMs };
+  } catch {
+    return { createdAt: 0, modifiedAt: 0 };
+  }
+};
+var parseTimestamp = (value) => {
+  if (value === void 0) return null;
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+var proofEntry = (proof, path) => {
+  const times = fileTimes(path);
+  const recordedStart = parseTimestamp(proof.startedAt);
+  const startedAt = recordedStart ?? times.createdAt;
+  return {
+    sessionId: proof.sessionId,
+    pid: proof.pid,
+    spawnId: proof.spawnId ?? null,
+    startedAt,
+    lastSeenAt: parseTimestamp(proof.heartbeatAt) ?? recordedStart ?? times.modifiedAt,
+    alive: processIsAlive(proof.pid)
+  };
+};
+var safeUnlink = (path) => {
+  try {
+    unlinkSync(path);
+  } catch {
+  }
+};
+var listProcessProofs = (options = {}) => {
+  const dir = ownershipDir(options);
+  const entries = [];
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      const path = join(dir, entry.name);
+      const stored = readJsonSafe(path);
+      if (stored.kind !== "ok" || !isProof(stored.value)) {
+        if (options.reapDead) safeUnlink(path);
+        continue;
+      }
+      const listed = proofEntry(stored.value, path);
+      if (!listed.alive && options.reapDead) safeUnlink(path);
+      entries.push(listed);
+    }
+  } catch {
+  }
+  return entries;
+};
+var pruneProofs = (dir) => {
+  listProcessProofs({ dir, reapDead: true });
+};
+var wasSpawned = (entry) => entry.spawnId !== null;
+var silentSpawnedProofs = (entries, now, silenceMs) => {
+  const freshestByPid = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    freshestByPid.set(entry.pid, Math.max(freshestByPid.get(entry.pid) ?? 0, entry.lastSeenAt));
+  }
+  const reported = /* @__PURE__ */ new Set();
+  return entries.filter((entry) => {
+    if (!entry.alive || !wasSpawned(entry) || reported.has(entry.pid)) return false;
+    if (now - (freshestByPid.get(entry.pid) ?? 0) < silenceMs) return false;
+    reported.add(entry.pid);
+    return true;
+  });
+};
+var startProcessOwnership = (identity, options = {}) => {
+  const dir = ownershipDir(options);
+  const path = proofPath(dir, identity.sessionId);
+  const token = randomUUID();
+  let stopped = false;
+  let proof = null;
+  let settleReady = () => {
+  };
+  const server = createServer((socket) => {
+    let request = "";
+    socket.setTimeout(500, () => socket.destroy());
+    socket.on("error", () => {
+    });
+    socket.on("data", (chunk) => {
+      request += String(chunk);
+      if (!proof || request.length > token.length) socket.destroy();
+      else if (request.length === token.length) {
+        if (request === token) socket.end(JSON.stringify(proof));
+        else socket.destroy();
+      }
+    });
+  });
+  server.maxConnections = 4;
+  const ready = new Promise((resolve) => {
+    settleReady = resolve;
+    const resolveOnce = () => resolve();
+    server.once("error", resolveOnce);
+    server.listen(0, "127.0.0.1", () => {
+      server.off("error", resolveOnce);
+      server.on("error", () => {
+      });
+      if (stopped) {
+        server.close();
+        resolve();
+        return;
+      }
+      const address = server.address();
+      if (!address || typeof address === "string") {
+        server.close();
+        resolve();
+        return;
+      }
+      try {
+        proof = { ...identity, port: address.port, token, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        mkdirSync(dir, { recursive: true, mode: 448 });
+        pruneProofs(dir);
+        writeFileSync(path, JSON.stringify(proof), {
+          encoding: "utf8",
+          mode: 384,
+          flag: options.exclusive ? "wx" : "w"
+        });
+        resolve();
+      } catch {
+        server.close();
+        resolve();
+      }
+    });
+  });
+  const cleanup = () => removeProof(path, token);
+  process.once("exit", cleanup);
+  return {
+    ready,
+    touch(at = Date.now()) {
+      if (stopped || !proof) return;
+      proof = { ...proof, heartbeatAt: new Date(at).toISOString() };
+      try {
+        writeFileSync(path, JSON.stringify(proof), { encoding: "utf8", mode: 384 });
+      } catch {
+      }
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      settleReady();
+      process.off("exit", cleanup);
+      server.close();
+      cleanup();
+    }
+  };
+};
+var withSpawnProcessOwnership = async (spawnId, run, options = {}) => {
+  if (!spawnId) return run();
+  const sessionId = `spawn:${spawnId}`;
+  const ownership = startProcessOwnership({
+    sessionId,
+    pid: process.pid,
+    spawnId
+  }, { ...options, exclusive: true });
+  await ownership.ready;
+  if (!await ownsLiveProcess({ sessionId, pid: process.pid, spawnId }, options)) {
+    ownership.stop();
+    throw new Error("Could not establish spawned process ownership");
+  }
+  try {
+    return await run();
+  } finally {
+    ownership.stop();
+  }
+};
+var ownsLiveProcess = async (request, options = {}) => {
+  const stored = readJsonSafe(proofPath(ownershipDir(options), request.sessionId));
+  if (stored.kind !== "ok" || !isProof(stored.value)) return false;
+  const proof = stored.value;
+  if (proof.sessionId !== request.sessionId || proof.pid !== request.pid) return false;
+  if (request.spawnId && proof.spawnId !== request.spawnId) return false;
+  return verifyProof(proof, options);
+};
+var findLiveProcessBySpawnId = async (spawnId, options = {}) => {
+  try {
+    const dir = ownershipDir(options);
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
+      const stored = readJsonSafe(join(dir, entry.name));
+      if (stored.kind !== "ok" || !isProof(stored.value) || stored.value.spawnId !== spawnId) continue;
+      if (await verifyProof(stored.value, options)) return stored.value.pid;
+    }
+  } catch {
+  }
+  return null;
+};
+var verifyProof = (proof, options) => new Promise((resolve) => {
+  let settled = false;
+  let raw = "";
+  const socket = createConnection({ host: "127.0.0.1", port: proof.port });
+  const finish = (owned) => {
+    if (settled) return;
+    settled = true;
+    socket.destroy();
+    resolve(owned);
+  };
+  socket.setTimeout(options.connectTimeoutMs ?? 500, () => finish(false));
+  socket.on("error", () => finish(false));
+  socket.on("connect", () => socket.write(proof.token));
+  socket.on("data", (chunk) => {
+    raw += String(chunk);
+    if (raw.length > MAX_PROOF_BYTES) finish(false);
+  });
+  socket.on("end", () => {
+    try {
+      const live = JSON.parse(raw);
+      finish(isProof(live) && live.token === proof.token && live.sessionId === proof.sessionId && live.pid === proof.pid && live.spawnId === proof.spawnId);
+    } catch {
+      finish(false);
+    }
+  });
+});
+
+// src/session-idle.ts
+var SESSION_IDLE_TIMEOUT_MS = 10 * 6e4;
+var SESSION_REAP_GRACE_MS = 5 * 6e4;
+var SESSION_REAP_SILENCE_MS = SESSION_IDLE_TIMEOUT_MS + SESSION_REAP_GRACE_MS;
+var idleDeadlinePassed = (idleSince, now, timeoutMs = SESSION_IDLE_TIMEOUT_MS) => idleSince !== null && now - idleSince >= timeoutMs;
+var describeIdleWindow = (timeoutMs) => {
+  const minutes = Math.round(timeoutMs / 6e4);
+  return minutes >= 1 ? `${minutes} minute${minutes === 1 ? "" : "s"}` : `${Math.round(timeoutMs / 1e3)}s`;
+};
+
+export {
+  listProcessProofs,
+  silentSpawnedProofs,
+  startProcessOwnership,
+  withSpawnProcessOwnership,
+  ownsLiveProcess,
+  findLiveProcessBySpawnId,
+  SESSION_IDLE_TIMEOUT_MS,
+  SESSION_REAP_SILENCE_MS,
+  idleDeadlinePassed,
+  describeIdleWindow
+};

package/dist/chunk-ZVSKMPBZ.js

@@ -0,0 +1,135 @@
+import {
+  parseFlags
+} from "./chunk-GMXKITVA.js";
+import {
+  UsageError
+} from "./chunk-7QLSKOSU.js";
+import {
+  SETUP_AGENT_CHOICES,
+  SETUP_CONNECT_MODES,
+  isSetupConnectMode,
+  isValidApiKey
+} from "./chunk-NQTHFF4W.js";
+
+// src/setup/options.ts
+var AGENT_CHOICES = SETUP_AGENT_CHOICES;
+var CONNECT_ALIASES = { auto: "app", pwa: "web" };
+var parseConnectMode = (raw) => {
+  const value = raw.trim().toLowerCase();
+  if (Object.hasOwn(CONNECT_ALIASES, value)) return CONNECT_ALIASES[value];
+  if (isSetupConnectMode(value)) return value;
+  throw new UsageError(`--connect must be one of: ${SETUP_CONNECT_MODES.join(", ")} (got ${raw})`);
+};
+var VERIFY_MODES = ["roundtrip", "push", "none"];
+var parseVerifyMode = (raw) => {
+  const value = raw.trim().toLowerCase();
+  if (VERIFY_MODES.includes(value)) return value;
+  throw new UsageError(`--verify must be one of: ${VERIFY_MODES.join(", ")} (got ${raw})`);
+};
+var CONTROL_MODES = ["auto", "on", "off"];
+var parseControlMode = (raw) => {
+  const value = raw.trim().toLowerCase();
+  if (CONTROL_MODES.includes(value)) return value;
+  throw new UsageError(`--control must be one of: ${CONTROL_MODES.join(", ")} (got ${raw})`);
+};
+var effectiveVerify = (options, context) => {
+  if (options.verifyExplicit) return options.verify;
+  if (options.verify === "roundtrip") return "roundtrip";
+  return context.paired ? "roundtrip" : options.verify;
+};
+var SETUP_FLAGS = {
+  bools: ["key-stdin", "skip-phone", "yes", "y", "json", "dry-run", "take-over-hooks", "help", "h"],
+  values: ["key", "connect", "agents", "verify", "control", "transcripts"]
+};
+var effectiveControlMode = (options, stored, configPresent) => options.controlExplicit ? options.control : stored ?? (configPresent ? null : options.control);
+var isAgentChoice = (value) => AGENT_CHOICES.includes(value);
+var parseAgentSelection = (raw, yes) => {
+  if (raw === void 0) {
+    return yes ? { kind: "auto" } : { kind: "ask" };
+  }
+  const value = raw.trim().toLowerCase();
+  if (value === "auto") return { kind: "auto" };
+  if (value === "none") return { kind: "none" };
+  const parts = value.split(",").map((part) => part.trim()).filter((part) => part !== "");
+  if (parts.length === 0) throw new UsageError("--agents needs a value");
+  const unknown = parts.filter((part) => !isAgentChoice(part));
+  if (unknown.length > 0) {
+    throw new UsageError(
+      `--agents does not know: ${unknown.join(", ")}. Use auto, none, or any of: ${AGENT_CHOICES.join(", ")}`
+    );
+  }
+  return { kind: "explicit", agents: [...new Set(parts)] };
+};
+var parseSetupOptions = (input) => {
+  const flags = parseFlags(input.argv, SETUP_FLAGS);
+  const stray = [
+    ...flags.command !== void 0 && flags.command !== "setup" ? [flags.command] : [],
+    ...flags.rest
+  ];
+  if (stray.length > 0) {
+    throw new UsageError(
+      `setup takes no positional arguments (got ${stray.join(", ")}). Did you mean --agents ${stray[0]}?`
+    );
+  }
+  const yes = flags.bools.has("yes") || flags.bools.has("y");
+  const help = flags.bools.has("help") || flags.bools.has("h");
+  const agentsFlag = flags.values.get("agents");
+  const agents = parseAgentSelection(agentsFlag, yes);
+  const connectRaw = flags.values.get("connect");
+  const connectMode = connectRaw === void 0 ? "app" : parseConnectMode(connectRaw);
+  const verifyRaw = flags.values.get("verify");
+  const controlRaw = flags.values.get("control");
+  const transcriptsRaw = flags.values.get("transcripts")?.trim().toLowerCase();
+  if (transcriptsRaw !== void 0 && transcriptsRaw !== "on" && transcriptsRaw !== "off") {
+    throw new UsageError(`--transcripts must be one of: on, off (got ${transcriptsRaw})`);
+  }
+  const nonInteractive = yes || agentsFlag !== void 0 || flags.bools.has("json") || !input.stdinIsTty;
+  const verify = verifyRaw !== void 0 ? parseVerifyMode(verifyRaw) : nonInteractive ? "push" : "roundtrip";
+  const key = flags.values.get("key")?.trim() || null;
+  const keyStdin = flags.bools.has("key-stdin");
+  if (key && keyStdin) {
+    throw new UsageError("Pass either --key or --key-stdin, not both");
+  }
+  if (key && !isValidApiKey(key)) {
+    throw new UsageError("--key is not a valid API key. Expected the pk_xxx.xxx shape from pushary.com/dashboard/agent/settings");
+  }
+  return {
+    connectMode,
+    connectExplicit: connectRaw !== void 0,
+    // `--connect none` and `--skip-phone` are the same instruction, so they
+    // resolve to the same field rather than being checked separately at the two
+    // call sites that would inevitably drift apart.
+    skipPhone: flags.bools.has("skip-phone") || connectMode === "none",
+    // Anything that means "there is nobody to answer a prompt". A non-TTY stdin
+    // is included because that is the case that used to hang: it is better to
+    // take the defaults and say so than to wait forever for a keypress.
+    //
+    // --json counts. Under it stdout carries exactly one object and every human
+    // line is redirected to stderr, so a prompt has nowhere to render: the
+    // question goes to stderr while the run blocks on a keypress the caller
+    // cannot see it is waiting for, and whatever is reading stdout waits forever
+    // for an object that never arrives. Asking for machine-readable output is
+    // itself a statement that no human is watching.
+    nonInteractive,
+    json: flags.bools.has("json"),
+    dryRun: flags.bools.has("dry-run"),
+    help,
+    agents,
+    key,
+    keyStdin,
+    verify,
+    verifyExplicit: verifyRaw !== void 0,
+    control: controlRaw === void 0 ? "auto" : parseControlMode(controlRaw),
+    controlExplicit: controlRaw !== void 0,
+    transcripts: transcriptsRaw === void 0 ? null : transcriptsRaw === "on",
+    takeOverHooks: flags.bools.has("take-over-hooks")
+  };
+};
+
+export {
+  AGENT_CHOICES,
+  effectiveVerify,
+  SETUP_FLAGS,
+  effectiveControlMode,
+  parseSetupOptions
+};

package/dist/reapply-CW3MA66V.js

@@ -0,0 +1,34 @@
+import {
+  ensureCodexTrustAfterReapply,
+  inspectConfiguredManagedProviders,
+  reapplyAllAgents,
+  reapplyClaudeForVersion,
+  reapplyClaudeSettings,
+  reapplyCodexSettings,
+  reapplyCursorPlugin,
+  reapplyGeminiSettings,
+  reapplyVsCodePlugin,
+  repairCodexHolds
+} from "./chunk-VQKRG3AC.js";
+import "./chunk-SIFVFP6T.js";
+import "./chunk-RHR6NARM.js";
+import "./chunk-AXPCESYO.js";
+import "./chunk-6J2JC2RT.js";
+import "./chunk-3EVPNIBE.js";
+import "./chunk-XHKBHWLX.js";
+import "./chunk-EPCXUP3P.js";
+import "./chunk-A2A2YTMG.js";
+import "./chunk-T7E75EKA.js";
+import "./chunk-NQTHFF4W.js";
+export {
+  ensureCodexTrustAfterReapply,
+  inspectConfiguredManagedProviders,
+  reapplyAllAgents,
+  reapplyClaudeForVersion,
+  reapplyClaudeSettings,
+  reapplyCodexSettings,
+  reapplyCursorPlugin,
+  reapplyGeminiSettings,
+  reapplyVsCodePlugin,
+  repairCodexHolds
+};

package/dist/src/index.d.ts

@@ -0,0 +1,204 @@
+import { CanonicalGateInputs, ReceiptMeta } from '@pushary/hook-mapping';
+import { ClaudePreToolUseOutput, SetupOutcomeBeacon, MachineDecisionOrigin, SettledOutcome, AgentQuestion, PolicyConfig, ApprovalMode, ModeState } from '@pushary/contracts';
+export { ApprovalMode, ModeState, PolicyConfig, ToolPolicy, resolvePolicy } from '@pushary/contracts';
+
+interface ToolHookInput {
+    readonly hook_event_name?: string;
+    readonly tool_name: string;
+    readonly tool_input: Record<string, unknown>;
+    readonly session_id?: string;
+    readonly cwd?: string;
+    readonly transcript_path?: string;
+    readonly tool_use_id?: string;
+    readonly permission_mode?: string;
+}
+
+type HookOutput = ClaudePreToolUseOutput;
+declare const handlePreToolUse: (input: ToolHookInput, canonical?: CanonicalGateInputs | null) => Promise<HookOutput | undefined>;
+
+interface UsageReport {
+    readonly eventId: string;
+    readonly reportedAt: number;
+    readonly tokensIn: number;
+    readonly tokensOut: number;
+    readonly costUsd: number;
+    readonly deltaUsd: number;
+}
+
+type DecisionSource = 'policy_auto' | 'human' | 'terminal';
+interface AgentIdentity {
+    readonly type: string;
+    readonly label: string;
+}
+interface AgentEvent extends Partial<Omit<SetupOutcomeBeacon, 'agents'>> {
+    occurredAt?: string;
+    toolUseId?: string;
+    event: string;
+    agentType: string;
+    agentName?: string;
+    action?: string;
+    machineId?: string;
+    repoKey?: string;
+    sessionId?: string;
+    parentSessionId?: string;
+    error?: string;
+    taskTitle?: string;
+    decisionSource?: DecisionSource;
+    decisionOrigin?: MachineDecisionOrigin;
+    decisionOutcome?: SettledOutcome;
+    toolName?: string;
+    toolTarget?: string;
+    agents?: readonly string[];
+    meta?: ReceiptMeta;
+    usage?: UsageReport;
+    pid?: number;
+}
+interface ReportEventOptions {
+    signal?: AbortSignal;
+    maxAttempts?: number;
+    timeoutMs?: number;
+    /**
+     * Total wall clock this call may spend, acknowledge round trip included.
+     *
+     * Deliberately not `timeoutMs`. That option doubles as the "I am a side report"
+     * signal (`clientCanDrain` below is keyed on its absence), so a drain-carrying
+     * caller that set it to bound its time would silently stop delivering the
+     * instructions a person sent from their phone. This bounds the clock and says
+     * nothing about draining.
+     *
+     * Without it, a single report could spend `timeoutMs ?? 10_000` on the event
+     * POST and then a further `timeoutMs ?? 10_000` acknowledging a pending command,
+     * which is twice the ceiling the hook was given and, on Codex, twice what the
+     * agent will wait before killing the process mid-flight.
+     */
+    budgetMs?: number;
+    /**
+     * Tells the server not to pop a queued instruction for this report.
+     *
+     * `canDrainCommand: false` is not enough. The route's first disjunct is
+     * `event === "session_end" && consumesDrainedCommand(agentType)`, which never
+     * reads that flag, so any `session_end` from an agent whose Stop carries text
+     * back pops the queue destructively. A subagent's stop is a `session_end` and
+     * its caller throws the response away, which is a queued instruction destroyed
+     * rather than delivered. `skipCommandDrain` is the route's own first check.
+     */
+    skipDrain?: boolean;
+    requireOk?: boolean;
+    /**
+     * Authenticate with this key instead of the ambient one.
+     *
+     * getApiKey() reads the environment and ~/.pushary/config.json, so it can only
+     * ever speak for a key that is already installed. setup resolves a key minutes
+     * before it writes one, and its abort beacons run inside that window: without
+     * an override they post as nobody, so the runs that fail before saveApiKey are
+     * exactly the runs that cannot report failing.
+     */
+    apiKey?: string;
+}
+interface EventResponse {
+    readonly ok?: boolean;
+    readonly pendingCommand?: string;
+    readonly pendingCommandId?: string;
+    readonly pendingCommandExpiresAtMs?: number;
+}
+declare const reportEvent: (event: AgentEvent, options?: ReportEventOptions) => Promise<EventResponse | null>;
+declare const handlePostToolUse: (input: {
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    tool_response?: unknown;
+    tool_result?: unknown;
+    cwd?: string;
+    session_id?: string;
+    agent_id?: string;
+    transcript_path?: string;
+    tool_use_id?: string;
+}, agent?: AgentIdentity) => Promise<string | undefined>;
+interface StopHookOutput {
+    readonly decision: 'block';
+    readonly reason: string;
+}
+declare const handleStop: (input: {
+    cwd?: string;
+    session_id?: string;
+    agent_id?: string;
+    stop_hook_active?: boolean;
+    transcript_path?: string;
+    last_assistant_message?: string;
+    background_tasks?: unknown;
+    session_crons?: unknown;
+}, agent?: AgentIdentity) => Promise<StopHookOutput | undefined>;
+declare const handleNotification: (input: {
+    message?: string;
+    title?: string;
+    type?: string;
+    notification_type?: string;
+    hook_event_name?: string;
+    cwd?: string;
+    session_id?: string;
+}, agent?: AgentIdentity) => Promise<void>;
+
+interface AskUserParams {
+    question: string;
+    type?: 'confirm' | 'select' | 'input';
+    options?: string[];
+    questions?: AgentQuestion[];
+    context?: string;
+    agentName?: string;
+    sessionId?: string;
+    machineId?: string;
+    toolName?: string;
+    toolTarget?: string;
+    toolPath?: string;
+    repoKey?: string;
+    intent?: string;
+    action?: string;
+    blocker?: string;
+    actionBody?: string;
+    scopePath?: string;
+    toolUseId?: string;
+    waitEndsAt?: string;
+    requestId?: string;
+    sessionToolAware?: true;
+}
+interface AskUserResponse {
+    correlationId: string;
+    status: string;
+    handoffAction?: string;
+    delivery?: {
+        web: number;
+        mobile: number;
+    };
+    suppressed?: boolean;
+    noDevices?: boolean;
+    answered?: boolean;
+    value?: string;
+    note?: string;
+    waitEndsAt?: string;
+    answerUrl?: string;
+}
+interface AnswerResult {
+    status?: string;
+    handoffAction?: string;
+    answered: boolean;
+    value?: string;
+    note?: string;
+}
+declare const askUser: (apiKey: string, params: AskUserParams, timeoutMs?: number) => Promise<AskUserResponse>;
+declare const waitForAnswer: (apiKey: string, correlationId: string, timeoutMs?: number, signal?: AbortSignal) => Promise<AnswerResult>;
+declare const cancelQuestion: (apiKey: string, correlationId: string, signal?: AbortSignal) => Promise<{
+    cancelled?: boolean;
+    status?: string;
+    handoffAction?: string;
+}>;
+
+declare const getPolicy: (apiKey: string, expectedVersion?: string | null, agent?: string, repoAware?: boolean, sessionId?: string) => Promise<PolicyConfig>;
+
+declare const fetchModeState: (apiKey: string, sessionId?: string, reuseWithinMs?: number, signal?: AbortSignal) => Promise<ModeState>;
+declare const fetchModeOverride: (apiKey: string) => Promise<ApprovalMode | null>;
+
+declare const getApiKey: () => string;
+declare const getBaseUrl: () => string;
+
+declare const fetchAccountPublicKey: (apiKey: string, baseUrl?: string) => Promise<string | null>;
+
+export { askUser, cancelQuestion, fetchAccountPublicKey, fetchModeOverride, fetchModeState, getApiKey, getBaseUrl, getPolicy, handleNotification, handlePostToolUse, handlePreToolUse, handleStop, reportEvent, waitForAnswer };