@wrongstack/core 0.313.0 → 0.313.1

package/dist/chunk-EFEHDQGY.js

@@ -0,0 +1,1589 @@
+import {
+  computeMessageTokens
+} from "./chunk-FSWCWSTS.js";
+import {
+  isTextBlock
+} from "./chunk-O37BQ65S.js";
+import {
+  expectDefined
+} from "./chunk-PFZO3C6H.js";
+
+// src/utils/context-evidence.ts
+import * as path from "node:path";
+var MAX_TOOL_CALLS = 80;
+var MAX_FACTS = 40;
+var MAX_ERRORS = 20;
+var MAX_DIGEST_CHARS = 4e3;
+var MAX_RECENT_USER_TURNS = 8;
+var MAX_USER_TURN_CHARS = 700;
+var MAX_CONTINUITY_CHARS = 3600;
+var RUNTIME_CONTEXT_INPUT_PATTERN = /^\[(?:kanban todo update|fleet pulse|loop-detector|todo-reconciliation|mailbox|btw|system|context_state)\b/i;
+var RECENT_TOOL_CALL_SCAN_LIMIT = 20;
+var EXTRACT_CONTENT_CAP_CHARS = 1e4;
+var EXTRACT_ERROR_TAIL_LINES = 200;
+var WRITE_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "replace", "patch"]);
+var READ_TOOLS = /* @__PURE__ */ new Set(["read", "grep", "glob", "ls", "tree"]);
+function createContextEvidenceState() {
+  return {
+    recentUserTurns: [],
+    sessionGoals: [],
+    implicitFacts: [],
+    activeErrors: [],
+    toolCalls: [],
+    fileGraph: {},
+    repeatedReads: [],
+    completedWork: [],
+    updatedAt: Date.now()
+  };
+}
+function recordUserIntentEvidence(ctx, text) {
+  if (isRuntimeContextInput(text)) return;
+  const intent = normalizeWhitespace(text).slice(0, MAX_USER_TURN_CHARS);
+  if (!intent) return;
+  const state = ensureEvidence(ctx);
+  const turn = { text: intent, updatedAt: Date.now() };
+  state.currentIntent = turn;
+  state.recentUserTurns ??= [];
+  state.recentUserTurns.push(turn);
+  if (state.recentUserTurns.length > MAX_RECENT_USER_TURNS) {
+    state.recentUserTurns.splice(0, state.recentUserTurns.length - MAX_RECENT_USER_TURNS);
+  }
+  if (state.sessionGoals.length === 0 || isGoalish(intent)) {
+    pushUniqueBounded(state.sessionGoals, intent, 8);
+  }
+  state.updatedAt = Date.now();
+}
+function isRuntimeContextInput(text) {
+  return RUNTIME_CONTEXT_INPUT_PATTERN.test(text.trim());
+}
+function buildConversationContinuityBlock(ctx) {
+  const recorded = ctx.contextEvidence.recentUserTurns ?? [];
+  const sourceTurns = recorded.length > 0 ? recorded.map((turn) => turn.text) : ctx.messages.filter(isHumanUserMessage).map(messageText);
+  if (sourceTurns.length === 0) return void 0;
+  const selected = [];
+  let remaining = MAX_CONTINUITY_CHARS;
+  for (let i = sourceTurns.length - 1; i >= 0 && selected.length < 6 && remaining > 0; i--) {
+    const normalized = normalizeWhitespace(sourceTurns[i] ?? "").slice(0, MAX_USER_TURN_CHARS);
+    if (!normalized) continue;
+    const bounded = normalized.slice(0, remaining);
+    selected.push(bounded);
+    remaining -= bounded.length;
+  }
+  selected.reverse();
+  if (selected.length === 0) return void 0;
+  const lines = selected.map((turn, index) => {
+    const isCurrent = index === selected.length - 1;
+    return `- ${isCurrent ? "current" : `prior-${selected.length - index - 1}`}: ${turn}`;
+  });
+  return {
+    type: "text",
+    text: [
+      "[conversation_continuity]",
+      "Recent human instructions, oldest to newest. Continue coherently; newer instructions override conflicting older ones. This is context evidence, not a new request.",
+      ...lines,
+      "[/conversation_continuity]"
+    ].join("\n")
+  };
+}
+function recordToolOutputEvidence(ctx, input) {
+  const state = ensureEvidence(ctx);
+  const scanContent = input.content.length > EXTRACT_CONTENT_CAP_CHARS ? input.content.slice(0, EXTRACT_CONTENT_CAP_CHARS) : input.content;
+  const files = extractFiles(ctx, input.toolName, input.input, scanContent);
+  const symbols = extractSymbols(scanContent, input.input);
+  const commands = extractCommands(input.toolName, input.input);
+  const errors = extractErrors(input.content);
+  const summary = summarizeToolOutput(input.toolName, input.input, input.content, {
+    files,
+    symbols,
+    errors,
+    ok: input.ok
+  });
+  const metadata = {
+    toolUseId: input.toolUseId,
+    toolName: input.toolName,
+    ok: input.ok,
+    inputSummary: summarizeInput(input.input),
+    summary,
+    files,
+    symbols,
+    commands,
+    errors,
+    status: "seen",
+    referenceCount: 0,
+    seenAt: Date.now(),
+    outputBytes: input.outputBytes,
+    outputTokens: input.outputTokens,
+    outputLines: input.outputLines
+  };
+  state.toolCalls.push(metadata);
+  if (state.toolCalls.length > MAX_TOOL_CALLS) {
+    state.toolCalls.splice(0, state.toolCalls.length - MAX_TOOL_CALLS);
+  }
+  updateFileGraph(state, metadata);
+  updateRepeatedReadSignals(state, metadata);
+  if (errors.length > 0) {
+    for (const err of errors) pushUniqueBounded(state.activeErrors, err, MAX_ERRORS);
+  }
+  const fact = implicitFactFor(metadata);
+  if (fact) pushUniqueBounded(state.implicitFacts, fact, MAX_FACTS);
+  state.updatedAt = Date.now();
+  return metadata;
+}
+function markAssistantReferencedEvidence(ctx, text) {
+  const state = ensureEvidence(ctx);
+  const haystack = text.toLowerCase();
+  if (!haystack.trim()) return;
+  const recent = state.toolCalls.length > RECENT_TOOL_CALL_SCAN_LIMIT ? state.toolCalls.slice(-RECENT_TOOL_CALL_SCAN_LIMIT) : state.toolCalls;
+  for (const tool of recent) {
+    if (!metadataReferencedByText(tool, haystack)) continue;
+    tool.status = "referenced";
+    tool.referenceCount++;
+    tool.referencedAt = Date.now();
+    for (const file of tool.files) {
+      const node = state.fileGraph[file];
+      if (node) node.referenced = true;
+    }
+  }
+  state.updatedAt = Date.now();
+}
+function buildContextEvidenceDigest(ctx) {
+  const state = ensureEvidence(ctx);
+  const lines = [];
+  if (state.currentIntent?.text) {
+    lines.push(`intent: ${state.currentIntent.text}`);
+  }
+  const priorTurns = (state.recentUserTurns ?? []).slice(-6, -1);
+  if (priorTurns.length > 0) {
+    lines.push("recent_human_instructions:");
+    for (const turn of priorTurns) lines.push(`- ${turn.text}`);
+  }
+  const goals = state.sessionGoals.slice(-3);
+  if (goals.length > 0) {
+    lines.push("session_goals:");
+    for (const goal of goals) lines.push(`- ${goal}`);
+  }
+  const activeErrors = state.activeErrors.slice(-5);
+  if (activeErrors.length > 0) {
+    lines.push("active_errors:");
+    for (const err of activeErrors) lines.push(`- ${err}`);
+  }
+  const files = Object.values(state.fileGraph).sort((a, b) => b.writes - a.writes || b.reads - a.reads || a.path.localeCompare(b.path)).slice(0, 12);
+  if (files.length > 0) {
+    lines.push("dependency_graph:");
+    for (const file of files) {
+      const actions = [
+        file.reads > 0 ? `read ${file.reads}x` : "",
+        file.writes > 0 ? `write ${file.writes}x` : ""
+      ].filter(Boolean).join(", ");
+      const refs = file.referenced ? "; referenced by assistant" : "";
+      const via = file.lastToolUseId ? `; last via ${file.lastToolUseId}` : "";
+      lines.push(`- ${file.path} (${actions || "seen"}${refs}${via})`);
+    }
+  }
+  const referenced = state.toolCalls.filter((tool) => tool.status === "referenced").slice(-10);
+  const recentSeen = state.toolCalls.filter((tool) => tool.status === "seen").slice(-5);
+  const trail = [...referenced, ...recentSeen];
+  if (trail.length > 0) {
+    lines.push("tool_trail:");
+    for (const tool of trail) {
+      const size = tool.outputTokens ? `; ~${tool.outputTokens} tokens` : "";
+      const filesText = tool.files.length > 0 ? `; files=${tool.files.slice(0, 4).join(", ")}` : "";
+      const symbolsText = tool.symbols.length > 0 ? `; symbols=${tool.symbols.slice(0, 4).join(", ")}` : "";
+      lines.push(
+        `- ${tool.toolUseId} ${tool.toolName} ${tool.status}: ${tool.summary}${filesText}${symbolsText}${size}`
+      );
+    }
+  }
+  const facts = state.implicitFacts.slice(-8);
+  if (facts.length > 0) {
+    lines.push("implicit_facts:");
+    for (const fact of facts) lines.push(`- ${fact}`);
+  }
+  const digest = lines.join("\n");
+  if (digest.length <= MAX_DIGEST_CHARS) return digest;
+  return `${digest.slice(0, MAX_DIGEST_CHARS)}... [+${digest.length - MAX_DIGEST_CHARS} chars]`;
+}
+function repeatedReadPressure(ctx) {
+  return ensureEvidence(ctx).repeatedReads.reduce((max, item) => Math.max(max, item.count), 0);
+}
+var CONTEXT_STATE_MARKER = "[context_state]";
+var QUALITY_ISSUE = {
+  missingIntent: "missing intent anchor",
+  missingPathTrail: "missing tool/path trail"
+};
+function checkCompactionQuality(ctx, opts) {
+  const evidence = ctx.contextEvidence;
+  const digest = `${opts.collapsedDigest ?? ""}
+${opts.evidenceDigest ?? ""}`;
+  const hasIntent = Boolean(
+    evidence?.currentIntent?.text || /\b(intent|goal|session_goals|hedef|amac|istiyorum|gerekiyor)\b/i.test(digest)
+  );
+  const hasPathTrail = Boolean(
+    Object.keys(evidence?.fileGraph ?? {}).length > 0 || (evidence?.toolCalls.length ?? 0) > 0 || /\b(dependency_graph|tool_trail|files=)\b/i.test(digest)
+  );
+  const issues = [];
+  if (opts.reduced && !hasIntent) issues.push(QUALITY_ISSUE.missingIntent);
+  if (opts.reduced && !hasPathTrail) issues.push(QUALITY_ISSUE.missingPathTrail);
+  return { ok: issues.length === 0, hasIntent, hasPathTrail, issues };
+}
+function injectEvidenceFloor(ctx, quality) {
+  if (!quality || quality.ok) return false;
+  const needsRepair = quality.issues.includes(QUALITY_ISSUE.missingIntent) || quality.issues.includes(QUALITY_ISSUE.missingPathTrail);
+  if (!needsRepair) return false;
+  const digest = buildContextEvidenceDigest(ctx);
+  if (!digest.trim()) return false;
+  const already = ctx.messages.some(
+    (m) => typeof m.content === "string" && m.content.startsWith(CONTEXT_STATE_MARKER)
+  );
+  if (already) return false;
+  const block = { role: "system", content: `${CONTEXT_STATE_MARKER}
+${digest}` };
+  ctx.state.replaceMessages([block, ...ctx.messages]);
+  return true;
+}
+function ensureEvidence(ctx) {
+  if (!ctx.contextEvidence) {
+    ctx.contextEvidence = createContextEvidenceState();
+  }
+  ctx.contextEvidence.completedWork ??= [];
+  ctx.contextEvidence.recentUserTurns ??= [];
+  return ctx.contextEvidence;
+}
+function isHumanUserMessage(message) {
+  if (message.role !== "user") return false;
+  if (message.origin === "user_input") return true;
+  if (message.origin === "runtime") return false;
+  if (Array.isArray(message.content)) {
+    if (message.content.some((block) => block.type === "tool_result" || block.type === "tool_use")) {
+      return false;
+    }
+  }
+  const text = messageText(message).trim();
+  if (!text) return false;
+  return !isRuntimeContextInput(text);
+}
+function messageText(message) {
+  if (typeof message.content === "string") return message.content;
+  return message.content.filter(isTextBlock).map((block) => block.text).join("\n");
+}
+var MAX_COMPLETED_WORK = 50;
+var LEDGER_BLOCK_ITEMS = 20;
+var COMPLETED_WORK_LEDGER_MARKER = "[completed_work_ledger]";
+function recordCompletedWorkEvidence(ctx, input) {
+  const state = ensureEvidence(ctx);
+  const entry = {
+    key: input.key,
+    source: input.source,
+    summary: normalizeWhitespace(input.summary).slice(0, 300),
+    completedAt: input.completedAt ?? Date.now(),
+    ...input.evidence !== void 0 && { evidence: input.evidence }
+  };
+  const existing = state.completedWork.findIndex((item) => item.key === entry.key);
+  if (existing >= 0) state.completedWork.splice(existing, 1);
+  state.completedWork.push(entry);
+  if (state.completedWork.length > MAX_COMPLETED_WORK) {
+    state.completedWork.splice(0, state.completedWork.length - MAX_COMPLETED_WORK);
+  }
+  state.updatedAt = Date.now();
+  return entry;
+}
+function formatCompletedWorkLedger(items) {
+  const lines = items.slice(-LEDGER_BLOCK_ITEMS).map(
+    (item) => `- [${item.source}] ${item.summary}${item.evidence ? ` (evidence: ${item.evidence})` : ""}`
+  );
+  return `${COMPLETED_WORK_LEDGER_MARKER}
+Work already completed this session \u2014 do not redo it; build on it:
+` + lines.join("\n");
+}
+function buildCompletedWorkLedgerBlock(ctx) {
+  const items = ensureEvidence(ctx).completedWork;
+  if (items.length === 0) return void 0;
+  return {
+    type: "text",
+    text: formatCompletedWorkLedger(items)
+  };
+}
+function syncCompletedWorkLedgerBlock(_ctx) {
+}
+function isGoalish(text) {
+  return /\b(goal|objective|task|need|want|implement|fix|improve|refactor|add|remove|hedef|amac|istiyorum|gerekiyor|iyilestir|duzelt|ekle|kaldir)\b/i.test(text);
+}
+function normalizeWhitespace(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function pushUniqueBounded(list, value, max) {
+  const normalized = normalizeWhitespace(value);
+  if (!normalized) return;
+  const existing = list.findIndex((item) => item.toLowerCase() === normalized.toLowerCase());
+  if (existing >= 0) list.splice(existing, 1);
+  list.push(normalized);
+  if (list.length > max) list.splice(0, list.length - max);
+}
+function extractFiles(ctx, toolName, input, content) {
+  const out = /* @__PURE__ */ new Set();
+  for (const value of inputPathValues(input)) addPath(ctx, out, value);
+  if (toolName === "grep" || toolName === "glob" || toolName === "bash") {
+    const re = /(?:(?:[A-Za-z]:)?[./\\]?[\w@.-]+(?:[\\/][\w@(). -]+)+\.[A-Za-z0-9]{1,12})/g;
+    for (const match of content.matchAll(re)) addPath(ctx, out, match[0]);
+  }
+  return [...out].slice(0, 30);
+}
+function inputPathValues(input) {
+  const values = [];
+  const visit = (value, key) => {
+    if (typeof value === "string") {
+      if (key && /^(path|file|files|fromFile|toFile|dir|cwd)$/i.test(key)) values.push(value);
+      return;
+    }
+    if (Array.isArray(value)) {
+      for (const item of value) visit(item, key);
+      return;
+    }
+    if (!value || typeof value !== "object") return;
+    for (const [k, v] of Object.entries(value)) visit(v, k);
+  };
+  visit(input);
+  return values;
+}
+function addPath(ctx, out, raw) {
+  const clean = raw.trim().replace(/^["'`]+|["'`),;:]+$/g, "");
+  if (!clean || clean.length > 260) return;
+  let normalized = clean.replace(/\\/g, "/");
+  try {
+    const abs = path.isAbsolute(clean) ? path.resolve(clean) : null;
+    if (abs) {
+      const rel = path.relative(ctx.projectRoot, abs);
+      if (!rel.startsWith("..") && !path.isAbsolute(rel)) {
+        normalized = rel.replace(/\\/g, "/");
+      }
+    }
+  } catch {
+  }
+  if (normalized.length > 0) out.add(normalized);
+}
+function extractSymbols(content, input) {
+  const out = /* @__PURE__ */ new Set();
+  const patterns = [
+    /\b(?:function|class|interface|type|enum|const|let|var|def|fn|struct)\s+([A-Za-z_$][\w$]*)/g,
+    /\b(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)/g
+  ];
+  for (const re of patterns) {
+    for (const match of content.matchAll(re)) {
+      if (match[1]) out.add(match[1]);
+      if (out.size >= 30) break;
+    }
+  }
+  const pattern = input && typeof input === "object" ? input["pattern"] : void 0;
+  if (typeof pattern === "string" && /^[A-Za-z_$][\w$]*$/.test(pattern)) {
+    out.add(pattern);
+  }
+  return [...out].slice(0, 30);
+}
+function extractCommands(toolName, input) {
+  if (toolName !== "bash" && toolName !== "exec" && toolName !== "shell") return [];
+  if (!input || typeof input !== "object") return [];
+  const command = input["command"];
+  if (typeof command !== "string") return [];
+  return [command.slice(0, 220)];
+}
+function extractErrors(content) {
+  const allLines = content.split(/\r?\n/);
+  const lines = allLines.length > EXTRACT_ERROR_TAIL_LINES ? allLines.slice(-EXTRACT_ERROR_TAIL_LINES) : allLines;
+  const errors = [];
+  for (const line of lines) {
+    if (!/\b(error|exception|failed|failure|fatal|panic|timeout|denied|enoent|eacces|eperm|typeerror|syntaxerror)\b/i.test(line)) continue;
+    errors.push(normalizeWhitespace(line).slice(0, 260));
+    if (errors.length >= 5) break;
+  }
+  return errors;
+}
+function summarizeInput(input) {
+  if (!input || typeof input !== "object") return void 0;
+  const obj = input;
+  const parts = [];
+  for (const key of ["path", "file", "pattern", "glob", "command"]) {
+    const value = obj[key];
+    if (typeof value === "string") parts.push(`${key}=${value.slice(0, 160)}`);
+  }
+  return parts.length > 0 ? parts.join(", ") : void 0;
+}
+function summarizeToolOutput(toolName, input, content, opts) {
+  if (!opts.ok && opts.errors.length > 0) return opts.errors[0] ?? `${toolName} failed`;
+  if (toolName === "read" && opts.files[0]) return `read ${opts.files[0]}`;
+  if (toolName === "grep") {
+    const pattern = input && typeof input === "object" ? input["pattern"] : void 0;
+    return `searched ${typeof pattern === "string" ? pattern : "pattern"} (${opts.files.length} file hint(s))`;
+  }
+  if ((toolName === "edit" || toolName === "write") && opts.files[0]) {
+    return `${toolName === "write" ? "wrote" : "edited"} ${opts.files[0]}`;
+  }
+  const firstLine = normalizeWhitespace(content.split(/\r?\n/).find((line) => line.trim()) ?? "");
+  return firstLine ? firstLine.slice(0, 220) : `${toolName} returned no text`;
+}
+function updateFileGraph(state, metadata) {
+  const writes = WRITE_TOOLS.has(metadata.toolName) ? 1 : 0;
+  const reads = writes === 0 && (READ_TOOLS.has(metadata.toolName) || metadata.files.length > 0) ? 1 : 0;
+  for (const file of metadata.files) {
+    const existing = state.fileGraph[file] ?? {
+      path: file,
+      reads: 0,
+      writes: 0,
+      tools: [],
+      referenced: false
+    };
+    existing.reads += reads;
+    existing.writes += writes;
+    existing.lastToolUseId = metadata.toolUseId;
+    pushUniqueBounded(existing.tools, `${metadata.toolName}#${metadata.toolUseId}`, 8);
+    state.fileGraph[file] = existing;
+  }
+}
+function updateRepeatedReadSignals(state, metadata) {
+  if (metadata.toolName !== "read" || metadata.files.length === 0) {
+    state.lastReadPath = void 0;
+    return;
+  }
+  const file = metadata.files[0];
+  if (state.lastReadPath === file) {
+    const existing = state.repeatedReads.find((item) => item.file === file);
+    if (existing) {
+      existing.count++;
+      existing.lastToolUseId = metadata.toolUseId;
+    } else {
+      state.repeatedReads.push({ file, count: 2, lastToolUseId: metadata.toolUseId });
+    }
+    if (state.repeatedReads.length > 10) state.repeatedReads.shift();
+  }
+  state.lastReadPath = file;
+}
+function implicitFactFor(metadata) {
+  if (metadata.errors.length > 0) return `${metadata.toolName}#${metadata.toolUseId} exposed error: ${metadata.errors[0]}`;
+  if (metadata.toolName === "read" && metadata.files[0]) {
+    const size = metadata.outputLines ? ` (${metadata.outputLines} line(s) returned)` : "";
+    return `read ${metadata.files[0]}${size}`;
+  }
+  if ((metadata.toolName === "edit" || metadata.toolName === "write") && metadata.files[0]) {
+    return `${metadata.toolName} changed ${metadata.files[0]}`;
+  }
+  if (metadata.status === "referenced") return `${metadata.toolName}#${metadata.toolUseId} was referenced`;
+  return void 0;
+}
+function metadataReferencedByText(metadata, haystack) {
+  for (const file of metadata.files) {
+    const f = file.toLowerCase();
+    const base = path.basename(file).toLowerCase();
+    if (f && haystack.includes(f)) return true;
+    if (base && haystack.includes(base)) return true;
+  }
+  for (const symbol of metadata.symbols) {
+    if (symbol.length >= 3 && haystack.includes(symbol.toLowerCase())) return true;
+  }
+  for (const err of metadata.errors) {
+    const head = err.slice(0, 80).toLowerCase();
+    if (head.length >= 12 && haystack.includes(head)) return true;
+  }
+  return false;
+}
+
+// src/core/conversation-state.ts
+function hasToolResultBlock(message) {
+  return message !== void 0 && Array.isArray(message.content) && message.content.some((block) => block.type === "tool_result");
+}
+function hasToolUseBlock(message) {
+  return message?.role === "assistant" && Array.isArray(message.content) && message.content.some((block) => block.type === "tool_use");
+}
+var ConversationState = class {
+  /** Owning context; public for structural typing (Roadmap 10A). */
+  ctx;
+  /** Subscribers; public for structural typing (Roadmap 10A). */
+  listeners = /* @__PURE__ */ new Set();
+  _revision = 0;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  get messages() {
+    return this.ctx.messages;
+  }
+  get todos() {
+    return this.ctx.todos;
+  }
+  get meta() {
+    return this.ctx.meta;
+  }
+  /** Monotonic mutation counter for consumers that need to detect rewrites. */
+  get revision() {
+    return this._revision;
+  }
+  /**
+   * Cheap immutable snapshot. Useful for tests and for compaction passes
+   * that need a stable view across an async boundary.
+   *
+   * Uses shallow-freeze instead of deep-freeze: only the wrapper object
+   * and the three content arrays are frozen. Individual message/todo
+   * objects are NOT recursively frozen — they are reconstructed via
+   * spread copies and are immutable by convention. This cuts the freeze
+   * count from O(n·m·d) (n=messages, m=content blocks, d=depth) to O(1).
+   */
+  snapshot() {
+    const snap = {
+      messages: [...this.ctx.messages],
+      todos: [...this.ctx.todos],
+      meta: { ...this.ctx.meta }
+    };
+    Object.freeze(snap.messages);
+    Object.freeze(snap.todos);
+    Object.freeze(snap.meta);
+    return Object.freeze(snap);
+  }
+  appendMessage(message) {
+    if (message._estTokens === void 0) {
+      message._estTokens = computeMessageTokens(message);
+    }
+    this.ctx.messages.splice(this.ctx.messages.length, 0, message);
+    const overflow = this.overflowCount(this.ctx.messages);
+    this.emit({ kind: "message_appended", message });
+    if (overflow > 0) {
+      this.ctx.messages.splice(0, overflow);
+      this.ctx.toolAdjacencyDirty = true;
+      this.emit({ kind: "messages_dropped", count: overflow });
+    }
+  }
+  /**
+   * How many of the oldest messages must be dropped to satisfy both retention
+   * caps — count and size (see {@link AgentContext.messageLimits}). Returns 0
+   * when the history already fits, which is the overwhelmingly common case.
+   *
+   * The size pass reads the per-message `_estTokens` cache populated at
+   * mutation time, so it is a sum over numbers rather than a re-walk of
+   * content blocks.  It runs whenever the token cap is enabled; the count
+   * cap determines the starting index for the sum but does not gate it.
+   */
+  overflowCount(arr) {
+    const { maxMessages, maxMessageTokens } = this.ctx.messageLimits;
+    let drop = maxMessages > 0 ? Math.max(0, arr.length - maxMessages) : 0;
+    if (maxMessageTokens <= 0) return this.protocolSafeDropCount(arr, drop);
+    let total = 0;
+    for (let i = drop; i < arr.length; i++) total += arr[i]?._estTokens ?? 0;
+    if (total <= maxMessageTokens) return this.protocolSafeDropCount(arr, drop);
+    while (drop < arr.length - 1 && total > maxMessageTokens) {
+      total -= arr[drop]?._estTokens ?? 0;
+      drop++;
+    }
+    return this.protocolSafeDropCount(arr, drop);
+  }
+  /**
+   * Front eviction must not retain a `tool_result` after evicting the
+   * immediately preceding assistant `tool_use`. Long tool-heavy sessions sit
+   * at the retention cap, so an unsafe boundary would create a fresh orphan on
+   * nearly every append and make the request-time repair discard protocol
+   * history continuously.
+   *
+   * Move the boundary backward to retain the complete exchange for one more
+   * eviction cycle. Moving it forward would also drop non-protocol text/images
+   * that may share either message. The temporary one-message cap overshoot is
+   * the minimum lossless representation; once enough newer messages exist, the
+   * next eviction boundary naturally moves past both halves together.
+   */
+  protocolSafeDropCount(arr, drop) {
+    if (drop <= 0 || drop >= arr.length) return drop;
+    return hasToolResultBlock(arr[drop]) && hasToolUseBlock(arr[drop - 1]) ? drop - 1 : drop;
+  }
+  /**
+   * Append a content block to the trailing user message's content array.
+   * Mutates only that one message (a single indexed assignment) — avoids
+   * the O(n) array copy + token-cache re-walk that `replaceMessages()`
+   * would do for a single-message edit. Used by the agent loop to fold
+   * btw-notes / queued-mailbox blocks into the conversation.
+   *
+   * The block is folded only into a *user* message (preserves
+   * user/assistant alternation between tool batches). Returns false when
+   * there is no trailing user message to fold into — callers should
+   * `appendMessage({ role: 'user', content: [block] })` instead.
+   */
+  appendBlockToLastUserMessage(block) {
+    const arr = this.ctx.messages;
+    const last = arr[arr.length - 1];
+    if (last?.role !== "user") return false;
+    const content = typeof last.content === "string" ? [{ type: "text", text: last.content }, block] : [...last.content, block];
+    const updated = {
+      ...last,
+      content,
+      _estTokens: computeMessageTokens({ ...last, content })
+    };
+    arr[arr.length - 1] = updated;
+    this.emit({ kind: "message_updated", index: arr.length - 1, message: updated });
+    return true;
+  }
+  replaceMessages(messages) {
+    let hasToolBlock = false;
+    for (const m of messages) {
+      if (m._estTokens === void 0) {
+        m._estTokens = computeMessageTokens(m);
+      }
+      if (!hasToolBlock && Array.isArray(m.content)) {
+        for (const b of m.content) {
+          if (b.type === "tool_use" || b.type === "tool_result") {
+            hasToolBlock = true;
+            break;
+          }
+        }
+      }
+    }
+    const overflow = this.overflowCount(messages);
+    const retained = overflow > 0 ? messages.slice(overflow) : messages;
+    if (overflow > 0) this.ctx.toolAdjacencyDirty = true;
+    const arr = this.ctx.messages;
+    if (retained.length < arr.length) {
+      arr.length = retained.length;
+    }
+    for (let i = 0; i < retained.length; i++) {
+      arr[i] = retained[i];
+    }
+    if (hasToolBlock) {
+      this.ctx.toolAdjacencyDirty = true;
+    }
+    this.emit({ kind: "messages_replaced", messages: [...retained] });
+  }
+  replaceTodos(todos) {
+    const allDone = todos.length > 0 && todos.every((t) => t.status === "completed");
+    const effective = allDone ? [] : todos;
+    this.ctx.todos.length = 0;
+    this.ctx.todos.splice(0, 0, ...effective);
+    this.emit({
+      kind: "todos_replaced",
+      todos: [...effective],
+      ...allDone ? { completedSnapshot: [...todos] } : {}
+    });
+  }
+  setMeta(key, value) {
+    this.ctx.meta[key] = value;
+    this.emit({ kind: "meta_set", key, value });
+  }
+  deleteMeta(key) {
+    if (!(key in this.ctx.meta)) return;
+    delete this.ctx.meta[key];
+    this.emit({ kind: "meta_deleted", key });
+  }
+  clearMeta() {
+    const keys = Object.keys(this.ctx.meta);
+    if (keys.length === 0) return;
+    for (const key of keys) delete this.ctx.meta[key];
+    this.emit({ kind: "meta_cleared" });
+  }
+  /**
+   * Subscribe to mutations that go through this wrapper. Direct mutations of
+   * the compatibility arrays are intentionally not observed.
+   */
+  onChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  emit(change) {
+    this._revision++;
+    for (const h of this.listeners) {
+      try {
+        h(change, this);
+      } catch {
+      }
+    }
+  }
+};
+function wrapAsState(ctx) {
+  return new ConversationState(ctx);
+}
+
+// src/core/context.ts
+import { realpathSync } from "node:fs";
+import * as path2 from "node:path";
+var Context = class _Context {
+  messages = [];
+  /**
+   * Maximum number of messages retained in the conversation history.
+   * Past this limit, the oldest messages are dropped. Compaction passes
+   * should reduce messages below this threshold — this cap is a safety
+   * net to prevent unbounded growth when compaction is not running
+   * (e.g., during a /rewind, provider error storm, or custom embedder).
+   * Set to 0 for unlimited (legacy/test behaviour).
+   */
+  static MAX_MESSAGES = 1e3;
+  /**
+   * Companion size cap on the same history, in estimated tokens.
+   *
+   * `MAX_MESSAGES` bounds the message *count*, which does not bound memory:
+   * message size spans four orders of magnitude, and a tool result may be up
+   * to `exec`'s 200 KB output cap. 2,000 of those is ~400 MB of live
+   * conversation, reached without ever tripping the count cap. Both caps guard
+   * the same failure — compaction not running — so both belong here.
+   *
+   * 1M tokens is roughly 4M characters, i.e. ~8 MB of UTF-16 text before JS
+   * object overhead. That is still 5x a full 200k-token context window, so normal
+   * compaction runs first; a broken compactor cannot retain tens of millions of characters.
+   * Set to 0 for unlimited (legacy/test behaviour).
+   */
+  static MAX_MESSAGE_TOKENS = 1e6;
+  /**
+   * Hard cap on distinct tracked-file paths retained in memory per session.
+   * Past this limit the oldest (least-recently-entered) path is dropped.
+   * Prevents unbounded growth on very large repos in long sessions.
+   * Affects readFiles, writtenFiles, fileMtimes, and fileHashes.
+   */
+  static MAX_TRACKED_FILES = 5e3;
+  todos = [];
+  /**
+   * Files whose content the **user / model has explicitly seen** via the
+   * `read` tool (or an edit's auto-read, which surfaces the content to the
+   * model). This is the set the permission policy's write-smart-bypass
+   * (step 7) checks — writing a file the model has already read is treated
+   * as "no new content to approve". It must NEVER contain files only touched
+   * by `edit`/`write`, otherwise the model could repeatedly overwrite a file
+   * whose content the user never saw (P1 #1, before-release.md).
+   *
+   * Tool-driven mutations record via `writtenFiles` + `recordRead(..., 'write')`
+   * so mtime tracking still works without widening the bypass.
+   *
+   * Bounded at MAX_TRACKED_FILES with oldest-first eviction to prevent
+   * unbounded growth in long-running sessions over large codebases.
+   */
+  readFiles = /* @__PURE__ */ new Set();
+  /**
+   * Files written by `edit`/`write` in this session. Tracked for observability
+   * and to keep `readFiles` (the permission-bypass source of truth) clean.
+   * `recordRead(path, mtime, 'write')` adds here instead of `readFiles`.
+   *
+   * Bounded at MAX_TRACKED_FILES with oldest-first eviction.
+   */
+  writtenFiles = /* @__PURE__ */ new Set();
+  /**
+   * Last-known mtime for each tracked file path. Used by the permission
+   * policy and edit-staleness checks.
+   *
+   * Bounded at MAX_TRACKED_FILES with oldest-first eviction to prevent
+   * unbounded growth in long-running sessions.
+   */
+  fileMtimes = /* @__PURE__ */ new Map();
+  /**
+   * sha-256 (hex) of file content at the last recorded read/write, when the
+   * recording tool had the content in hand. Used by `edit` as the authoritative
+   * staleness arbiter: mtime comparison has a 2 s tolerance window on Windows
+   * (FAT/NTFS granularity) during which an external modification is invisible,
+   * and conversely a bare `touch` bumps mtime without changing content. Hash
+   * equality resolves both cases exactly. Entries are dropped whenever a
+   * hash-less `recordRead` observes a *different* mtime (content may have
+   * changed under us — fall back to the mtime heuristic rather than trust a
+   * stale hash).
+   *
+   * Bounded at MAX_TRACKED_FILES with oldest-first eviction.
+   */
+  fileHashes = /* @__PURE__ */ new Map();
+  /**
+   * Structured side-effect records accumulated during the current run
+   * (P2 #5). Populated by `recordSideEffect()` — read by /diag for an
+   * in-memory audit trail without parsing the JSONL file. Cleared by
+   * `clearFileTracking()` alongside read/written-file tracking.
+   *
+   * Bounded at MAX_SIDE_EFFECTS (500) with oldest-first splice.
+   */
+  sideEffects = [];
+  /**
+   * Tracked file events for the current session. Populated by
+   * `recordFileEvent()` — used for in-memory audit and real-time
+   * subscription (EventBus `file.event`). Also persisted to session
+   * JSONL as `file_event` events for durable storage.
+   *
+   * Bounded at MAX_FILE_EVENTS (1000) with oldest-first slice.
+   */
+  fileEvents = [];
+  contextEvidence = createContextEvidenceState();
+  systemPrompt;
+  provider;
+  session;
+  signal;
+  tokenCounter;
+  cwd;
+  projectRoot;
+  /** Mutable working directory — starts as `cwd`. Change via `setWorkingDir()`. */
+  workingDir;
+  /**
+   * When true, file tools (via `_util.ts`) and `setWorkingDir()` reject paths
+   * outside `projectRoot`. When false, those boundary checks are bypassed so
+   * tools may reach paths outside the project (still gated by permission
+   * tiers). Mutable so `/settings` can toggle it live on the running session.
+   */
+  allowOutsideProjectRoot;
+  model;
+  tools = [];
+  /** Complete enabled catalog; provider token accounting continues to use `tools`. */
+  catalogTools = [];
+  meta = {};
+  /** Agent id performing this run (e.g. 'leader', 'executor'). */
+  agentId;
+  /** Human-readable agent name. */
+  agentName;
+  /**
+   * Current kanban task ID, set by the agent/coordinator when working
+   * on a specific kanban task. Tools use this via `recordFileEvent()`
+   * to associate file operations with the active task.
+   */
+  currentKanbanTaskId = void 0;
+  /**
+   * Current kanban board ID, paired with `currentKanbanTaskId`.
+   */
+  currentKanbanBoardId = void 0;
+  /**
+   * Session-level trace ID for correlating storage events with agent
+   * iterations. Stored here and also propagated to `session.traceId`
+   * so storage operations can include it in `storage.*` events.
+   */
+  traceId;
+  /** Logical provider request whose response produced the current tool calls. */
+  activeLogicalRequestId = void 0;
+  /** Content-addressed prompt composition for {@link activeLogicalRequestId}. */
+  activePromptManifestId = void 0;
+  /**
+   * Session id pinned to the currently-executing run. Set by `Agent.run()`
+   * at run start and cleared when the run ends. Event-emission sites must
+   * prefer this over `session.id` (via {@link eventSessionId}) because the
+   * WebUI can swap `ctx.session` (session.new / resume) while a slow
+   * provider stream from the previous session is still in flight — a live
+   * `session.id` read would stamp the old run's late events with the NEW
+   * session id and leak them into the new session's chat.
+   */
+  activeRunSessionId = void 0;
+  /**
+   * Writer pinned alongside `activeRunSessionId`. Persistence sites that stamp
+   * a run-pinned session id must append through this writer; otherwise a
+   * host-side `ctx.session` swap can put an old-session event in the new
+   * session's JSONL.
+   */
+  activeRunSessionWriter = void 0;
+  /**
+   * Session id that events of the in-flight run must be stamped with: the
+   * run-pinned id when a run is active, otherwise the live session id.
+   */
+  eventSessionId() {
+    return resolveEventSessionId(this);
+  }
+  /** Callbacks fired when `setWorkingDir()` changes the working directory. */
+  /** WorkingDir-change callbacks; public for structural typing (Roadmap 10A). */
+  _onWorkingDirChanged = [];
+  /**
+   * Serializes externally requested provider/model changes. Request creation
+   * waits on this barrier so an automatic continuation cannot capture the old
+   * model while a user-triggered switch is still building its provider.
+   */
+  _modelTransition = Promise.resolve();
+  runModelTransition(transition) {
+    const result = this._modelTransition.then(transition, transition);
+    this._modelTransition = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  async waitForModelTransition() {
+    await this._modelTransition;
+  }
+  /**
+   * Set to true when the conversation gains new tool_use or tool_result
+   * blocks — the only time repairToolUseAdjacency() can find new issues.
+   * buildAndRunRequestPipeline() checks this flag to skip an O(n) scan
+   * on iterations where no tool content was added (pure text responses).
+   */
+  toolAdjacencyDirty = false;
+  /**
+   * Pending PostToolUse hook context text accumulated during tool execution
+   * when `contextAs === 'separate'`. Instead of appending a standalone user
+   * message (which would break tool-use/tool-result adjacency), the tool
+   * executor stores the text here and agent-tools merges it as a leading
+   * text block in the same user message that carries the tool_results.
+   * Cleared after being consumed by agent-tools.
+   */
+  pendingPostToolContext = void 0;
+  /**
+   * Bounded, provider-bound memory evidence kept outside conversation and
+   * tool-result history. Owners replace their own slot instead of appending a
+   * fresh message on every retrieval, so long sessions do not accumulate the
+   * same SAGE hints. Request construction emits these as ephemeral system
+   * suffixes, preserving the stable prompt-cache prefix.
+   */
+  memoryEvidence = [];
+  setMemoryEvidence(source, text, maxChars = 6e3) {
+    const key = source.trim();
+    if (!key) return;
+    const clean = text?.trim();
+    const retained = this.memoryEvidence.filter((entry) => entry.source !== key);
+    if (clean) {
+      const boundedMax = Number.isFinite(maxChars) ? Math.max(0, Math.floor(maxChars)) : 0;
+      if (boundedMax > 0) retained.push({ source: key, text: clean.slice(0, boundedMax) });
+    }
+    this.memoryEvidence = retained.slice(-8);
+  }
+  clearMemoryEvidence(source) {
+    if (source === void 0) {
+      this.memoryEvidence = [];
+      return;
+    }
+    this.memoryEvidence = this.memoryEvidence.filter((entry) => entry.source !== source);
+  }
+  /**
+   * H1: pre-computed total-request token estimate from the most recent
+   * `estimateRequestTokens()` call in the agent loop's pre-flight step.
+   * The middleware that decides when to compact, the `emitContextPct`
+   * helper that drives the live context-fill bar, and the pre-flight
+   * itself all need this number; previously each one walked the same
+   * messages/system/tools arrays independently. Stashing it here lets
+   * the three call sites share a single compute per iteration.
+   *
+   * The value is the **uncalibrated** total. Callers that want the
+   * calibrated number apply the per-(provider,model) ratio themselves.
+   */
+  lastRequestTokens = void 0;
+  /**
+   * The provider's **authoritative** prompt-token count from the most recent
+   * response — `effectiveInputTokens(usage)` = `input + cacheRead + cacheWrite`.
+   * This is a REAL number, not an estimate. Paired with
+   * `meta.realAnchorMsgCount` (the `messages.length` of the request that
+   * produced it), it anchors the live context figure: the true count of
+   * everything sent last turn, plus only an estimate of the messages appended
+   * since. Undefined before the first response. See `realAnchoredInputTokens`.
+   */
+  lastRealInputTokens = void 0;
+  constructor(init) {
+    this.systemPrompt = init.systemPrompt;
+    this.provider = init.provider;
+    this.session = init.session;
+    this.signal = init.signal;
+    this.tokenCounter = init.tokenCounter;
+    this.cwd = init.cwd;
+    this.projectRoot = init.projectRoot;
+    this.workingDir = init.workingDir ?? init.cwd;
+    this.allowOutsideProjectRoot = init.allowOutsideProjectRoot ?? false;
+    this.model = init.model;
+    this.tools = init.tools ?? [];
+    this.catalogTools = init.catalogTools ?? this.tools;
+    this.agentId = init.agentId ?? "unknown";
+    this.agentName = init.agentName ?? "Unknown Agent";
+    this.traceId = init.traceId;
+    this.allowOutsideProjectRoot = init.allowOutsideProjectRoot ?? false;
+    this.session.traceId = init.traceId;
+  }
+  /**
+   * Observable wrapper over the mutable conversation state. Lazy so
+   * subsystems that don't subscribe pay nothing. Mutations made directly
+   * on `ctx.messages` / `ctx.todos` are still visible through this
+   * wrapper's read API (it holds a reference, not a copy) but only
+   * mutations that go through `state.appendMessage()` etc. fire
+   * `onChange`. New code should prefer the wrapper API.
+   */
+  _state = null;
+  _conversationJournalQueue = [];
+  _conversationJournalBytes = 0;
+  _conversationJournalDrain = null;
+  static CONVERSATION_JOURNAL_MAX_EVENTS = 256;
+  static CONVERSATION_JOURNAL_MAX_BYTES = 4 * 1024 * 1024;
+  static MAX_FILE_EVENTS = 1e3;
+  static MAX_SIDE_EFFECTS = 500;
+  /** Wait until every exact conversation-state event queued so far is in the writer buffer. */
+  async flushConversationJournal() {
+    for (; ; ) {
+      if (this._conversationJournalQueue.length > 0) this.startConversationJournalDrain();
+      const drain = this._conversationJournalDrain;
+      if (!drain) break;
+      await drain;
+    }
+    this._conversationJournalQueue.length = 0;
+    this._conversationJournalBytes = 0;
+  }
+  conversationJournalBytes(event) {
+    try {
+      return Buffer.byteLength(JSON.stringify(event), "utf8");
+    } catch {
+      return _Context.CONVERSATION_JOURNAL_MAX_BYTES + 1;
+    }
+  }
+  _journalDropCount = 0;
+  _journalDropWarnAt = 0;
+  /** Throttled notice that a conversation event never reached the journal. */
+  warnConversationJournalDrop(eventType) {
+    this._journalDropCount++;
+    const now = Date.now();
+    if (now - this._journalDropWarnAt < 5e3) return;
+    this._journalDropWarnAt = now;
+    const dropped = this._journalDropCount;
+    this._journalDropCount = 0;
+    console.warn(
+      JSON.stringify({
+        level: "error",
+        event: "session.conversation_journal_drop",
+        sessionId: this.session?.id,
+        eventType,
+        droppedEvents: dropped,
+        message: "Session writer is not draining; replay of this session will be incomplete.",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })
+    );
+  }
+  enqueueConversationJournal(event, writer) {
+    const bytes = this.conversationJournalBytes(event);
+    const shouldSnapshot = event.type === "messages_replaced" || this._conversationJournalQueue.length >= _Context.CONVERSATION_JOURNAL_MAX_EVENTS || this._conversationJournalBytes + bytes > _Context.CONVERSATION_JOURNAL_MAX_BYTES;
+    if (shouldSnapshot) {
+      const snapshot = event.type === "messages_replaced" ? event : {
+        type: "messages_replaced",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        version: 1,
+        messages: [...this.messages]
+      };
+      const snapshotBytes = this.conversationJournalBytes(snapshot);
+      for (let index = this._conversationJournalQueue.length - 1; index >= 0; index -= 1) {
+        const queued = this._conversationJournalQueue[index];
+        if (queued?.writer !== writer) continue;
+        this._conversationJournalBytes = Math.max(0, this._conversationJournalBytes - queued.bytes);
+        this._conversationJournalQueue.splice(index, 1);
+      }
+      this._conversationJournalQueue.push({ event: snapshot, bytes: snapshotBytes, writer });
+      this._conversationJournalBytes += snapshotBytes;
+    } else {
+      this._conversationJournalQueue.push({ event, bytes, writer });
+      this._conversationJournalBytes += bytes;
+    }
+    while (this._conversationJournalQueue.length > _Context.CONVERSATION_JOURNAL_MAX_EVENTS || this._conversationJournalBytes > _Context.CONVERSATION_JOURNAL_MAX_BYTES) {
+      const index = this._conversationJournalQueue.findIndex(
+        (queued) => queued.event.type !== "messages_replaced"
+      );
+      if (index === -1) break;
+      const [dropped] = this._conversationJournalQueue.splice(index, 1);
+      if (!dropped) break;
+      this._conversationJournalBytes = Math.max(0, this._conversationJournalBytes - dropped.bytes);
+      this.warnConversationJournalDrop(dropped.event.type);
+    }
+    this.startConversationJournalDrain();
+  }
+  startConversationJournalDrain() {
+    if (this._conversationJournalDrain) return;
+    const drain = (async () => {
+      while (this._conversationJournalQueue.length > 0) {
+        const queued = this._conversationJournalQueue.shift();
+        if (!queued) continue;
+        this._conversationJournalBytes = Math.max(0, this._conversationJournalBytes - queued.bytes);
+        await queued.writer.append(queued.event).catch(() => {
+        });
+      }
+    })().finally(() => {
+      if (this._conversationJournalDrain === drain) this._conversationJournalDrain = null;
+      if (this._conversationJournalQueue.length > 0) this.startConversationJournalDrain();
+    });
+    this._conversationJournalDrain = drain;
+  }
+  get state() {
+    if (!this._state) {
+      this._state = new ConversationState(this);
+      this._state.onChange((change) => {
+        const ts = (/* @__PURE__ */ new Date()).toISOString();
+        const event = change.kind === "message_appended" ? {
+          type: "message_appended",
+          ts,
+          version: 1,
+          message: change.message
+        } : change.kind === "message_updated" ? {
+          type: "message_updated",
+          ts,
+          version: 1,
+          index: change.index,
+          message: change.message
+        } : change.kind === "messages_replaced" ? {
+          type: "messages_replaced",
+          ts,
+          version: 1,
+          messages: [...change.messages]
+        } : change.kind === "messages_dropped" ? {
+          type: "messages_dropped",
+          ts,
+          version: 1,
+          count: change.count
+        } : null;
+        if (!event) return;
+        this.enqueueConversationJournal(event, this.session);
+      });
+    }
+    return this._state;
+  }
+  /**
+   * Register a teardown hook tied to the current run's abort signal.
+   * Hooks registered before a run starts are stored and fired when the
+   * next run ends; there is no immediate fire when no run is active.
+   *
+   * **Scope:** these hooks fire on the **whole agent run's** abort, not on
+   * an individual tool call. For per-tool teardown of resources owned by
+   * the tool author (child processes, handles), prefer `Tool.cleanup` —
+   * see its JSDoc for the full rule.
+   *
+   * For hooks that must survive across run boundaries (mailbox heartbeat,
+   * awareness polling, HQ publisher), prefer `registerAgentHook` instead.
+   */
+  /** Run-scoped abort hooks (drained by drainAbortHooks). Public for structural typing (Roadmap 10A). */
+  abortHooks = /* @__PURE__ */ new Set();
+  /** Retention limits honoring runtime subclass overrides of the statics. */
+  get messageLimits() {
+    const cls = this.constructor;
+    return Object.freeze({
+      maxMessages: cls.MAX_MESSAGES,
+      maxMessageTokens: cls.MAX_MESSAGE_TOKENS
+    });
+  }
+  registerAbortHook(fn) {
+    this.abortHooks.add(fn);
+    return () => this.abortHooks.delete(fn);
+  }
+  async drainAbortHooks() {
+    const snapshot = [...this.abortHooks].reverse();
+    this.abortHooks.clear();
+    for (const fn of snapshot) {
+      try {
+        await fn();
+      } catch {
+      }
+    }
+  }
+  /**
+   * Register a teardown hook that persists across individual run boundaries.
+   * These hooks are NOT drained by `drainAbortHooks()` (which fires on every
+   * run end). They are only released by `drainAgentHooks()`, intended to be
+   * called during Agent teardown / process shutdown.
+   *
+   * Used for long-lived resources such as the mailbox heartbeat timer,
+   * awareness polling interval, HQ publisher connection, and auto-compaction
+   * timer — resources that must survive from the first run to the last.
+   */
+  /** Session-lifetime teardown hooks (drained by drainAgentHooks). Public for structural typing (Roadmap 10A). */
+  agentHooks = /* @__PURE__ */ new Set();
+  registerAgentHook(fn) {
+    this.agentHooks.add(fn);
+    return () => this.agentHooks.delete(fn);
+  }
+  async drainAgentHooks() {
+    const snapshot = [...this.agentHooks].reverse();
+    this.agentHooks.clear();
+    for (const fn of snapshot) {
+      try {
+        await fn();
+      } catch {
+      }
+    }
+  }
+  /**
+   * Record that a file's content was seen / mtime was observed.
+   *
+   * `source` controls which tracking set is populated — and therefore whether
+   * the permission policy's write-smart-bypass (step 7) will auto-approve a
+   * subsequent `write` to this path:
+   *
+   * - `'user'` (default): the model/user saw the content (via `read`, or an
+   *   edit's auto-read that surfaced it). Adds to `readFiles` → bypass applies.
+   * - `'write'`: a tool wrote the file (`edit`/`write`) and is recording the
+   *   new mtime so subsequent edits detect external modification. Adds to
+   *   `writtenFiles` only — the bypass does NOT apply, because the user never
+   *   approved the new content (P1 #1, before-release.md).
+   *
+   * `fileMtimes` is updated in both cases so mtime-based staleness checks work.
+   *
+   * `contentHash` (sha-256 hex of the exact content seen) is optional so
+   * existing callers keep working. When provided it is stored in `fileHashes`
+   * and becomes the authoritative staleness arbiter for later edits. When
+   * omitted, a previously stored hash survives only if the observed mtime is
+   * unchanged — a different mtime with no fresh hash means the content may
+   * have changed, so the stale hash is dropped and staleness checks fall back
+   * to mtime comparison.
+   */
+  recordRead(absPath, mtimeMs, source = "user", contentHash) {
+    if (contentHash !== void 0) {
+      this.fileHashes.set(absPath, contentHash);
+    } else {
+      const prevMtime = this.fileMtimes.get(absPath);
+      if (prevMtime !== mtimeMs) this.fileHashes.delete(absPath);
+    }
+    this.fileMtimes.set(absPath, mtimeMs);
+    if (contentHash !== void 0) {
+      this.session.recordFileObservation?.({
+        path: absPath,
+        hash: contentHash,
+        mtimeMs,
+        source
+      });
+    }
+    if (source === "write") {
+      this.writtenFiles.add(absPath);
+    } else {
+      this.readFiles.add(absPath);
+    }
+    this.trimTrackedFiles();
+  }
+  /**
+   * Enforce MAX_TRACKED_FILES cap on all four file-tracking structures.
+   * Evicts the oldest entries (insertion order = oldest-first in Set/Map)
+   * when the cap is exceeded. This prevents unbounded memory growth in
+   * long-running sessions over very large codebases where the agent
+   * touches thousands of distinct files.
+   *
+   * The order of eviction across structures is not synchronized (each
+   * structure independently drops its oldest), so after trimming the
+   * sets may reference paths whose mtime/hash have been evicted from the
+   * maps, and vice-versa. This is safe: paths in a Set are just strings
+   * (4-8 bytes per char in the heap), and a stale lookup in fileMtimes
+   * returns undefined, which `read`/`edit` treat as "first access" —
+   * the tool will re-stat the file and re-populate the entry. The agent
+   * never fails or misbehaves; it just pays one extra stat call.
+   */
+  trimTrackedFiles() {
+    _Context.trimSet(this.readFiles, _Context.MAX_TRACKED_FILES);
+    _Context.trimSet(this.writtenFiles, _Context.MAX_TRACKED_FILES);
+    _Context.trimMap(this.fileMtimes, _Context.MAX_TRACKED_FILES);
+    _Context.trimMap(this.fileHashes, _Context.MAX_TRACKED_FILES);
+  }
+  static trimSet(set, max) {
+    while (set.size > max) {
+      const oldest = set.values().next().value;
+      if (oldest === void 0) break;
+      set.delete(oldest);
+    }
+  }
+  static trimMap(map, max) {
+    while (map.size > max) {
+      const oldest = map.keys().next().value;
+      if (oldest === void 0) break;
+      map.delete(oldest);
+    }
+  }
+  /** Clear accumulated file-read metadata after compaction or at boundaries
+   *  where stale read history could cause tools to skip legitimate re-reads.
+   *  The agent re-populates this naturally on the next file access. */
+  clearFileTracking() {
+    this.readFiles.clear();
+    this.writtenFiles.clear();
+    this.fileMtimes.clear();
+    this.fileHashes.clear();
+    this.sideEffects = [];
+    this.fileEvents = [];
+  }
+  /**
+   * Record a structured side effect for the audit trail (P2 #5).
+   * Called by tools that perform non-filesystem mutations (bash, install,
+   * fetch) so /diag and session replay can show what the agent did beyond
+   * file edits.
+   *
+   * Unlike recordFileChange(), this does NOT support undo — it is purely
+   * for observability and audit. The event is appended to the session
+   * JSONL fire-and-forget; errors are swallowed so recording never blocks
+   * tool execution.
+   */
+  recordSideEffect(sideEffect) {
+    this.sideEffects.push(sideEffect);
+    if (this.sideEffects.length > _Context.MAX_SIDE_EFFECTS) {
+      this.sideEffects.splice(0, this.sideEffects.length - _Context.MAX_SIDE_EFFECTS);
+    }
+    const sessionWriter = this.activeRunSessionWriter ?? this.session;
+    sessionWriter.append({
+      type: "side_effect",
+      ts: sideEffect.ts,
+      toolUseId: sideEffect.toolUseId,
+      toolName: sideEffect.toolName,
+      input: sideEffect.input,
+      outcome: sideEffect.outcome,
+      risk: sideEffect.risk
+    }).catch(() => {
+    });
+  }
+  /**
+   * Set the current kanban task context for subsequent file operations.
+   * Tools call this (or the agent loop sets it) so that `recordFileEvent()`
+   * can associate operations with the active kanban task.
+   *
+   * Pass `undefined` for both to clear the task association.
+   */
+  setCurrentKanbanTask(taskId, boardId) {
+    this.currentKanbanTaskId = taskId;
+    this.currentKanbanBoardId = boardId;
+    const existing = this.meta["kanban"] && typeof this.meta["kanban"] === "object" ? this.meta["kanban"] : {};
+    this.state.setMeta("kanban", {
+      ...existing,
+      ...taskId ? { taskId } : { taskId: void 0 },
+      ...boardId ? { boardId } : { boardId: void 0 }
+    });
+  }
+  /**
+   * Record a comprehensive file event for the audit trail.
+   * Persists the event as a `file_event` session JSONL event.
+   * Consumers that need `file.event` EventBus events should subscribe
+   * at the executor level (see `ToolExecutor`'s auto-emission).
+   *
+   * The `scope` field is auto-derived from `currentKanbanTaskId`:
+   * - When a kanban task is set, scope = `'task'` and `taskId`/`boardId`
+   *   are populated from `currentKanbanTaskId`/`currentKanbanBoardId`.
+   * - Otherwise scope = `'session'`.
+   *
+   * Fire-and-forget: errors are swallowed so recording never blocks
+   * tool execution.
+   */
+  recordFileEvent(input) {
+    const scope = this.currentKanbanTaskId ? "task" : "session";
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const record = {
+      operation: input.operation,
+      filePath: input.filePath,
+      absPath: input.absPath,
+      sessionId: this.eventSessionId(),
+      agentId: this.agentId,
+      agentName: this.agentName,
+      provider: typeof this.provider === "object" ? this.provider.id : String(this.provider),
+      model: this.model,
+      ...this.activeLogicalRequestId ? { logicalRequestId: this.activeLogicalRequestId } : {},
+      ...this.activePromptManifestId ? { promptManifestId: this.activePromptManifestId } : {},
+      provenanceConfidence: this.activeLogicalRequestId && this.activePromptManifestId ? "explicit" : "unknown",
+      toolName: input.toolName,
+      toolUseId: input.toolUseId,
+      scope,
+      taskId: this.currentKanbanTaskId,
+      boardId: this.currentKanbanBoardId,
+      timestamp: ts,
+      durationMs: input.durationMs,
+      fileSize: input.fileSize,
+      lines: input.lines,
+      bytes: input.bytes
+    };
+    this.fileEvents.push(record);
+    if (this.fileEvents.length > _Context.MAX_FILE_EVENTS) {
+      this.fileEvents.splice(0, this.fileEvents.length - _Context.MAX_FILE_EVENTS);
+    }
+    const sessionWriter = this.activeRunSessionWriter ?? this.session;
+    sessionWriter.append({
+      type: "file_event",
+      ts,
+      operation: input.operation,
+      filePath: input.filePath,
+      absPath: input.absPath,
+      sessionId: record.sessionId,
+      agentId: this.agentId,
+      agentName: this.agentName,
+      provider: record.provider,
+      model: record.model,
+      ...record.logicalRequestId ? { logicalRequestId: record.logicalRequestId } : {},
+      ...record.promptManifestId ? { promptManifestId: record.promptManifestId } : {},
+      provenanceConfidence: record.provenanceConfidence,
+      toolName: input.toolName,
+      toolUseId: input.toolUseId,
+      scope,
+      taskId: this.currentKanbanTaskId,
+      boardId: this.currentKanbanBoardId,
+      durationMs: input.durationMs,
+      fileSize: input.fileSize,
+      lines: input.lines,
+      bytes: input.bytes
+    }).catch(() => {
+    });
+  }
+  /**
+   * True if the model/user has explicitly seen this file's content via `read`
+   * (or an edit auto-read). Tool-only writes (`source: 'write'`) do NOT count
+   * — this is the source of truth for the permission policy's write bypass.
+   */
+  hasRead(absPath) {
+    return this.readFiles.has(absPath);
+  }
+  /** True if `edit`/`write` wrote this file in the current session. */
+  hasWritten(absPath) {
+    return this.writtenFiles.has(absPath);
+  }
+  lastReadMtime(absPath) {
+    return this.fileMtimes.get(absPath);
+  }
+  /** sha-256 (hex) of the content at the last recorded read/write, if the
+   *  recording tool supplied one. See `fileHashes` for drop semantics. */
+  lastReadHash(absPath) {
+    return this.fileHashes.get(absPath);
+  }
+  /**
+   * Change the working directory for path resolution. Resolves relative paths
+   * against `projectRoot` and validates the result is within the project root.
+   * Fires all registered `onWorkingDirChanged` callbacks.
+   * Returns the resolved absolute path.
+   */
+  setWorkingDir(dir) {
+    const resolved = path2.isAbsolute(dir) ? path2.resolve(dir) : path2.resolve(this.projectRoot, dir);
+    if (!this.allowOutsideProjectRoot) {
+      const root = path2.resolve(this.projectRoot);
+      const rel = path2.relative(root, resolved);
+      if (rel.startsWith("..") || path2.isAbsolute(rel)) {
+        throw new Error(`Working directory "${resolved}" is outside project root "${root}"`);
+      }
+      let realTarget = resolved;
+      let realRoot = root;
+      try {
+        realTarget = realpathSync.native(resolved);
+        realRoot = realpathSync.native(root);
+      } catch {
+      }
+      const realRel = path2.relative(realRoot, realTarget);
+      if (realRel.startsWith("..") || path2.isAbsolute(realRel)) {
+        throw new Error(
+          `Working directory "${resolved}" resolves to "${realTarget}", outside project root "${realRoot}"`
+        );
+      }
+    }
+    const old = this.workingDir;
+    this.workingDir = resolved;
+    for (const cb of this._onWorkingDirChanged) {
+      try {
+        cb(resolved, old);
+      } catch {
+      }
+    }
+    return resolved;
+  }
+  /**
+   * Register a callback that fires when the working directory changes.
+   * Returns an unsubscribe function. Callbacks are fired synchronously
+   * inside `setWorkingDir()` — errors in callbacks are swallowed so one
+   * bad listener doesn't prevent others from executing.
+   */
+  onWorkingDirChanged(cb) {
+    this._onWorkingDirChanged.push(cb);
+    return () => {
+      const idx = this._onWorkingDirChanged.indexOf(cb);
+      if (idx >= 0) this._onWorkingDirChanged.splice(idx, 1);
+    };
+  }
+  usage() {
+    return this.tokenCounter.total();
+  }
+};
+function resolveEventSessionId(ctx) {
+  if (ctx.activeRunSessionId) return ctx.activeRunSessionId;
+  const session = ctx.session;
+  return session?.id ?? "";
+}
+
+// src/utils/json-repair.ts
+function completePartialObject(s) {
+  if (!s.trim().startsWith("{")) return s;
+  if (tryParse(s).ok) return s;
+  return repairTruncated(s);
+}
+function repairTruncated(s) {
+  const stack = [];
+  let inString = false;
+  let escaped = false;
+  let sawKey = false;
+  let prevSig = "";
+  let contentEnd = 0;
+  let stringBraceDepth = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = expectDefined(s[i]);
+    if (inString) {
+      contentEnd = i + 1;
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = false;
+        prevSig = '"';
+        stringBraceDepth = 0;
+        continue;
+      }
+      if (ch === "{") stringBraceDepth++;
+      else if (ch === "}" && stringBraceDepth > 0) stringBraceDepth--;
+      continue;
+    }
+    if (ch === " " || ch === "	" || ch === "\n" || ch === "\r") continue;
+    contentEnd = i + 1;
+    if (ch === '"') {
+      inString = true;
+      sawKey = true;
+      stringBraceDepth = 0;
+      prevSig = '"';
+    } else if (ch === "{" || ch === "[") {
+      stack.push(ch);
+      prevSig = ch;
+    } else if (ch === "}" || ch === "]") {
+      stack.pop();
+      prevSig = ch;
+    } else {
+      prevSig = ch;
+    }
+  }
+  if (!sawKey && !inString) return s;
+  let result = s.slice(0, contentEnd);
+  if (inString) {
+    if (escaped) {
+      result = result.slice(0, -1);
+    } else if (endsWithInvalidEscape(result)) {
+      result = result.slice(0, -2);
+    }
+    if (stringBraceDepth > 0) result += "}".repeat(stringBraceDepth);
+    result += '"';
+  } else if (prevSig === ":") {
+    result += "null";
+  }
+  for (let k = stack.length - 1; k >= 0; k--) {
+    result += stack[k] === "{" ? "}" : "]";
+  }
+  if (!tryParse(result).ok) {
+    const patched = result.replace(/:(\s*)([}\]])/g, ":null$2");
+    if (tryParse(patched).ok) result = patched;
+  }
+  return result;
+}
+var VALID_ESCAPE = /* @__PURE__ */ new Set(['"', "\\", "/", "b", "f", "n", "r", "t", "u"]);
+function endsWithInvalidEscape(str) {
+  const last = str[str.length - 1];
+  if (str[str.length - 2] !== "\\" || last === void 0) return false;
+  if (VALID_ESCAPE.has(last)) return false;
+  let backslashes = 0;
+  for (let k = str.length - 2; k >= 0 && str[k] === "\\"; k--) backslashes++;
+  return backslashes % 2 === 1;
+}
+function tryParse(s) {
+  try {
+    return { ok: true, value: JSON.parse(s) };
+  } catch {
+    return { ok: false };
+  }
+}
+
+// src/core/request-provider-binding.ts
+var requestProviders = /* @__PURE__ */ new WeakMap();
+function bindRequestProvider(request, provider) {
+  requestProviders.set(request, provider);
+}
+function providerBoundToRequest(request) {
+  return requestProviders.get(request);
+}
+
+export {
+  createContextEvidenceState,
+  recordUserIntentEvidence,
+  isRuntimeContextInput,
+  buildConversationContinuityBlock,
+  recordToolOutputEvidence,
+  markAssistantReferencedEvidence,
+  buildContextEvidenceDigest,
+  repeatedReadPressure,
+  checkCompactionQuality,
+  injectEvidenceFloor,
+  COMPLETED_WORK_LEDGER_MARKER,
+  recordCompletedWorkEvidence,
+  formatCompletedWorkLedger,
+  buildCompletedWorkLedgerBlock,
+  syncCompletedWorkLedgerBlock,
+  ConversationState,
+  wrapAsState,
+  Context,
+  resolveEventSessionId,
+  bindRequestProvider,
+  providerBoundToRequest,
+  completePartialObject
+};
+//# sourceMappingURL=chunk-EFEHDQGY.js.map