agent-standup 0.20.0

package/dist/chunk-N7G677FC.js

@@ -0,0 +1,1042 @@
+import {
+  INTERVENTION_SCORE_MEANINGS,
+  MAX_COMMAND_CHARS,
+  MAX_SESSION_ID_CHARS,
+  MAX_TOOL_CHARS,
+  SCALE_POINTS,
+  capPaths,
+  capText,
+  isBlockingLevel
+} from "./chunk-VBXNDGOD.js";
+
+// src/lib/hook/override.ts
+var MIN_OVERRIDE_REASON_LENGTH = 20;
+var MAX_OVERRIDE_REASON_LENGTH = 1e3;
+function overrideApplies(claim, entryId, level) {
+  if (level === "hard-block") {
+    return { applies: false, refusal: "level-not-overridable" };
+  }
+  if (!isBlockingLevel(level)) return { applies: false };
+  if (claim === void 0) return { applies: false, refusal: "no-override" };
+  if (claim.entryId !== entryId) return { applies: false, refusal: "wrong-entry" };
+  const reason = claim.reason.trim();
+  if (reason.length < MIN_OVERRIDE_REASON_LENGTH) {
+    return { applies: false, refusal: "reason-too-short" };
+  }
+  return { applies: true, reason: reason.slice(0, MAX_OVERRIDE_REASON_LENGTH) };
+}
+function readOverrideClaim(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const record = value;
+  const entryId = record.entryId ?? record.entry_id;
+  const reason = record.reason;
+  if (typeof entryId !== "string" || entryId.trim() === "") return void 0;
+  if (typeof reason !== "string" || reason.trim() === "") return void 0;
+  return { entryId: entryId.trim(), reason: reason.trim() };
+}
+function overrideRemedy(entryId, level) {
+  if (level !== "block-overridable") return null;
+  return `This block can be overridden. To proceed, re-run the call with an override naming "${entryId}" and a written reason of at least ${MIN_OVERRIDE_REASON_LENGTH} characters saying why it is right to go ahead. The reason is recorded against this finding and can be read later \u2014 it is kept as a record, not checked for correctness.`;
+}
+
+// src/lib/hook/payload.ts
+var HOOK_EVENT_TYPES = ["PreToolUse", "PostToolUse", "Stop"];
+function isHookEventType(value) {
+  return typeof value === "string" && HOOK_EVENT_TYPES.includes(value);
+}
+var MAX_TOOL_RESULT_CHARS = 4e3;
+var COMMAND_FIELDS = ["command", "file_path", "filePath", "path", "pattern", "url"];
+function property(value, key) {
+  return typeof value === "object" && value !== null ? value[key] : void 0;
+}
+function firstString(source, keys) {
+  for (const key of keys) {
+    const value = property(source, key);
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return void 0;
+}
+function parseHookPayload(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return { ok: false, reason: "the hook payload was not valid JSON" };
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    return { ok: false, reason: "the hook payload was not a JSON object" };
+  }
+  const eventType = firstString(raw, ["hook_event_name", "hookEventName", "eventType"]);
+  if (!isHookEventType(eventType)) {
+    return {
+      ok: false,
+      reason: `unrecognised hook event type ${eventType === void 0 ? "(absent)" : `"${eventType}"`}`
+    };
+  }
+  const sessionId = firstString(raw, ["session_id", "sessionId"]);
+  if (sessionId === void 0) {
+    return { ok: false, reason: "the hook payload carried no session identifier" };
+  }
+  const tool = firstString(raw, ["tool_name", "toolName", "tool"]);
+  const toolInput = property(raw, "tool_input") ?? property(raw, "toolInput");
+  const command = firstString(toolInput, COMMAND_FIELDS);
+  const toolResult = readToolResult(
+    property(raw, "tool_response") ?? property(raw, "toolResponse")
+  );
+  const override = readOverrideClaim(
+    property(raw, "standup_override") ?? property(raw, "standupOverride")
+  );
+  return {
+    ok: true,
+    event: {
+      eventType,
+      sessionId,
+      ...tool === void 0 ? {} : { tool },
+      ...command === void 0 ? {} : { command },
+      ...toolResult === void 0 ? {} : { toolResult },
+      ...override === void 0 ? {} : { override }
+    }
+  };
+}
+function readToolResult(value) {
+  if (value === void 0 || value === null) return void 0;
+  let text;
+  if (typeof value === "string") {
+    text = value;
+  } else {
+    try {
+      text = JSON.stringify(value) ?? "";
+    } catch {
+      return void 0;
+    }
+  }
+  if (text.length === 0) return void 0;
+  return text.length > MAX_TOOL_RESULT_CHARS ? text.slice(0, MAX_TOOL_RESULT_CHARS) : text;
+}
+
+// src/lib/hook/response.ts
+var HOOK_EXIT = {
+  /** Allowed — say nothing. */
+  ALLOW: 0,
+  /**
+   * Denied. `2` rather than `1` because agent tools conventionally treat a
+   * hook's `2` as "block and feed stderr back to the model", where `1` is
+   * an ordinary script failure that is reported to the person and otherwise
+   * ignored — and a guard whose refusal the model never sees is a guard that
+   * does not change what the model does next.
+   */
+  DENY: 2
+};
+function renderResponse(verdict, eventName) {
+  if (verdict.decision === "allow") {
+    return { stdout: "", stderr: "", exitCode: HOOK_EXIT.ALLOW };
+  }
+  const output = {
+    decision: "deny",
+    reason: verdict.reason,
+    source: verdict.source,
+    hookSpecificOutput: {
+      hookEventName: eventName,
+      permissionDecision: "deny",
+      permissionDecisionReason: verdict.reason
+    }
+  };
+  return {
+    stdout: `${JSON.stringify(output)}
+`,
+    stderr: `${verdict.reason}
+`,
+    exitCode: HOOK_EXIT.DENY
+  };
+}
+function renderWithStopCatch(response, stopCatch) {
+  if (stopCatch === null) return response;
+  const advisory = `[standup:${stopCatch.kind}] ${stopCatch.text}
+`;
+  return {
+    stdout: response.stdout,
+    stderr: `${response.stderr}${advisory}`,
+    // Deliberately the response's own code — see the note above.
+    exitCode: response.exitCode
+  };
+}
+function renderWithNudges(verdict, eventName, nudges) {
+  const base = renderResponse(verdict, eventName);
+  if (nudges.length === 0) return base;
+  const advisory = nudges.map((nudge) => `[standup:${nudge.kind}] ${nudge.text}`).join("\n");
+  return {
+    stdout: base.stdout,
+    stderr: base.stderr === "" ? `${advisory}
+` : `${base.stderr}${advisory}
+`,
+    // Deliberately `base.exitCode`, never a value derived from `nudges`.
+    exitCode: base.exitCode
+  };
+}
+function renderWithStopSurvey(response, survey) {
+  if (survey === null) return response;
+  const advisory = `[standup:${survey.kind}] ${survey.text}
+`;
+  return {
+    stdout: response.stdout,
+    stderr: `${response.stderr}${advisory}`,
+    // Deliberately the response's own code, never a value derived from the
+    // survey. A questionnaire that could raise an exit code would be a
+    // refused stop, which DECISIONS.md section 6 rules out outright.
+    exitCode: response.exitCode
+  };
+}
+
+// src/lib/hook/enforcement.ts
+var SESSION_STATUSES = ["active", "displaced", "unregistered", "incompatible"];
+function isSessionStatus(value) {
+  return typeof value === "string" && SESSION_STATUSES.includes(value);
+}
+var REASONS = Object.freeze({
+  displaced: "This session holds no claim on the work it is running \u2014 the item was taken over by another session. Stop here and report what you had completed; do not continue making changes.",
+  unregistered: "This session has not registered with the server, so its actions cannot be attributed or guarded. Register the session, then retry.",
+  incompatible: "This session's hook is older than the server's minimum supported protocol version, so the rules it would enforce are not the rules the server expects. Update, then retry."
+});
+function enforcementRefusal(enforcement) {
+  if (enforcement === void 0) return null;
+  if (enforcement.status === "active") return null;
+  if (!isSessionStatus(enforcement.status)) {
+    return {
+      status: "incompatible",
+      reason: "The server reported a session status this hook does not recognise, so it cannot tell whether this session is allowed to act. Update, then retry."
+    };
+  }
+  const base = REASONS[enforcement.status];
+  return {
+    status: enforcement.status,
+    reason: enforcement.detail === void 0 || enforcement.detail.length === 0 ? base : `${base} (${enforcement.detail})`
+  };
+}
+function readSessionStatus(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record = value;
+  const status = record.status;
+  if (typeof status !== "string") return void 0;
+  const detail = typeof record.detail === "string" ? record.detail : void 0;
+  return { status, ...detail === void 0 ? {} : { detail } };
+}
+
+// src/lib/hook/nudge.ts
+var NUDGE_KINDS = [
+  "delegate",
+  "staging",
+  "escalation",
+  "wind-down",
+  "background"
+];
+function isNudgeKind(value) {
+  return typeof value === "string" && NUDGE_KINDS.includes(value);
+}
+var BUDGET_BANDS = ["free", "selective", "wind-down", "stop"];
+var WRITE_SHAPED_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "NotebookEdit", "Bash"]);
+function isWriteShaped(tool) {
+  return tool !== void 0 && WRITE_SHAPED_TOOLS.has(tool);
+}
+var DELEGATE_TEXT = "You are orchestrating and this call changes something directly. Consider dispatching it to a crew member instead \u2014 delegation is the configured preference here. This is advice, not a refusal: the call has already run.";
+var STAGING_TEXT = (count) => `There ${count === 1 ? "is" : "are"} ${count} file${count === 1 ? "" : "s"} of uncommitted work in this session. Commit at a logical checkpoint so the work is not lost if the session ends unexpectedly.`;
+var BACKGROUND_NUDGE_THRESHOLD_SECONDS = 120;
+var WIND_DOWN_TEXT = "The budget window has reached its wind-down band. Start nothing new: bring in-flight work to a good stopping point, take shortcuts to a clean pause, and write the handoff. Finishing is not required \u2014 a clean pause is.";
+function approximateDuration(seconds) {
+  if (seconds < 60) return `~${Math.round(seconds)}s`;
+  return `~${Math.round(seconds / 60)} min`;
+}
+var BACKGROUND_TEXT = (seconds) => `This command has taken ${approximateDuration(seconds)} on previous runs. Consider running it in the background and picking the result up later, rather than blocking this session while it runs. Some calls genuinely cannot be backgrounded \u2014 this is advice, not a refusal.`;
+function evaluateNudges(context) {
+  const already = new Set(context.alreadyNudged ?? []);
+  const nudges = [];
+  if (context.delegationMode === "allowed" && context.isOrchestrator === true && context.writeShaped === true) {
+    nudges.push({ kind: "delegate", text: DELEGATE_TEXT });
+  }
+  if (context.writeShaped === true && context.unstagedFiles !== void 0 && context.unstagedFiles > 0) {
+    nudges.push({ kind: "staging", text: STAGING_TEXT(context.unstagedFiles) });
+  }
+  if (context.escalation !== void 0 && context.escalation.length > 0) {
+    nudges.push({ kind: "escalation", text: context.escalation });
+  }
+  if (context.budgetBand === "wind-down") {
+    nudges.push({ kind: "wind-down", text: WIND_DOWN_TEXT });
+  }
+  if (context.beforeCall === true && context.alreadyBackgrounded !== true && context.typicalDurationSeconds !== void 0 && Number.isFinite(context.typicalDurationSeconds) && context.typicalDurationSeconds > BACKGROUND_NUDGE_THRESHOLD_SECONDS) {
+    nudges.push({
+      kind: "background",
+      text: BACKGROUND_TEXT(context.typicalDurationSeconds)
+    });
+  }
+  return nudges.filter((nudge) => !already.has(nudge.kind));
+}
+function readNudgeContext(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const record = value;
+  const delegationMode = record.delegationMode === "never" || record.delegationMode === "allowed" || record.delegationMode === "required" ? record.delegationMode : void 0;
+  const budgetBand = BUDGET_BANDS.includes(record.budgetBand) ? record.budgetBand : void 0;
+  const unstagedFiles = typeof record.unstagedFiles === "number" && Number.isInteger(record.unstagedFiles) ? record.unstagedFiles : void 0;
+  const escalation = typeof record.escalation === "string" ? record.escalation : void 0;
+  const alreadyNudged = Array.isArray(record.alreadyNudged) ? record.alreadyNudged.filter(isNudgeKind) : void 0;
+  const typicalDurationSeconds = typeof record.typicalDurationSeconds === "number" && Number.isFinite(record.typicalDurationSeconds) && record.typicalDurationSeconds >= 0 ? record.typicalDurationSeconds : void 0;
+  const context = {
+    ...delegationMode === void 0 ? {} : { delegationMode },
+    ...typeof record.isOrchestrator === "boolean" ? { isOrchestrator: record.isOrchestrator } : {},
+    ...unstagedFiles === void 0 ? {} : { unstagedFiles },
+    ...escalation === void 0 ? {} : { escalation },
+    ...budgetBand === void 0 ? {} : { budgetBand },
+    ...alreadyNudged === void 0 ? {} : { alreadyNudged },
+    ...typicalDurationSeconds === void 0 ? {} : { typicalDurationSeconds },
+    ...typeof record.alreadyBackgrounded === "boolean" ? { alreadyBackgrounded: record.alreadyBackgrounded } : {}
+  };
+  return Object.keys(context).length === 0 ? void 0 : context;
+}
+
+// src/lib/hook/decide.ts
+var ALLOW = (source, reason) => ({
+  decision: "allow",
+  reason,
+  source
+});
+function canBlock(event) {
+  return event.eventType === "PreToolUse";
+}
+async function decide({
+  event,
+  askServer,
+  enforcement
+}) {
+  const localRefusal = enforcementRefusal(enforcement);
+  if (localRefusal !== null && canBlock(event)) {
+    return { decision: "deny", reason: localRefusal.reason, source: "enforcement" };
+  }
+  let answer;
+  try {
+    answer = await askServer(event);
+  } catch {
+    answer = void 0;
+  }
+  if (answer === void 0) {
+    return ALLOW(
+      "server-unreachable",
+      "the server could not be reached for a verdict; the hook allows when it has no answer"
+    );
+  }
+  if (!canBlock(event)) {
+    return ALLOW(
+      "post-cannot-block",
+      "this event fires after the call has run, so it reports rather than refuses"
+    );
+  }
+  const refusal = enforcementRefusal(answer.enforcement);
+  if (refusal !== null) {
+    return { decision: "deny", reason: refusal.reason, source: "enforcement" };
+  }
+  if (answer.decision === "block") {
+    const blocking = (answer.findings ?? []).filter((finding) => isBlockingLevel(finding.level));
+    const overridden = blocking.filter(
+      (finding) => overrideApplies(event.override, finding.id, finding.level).applies
+    );
+    if (blocking.length > 0 && overridden.length === blocking.length) {
+      const reason = overrideApplies(event.override, blocking[0].id, blocking[0].level).reason ?? "";
+      return {
+        ...ALLOW("override", `overridden by the caller with a written reason: ${reason}`),
+        // The structured record. The prose above is for a person reading
+        // stderr; this is what reaches `intervention_events.override_reason`
+        // so the reason survives the process that printed it.
+        override: { entryIds: overridden.map((finding) => finding.id), reason }
+      };
+    }
+    const remedies = blocking.map((finding) => overrideRemedy(finding.id, finding.level)).filter((remedy) => remedy !== null);
+    const base = answer.reason ?? "blocked by the server";
+    return {
+      decision: "deny",
+      reason: remedies.length === 0 ? base : `${base} ${remedies.join(" ")}`,
+      source: "server"
+    };
+  }
+  return ALLOW("server", answer.reason ?? "allowed by the server");
+}
+async function decideWithNudges(options) {
+  let volunteered;
+  let findings;
+  const askServer = async (asked) => {
+    const answer = await options.askServer(asked);
+    if (answer?.nudge !== void 0) volunteered = answer.nudge;
+    if (answer?.findings !== void 0) findings = answer.findings;
+    return answer;
+  };
+  const verdict = await decide({ ...options, askServer });
+  const merged = { ...options.nudge, ...volunteered };
+  const nudges = evaluateNudges({
+    ...merged,
+    // The event knows which tool ran; the context does not, and nothing
+    // upstream should have to restate it. A `writeShaped` already on the
+    // context still wins.
+    writeShaped: merged.writeShaped ?? isWriteShaped(options.event.tool),
+    // Same reasoning for `beforeCall`, which the backgrounding nudge keys
+    // off (MILESTONES.md #65). This is read from the *event*, never from
+    // the server: whether the call has already run is a local fact, and a
+    // server that claimed otherwise would be overriding something it
+    // cannot observe. Hence `??` on the two fields above and a plain
+    // assignment here.
+    beforeCall: options.event.eventType === "PreToolUse"
+  });
+  return { verdict, nudges, findings: findings ?? [] };
+}
+
+// src/lib/interventions/survey.ts
+var MAX_SURVEY_ITEMS = 5;
+var WIND_DOWN_QUIET_MS = 2 * 60 * 1e3;
+function shouldSurvey(context, quietMs = WIND_DOWN_QUIET_MS) {
+  if (context.alreadySurveyed === true) return false;
+  const unrated = context.unrated;
+  if (unrated === void 0 || unrated.length === 0) return false;
+  if (context.liveCrew !== void 0 && context.liveCrew > 0) return false;
+  if (context.wakeScheduled === true) return false;
+  const idleMs = context.idleMs;
+  if (idleMs === void 0) return false;
+  return idleMs >= quietMs;
+}
+function dedupeForSurvey(firings, limit = MAX_SURVEY_ITEMS) {
+  const latestByEntry = /* @__PURE__ */ new Map();
+  for (const firing of firings) {
+    const held = latestByEntry.get(firing.entryId);
+    if (held === void 0 || firing.at > held.at) latestByEntry.set(firing.entryId, firing);
+  }
+  return [...latestByEntry.values()].sort((a, b) => b.at - a.at).slice(0, Math.max(0, limit));
+}
+function buildSurvey(firings) {
+  const asked = dedupeForSurvey(firings);
+  if (asked.length === 0) return null;
+  const scale = SCALE_POINTS.map(
+    (score) => `  ${score} \u2014 ${INTERVENTION_SCORE_MEANINGS[score]}`
+  ).join("\n");
+  const items = asked.map((firing, index) => {
+    const parts = [`${index + 1}. [${firing.entryId}] eventId ${firing.eventId}`];
+    if (firing.tool !== void 0) parts.push(`   you were calling: ${firing.tool}`);
+    if (firing.outcome !== void 0) parts.push(`   it: ${firing.outcome}`);
+    if (firing.message !== void 0) parts.push(`   it told you: ${firing.message}`);
+    return parts.join("\n");
+  }).join("\n");
+  const prompt = [
+    `Before you finish: ${asked.length} intervention${asked.length === 1 ? "" : "s"} fired during this session. Rate how useful each one actually was, so the unhelpful ones can be removed.`,
+    "",
+    scale,
+    "",
+    items,
+    "",
+    "Reply with JSON only \u2014 no prose, no explanation outside the notes:",
+    '{"scores":[{"eventId":"<id>","score":<1-5>,"note":"<optional, one line>"}]}',
+    "",
+    "A note is worth adding when the score is low, because a 1 or a 2 can mean two very different things: the detection was wrong, or the detection was right and the message did not say what to do next. Only the second is fixed by rewording it."
+  ].join("\n");
+  return { kind: "intervention-survey", firings: asked, prompt };
+}
+
+// src/lib/hook/stop-catch.ts
+function isWakeScheduled(context) {
+  return context.wakeScheduled === true || context.waitBackgrounded === true;
+}
+var stopText = (liveCrew) => `${liveCrew} crew member${liveCrew === 1 ? "" : "s"} ${liveCrew === 1 ? "is" : "are"} still running and nothing is scheduled to wake you when they finish, so their work would complete into a session that has stopped listening. Start a backgrounded wait before ending the turn. This is advice, not a refusal \u2014 the turn is not being held open.`;
+function evaluateStopCatch(event, context) {
+  if (event.eventType !== "Stop") return null;
+  if (context === void 0) return null;
+  if (context.alreadyCaught === true) return null;
+  if (isWakeScheduled(context)) return null;
+  const liveCrew = context.liveCrew;
+  if (liveCrew === void 0 || liveCrew <= 0) return null;
+  return { kind: "stop-catch", text: stopText(liveCrew), liveCrew };
+}
+function readStopContext(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const record = value;
+  const liveCrew = typeof record.liveCrew === "number" && Number.isInteger(record.liveCrew) && record.liveCrew >= 0 ? record.liveCrew : void 0;
+  const context = {
+    ...liveCrew === void 0 ? {} : { liveCrew },
+    ...typeof record.wakeScheduled === "boolean" ? { wakeScheduled: record.wakeScheduled } : {},
+    ...typeof record.waitBackgrounded === "boolean" ? { waitBackgrounded: record.waitBackgrounded } : {},
+    ...typeof record.alreadyCaught === "boolean" ? { alreadyCaught: record.alreadyCaught } : {}
+  };
+  return Object.keys(context).length === 0 ? void 0 : context;
+}
+function evaluateStopSurvey(event, context) {
+  if (event.eventType !== "Stop") return null;
+  if (context === void 0) return null;
+  if (!shouldSurvey(context)) return null;
+  const survey = buildSurvey(context.unrated ?? []);
+  if (survey === null) return null;
+  return {
+    kind: "intervention-survey",
+    text: survey.prompt,
+    asked: survey.firings.length
+  };
+}
+
+// src/lib/hook/run.ts
+async function runHook(options) {
+  const parsed = parseHookPayload(options.stdin);
+  if (!parsed.ok) {
+    const verdict2 = {
+      decision: "allow",
+      reason: `the hook could not read this event (${parsed.reason})`,
+      source: "unreadable-payload"
+    };
+    return renderResponse(verdict2, "Unknown");
+  }
+  const event = parsed.event;
+  let volunteeredStop;
+  const askServer = async (asked) => {
+    const answer = await options.askServer(asked);
+    if (answer?.stop !== void 0) volunteeredStop = answer.stop;
+    return answer;
+  };
+  const { verdict, nudges, findings } = await decideWithNudges({
+    event,
+    askServer,
+    ...options.enforcement === void 0 ? {} : { enforcement: options.enforcement },
+    ...options.nudge === void 0 ? {} : { nudge: options.nudge }
+  });
+  if (findings.length > 0 && options.onFindings !== void 0) {
+    try {
+      await options.onFindings({
+        event,
+        findings,
+        blocked: verdict.decision === "deny",
+        // Only ever set on an allow whose source is `override`, so a
+        // callback can record the reason against the findings it excused.
+        ...verdict.override === void 0 ? {} : { override: verdict.override }
+      });
+    } catch {
+    }
+  }
+  const stopCatch = evaluateStopCatch(event, mergeStopContext(options.stop, volunteeredStop));
+  const survey = evaluateStopSurvey(event, options.survey);
+  return renderWithStopSurvey(
+    renderWithStopCatch(renderWithNudges(verdict, event.eventType, nudges), stopCatch),
+    survey
+  );
+}
+function mergeStopContext(local, volunteered) {
+  if (local === void 0) return volunteered;
+  if (volunteered === void 0) return local;
+  return { ...local, ...volunteered };
+}
+function captureContextFor(report) {
+  return {
+    sessionId: report.event.sessionId,
+    ...report.event.tool === void 0 ? {} : { tool: report.event.tool },
+    ...report.event.command === void 0 ? {} : { command: report.event.command },
+    blocked: report.blocked,
+    ...report.override === void 0 ? {} : {
+      overriddenEntryIds: report.override.entryIds,
+      overrideReason: report.override.reason
+    }
+  };
+}
+
+// src/lib/hook/spool.ts
+var DEFAULT_MAX_RECORDS = 2e4;
+var DEFAULT_BATCH_SIZE = 200;
+function serialiseRecord(record) {
+  return `${JSON.stringify(record)}
+`;
+}
+function parseRecord(line) {
+  let raw;
+  try {
+    raw = JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return void 0;
+  const value = raw;
+  if (typeof value.sessionId !== "string" || value.sessionId.length === 0) return void 0;
+  if (typeof value.ts !== "string" || value.ts.length === 0) return void 0;
+  if (typeof value.tool !== "string" || value.tool.length === 0) return void 0;
+  return raw;
+}
+function readSpool(text) {
+  if (text === void 0 || text.length === 0) return { records: [], skipped: 0 };
+  const records = [];
+  let skipped = 0;
+  for (const line of text.split("\n")) {
+    if (line.trim().length === 0) continue;
+    const record = parseRecord(line);
+    if (record === void 0) skipped += 1;
+    else records.push(record);
+  }
+  return { records, skipped };
+}
+function serialiseSpool(records) {
+  return records.map(serialiseRecord).join("");
+}
+function trimSpool(records, maxRecords = DEFAULT_MAX_RECORDS) {
+  if (maxRecords <= 0) return { records: [], dropped: records.length };
+  if (records.length <= maxRecords) return { records, dropped: 0 };
+  const dropped = records.length - maxRecords;
+  return { records: records.slice(dropped), dropped };
+}
+var DEFAULT_TRIM_INTERVAL = 1e3;
+function shouldTrimOnAppend(appendCount, interval = DEFAULT_TRIM_INTERVAL) {
+  if (interval <= 1) return true;
+  return appendCount % Math.floor(interval) === 0;
+}
+function batches(records, size = DEFAULT_BATCH_SIZE) {
+  const step = size > 0 ? Math.floor(size) : 1;
+  const out = [];
+  for (let index = 0; index < records.length; index += step) {
+    out.push(records.slice(index, index + step));
+  }
+  return out;
+}
+
+// src/lib/hook/flush.ts
+function toWireCall(record) {
+  return {
+    tool: record.tool,
+    ts: record.ts,
+    ...record.command === void 0 ? {} : { command: record.command },
+    ...record.paths === void 0 ? {} : { paths: record.paths },
+    inputTokens: record.inputTokens,
+    outputTokens: record.outputTokens,
+    cacheWriteTokens: record.cacheWriteTokens,
+    cacheReadTokens: record.cacheReadTokens,
+    ...record.model === void 0 ? {} : { model: record.model },
+    ...record.effort === void 0 ? {} : { effort: record.effort },
+    ...record.usage5h === void 0 ? {} : { usage5h: record.usage5h },
+    ...record.usageWeekly === void 0 ? {} : { usageWeekly: record.usageWeekly }
+  };
+}
+async function flushSpool(options) {
+  const { records, skipped } = readSpool(options.spoolText);
+  const trimmed = trimSpool(records, options.maxRecords ?? DEFAULT_MAX_RECORDS);
+  const bySession = /* @__PURE__ */ new Map();
+  for (const record of trimmed.records) {
+    const existing = bySession.get(record.sessionId);
+    if (existing === void 0) bySession.set(record.sessionId, [record]);
+    else existing.push(record);
+  }
+  const size = options.batchSize ?? DEFAULT_BATCH_SIZE;
+  let sent = 0;
+  let attempted = 0;
+  let stoppedEarly = false;
+  const acknowledged = /* @__PURE__ */ new Set();
+  for (const [sessionId, sessionRecords] of bySession) {
+    for (const batch of batches(sessionRecords, size)) {
+      attempted += 1;
+      let accepted = false;
+      try {
+        accepted = await options.send({ sessionId, calls: batch.map(toWireCall) });
+      } catch {
+        accepted = false;
+      }
+      if (!accepted) {
+        stoppedEarly = true;
+        break;
+      }
+      for (const record of batch) acknowledged.add(record);
+      sent += batch.length;
+    }
+  }
+  const retainedRecords = trimmed.records.filter((record) => !acknowledged.has(record));
+  return {
+    sent,
+    retained: retainedRecords.length,
+    skipped,
+    dropped: trimmed.dropped,
+    attempted,
+    stoppedEarly,
+    remaining: serialiseSpool(retainedRecords)
+  };
+}
+
+// src/lib/hook/spool-record.ts
+function countOf(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return 0;
+  return Math.floor(value);
+}
+function readingOf(value) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) return void 0;
+  return value;
+}
+function label(value, max) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return void 0;
+  return capText(trimmed, max);
+}
+function capPaths2(value) {
+  if (!Array.isArray(value)) return void 0;
+  const cleaned = [];
+  for (const entry of value) {
+    if (typeof entry !== "string") continue;
+    const trimmed = entry.trim();
+    if (trimmed.length > 0) cleaned.push(trimmed);
+  }
+  if (cleaned.length === 0) return void 0;
+  return capPaths(cleaned);
+}
+function buildRecord(options) {
+  const { event, now, usage } = options;
+  const tool = label(event.tool, MAX_TOOL_CHARS);
+  if (tool === void 0) return void 0;
+  const command = event.command === void 0 ? void 0 : label(event.command, MAX_COMMAND_CHARS);
+  const paths = capPaths2(options.paths);
+  const model = label(usage?.model, MAX_TOOL_CHARS);
+  const effort = label(usage?.effort, MAX_TOOL_CHARS);
+  const usage5h = readingOf(usage?.usage5h);
+  const usageWeekly = readingOf(usage?.usageWeekly);
+  return {
+    // Capped to the same bound the ingest applies, so the value the flush
+    // groups by is the value the server stores. Capping only server-side
+    // would let two sessions whose ids differ past the cap be spooled apart
+    // and stored together, which merges two sessions' telemetry silently.
+    sessionId: capText(event.sessionId, MAX_SESSION_ID_CHARS),
+    ts: new Date(now).toISOString(),
+    tool,
+    ...command === void 0 ? {} : { command },
+    ...paths === void 0 ? {} : { paths },
+    inputTokens: countOf(usage?.inputTokens),
+    outputTokens: countOf(usage?.outputTokens),
+    cacheWriteTokens: countOf(usage?.cacheWriteTokens),
+    cacheReadTokens: countOf(usage?.cacheReadTokens),
+    ...model === void 0 ? {} : { model },
+    ...effort === void 0 ? {} : { effort },
+    ...usage5h === void 0 ? {} : { usage5h },
+    ...usageWeekly === void 0 ? {} : { usageWeekly }
+  };
+}
+
+// src/lib/hook/usage.ts
+function property2(value, key) {
+  return typeof value === "object" && value !== null ? value[key] : void 0;
+}
+function first(source, keys) {
+  for (const key of keys) {
+    const value = property2(source, key);
+    if (value !== void 0 && value !== null) return value;
+  }
+  return void 0;
+}
+var USAGE_CONTAINERS = ["usage", "token_usage", "tokenUsage"];
+var INPUT_KEYS = ["input_tokens", "inputTokens"];
+var OUTPUT_KEYS = ["output_tokens", "outputTokens"];
+var CACHE_WRITE_KEYS = [
+  "cache_creation_input_tokens",
+  "cache_write_tokens",
+  "cacheWriteTokens"
+];
+var CACHE_READ_KEYS = [
+  "cache_read_input_tokens",
+  "cache_read_tokens",
+  "cacheReadTokens"
+];
+var MODEL_KEYS = ["model", "model_id", "modelId"];
+var EFFORT_KEYS = ["effort", "reasoning_effort", "reasoningEffort"];
+var USAGE_5H_KEYS = ["usage_5h", "usage5h"];
+var USAGE_WEEKLY_KEYS = ["usage_weekly", "usageWeekly"];
+function readReportedUsage(raw) {
+  const containers = [];
+  for (const key of USAGE_CONTAINERS) {
+    const nested = property2(raw, key);
+    if (nested !== void 0 && nested !== null) containers.push(nested);
+  }
+  containers.push(raw);
+  const pick = (keys) => {
+    for (const container of containers) {
+      const value = first(container, keys);
+      if (value !== void 0) return value;
+    }
+    return void 0;
+  };
+  const numeric = (keys) => {
+    const value = pick(keys);
+    return typeof value === "number" ? value : void 0;
+  };
+  const text = (keys) => {
+    const value = pick(keys);
+    return typeof value === "string" ? value : void 0;
+  };
+  const inputTokens = numeric(INPUT_KEYS);
+  const outputTokens = numeric(OUTPUT_KEYS);
+  const cacheWriteTokens = numeric(CACHE_WRITE_KEYS);
+  const cacheReadTokens = numeric(CACHE_READ_KEYS);
+  const model = text(MODEL_KEYS);
+  const effort = text(EFFORT_KEYS);
+  const usage5h = numeric(USAGE_5H_KEYS);
+  const usageWeekly = numeric(USAGE_WEEKLY_KEYS);
+  return {
+    ...inputTokens === void 0 ? {} : { inputTokens },
+    ...outputTokens === void 0 ? {} : { outputTokens },
+    ...cacheWriteTokens === void 0 ? {} : { cacheWriteTokens },
+    ...cacheReadTokens === void 0 ? {} : { cacheReadTokens },
+    ...model === void 0 ? {} : { model },
+    ...effort === void 0 ? {} : { effort },
+    ...usage5h === void 0 ? {} : { usage5h },
+    ...usageWeekly === void 0 ? {} : { usageWeekly }
+  };
+}
+var PATH_LIST_KEYS = ["paths", "file_paths", "filePaths"];
+var PATH_SINGLE_KEYS = ["file_path", "filePath", "path", "notebook_path"];
+function readReportedPaths(raw) {
+  const toolInput = property2(raw, "tool_input") ?? property2(raw, "toolInput");
+  for (const source of [toolInput, raw]) {
+    const list = first(source, PATH_LIST_KEYS);
+    if (Array.isArray(list)) return list.filter((one) => typeof one === "string");
+    const single = first(source, PATH_SINGLE_KEYS);
+    if (typeof single === "string" && single.length > 0) return [single];
+  }
+  return void 0;
+}
+
+// src/lib/cli/envelope.ts
+var EXIT = {
+  /** Accepted. */
+  OK: 0,
+  /** Unexpected failure — the caller did nothing wrong to cause it. */
+  FAILURE: 1,
+  /** Malformed command — not a thing this build can be asked to do. */
+  MALFORMED: 2,
+  /** Rejected by a rule. */
+  REJECTED: 3,
+  /** Not configured — neither binding could be resolved. */
+  UNCONFIGURED: 4
+};
+var EXIT_BY_CODE = {
+  invalid_input: EXIT.MALFORMED,
+  not_found: EXIT.REJECTED,
+  guard_rejected: EXIT.REJECTED,
+  conflict: EXIT.REJECTED,
+  forbidden: EXIT.REJECTED,
+  not_implemented: EXIT.FAILURE,
+  internal: EXIT.FAILURE
+};
+function exitCodeFor(envelope) {
+  if (envelope.ok) return EXIT.OK;
+  if (envelope.error.code === "malformed_command") return EXIT.MALFORMED;
+  return EXIT_BY_CODE[envelope.error.code];
+}
+function ok(data) {
+  return { ok: true, data };
+}
+function rejected(rejection, message) {
+  return {
+    ok: false,
+    error: {
+      code: rejection.code,
+      message,
+      fields: rejection.fields,
+      ...rejection.guard === void 0 ? {} : { guard: rejection.guard }
+    }
+  };
+}
+function malformed(message, fields = []) {
+  return { ok: false, error: { code: "malformed_command", message, fields } };
+}
+
+// src/lib/cli/hook-command.ts
+var HOOK_VERBS = ["run", "flush", "status"];
+function isHookVerb(value) {
+  return typeof value === "string" && HOOK_VERBS.includes(value);
+}
+function spoolEvent(raw, spool, now, options) {
+  const parsed = parseHookPayload(raw);
+  if (!parsed.ok) return void 0;
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  const record = buildRecord({
+    event: parsed.event,
+    now,
+    usage: readReportedUsage(payload),
+    paths: readReportedPaths(payload)
+  });
+  if (record === void 0) return void 0;
+  try {
+    spool.append(serialiseRecord(record));
+    enforceCeiling(spool, options);
+  } catch {
+    return void 0;
+  }
+  return record;
+}
+function enforceCeiling(spool, options) {
+  const interval = options?.trimInterval ?? DEFAULT_TRIM_INTERVAL;
+  const counter = options?.appendCounter;
+  if (counter === void 0) return;
+  if (!shouldTrimOnAppend(counter(), interval)) return;
+  const text = spool.read();
+  const { records } = readSpool(text);
+  const trimmed = trimSpool(records, options?.maxRecords ?? DEFAULT_MAX_RECORDS);
+  if (trimmed.dropped === 0) return;
+  spool.replace(serialiseSpool(trimmed.records));
+}
+async function runHookCommand(options) {
+  if (options.verb === "run") {
+    const stdin = options.stdin ?? "";
+    const response = await runHook({
+      stdin,
+      now: options.now,
+      askServer: options.hook?.askServer ?? (async () => void 0),
+      ...options.hook?.enforcement === void 0 ? {} : { enforcement: options.hook.enforcement }
+    });
+    spoolEvent(stdin, options.spool, options.now, {
+      ...options.appendCounter === void 0 ? {} : { appendCounter: options.appendCounter },
+      ...options.maxRecords === void 0 ? {} : { maxRecords: options.maxRecords },
+      ...options.trimInterval === void 0 ? {} : { trimInterval: options.trimInterval }
+    });
+    return { kind: "hook-response", response };
+  }
+  if (options.verb === "status") {
+    let text2;
+    try {
+      text2 = options.spool.read();
+    } catch {
+      text2 = void 0;
+    }
+    const contents = readSpool(text2);
+    const envelope = ok({
+      pending: contents.records.length,
+      unreadableLines: contents.skipped
+    });
+    return { kind: "envelope", envelope, exitCode: EXIT.OK };
+  }
+  if (options.send === void 0) {
+    return {
+      kind: "envelope",
+      envelope: malformed("standup hook flush needs somewhere to send to", ["send"]),
+      exitCode: EXIT.MALFORMED
+    };
+  }
+  let text;
+  try {
+    text = options.spool.read();
+  } catch {
+    text = void 0;
+  }
+  const result = await flushSpool({
+    send: options.send,
+    ...text === void 0 ? {} : { spoolText: text },
+    ...options.batchSize === void 0 ? {} : { batchSize: options.batchSize },
+    ...options.maxRecords === void 0 ? {} : { maxRecords: options.maxRecords }
+  });
+  const changed = result.sent > 0 || result.dropped > 0 || result.skipped > 0;
+  if (changed) {
+    try {
+      options.spool.replace(result.remaining);
+    } catch {
+    }
+  }
+  return {
+    kind: "envelope",
+    envelope: ok({
+      sent: result.sent,
+      retained: result.retained,
+      skipped: result.skipped,
+      dropped: result.dropped,
+      batches: result.attempted,
+      stoppedEarly: result.stoppedEarly
+    }),
+    exitCode: EXIT.OK
+  };
+}
+
+// src/lib/hook/flush-http.ts
+var DEFAULT_FLUSH_TIMEOUT_MS = 15e3;
+function isPermanent(status) {
+  if (status === 408 || status === 429) return false;
+  return status >= 400 && status < 500;
+}
+function createHttpFlush(options) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_FLUSH_TIMEOUT_MS;
+  const makeSignal = options.timeoutSignal ?? ((ms) => typeof AbortSignal?.timeout === "function" ? AbortSignal.timeout(ms) : void 0);
+  return async (batch) => {
+    const signal = makeSignal(timeoutMs);
+    try {
+      const response = await options.fetch(
+        `${options.baseUrl.replace(/\/+$/, "")}/api/tool-calls`,
+        {
+          method: "POST",
+          headers: {
+            "content-type": "application/json",
+            ...options.token === void 0 || options.token === "" ? {} : { authorization: `Bearer ${options.token}` }
+          },
+          body: JSON.stringify(batch),
+          ...signal === void 0 ? {} : { signal }
+        }
+      );
+      if (response.ok) return true;
+      options.onFailure?.({ status: response.status, permanent: isPermanent(response.status) });
+      return false;
+    } catch {
+      options.onFailure?.({ permanent: false });
+      return false;
+    }
+  };
+}
+
+// src/lib/cli/spool-file.ts
+import { appendFileSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+function spoolPath(env) {
+  const configured = env.STANDUP_SPOOL;
+  if (configured !== void 0 && configured.trim() !== "") return configured.trim();
+  const home = env.HOME ?? env.USERPROFILE ?? ".";
+  return path.join(home, ".standup", "telemetry.jsonl");
+}
+function fileSpool(file) {
+  return {
+    append: (line) => {
+      mkdirSync(path.dirname(file), { recursive: true });
+      appendFileSync(file, line, "utf-8");
+    },
+    read: () => {
+      try {
+        return readFileSync(file, "utf-8");
+      } catch {
+        return void 0;
+      }
+    },
+    replace: (text) => {
+      mkdirSync(path.dirname(file), { recursive: true });
+      writeFileSync(file, text, "utf-8");
+    }
+  };
+}
+function fileAppendCounter(file) {
+  return () => {
+    try {
+      return Math.floor(statSync(file).size / APPROXIMATE_RECORD_BYTES);
+    } catch {
+      return 0;
+    }
+  };
+}
+var APPROXIMATE_RECORD_BYTES = 600;
+
+export {
+  EXIT,
+  exitCodeFor,
+  ok,
+  rejected,
+  malformed,
+  parseHookPayload,
+  readSessionStatus,
+  readNudgeContext,
+  HOOK_EXIT,
+  readStopContext,
+  runHook,
+  captureContextFor,
+  flushSpool,
+  HOOK_VERBS,
+  isHookVerb,
+  spoolEvent,
+  runHookCommand,
+  createHttpFlush,
+  spoolPath,
+  fileSpool,
+  fileAppendCounter
+};