@jentrix/runner 0.5.3

package/dist/session-host-2Y7475EG.js

@@ -0,0 +1,1894 @@
+import {
+  RUNNER_VERSION
+} from "./chunk-A6NTXRVS.js";
+import {
+  appendHookEvent,
+  readHookLines,
+  safeParse
+} from "./chunk-PMRDMBQR.js";
+
+// lib/session-host.ts
+import { spawn } from "node:child_process";
+import {
+  existsSync,
+  readFileSync as readFileSync3,
+  statSync as statSync2,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync4
+} from "node:fs";
+import { homedir } from "node:os";
+import { join as join3 } from "node:path";
+import { createInterface } from "node:readline";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+
+// lib/session-auth.ts
+import { randomBytes } from "node:crypto";
+import {
+  chmodSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  writeFileSync
+} from "node:fs";
+import { dirname } from "node:path";
+function staticBearerSource(bearer) {
+  return { get: () => bearer, refresh: async () => null };
+}
+function readConfig(configPath) {
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, "utf8"));
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed))
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function writeConfig(configPath, config) {
+  mkdirSync(dirname(configPath), { recursive: true });
+  const tmp = `${configPath}.tmp.${process.pid}.${randomBytes(6).toString("hex")}`;
+  writeFileSync(tmp, `${JSON.stringify(config, null, 2)}
+`, {
+    mode: 384,
+    flag: "wx"
+  });
+  chmodSync(tmp, 384);
+  renameSync(tmp, configPath);
+}
+function oauthRecordOf(config) {
+  const oauth = config?.oauth;
+  if (oauth && typeof oauth.refreshToken === "string" && oauth.refreshToken.length > 0 && typeof oauth.tokenEndpoint === "string" && typeof oauth.clientId === "string") {
+    return oauth;
+  }
+  return null;
+}
+var FRESH_BEARER_WINDOW_MS = 12e4;
+function createConfigBearerSource(opts) {
+  const doFetch = opts.fetchImpl ?? fetch;
+  const log = opts.log ?? (() => void 0);
+  const now = opts.now ?? Date.now;
+  let pending = null;
+  let lastProduced = null;
+  let halted = false;
+  const get = () => {
+    const token = readConfig(opts.configPath)?.token;
+    return typeof token === "string" && token.length > 0 ? token : opts.fallback;
+  };
+  const refreshOnce = async (failedBearer) => {
+    const current = get();
+    if (current !== failedBearer) return current;
+    const config = readConfig(opts.configPath);
+    const oauth = oauthRecordOf(config);
+    if (!oauth) return null;
+    try {
+      const res = await doFetch(oauth.tokenEndpoint, {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+          grant_type: "refresh_token",
+          refresh_token: oauth.refreshToken,
+          client_id: oauth.clientId
+        }).toString()
+      });
+      if (!res.ok) throw new Error(`token endpoint ${res.status}`);
+      const pair = await res.json();
+      if (!pair.access_token || !pair.refresh_token) {
+        throw new Error("token endpoint returned no pair");
+      }
+      const expiresAt = new Date(
+        Date.now() + (pair.expires_in ?? 3600) * 1e3
+      ).toISOString();
+      writeConfig(opts.configPath, {
+        ...readConfig(opts.configPath) ?? {},
+        token: pair.access_token,
+        oauth: {
+          refreshToken: pair.refresh_token,
+          expiresAt,
+          clientId: oauth.clientId,
+          tokenEndpoint: oauth.tokenEndpoint,
+          ...pair.scope ? { scope: pair.scope } : {}
+        }
+      });
+      log("bearer refreshed (session host rotated the OAuth token)");
+      return pair.access_token;
+    } catch (error) {
+      const after = get();
+      if (after !== failedBearer) {
+        log("bearer refreshed by a concurrent process \u2014 adopted");
+        return after;
+      }
+      log(
+        `bearer refresh failed (${error instanceof Error ? error.message : String(error)})`
+      );
+      return null;
+    }
+  };
+  return {
+    get,
+    refresh: (failedBearer) => {
+      if (halted) return Promise.resolve(null);
+      if (lastProduced !== null && failedBearer === lastProduced.bearer && now() - lastProduced.at < FRESH_BEARER_WINDOW_MS) {
+        halted = true;
+        log(
+          "bearer halt: a freshly refreshed token was still unauthorized \u2014 the endpoint rejects this credential's whole chain (wrong deployment for this bearer?). Halting token rotation so sibling hosts keep theirs; end this host and re-align against the right deployment."
+        );
+        return Promise.resolve(null);
+      }
+      if (!pending) {
+        pending = refreshOnce(failedBearer).then((produced) => {
+          if (produced !== null) {
+            lastProduced = { bearer: produced, at: now() };
+          }
+          return produced;
+        }).finally(() => {
+          pending = null;
+        });
+      }
+      return pending;
+    }
+  };
+}
+function isUnauthorizedishError(e) {
+  if (typeof e === "object" && e !== null) {
+    const rec = e;
+    if (rec.code === 401 || rec.status === 401) return true;
+  }
+  const message = e instanceof Error ? e.message : String(e);
+  return /\b401\b|unauthorized|invalid_token|no authorization/i.test(message);
+}
+
+// lib/session-bridge.ts
+import { unlinkSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { join } from "node:path";
+
+// lib/session-events.ts
+var SESSION_EVENT_VERSION = 1;
+function serializeSessionEvent(event) {
+  return `${JSON.stringify({
+    version: event.version,
+    sequence: event.sequence,
+    at: event.at,
+    provider: event.provider,
+    ...event.providerEventId ? { providerEventId: event.providerEventId } : {},
+    kind: event.kind,
+    payload: event.payload
+  })}
+`;
+}
+
+// lib/session-usage.ts
+function insideOneRange(ranges, from, to) {
+  return ranges.some((r) => r.from <= from && to <= r.to);
+}
+function aggregateSessionUsage(input) {
+  const missing = [];
+  const seen = /* @__PURE__ */ new Set();
+  const receipts = input.receipts.filter((r) => {
+    if (seen.has(r.eventId)) return false;
+    seen.add(r.eventId);
+    return true;
+  }).sort((a, b) => a.at - b.at);
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let usable = 0;
+  const receiptTurnIds = /* @__PURE__ */ new Set();
+  let cacheReadTokens = 0;
+  let cacheReadReported = false;
+  let cacheCreationTokens = 0;
+  let cacheCreationReported = false;
+  let reasoningOutputTokens = 0;
+  let reasoningReported = false;
+  const buckets = /* @__PURE__ */ new Map();
+  const contribute = (c) => {
+    inputTokens += c.inputTokens;
+    outputTokens += c.outputTokens;
+    const bucket = buckets.get(c.modelId) ?? {
+      inputTokens: 0,
+      outputTokens: 0,
+      cacheReadTokens: 0,
+      cacheReadReported: false,
+      cacheCreationTokens: 0,
+      cacheCreationReported: false,
+      reasoningOutputTokens: 0,
+      reasoningReported: false
+    };
+    bucket.inputTokens += c.inputTokens;
+    bucket.outputTokens += c.outputTokens;
+    if (typeof c.cacheReadTokens === "number") {
+      cacheReadTokens += c.cacheReadTokens;
+      cacheReadReported = true;
+      bucket.cacheReadTokens += c.cacheReadTokens;
+      bucket.cacheReadReported = true;
+    }
+    if (typeof c.cacheCreationTokens === "number") {
+      cacheCreationTokens += c.cacheCreationTokens;
+      cacheCreationReported = true;
+      bucket.cacheCreationTokens += c.cacheCreationTokens;
+      bucket.cacheCreationReported = true;
+    }
+    if (typeof c.reasoningOutputTokens === "number") {
+      reasoningOutputTokens += c.reasoningOutputTokens;
+      reasoningReported = true;
+      bucket.reasoningOutputTokens += c.reasoningOutputTokens;
+      bucket.reasoningReported = true;
+    }
+    buckets.set(c.modelId, bucket);
+    usable += 1;
+  };
+  const modelOf = (receipt) => receipt.modelId?.trim() || null;
+  let cumulativeBaseline = null;
+  for (const receipt of receipts) {
+    if (receipt.turnId) receiptTurnIds.add(receipt.turnId);
+    if (receipt.kind === "delta") {
+      contribute({
+        modelId: modelOf(receipt),
+        inputTokens: receipt.inputTokens,
+        outputTokens: receipt.outputTokens,
+        ...typeof receipt.cacheReadTokens === "number" ? { cacheReadTokens: receipt.cacheReadTokens } : {},
+        ...typeof receipt.cacheCreationTokens === "number" ? { cacheCreationTokens: receipt.cacheCreationTokens } : {},
+        ...typeof receipt.reasoningOutputTokens === "number" ? { reasoningOutputTokens: receipt.reasoningOutputTokens } : {}
+      });
+      continue;
+    }
+    if (cumulativeBaseline === null) {
+      cumulativeBaseline = receipt;
+      missing.push(
+        `cumulative receipt ${receipt.eventId} established a baseline only \u2014 the thread total before it is not attributable to this session`
+      );
+      continue;
+    }
+    if (!insideOneRange(input.observedRanges, cumulativeBaseline.at, receipt.at)) {
+      missing.push(
+        `cumulative interval ${cumulativeBaseline.eventId}\u2192${receipt.eventId} crossed an unobserved range and was not counted`
+      );
+      cumulativeBaseline = receipt;
+      continue;
+    }
+    const dIn = receipt.inputTokens - cumulativeBaseline.inputTokens;
+    const dOut = receipt.outputTokens - cumulativeBaseline.outputTokens;
+    if (dIn < 0 || dOut < 0) {
+      missing.push(
+        `cumulative receipt ${receipt.eventId} regressed below its baseline and was not counted`
+      );
+      cumulativeBaseline = receipt;
+      continue;
+    }
+    contribute({
+      modelId: modelOf(receipt),
+      inputTokens: dIn,
+      outputTokens: dOut,
+      ...typeof receipt.cacheReadTokens === "number" && typeof cumulativeBaseline.cacheReadTokens === "number" && receipt.cacheReadTokens >= cumulativeBaseline.cacheReadTokens ? {
+        cacheReadTokens: receipt.cacheReadTokens - cumulativeBaseline.cacheReadTokens
+      } : {},
+      ...typeof receipt.cacheCreationTokens === "number" && typeof cumulativeBaseline.cacheCreationTokens === "number" && receipt.cacheCreationTokens >= cumulativeBaseline.cacheCreationTokens ? {
+        cacheCreationTokens: receipt.cacheCreationTokens - cumulativeBaseline.cacheCreationTokens
+      } : {},
+      ...typeof receipt.reasoningOutputTokens === "number" && typeof cumulativeBaseline.reasoningOutputTokens === "number" && receipt.reasoningOutputTokens >= cumulativeBaseline.reasoningOutputTokens ? {
+        reasoningOutputTokens: receipt.reasoningOutputTokens - cumulativeBaseline.reasoningOutputTokens
+      } : {}
+    });
+    cumulativeBaseline = receipt;
+  }
+  const perModel = [...buckets.entries()].map(
+    ([modelId, bucket]) => ({
+      modelId,
+      inputTokens: bucket.inputTokens,
+      outputTokens: bucket.outputTokens,
+      cacheReadTokens: bucket.cacheReadReported ? bucket.cacheReadTokens : null,
+      cacheCreationTokens: bucket.cacheCreationReported ? bucket.cacheCreationTokens : null,
+      reasoningOutputTokens: bucket.reasoningReported ? bucket.reasoningOutputTokens : null
+    })
+  );
+  function sumIntervals(intervals, label) {
+    let total = 0;
+    let closed = 0;
+    for (const interval of intervals) {
+      if (interval.endedAt == null) {
+        missing.push(`${label} interval ${interval.id} never observed its terminal event`);
+        continue;
+      }
+      total += Math.max(0, interval.endedAt - interval.startedAt);
+      closed += 1;
+    }
+    if (intervals.length === 0) return { total: null, complete: true };
+    return { total, complete: closed === intervals.length };
+  }
+  const provider = sumIntervals(input.providerTurns, "provider turn");
+  const tool = sumIntervals(input.toolIntervals, "tool");
+  const turnsWithoutReceipts = input.providerTurns.filter(
+    (t) => !receiptTurnIds.has(t.id)
+  );
+  for (const turn of turnsWithoutReceipts) {
+    missing.push(`provider turn ${turn.id} carried no usable usage receipt`);
+  }
+  if (usable === 0) {
+    return {
+      inputTokens: null,
+      outputTokens: null,
+      cacheReadTokens: null,
+      cacheCreationTokens: null,
+      reasoningOutputTokens: null,
+      providerActiveDurationMs: provider.total,
+      toolDurationMs: tool.total,
+      coverage: "UNAVAILABLE",
+      missingRanges: missing,
+      perModel: []
+    };
+  }
+  const complete = missing.length === 0 && provider.complete && tool.complete;
+  return {
+    inputTokens,
+    outputTokens,
+    cacheReadTokens: cacheReadReported ? cacheReadTokens : null,
+    cacheCreationTokens: cacheCreationReported ? cacheCreationTokens : null,
+    reasoningOutputTokens: reasoningReported ? reasoningOutputTokens : null,
+    providerActiveDurationMs: provider.total,
+    toolDurationMs: tool.total,
+    coverage: complete ? "COMPLETE" : "PARTIAL",
+    missingRanges: missing,
+    perModel
+  };
+}
+
+// lib/session-bridge.ts
+var MAX_FINAL_RESPONSE_BYTES = 2 * 1024 * 1024;
+var HEARTBEAT_MIN_INTERVAL_MS = 3e4;
+var SessionBridge = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  sequence = 0;
+  receipts = [];
+  providerTurns = /* @__PURE__ */ new Map();
+  toolIntervals = /* @__PURE__ */ new Map();
+  observedRanges = [];
+  /**
+   * control-room AC2.1/AC2.2 — the LAST model the provider was observed
+   * running. Last, not first: a session may legitimately switch models
+   * mid-flight and the model that ran is the one that ran. Null until a line
+   * names one; the heartbeat then omits the field entirely, so an unobserved
+   * model can never overwrite a proven one server-side.
+   */
+  observedModelId = null;
+  observingSince = null;
+  ackedParts = /* @__PURE__ */ new Map();
+  terminalParts = /* @__PURE__ */ new Set();
+  lastHeartbeatAt = 0;
+  unrecognizedEvents = 0;
+  capability = null;
+  inactive = false;
+  /**
+   * AGE-649 — the newest non-empty assistant message observed, kept so the
+   * session's own OUTPUT survives the close. Held in memory only: this is a
+   * projection of an event the host already sees, never a second capture
+   * channel, and it is recorded even when TRACE capture is off (which is the
+   * whole point — capture-off is the MVP default, and without this a closed
+   * session keeps its telemetry and loses what it actually concluded).
+   */
+  lastAssistantMessage = null;
+  /**
+   * True after a heartbeat came back 409 SESSION_NOT_ACTIVE — the session is
+   * terminal server-side. The watch host uses this as its end signal when no
+   * lifecycle hook can reach it; network loss never sets it.
+   */
+  get sessionInactive() {
+    return this.inactive;
+  }
+  /** Server-acknowledged parts so far — the host stamps this into host.json. */
+  get ackedPartCount() {
+    return this.ackedParts.size;
+  }
+  /** The injected MCP tool caller (host convenience — same credential). */
+  get tool() {
+    return this.deps.callTool;
+  }
+  now() {
+    return (this.deps.monotonic ?? (() => performance.now()))();
+  }
+  wall() {
+    return (this.deps.wallClock ?? (() => /* @__PURE__ */ new Date()))();
+  }
+  fetch() {
+    return this.deps.fetchImpl ?? fetch;
+  }
+  /** Begin (or resume) continuous observation — opens an observed range. */
+  startObserving() {
+    if (this.observingSince === null) this.observingSince = this.now();
+  }
+  /** A capture gap (stream drop, provider restart): closes the range. */
+  recordGap(reason) {
+    if (this.observingSince !== null) {
+      this.observedRanges.push({ from: this.observingSince, to: this.now() });
+      this.observingSince = null;
+    }
+    this.record({ kind: "error", payload: { captureGap: reason } });
+  }
+  /** Record the provider capability snapshot (§15.3) as an observable event. */
+  recordCapabilities(snapshot) {
+    this.capability = snapshot;
+    this.record({ kind: "session", payload: { capabilities: snapshot } });
+  }
+  get capabilities() {
+    return this.capability;
+  }
+  countUnrecognized() {
+    this.unrecognizedEvents += 1;
+  }
+  /**
+   * Append one observable event: sequence + wall timestamp stamped here, the
+   * whole line REDACTED before it becomes durable, usage receipts collected
+   * for the rollup (deduped downstream by provider event identity).
+   */
+  record(event) {
+    const full = {
+      version: 1,
+      sequence: this.sequence++,
+      at: event.at ?? this.wall().toISOString(),
+      provider: this.deps.provider,
+      ...event.providerEventId ? { providerEventId: event.providerEventId } : {},
+      kind: event.kind,
+      payload: this.deps.redactor.value(event.payload)
+    };
+    if (this.deps.traceCapture !== false) {
+      this.deps.spool.append(
+        this.deps.redactor.text(serializeSessionEvent(full))
+      );
+    }
+    if (full.kind === "assistant_message") {
+      const text2 = full.payload?.text;
+      if (typeof text2 === "string" && text2.trim().length > 0) {
+        this.lastAssistantMessage = {
+          text: text2,
+          at: full.at,
+          sequence: full.sequence
+        };
+      }
+    }
+    if (full.kind === "usage") {
+      const payload = full.payload;
+      if ((payload?.kind === "delta" || payload?.kind === "cumulative") && typeof payload.inputTokens === "number" && typeof payload.outputTokens === "number") {
+        this.receipts.push({
+          eventId: full.providerEventId ?? `seq:${full.sequence}`,
+          turnId: payload.turnId ?? null,
+          kind: payload.kind,
+          inputTokens: payload.inputTokens,
+          outputTokens: payload.outputTokens,
+          ...typeof payload.cacheReadTokens === "number" ? { cacheReadTokens: payload.cacheReadTokens } : {},
+          ...typeof payload.cacheCreationTokens === "number" ? { cacheCreationTokens: payload.cacheCreationTokens } : {},
+          // TPM Slice 2 (AC2.4/AC2.7): the receipt's own model and reasoning
+          // split, when the mapper reported them — grouped receipts, never
+          // estimates.
+          ...typeof payload.reasoningOutputTokens === "number" ? { reasoningOutputTokens: payload.reasoningOutputTokens } : {},
+          ...typeof payload.modelId === "string" && payload.modelId.trim() ? { modelId: payload.modelId.trim() } : {},
+          at: this.now()
+        });
+        this.persistUsageSnapshot();
+      }
+    }
+    return full;
+  }
+  /** Best-effort spool-side snapshot of the current rollup (provider receipts). */
+  persistUsageSnapshot() {
+    try {
+      writeFileSync2(
+        join(this.deps.spool.directory, "usage.json"),
+        JSON.stringify({
+          rollup: this.usageRollup(),
+          updatedAt: this.wall().toISOString()
+        }),
+        { mode: 384 }
+      );
+    } catch {
+    }
+  }
+  /** Record the model a transcript line named (pure accumulation, no I/O). */
+  observeModel(modelId) {
+    const next = modelId.trim();
+    if (next) this.observedModelId = next;
+  }
+  /** What the host has observed running, for tests and the close-time record. */
+  get modelId() {
+    return this.observedModelId;
+  }
+  /**
+   * control-room AC3.7 — record an interval whose bounds were OBSERVED rather
+   * than measured on this process's clock. The Claude path replays timestamps
+   * the transcript already carries, so `this.now()` (which the mark* pair
+   * below uses for the live Codex path) would time the tail, not the turn.
+   */
+  recordInterval(interval) {
+    const target = interval.kind === "turn" ? this.providerTurns : this.toolIntervals;
+    target.set(interval.id, {
+      id: interval.id,
+      startedAt: interval.startedAt,
+      endedAt: interval.endedAt
+    });
+  }
+  /**
+   * An interval opened and never closed — a tool that never returned, a host
+   * killed mid-turn. Recorded WITHOUT an end so `aggregateSessionUsage` names
+   * the gap and degrades coverage to PARTIAL, instead of the total quietly
+   * omitting it and reading as complete.
+   */
+  recordUnclosedInterval(kind, id) {
+    const target = kind === "turn" ? this.providerTurns : this.toolIntervals;
+    if (!target.has(id)) target.set(id, { id, startedAt: 0, endedAt: null });
+  }
+  markTurnStarted(id) {
+    this.providerTurns.set(id, { id, startedAt: this.now(), endedAt: null });
+  }
+  markTurnEnded(id) {
+    const turn = this.providerTurns.get(id);
+    if (turn) turn.endedAt = this.now();
+  }
+  markToolStarted(id) {
+    this.toolIntervals.set(id, { id, startedAt: this.now(), endedAt: null });
+  }
+  markToolEnded(id) {
+    const interval = this.toolIntervals.get(id);
+    if (interval) interval.endedAt = this.now();
+  }
+  /** The current REST bearer (function form resolves per request). */
+  bearerOf() {
+    return typeof this.deps.bearer === "function" ? this.deps.bearer() : this.deps.bearer;
+  }
+  /** ≤ one heartbeat per 30s window (AC42); failures are silent (retry next). */
+  async maybeHeartbeat() {
+    const now = this.now();
+    if (now - this.lastHeartbeatAt < HEARTBEAT_MIN_INTERVAL_MS) return;
+    await this.postHeartbeat(now);
+  }
+  /**
+   * TPM Slice 2 (AC2.5): the flush receipt — an immediate beat that ignores
+   * the 30-second window, posted before a task-changing re-align so the OLD
+   * alignment's open interval absorbs everything observed so far. Host-side
+   * ordering only: a killed host's mid-switch smear stays bounded by one
+   * beat window, which the CLI disclosure names.
+   */
+  async flushUsageNow() {
+    return this.postHeartbeat(this.now());
+  }
+  /** @returns true when the server acknowledged the beat (HTTP ok). */
+  async postHeartbeat(now) {
+    this.lastHeartbeatAt = now;
+    const bearer = this.bearerOf();
+    try {
+      const response = await this.fetch()(
+        new URL("/api/agent-sessions/heartbeat", this.deps.jentrixBaseUrl),
+        {
+          method: "POST",
+          headers: {
+            authorization: `Bearer ${bearer}`,
+            "content-type": "application/json"
+          },
+          body: JSON.stringify({
+            sessionId: this.deps.sessionId,
+            // control-room AC2.1: the heartbeat is the host's "what I
+            // observed" channel. No new timer, no new route, no new tool —
+            // and host-attested by construction, since the route writes only
+            // the authenticated operator's own open session.
+            ...this.observedModelId ? { modelId: this.observedModelId } : {},
+            // control-room AC4.1: the LIVE usage receipt on the same beat.
+            // Sent only once a receipt has actually been observed — an empty
+            // rollup would overwrite the session's totals with nulls and
+            // report UNAVAILABLE for a session that had already reported.
+            ...this.receipts.length > 0 ? { usage: this.usageRollup() } : {}
+          })
+        }
+      );
+      if (response.status === 401) {
+        void this.deps.onUnauthorized?.(bearer)?.catch(() => void 0);
+      }
+      if (response.status === 409) {
+        const body = await response.text().catch(() => "");
+        if (body.includes("SESSION_NOT_ACTIVE")) this.inactive = true;
+      }
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Upload every pending spool part. Returns the still-pending count — a
+   * non-zero result is "capture pending", printed prominently and encoded in
+   * the CLI exit code (§20). A redacted-slot refusal (terminal, §12.3) keeps
+   * the local file forever and is reported as a named gap.
+   */
+  async flushParts() {
+    if (this.deps.traceCapture === false) return { pending: 0, terminal: 0 };
+    let pending = 0;
+    for (const part of this.deps.spool.pendingParts()) {
+      if (this.terminalParts.has(part.part)) continue;
+      const bearer = this.bearerOf();
+      try {
+        const response = await this.fetch()(
+          new URL(
+            `/api/agent-sessions/${this.deps.sessionId}/parts`,
+            this.deps.jentrixBaseUrl
+          ),
+          {
+            method: "POST",
+            headers: {
+              authorization: `Bearer ${bearer}`,
+              "content-type": "application/json"
+            },
+            body: JSON.stringify({
+              part: part.part,
+              body: this.deps.spool.readPart(part.part)
+            })
+          }
+        );
+        if (response.ok) {
+          const ack = await response.json();
+          const acked = typeof ack.checksum === "string" ? ack.checksum : part.checksum;
+          this.ackedParts.set(part.part, acked);
+          this.deps.spool.deleteAcknowledged(part.part, acked, { force: true });
+          this.deps.spool.advancePast(part.part);
+          continue;
+        }
+        if (response.status === 401) {
+          void this.deps.onUnauthorized?.(bearer)?.catch(() => void 0);
+        }
+        const body = await response.text().catch(() => "");
+        if (response.status === 409 && body.includes("ARTIFACT_PART_REDACTED")) {
+          this.terminalParts.add(part.part);
+          this.deps.log?.(
+            `trace part ${part.part}: slot terminally redacted \u2014 local spool retained`
+          );
+          continue;
+        }
+        pending += 1;
+      } catch {
+        pending += 1;
+      }
+    }
+    return { pending, terminal: this.terminalParts.size };
+  }
+  /**
+   * AGE-649 — push the session's FINAL RESPONSE as a typed artifact.
+   *
+   * Why this exists: with TRACE capture off (the MVP default) a closed session
+   * keeps its telemetry and its typed artifacts, and nothing at all holds what
+   * the agent concluded. The RUN_SUMMARY cannot carry it — that document is a
+   * deterministic server projection and model prose is banned from it (M20.1
+   * AC31) — so the output lands as its own artifact, on the same typed-push
+   * boundary an operator's `jentrix push report` uses. One ingestion function,
+   * both redaction passes, checksum after redaction.
+   *
+   * Ordering is load-bearing: `COMPLETED` is a SEALED status for typed pushes,
+   * so this runs BEFORE `complete_agent_session`, never after.
+   *
+   * Absence stays absence. A session where the host observed no assistant text
+   * (capture never bound, a Codex thread that only ran tools) gets NO artifact
+   * rather than an empty one — the same rule the usage rollup follows for
+   * tokens. Failure never fails the close: the artifact is a bonus record, and
+   * losing it must not cost the operator their session completion.
+   *
+   * @returns the artifact id, or null when there was nothing to push.
+   */
+  async pushFinalResponse() {
+    const last = this.lastAssistantMessage;
+    if (!last) return null;
+    const body = this.finalResponseBody(last);
+    const bearer = this.bearerOf();
+    try {
+      const response = await this.fetch()(
+        new URL(
+          `/api/agent-sessions/${this.deps.sessionId}/artifacts`,
+          this.deps.jentrixBaseUrl
+        ),
+        {
+          method: "POST",
+          headers: {
+            authorization: `Bearer ${bearer}`,
+            "content-type": "application/json"
+          },
+          body: JSON.stringify({
+            // `report` → REPORT → the Execution layer, which is the session's
+            // own layer. No new push kind and no new ArtifactType: the seven
+            // kinds are frozen vocabulary and this is a report the agent wrote.
+            kind: "report",
+            title: `Final response \u2014 session ${this.deps.sessionId.slice(-8)}`,
+            body
+          })
+        }
+      );
+      if (response.ok) {
+        const ack = await response.json().catch(() => null);
+        return ack?.artifactId ?? null;
+      }
+      if (response.status === 401) {
+        void this.deps.onUnauthorized?.(bearer)?.catch(() => void 0);
+      }
+      this.deps.log?.(
+        `final response: not stored (HTTP ${response.status}) \u2014 the session's closing output was not captured`
+      );
+      return null;
+    } catch (error) {
+      this.deps.log?.(
+        `final response: not stored (${error instanceof Error ? error.message : "unknown"}) \u2014 the session's closing output was not captured`
+      );
+      return null;
+    }
+  }
+  /**
+   * The stored document. Self-describing on purpose: a reader has to be able to
+   * tell this apart from the RUN_SUMMARY sitting beside it, and has to know it
+   * is verbatim provider output rather than anything the server derived.
+   *
+   * Bounded here as well as server-side, and a truncation SAYS so — an artifact
+   * silently missing its tail is worse than one that names the cut.
+   */
+  finalResponseBody(last) {
+    const header = [
+      `# Final response \u2014 session ${this.deps.sessionId}`,
+      "",
+      `The last assistant message this session's host observed before close (event ${last.sequence}, ${last.at}).`,
+      "Verbatim provider output \u2014 redacted on this machine and again on arrival.",
+      "This is model prose, not a server projection: the RUN_SUMMARY artifact is the deterministic record of what the session did.",
+      "",
+      "---",
+      ""
+    ].join("\n");
+    const room = MAX_FINAL_RESPONSE_BYTES - Buffer.byteLength(header, "utf8");
+    if (Buffer.byteLength(last.text, "utf8") <= room) return header + last.text;
+    const notice = "\n\n[truncated \u2014 the response exceeded the artifact limit]";
+    const kept = Buffer.from(last.text, "utf8").subarray(0, Math.max(0, room - Buffer.byteLength(notice, "utf8"))).toString("utf8").replace(/�+$/, "");
+    return header + kept + notice;
+  }
+  /** The §12.5 rollup over everything observed so far. */
+  usageRollup() {
+    const ranges = [...this.observedRanges];
+    if (this.observingSince !== null) {
+      ranges.push({ from: this.observingSince, to: this.now() });
+    }
+    return aggregateSessionUsage({
+      receipts: this.receipts,
+      observedRanges: ranges,
+      providerTurns: [...this.providerTurns.values()],
+      toolIntervals: [...this.toolIntervals.values()]
+    });
+  }
+  /**
+   * Close the session: final flush, server-verified manifest from the ACKED
+   * checksums, rollup, then `complete_agent_session` under CAS. Returns the
+   * server's verdict plus the local pending count — the CLI exits non-zero
+   * while anything is pending (§20).
+   */
+  async complete(opts) {
+    const { pending } = await this.flushParts();
+    const finalResponseArtifactId = await this.pushFinalResponse();
+    const rollup = this.usageRollup();
+    const current = await this.deps.callTool("get_agent_session", {
+      sessionId: this.deps.sessionId
+    });
+    const traceOff = this.deps.traceCapture === false;
+    const manifest = traceOff ? void 0 : {
+      parts: [...this.ackedParts.entries()].sort(([a], [b]) => a - b).map(([part, checksum]) => ({ part, checksum }))
+    };
+    const captureError = opts.captureError ?? (traceOff ? null : pending > 0 ? `capture pending: ${pending} trace part(s) not yet acknowledged` : this.unrecognizedEvents > 0 ? `${this.unrecognizedEvents} provider event(s) had shapes this adapter does not observe` : null);
+    const result = await this.deps.callTool("complete_agent_session", {
+      sessionId: this.deps.sessionId,
+      outcome: opts.outcome,
+      endBranch: opts.end.branch,
+      endHead: opts.end.head,
+      endDirty: opts.end.dirty,
+      captureError,
+      ...manifest ? { manifest } : {},
+      usage: {
+        inputTokens: rollup.inputTokens,
+        outputTokens: rollup.outputTokens,
+        cacheReadTokens: rollup.cacheReadTokens,
+        cacheCreationTokens: rollup.cacheCreationTokens,
+        // TPM Slice 2 (AC2.6/AC2.7): the close corrects session TOTALS —
+        // reasoning included, perModel deliberately NOT sent (the server
+        // writes no segments at close; residuals stay disclosed).
+        reasoningOutputTokens: rollup.reasoningOutputTokens,
+        providerActiveDurationMs: rollup.providerActiveDurationMs,
+        toolDurationMs: rollup.toolDurationMs,
+        coverage: rollup.coverage,
+        ...rollup.missingRanges.length ? { missingRanges: rollup.missingRanges.slice(0, 200) } : {}
+      },
+      expectedUpdatedAt: current.updatedAt
+    });
+    try {
+      unlinkSync(join(this.deps.spool.directory, "usage.json"));
+    } catch {
+    }
+    return {
+      status: result.status ?? opts.outcome,
+      captureComplete: Boolean(result.captureComplete),
+      summaryArtifactId: result.summaryArtifactId ?? null,
+      finalResponseArtifactId,
+      pendingParts: pending
+    };
+  }
+};
+
+// lib/session-claude-transcript.ts
+function baseEvent(entry, kind, payload, idSuffix = "") {
+  return {
+    version: SESSION_EVENT_VERSION,
+    at: entry.timestamp ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    provider: "claude",
+    ...entry.uuid ? { providerEventId: `${entry.uuid}${idSuffix}` } : {},
+    kind,
+    payload
+  };
+}
+function textOf(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n");
+}
+function mapClaudeTranscriptLine(line) {
+  let entry;
+  try {
+    entry = JSON.parse(line);
+  } catch {
+    return { events: [], unrecognized: true };
+  }
+  if (entry?.type !== "user" && entry?.type !== "assistant") {
+    return { events: [], unrecognized: false };
+  }
+  const events = [];
+  const content = entry.message?.content;
+  if (entry.type === "user") {
+    const blocks2 = Array.isArray(content) ? content : [];
+    const toolResults = blocks2.filter((b) => b.type === "tool_result");
+    for (const block of toolResults) {
+      events.push(
+        baseEvent(
+          entry,
+          "tool_result",
+          {
+            toolUseId: block.tool_use_id ?? null,
+            isError: Boolean(block.is_error),
+            content: block.content ?? null
+          },
+          `:result:${block.tool_use_id ?? ""}`
+        )
+      );
+    }
+    const text3 = textOf(content);
+    if (text3) {
+      events.push(baseEvent(entry, "user_message", { text: text3 }));
+    }
+    return {
+      events,
+      unrecognized: false,
+      ...timingOf(entry, {
+        toolEnds: toolResults.map((block) => block.tool_use_id).filter((id) => typeof id === "string")
+      })
+    };
+  }
+  const modelId = typeof entry.message?.model === "string" && entry.message.model.trim() ? entry.message.model.trim() : void 0;
+  const blocks = Array.isArray(content) ? content : [];
+  const text2 = textOf(content);
+  if (text2) {
+    events.push(baseEvent(entry, "assistant_message", { text: text2 }));
+  }
+  for (const block of blocks) {
+    if (block.type === "tool_use") {
+      events.push(
+        baseEvent(
+          entry,
+          "tool_call",
+          { toolUseId: block.id ?? null, name: block.name ?? null, input: block.input ?? null },
+          `:tool:${block.id ?? ""}`
+        )
+      );
+    }
+  }
+  const usage = entry.message?.usage;
+  if (usage && (typeof usage.input_tokens === "number" || typeof usage.cache_creation_input_tokens === "number" || typeof usage.cache_read_input_tokens === "number" || typeof usage.output_tokens === "number")) {
+    const hasCacheFields = typeof usage.cache_read_input_tokens === "number" || typeof usage.cache_creation_input_tokens === "number";
+    events.push(
+      baseEvent(
+        entry,
+        "usage",
+        {
+          kind: "delta",
+          inputTokens: (usage.input_tokens ?? 0) + (usage.cache_creation_input_tokens ?? 0) + (usage.cache_read_input_tokens ?? 0),
+          outputTokens: usage.output_tokens ?? 0,
+          ...hasCacheFields ? {
+            cacheReadTokens: usage.cache_read_input_tokens ?? 0,
+            cacheCreationTokens: usage.cache_creation_input_tokens ?? 0
+          } : {},
+          // TPM Slice 2 (AC2.4): the model that produced THIS receipt — the
+          // same entry stamps both, which is what makes per-model grouping a
+          // grouped receipt rather than an estimate. Anthropic does not split
+          // reasoning tokens out, so no reasoningOutputTokens here (absent,
+          // never 0).
+          ...modelId ? { modelId } : {}
+        },
+        ":usage"
+      )
+    );
+  }
+  return {
+    events,
+    unrecognized: false,
+    ...modelId ? { modelId } : {},
+    ...timingOf(entry, {
+      toolStarts: blocks.filter((block) => block.type === "tool_use").map((block) => block.id).filter((id) => typeof id === "string")
+    })
+  };
+}
+function timingOf(entry, parts) {
+  const at = entry.timestamp ? Date.parse(entry.timestamp) : NaN;
+  if (!Number.isFinite(at)) return {};
+  return {
+    timing: {
+      at,
+      id: entry.uuid ?? String(at),
+      role: entry.type === "assistant" ? "assistant" : "user",
+      ...parts.toolStarts?.length ? { toolStarts: parts.toolStarts } : {},
+      ...parts.toolEnds?.length ? { toolEnds: parts.toolEnds } : {}
+    }
+  };
+}
+
+// lib/session-claude-timing.ts
+var ClaudeTimingTracker = class {
+  /**
+   * When the provider was last handed control: the newest user message or
+   * tool result. Null before the first one — an assistant entry with no
+   * preceding boundary (a resumed transcript whose head we never saw) yields
+   * NO interval rather than an invented one starting at zero.
+   */
+  boundaryAt = null;
+  openTools = /* @__PURE__ */ new Map();
+  /** Feed one line; returns every interval this line CLOSED. */
+  observe(line) {
+    const closed = [];
+    for (const toolUseId of line.toolEnds ?? []) {
+      const startedAt = this.openTools.get(toolUseId);
+      if (startedAt === void 0) continue;
+      this.openTools.delete(toolUseId);
+      closed.push({
+        kind: "tool",
+        id: `tool:${toolUseId}`,
+        startedAt,
+        endedAt: line.at
+      });
+    }
+    if (line.role === "assistant") {
+      if (this.boundaryAt !== null) {
+        closed.push({
+          kind: "turn",
+          id: `turn:${line.id}`,
+          startedAt: this.boundaryAt,
+          endedAt: line.at
+        });
+      }
+      for (const toolUseId of line.toolStarts ?? []) {
+        this.openTools.set(toolUseId, line.at);
+      }
+      this.boundaryAt = (line.toolStarts?.length ?? 0) > 0 ? null : line.at;
+      return closed;
+    }
+    this.boundaryAt = line.at;
+    return closed;
+  }
+  /**
+   * Tool calls still open at close — a killed host, a tool that never
+   * returned. Reported so the aggregator can NAME the gap and degrade
+   * coverage to PARTIAL rather than quietly summing a shorter total.
+   */
+  unclosedToolIds() {
+    return [...this.openTools.keys()].map((id) => `tool:${id}`);
+  }
+};
+
+// lib/session-codex-events.ts
+function make(kind, payload, providerEventId) {
+  return {
+    version: SESSION_EVENT_VERSION,
+    at: (/* @__PURE__ */ new Date(0)).toISOString(),
+    // stamped by the bridge at observation time
+    provider: "codex",
+    ...providerEventId ? { providerEventId } : {},
+    kind,
+    payload
+  };
+}
+function mapCodexThreadEvent(raw) {
+  const event = raw ?? {};
+  switch (event.type) {
+    case "thread.started":
+      return {
+        event: make("session", { threadId: event.thread_id ?? null }),
+        ...event.thread_id ? { threadId: event.thread_id } : {},
+        unrecognized: false
+      };
+    case "turn.started":
+      return { event: null, unrecognized: false };
+    case "turn_context": {
+      const model = (event.turn_context?.model ?? event.model)?.trim();
+      return {
+        event: null,
+        ...model ? { modelId: model } : {},
+        unrecognized: false
+      };
+    }
+    case "turn.completed":
+      return {
+        event: event.usage ? make("usage", {
+          kind: "delta",
+          inputTokens: event.usage.input_tokens ?? 0,
+          outputTokens: event.usage.output_tokens ?? 0,
+          ...typeof event.usage.cached_input_tokens === "number" ? { cacheReadTokens: event.usage.cached_input_tokens } : {},
+          // TPM Slice 2 (AC2.7): real spend visibility OpenAI reports
+          // and Anthropic does not split out — mapped only when present.
+          ...typeof event.usage.reasoning_output_tokens === "number" ? {
+            reasoningOutputTokens: event.usage.reasoning_output_tokens
+          } : {}
+        }) : null,
+        unrecognized: false
+      };
+    case "turn.failed":
+      return {
+        event: make("error", {
+          message: event.error?.message ?? "turn failed"
+        }),
+        unrecognized: false
+      };
+    case "item.completed": {
+      const item = event.item ?? {};
+      const id = item.id;
+      switch (item.type) {
+        case "agent_message":
+          return {
+            event: make("assistant_message", { text: item.text ?? "" }, id),
+            unrecognized: false
+          };
+        case "command_execution":
+          return {
+            event: make(
+              "command",
+              {
+                command: item.command ?? null,
+                exitCode: item.exit_code ?? null,
+                output: item.aggregated_output ?? null
+              },
+              id
+            ),
+            unrecognized: false
+          };
+        case "file_change":
+          return {
+            event: make("file_change", { changes: item.changes ?? null }, id),
+            unrecognized: false
+          };
+        case "mcp_tool_call":
+          return {
+            event: make(
+              "tool_call",
+              {
+                name: item.name ?? null,
+                input: item.arguments ?? null,
+                status: item.status ?? null
+              },
+              id
+            ),
+            unrecognized: false
+          };
+        case "reasoning":
+          return { event: null, unrecognized: false };
+        default:
+          return { event: null, unrecognized: true };
+      }
+    }
+    default:
+      return { event: null, unrecognized: true };
+  }
+}
+
+// lib/session-codex-hooks.ts
+function text(value) {
+  return typeof value === "string" && value.trim() ? value : null;
+}
+function mapCodexHook(event, payload) {
+  const modelId = text(payload.model);
+  switch (event) {
+    case "SessionStart":
+    case "SessionEnd":
+    case "PreCompact":
+    case "PostCompact":
+      return {
+        events: [
+          {
+            kind: "session",
+            payload: {
+              lifecycle: event,
+              sessionId: payload.session_id ?? null
+            }
+          }
+        ],
+        modelId
+      };
+    case "UserPromptSubmit": {
+      const prompt = text(payload.prompt);
+      return {
+        events: prompt ? [{ kind: "user_message", payload: { text: prompt } }] : [],
+        modelId
+      };
+    }
+    case "PostToolUse": {
+      const name = text(payload.tool_name) ?? "unknown";
+      const events = [
+        {
+          kind: "tool_call",
+          payload: { name, input: payload.tool_input ?? null }
+        }
+      ];
+      if ("tool_response" in payload) {
+        events.push({
+          kind: "tool_result",
+          payload: { name, result: payload.tool_response }
+        });
+      }
+      return { events, modelId };
+    }
+    case "Stop": {
+      const message = text(payload.last_assistant_message);
+      return {
+        events: message ? [{ kind: "assistant_message", payload: { text: message } }] : [],
+        modelId
+      };
+    }
+    default:
+      return { events: [], modelId };
+  }
+}
+
+// lib/session-redact.ts
+var REDACTED = "\u2039redacted\u203A";
+var SECRET_PATTERNS = [
+  /\btm[or]?_[A-Za-z0-9_-]{16,}\b/g,
+  /\bgh[posru]_[A-Za-z0-9]{20,}\b/g,
+  /\bgithub_pat_[A-Za-z0-9_]{20,}\b/g,
+  /\bwhsec_[A-Za-z0-9]{16,}\b/g,
+  /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g,
+  /\bxox[abpsr]-[A-Za-z0-9-]{10,}\b/g,
+  /\bAIza[A-Za-z0-9_-]{30,}\b/g,
+  /\bsk-ant-[A-Za-z0-9_-]{20,}\b/g,
+  /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/g,
+  /\b[rs]k_(?:live|test)_[A-Za-z0-9]{16,}\b/g,
+  /-----BEGIN (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA |PGP )?PRIVATE KEY-----/g,
+  /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g,
+  /\b(Authorization\s*[:=]\s*Bearer\s+)[A-Za-z0-9._~+/=-]{12,}/gi
+];
+var SECRET_ENV_NAMES = [
+  "STACKS_TOKEN",
+  "STACKS_BOOTSTRAP_TOKEN",
+  "STACKS_WEBHOOK_SECRET",
+  "STACKS_WORKLOAD_SVID",
+  "ANTHROPIC_API_KEY",
+  "OPENAI_API_KEY",
+  "GITHUB_TOKEN",
+  "AWS_SECRET_ACCESS_KEY",
+  "R2_SECRET_ACCESS_KEY"
+];
+function createSessionRedactor(opts = {}) {
+  const env = opts.env ?? process.env;
+  const literals = [
+    ...opts.literals ?? [],
+    ...SECRET_ENV_NAMES.map((name) => env[name]).filter(
+      (v) => typeof v === "string" && v.length >= 6
+    )
+  ];
+  const home = opts.homedir?.replace(/\/$/, "");
+  function text2(input) {
+    let out = input;
+    for (const literal of literals) {
+      out = out.split(literal).join(REDACTED);
+    }
+    for (const pattern of SECRET_PATTERNS) {
+      out = out.replace(pattern, REDACTED);
+    }
+    if (home && home.length > 1) {
+      out = out.split(home).join("~");
+    }
+    return out;
+  }
+  function value(input) {
+    if (typeof input === "string") return text2(input);
+    if (Array.isArray(input)) return input.map(value);
+    if (input && typeof input === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(input)) {
+        out[k] = value(v);
+      }
+      return out;
+    }
+    return input;
+  }
+  return { text: text2, value };
+}
+
+// lib/session-spool.ts
+import { createHash } from "node:crypto";
+import {
+  appendFileSync,
+  closeSync,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readdirSync,
+  readFileSync as readFileSync2,
+  renameSync as renameSync2,
+  statSync,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3,
+  writeSync
+} from "node:fs";
+import { join as join2 } from "node:path";
+function writeHostMarker(sessionDir, marker) {
+  mkdirSync2(sessionDir, { recursive: true, mode: 448 });
+  const body = {
+    ...marker,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeFileSync3(join2(sessionDir, "host.json"), JSON.stringify(body), {
+    mode: 384
+  });
+}
+function markHostTranscript(sessionDir, seen) {
+  const path = join2(sessionDir, "host.json");
+  let marker;
+  try {
+    marker = JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return;
+  }
+  marker.transcriptSeen = seen;
+  writeFileSync3(path, JSON.stringify(marker), { mode: 384 });
+}
+function markHostFlushed(sessionDir, ackedParts) {
+  const path = join2(sessionDir, "host.json");
+  let marker;
+  try {
+    marker = JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return;
+  }
+  marker.ackedParts = ackedParts;
+  marker.lastFlushAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeFileSync3(path, JSON.stringify(marker), { mode: 384 });
+}
+function markHostExited(sessionDir, exitCode) {
+  const path = join2(sessionDir, "host.json");
+  let marker;
+  try {
+    marker = JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return;
+  }
+  marker.exitedAt = (/* @__PURE__ */ new Date()).toISOString();
+  marker.exitCode = exitCode;
+  writeFileSync3(path, JSON.stringify(marker), { mode: 384 });
+}
+var SPOOL_PART_ROTATE_BYTES = 6 * 1024 * 1024;
+var PART_FILE = /^part-(\d{6})\.ndjson$/;
+var SessionSpool = class {
+  dir;
+  currentPart;
+  constructor(root, sessionId) {
+    this.dir = join2(root, sessionId);
+    mkdirSync2(this.dir, { recursive: true, mode: 448 });
+    const existing = this.listPartNumbers();
+    this.currentPart = existing.length ? Math.max(...existing) : 0;
+  }
+  get directory() {
+    return this.dir;
+  }
+  partPath(part) {
+    return join2(this.dir, `part-${String(part).padStart(6, "0")}.ndjson`);
+  }
+  listPartNumbers() {
+    return readdirSync(this.dir).map((name) => PART_FILE.exec(name)).filter((m) => m !== null).map((m) => Number(m[1]));
+  }
+  /**
+   * Append one ALREADY-REDACTED NDJSON line durably (0600, fsync'd). Rotates
+   * to the next part when the current one would cross the ingestion cap.
+   */
+  append(redactedLine) {
+    const path = this.partPath(this.currentPart);
+    let size = 0;
+    try {
+      size = statSync(path).size;
+    } catch {
+    }
+    if (size > 0 && size + Buffer.byteLength(redactedLine) > SPOOL_PART_ROTATE_BYTES) {
+      this.currentPart += 1;
+    }
+    const target = this.partPath(this.currentPart);
+    const fd = openSync(target, "a", 384);
+    try {
+      writeSync(fd, redactedLine);
+    } finally {
+      closeSync(fd);
+    }
+  }
+  /**
+   * Advance past a flushed (acked + deleted) part. Ingestion slots are
+   * append-only — same part + different checksum is a permanent CONFLICT —
+   * so a slot the server acknowledged must never be reused for new events.
+   */
+  advancePast(part) {
+    if (part >= this.currentPart) this.currentPart = part + 1;
+  }
+  /** Cheap append without rotation checks (tests / recovery merges). */
+  appendRaw(part, redactedLine) {
+    appendFileSync(this.partPath(part), redactedLine, { mode: 384 });
+    if (part > this.currentPart) this.currentPart = part;
+  }
+  /** Every pending part with its convergence checksum, ordered by number. */
+  pendingParts() {
+    return this.listPartNumbers().sort((a, b) => a - b).map((part) => {
+      const path = this.partPath(part);
+      const body = readFileSync2(path, "utf8");
+      return {
+        part,
+        path,
+        byteSize: Buffer.byteLength(body),
+        checksum: createHash("sha256").update(body, "utf8").digest("hex")
+      };
+    });
+  }
+  /** Read one part's redacted text for upload. */
+  readPart(part) {
+    return readFileSync2(this.partPath(part), "utf8");
+  }
+  /**
+   * Delete a part ONLY on a server acknowledgement of this exact content.
+   * `acknowledgedChecksum` is the STORED checksum from the server's ack; when
+   * the server's re-redaction changed the bytes, the caller records the acked
+   * checksum into its manifest first, then confirms deletion explicitly with
+   * `force`. An audit stub can never satisfy this — a refusal keeps the file.
+   */
+  deleteAcknowledged(part, acknowledgedChecksum, opts = {}) {
+    const path = this.partPath(part);
+    let body;
+    try {
+      body = readFileSync2(path, "utf8");
+    } catch {
+      return false;
+    }
+    const localChecksum = createHash("sha256").update(body, "utf8").digest("hex");
+    if (localChecksum !== acknowledgedChecksum && !opts.force) {
+      return false;
+    }
+    const tomb = `${path}.acked`;
+    renameSync2(path, tomb);
+    unlinkSync2(tomb);
+    return true;
+  }
+};
+
+// lib/session-host.ts
+function defaultSpoolRoot() {
+  return join3(homedir(), ".config", "stacks", "session-spool");
+}
+function bearerSourceOf(plan, log) {
+  return plan.configPath ? createConfigBearerSource({
+    configPath: plan.configPath,
+    fallback: plan.bearer,
+    log
+  }) : staticBearerSource(plan.bearer);
+}
+function sessionCallTool(mcpUrl, bearerSource, sessionId) {
+  const attempt = async (bearer, name, args) => {
+    const transport = new StreamableHTTPClientTransport(new URL(mcpUrl), {
+      requestInit: {
+        headers: {
+          Authorization: `Bearer ${bearer}`,
+          "X-Stacks-Session-Id": sessionId
+        }
+      }
+    });
+    const client = new Client({
+      name: "stacks-session-host",
+      version: RUNNER_VERSION
+    });
+    await client.connect(transport, { timeout: 6e4 });
+    try {
+      const res = await client.callTool({ name, arguments: args }, void 0, {
+        timeout: 6e4
+      });
+      if (res.isError) {
+        const text2 = Array.isArray(res.content) && res.content[0] && "text" in res.content[0] ? res.content[0].text : JSON.stringify(res.content);
+        throw new Error(`${name} failed: ${text2}`);
+      }
+      return res.structuredContent ?? {};
+    } finally {
+      await client.close();
+    }
+  };
+  return async (name, args) => {
+    const bearer = bearerSource.get();
+    try {
+      return await attempt(bearer, name, args);
+    } catch (error) {
+      if (!isUnauthorizedishError(error)) throw error;
+      const next = await bearerSource.refresh(bearer);
+      if (!next || next === bearer) throw error;
+      return attempt(next, name, args);
+    }
+  };
+}
+function claudeHookSettings(runnerBin, sessionDir) {
+  const hook = (event) => [
+    {
+      hooks: [
+        {
+          type: "command",
+          // argv carries only the runner binary, the session DIRECTORY, and
+          // the event name — never credentials or transcript content (§15.1).
+          command: `${runnerBin} session-hook --dir ${JSON.stringify(sessionDir)} --event ${event}`
+        }
+      ]
+    }
+  ];
+  return {
+    hooks: {
+      SessionStart: hook("SessionStart"),
+      UserPromptSubmit: hook("UserPromptSubmit"),
+      Stop: hook("Stop"),
+      SessionEnd: hook("SessionEnd")
+    }
+  };
+}
+async function endRepoState(repoRoot) {
+  const run = (args) => new Promise((resolve) => {
+    const child = spawn("git", args, { cwd: repoRoot });
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => stdout += String(chunk));
+    child.once("error", () => resolve({ code: 1, stdout: "" }));
+    child.once("exit", (code) => resolve({ code: code ?? 1, stdout }));
+  });
+  const [branch, head, status] = await Promise.all([
+    run(["symbolic-ref", "--short", "-q", "HEAD"]),
+    run(["rev-parse", "HEAD"]),
+    run(["status", "--porcelain"])
+  ]);
+  return {
+    branch: branch.code === 0 ? branch.stdout.trim() || null : null,
+    head: head.code === 0 ? head.stdout.trim() || null : null,
+    dirty: status.code === 0 ? status.stdout.trim().length > 0 : null
+  };
+}
+async function runClaudeSessionHost(plan, deps = {}) {
+  const log = deps.log ?? ((line) => process.stderr.write(`${line}
+`));
+  const spoolRoot = plan.spoolRoot ?? defaultSpoolRoot();
+  const spool = new SessionSpool(spoolRoot, plan.sessionId);
+  const sessionDir = spool.directory;
+  writeHostMarker(sessionDir, {
+    pid: process.pid,
+    provider: plan.provider,
+    mode: plan.mode === "watch" ? "watch" : "launch",
+    captureTrace: plan.captureTrace !== false,
+    // F1/P3: the transcript this host is bound to — what a compaction hook
+    // matches on to find its session without guessing from cwd.
+    ...plan.transcriptPath ? { transcriptPath: plan.transcriptPath } : {}
+  });
+  const traceCapture = plan.captureTrace !== false;
+  const bearerSource = bearerSourceOf(plan, log);
+  const bridge = new SessionBridge({
+    jentrixBaseUrl: plan.jentrixBaseUrl,
+    bearer: () => bearerSource.get(),
+    onUnauthorized: (failed) => bearerSource.refresh(failed),
+    sessionId: plan.sessionId,
+    provider: plan.provider,
+    spool,
+    redactor: createSessionRedactor({ homedir: homedir() }),
+    callTool: deps.callTool ?? sessionCallTool(plan.mcpUrl, bearerSource, plan.sessionId),
+    fetchImpl: deps.fetchImpl,
+    traceCapture,
+    log
+  });
+  bridge.recordCapabilities(
+    plan.provider === "codex" ? {
+      provider: "codex",
+      providerVersion: null,
+      observable: [
+        "session",
+        "user_message",
+        "assistant_message",
+        "tool_call",
+        "tool_result"
+      ],
+      notObservable: ["command", "file_change", "plan", "usage", "error"]
+    } : {
+      provider: "claude",
+      providerVersion: null,
+      observable: [
+        "session",
+        "user_message",
+        "assistant_message",
+        "tool_call",
+        "tool_result",
+        "usage",
+        "error"
+      ],
+      notObservable: ["command", "file_change", "plan"]
+    }
+  );
+  bridge.startObserving();
+  const watch = plan.mode === "watch";
+  let child = null;
+  if (!watch) {
+    const runnerBin = process.argv[1] ?? "stacks-runner";
+    const settingsPath = join3(sessionDir, "claude-hooks.json");
+    writeFileSync4(
+      settingsPath,
+      JSON.stringify(claudeHookSettings(runnerBin, sessionDir), null, 2),
+      { mode: 384 }
+    );
+    const args = ["--settings", settingsPath];
+    if (plan.resumeProviderSessionId) {
+      args.push("--resume", plan.resumeProviderSessionId);
+    }
+    child = (deps.spawnImpl ?? spawn)(plan.executablePath ?? "claude", args, {
+      cwd: plan.repoRoot,
+      stdio: "inherit"
+    });
+  }
+  const hookDir = plan.hookDir ?? sessionDir;
+  let hookOffset = 0;
+  if (watch && plan.hookDir && !plan.importHistory) {
+    try {
+      hookOffset = readFileSync3(join3(hookDir, "hooks.ndjson"), "utf8").length;
+    } catch {
+    }
+  }
+  let transcriptPath = watch ? plan.transcriptPath ?? null : null;
+  let transcriptOffset = 0;
+  const timing = new ClaudeTimingTracker();
+  let transcriptSeen = false;
+  let transcriptWarned = false;
+  const hostStartedMs = Date.now();
+  const noteTranscriptSeen = () => {
+    if (!transcriptSeen) {
+      transcriptSeen = true;
+      markHostTranscript(sessionDir, true);
+    }
+  };
+  if (watch && transcriptPath && !plan.importHistory) {
+    try {
+      transcriptOffset = statSync2(transcriptPath).size;
+      noteTranscriptSeen();
+    } catch {
+    }
+  }
+  let bound = watch;
+  let sessionEnded = false;
+  let lastPeriodicFlushAt = 0;
+  const poll = async () => {
+    const endRequestPath = join3(sessionDir, "end-request.json");
+    if (!sessionEnded && existsSync(endRequestPath)) {
+      try {
+        unlinkSync3(endRequestPath);
+      } catch {
+      }
+      sessionEnded = true;
+    }
+    const { lines, offset } = readHookLines(hookDir, hookOffset);
+    hookOffset = offset;
+    for (const line of lines) {
+      if (plan.provider === "codex" && line.payload.session_id !== plan.providerSessionId) {
+        continue;
+      }
+      if (plan.provider === "codex") {
+        const mapped = mapCodexHook(line.event, line.payload);
+        if (mapped.modelId) bridge.observeModel(mapped.modelId);
+        for (const event of mapped.events) bridge.record(event);
+      }
+      if (line.event === "SessionStart" && line.payload.session_id && !bound) {
+        bound = true;
+        transcriptPath = line.payload.transcript_path ?? null;
+        try {
+          await bridge.tool("attach_agent_session", {
+            sessionId: plan.sessionId,
+            provider: plan.provider,
+            connection: { kind: "local", installationId: plan.installationId },
+            providerSessionId: line.payload.session_id,
+            idempotencyKey: `bind:${plan.sessionId}:${line.payload.session_id}`
+          });
+          log(
+            `Capture connected \xB7 provider session ${line.payload.session_id}`
+          );
+        } catch (error) {
+          log(
+            `capture: provider binding failed (${error instanceof Error ? error.message : "unknown"})`
+          );
+        }
+      }
+      if (line.event === "SessionEnd" || line.event === "Stop") {
+        await bridge.flushParts().catch(() => void 0);
+        markHostFlushed(sessionDir, bridge.ackedPartCount);
+      }
+      if (line.event === "SessionEnd") sessionEnded = true;
+    }
+    if (plan.provider === "claude" && transcriptPath) {
+      try {
+        const size = statSync2(transcriptPath).size;
+        noteTranscriptSeen();
+        if (size > transcriptOffset) {
+          const buffer = readFileSync3(transcriptPath);
+          const body = buffer.subarray(transcriptOffset).toString("utf8");
+          transcriptOffset = buffer.byteLength;
+          for (const rawLine of body.split("\n").filter(Boolean)) {
+            const mapped = mapClaudeTranscriptLine(rawLine);
+            if (mapped.unrecognized) bridge.countUnrecognized();
+            if (mapped.modelId) bridge.observeModel(mapped.modelId);
+            if (mapped.timing) {
+              for (const interval of timing.observe(mapped.timing)) {
+                bridge.recordInterval(interval);
+              }
+            }
+            for (const event of mapped.events) bridge.record(event);
+          }
+        }
+      } catch {
+        if (!transcriptSeen && !transcriptWarned && Date.now() - hostStartedMs > 6e4) {
+          transcriptWarned = true;
+          markHostTranscript(sessionDir, false);
+          log(
+            `capture: transcript never appeared at ${transcriptPath} \u2014 observing no events; usage will be unavailable. End the session and re-align to rebind.`
+          );
+        }
+      }
+    }
+    const flushRequestPath = join3(sessionDir, "flush-request.json");
+    if (existsSync(flushRequestPath)) {
+      const acked = await bridge.flushUsageNow().catch(() => false);
+      if (acked) {
+        try {
+          unlinkSync3(flushRequestPath);
+        } catch {
+        }
+      }
+    }
+    const nowMs = Date.now();
+    if (!sessionEnded && nowMs - lastPeriodicFlushAt >= 15e3) {
+      lastPeriodicFlushAt = nowMs;
+      await bridge.flushParts().catch(() => void 0);
+      markHostFlushed(sessionDir, bridge.ackedPartCount);
+    }
+    await bridge.maybeHeartbeat();
+  };
+  const timer = setInterval(() => {
+    void poll();
+  }, 2e3);
+  const exitCode = await (watch ? (
+    // Watch mode: live capture beside the operator's own provider process.
+    // End signals: the SessionEnd lifecycle hook, an end request from
+    // `jentrix session end`, or a heartbeat 409 (session terminal
+    // server-side — the out-of-band case the hooks can never deliver).
+    new Promise((resolve) => {
+      const check = setInterval(() => {
+        if (sessionEnded || bridge.sessionInactive) {
+          clearInterval(check);
+          resolve(0);
+        }
+      }, 1e3);
+    })
+  ) : new Promise((resolve) => {
+    child.once("error", () => resolve(1));
+    child.once(
+      "exit",
+      (code, signal) => resolve(code ?? (signal ? 130 : 0))
+    );
+  }));
+  clearInterval(timer);
+  await poll().catch(() => void 0);
+  await bridge.flushParts().catch(() => void 0);
+  for (const id of timing.unclosedToolIds()) {
+    bridge.recordUnclosedInterval("tool", id);
+  }
+  const end = await endRepoState(plan.repoRoot);
+  const result = await bridge.complete({
+    outcome: exitCode === 0 ? "COMPLETED" : "INTERRUPTED",
+    end
+  }).catch((error) => {
+    log(
+      `capture: completion failed (${error instanceof Error ? error.message : "unknown"}) \u2014 spool retained for retry`
+    );
+    return null;
+  });
+  if (!result) {
+    markHostExited(sessionDir, 1);
+    return 1;
+  }
+  const output = result.finalResponseArtifactId ? ` \xB7 output ${result.finalResponseArtifactId}` : " \xB7 output not observed";
+  log(
+    !traceCapture ? `Session ${plan.sessionId} closed \xB7 TRACE capture off (typed artifacts only) \xB7 summary ${result.summaryArtifactId ?? "\u2014"}${output}` : result.captureComplete ? `Session ${plan.sessionId} closed \xB7 capture complete \xB7 summary ${result.summaryArtifactId ?? "\u2014"}${output}` : `Session ${plan.sessionId} closed \xB7 CAPTURE PENDING (${result.pendingParts} part(s)) \u2014 re-run \`jentrix session status ${plan.sessionId}\``
+  );
+  const finalCode = result.captureComplete || !traceCapture ? exitCode : exitCode || 1;
+  markHostExited(sessionDir, finalCode);
+  return finalCode;
+}
+async function runCodexSessionHost(plan, deps = {}) {
+  const log = deps.log ?? ((line) => process.stderr.write(`${line}
+`));
+  const spoolRoot = plan.spoolRoot ?? defaultSpoolRoot();
+  const spool = new SessionSpool(spoolRoot, plan.sessionId);
+  writeHostMarker(spool.directory, {
+    pid: process.pid,
+    provider: "codex",
+    mode: "launch"
+  });
+  const codexBearerSource = bearerSourceOf(plan, log);
+  const bridge = new SessionBridge({
+    jentrixBaseUrl: plan.jentrixBaseUrl,
+    bearer: () => codexBearerSource.get(),
+    onUnauthorized: (failed) => codexBearerSource.refresh(failed),
+    sessionId: plan.sessionId,
+    provider: "codex",
+    spool,
+    redactor: createSessionRedactor({ homedir: homedir() }),
+    callTool: sessionCallTool(plan.mcpUrl, codexBearerSource, plan.sessionId),
+    fetchImpl: deps.fetchImpl,
+    log
+  });
+  bridge.recordCapabilities({
+    provider: "codex",
+    providerVersion: null,
+    observable: [
+      "session",
+      "assistant_message",
+      "tool_call",
+      "command",
+      "file_change",
+      "usage",
+      "error"
+    ],
+    notObservable: ["plan", "tool_result"]
+  });
+  bridge.startObserving();
+  const { Codex } = await import("@openai/codex-sdk");
+  const codex = new Codex(
+    plan.executablePath ? { codexPathOverride: plan.executablePath } : {}
+  );
+  const thread = plan.resumeProviderSessionId ? codex.resumeThread(plan.resumeProviderSessionId, {
+    workingDirectory: plan.repoRoot,
+    skipGitRepoCheck: true
+  }) : codex.startThread({
+    workingDirectory: plan.repoRoot,
+    skipGitRepoCheck: true
+  });
+  let bound = Boolean(plan.resumeProviderSessionId);
+  let currentModel = null;
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const ask = (prompt) => new Promise((resolve) => {
+    rl.question(prompt, (answer) => resolve(answer));
+    rl.once("close", () => resolve(null));
+  });
+  log("Codex connected session \u2014 empty line or Ctrl-D ends the session.");
+  let outcome = "COMPLETED";
+  try {
+    for (; ; ) {
+      const input = await ask("codex> ");
+      if (input === null || input.trim() === "") break;
+      const turnId = `turn:${Date.now()}`;
+      bridge.markTurnStarted(turnId);
+      bridge.record({ kind: "user_message", payload: { text: input } });
+      try {
+        const { events } = await thread.runStreamed(input);
+        for await (const raw of events) {
+          const mapped = mapCodexThreadEvent(raw);
+          if (mapped.unrecognized) bridge.countUnrecognized();
+          if (mapped.modelId) {
+            currentModel = mapped.modelId;
+            bridge.observeModel(mapped.modelId);
+          }
+          if (mapped.threadId && !bound) {
+            bound = true;
+            try {
+              await bridge.tool("attach_agent_session", {
+                sessionId: plan.sessionId,
+                provider: "codex",
+                connection: {
+                  kind: "local",
+                  installationId: plan.installationId
+                },
+                providerSessionId: mapped.threadId,
+                idempotencyKey: `bind:${plan.sessionId}:${mapped.threadId}`
+              });
+              log(`Capture connected \xB7 provider thread ${mapped.threadId}`);
+            } catch (error) {
+              log(
+                `capture: provider binding failed (${error instanceof Error ? error.message : "unknown"})`
+              );
+            }
+          }
+          if (mapped.event) {
+            const recorded = bridge.record({
+              ...mapped.event,
+              at: (/* @__PURE__ */ new Date()).toISOString(),
+              payload: mapped.event.kind === "usage" ? {
+                ...mapped.event.payload,
+                turnId,
+                // TPM Slice 2 (AC2.4): the model the runtime last named
+                // for this thread rides the receipt — absent when no
+                // turn_context was ever observed (null-model bucket,
+                // disclosed, never guessed).
+                ...currentModel ? { modelId: currentModel } : {}
+              } : mapped.event.payload
+            });
+            if (recorded.kind === "assistant_message" && typeof recorded.payload?.text === "string") {
+              process.stdout.write(
+                `${recorded.payload.text}
+`
+              );
+            }
+          }
+        }
+      } catch (error) {
+        outcome = "INTERRUPTED";
+        bridge.recordGap(
+          `provider turn failed: ${error instanceof Error ? error.message : "unknown"}`
+        );
+        log("codex turn failed \u2014 session will close as INTERRUPTED");
+        break;
+      }
+      bridge.markTurnEnded(turnId);
+      await bridge.flushParts().catch(() => void 0);
+      await bridge.maybeHeartbeat();
+    }
+  } finally {
+    rl.close();
+  }
+  const end = await endRepoState(plan.repoRoot);
+  const result = await bridge.complete({ outcome, end }).catch(() => null);
+  if (!result) {
+    markHostExited(spool.directory, 1);
+    return 1;
+  }
+  log(
+    result.captureComplete ? `Session ${plan.sessionId} closed \xB7 capture complete \xB7 output ${result.finalResponseArtifactId ?? "not observed"}` : `Session ${plan.sessionId} closed \xB7 CAPTURE PENDING (${result.pendingParts} part(s))`
+  );
+  const finalCode = result.captureComplete ? 0 : 1;
+  markHostExited(spool.directory, finalCode);
+  return finalCode;
+}
+async function runSessionHost(plan, deps = {}) {
+  return plan.mode === "watch" || plan.provider === "claude" ? runClaudeSessionHost(plan, deps) : runCodexSessionHost(plan, deps);
+}
+export {
+  appendHookEvent,
+  claudeHookSettings,
+  defaultSpoolRoot,
+  readHookLines,
+  runClaudeSessionHost,
+  runCodexSessionHost,
+  runSessionHost,
+  safeParse,
+  sessionCallTool
+};
+//# sourceMappingURL=session-host-2Y7475EG.js.map