@iowarp/clio-coder 0.3.1 → 0.3.2

package/dist/chunk-OAO4GE4M.js

@@ -0,0 +1,619 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  ceilChars
+} from "./chunk-LZSJBIVT.js";
+import {
+  clioStateDir
+} from "./chunk-BNAZZHFG.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/memory/task-bank.ts
+init_esm_shims();
+var TASK_MEMORY_VERSION = 1;
+var TASK_MEMORY_DEFAULT_KNOWLEDGE_CAP = 20;
+var TASK_MEMORY_DEFAULT_PROCEDURAL_CAP = 30;
+var TASK_MEMORY_CONTENT_MAX_CHARS = 1200;
+var TaskMemoryBank = class {
+  #knowledgeCap;
+  #proceduralCap;
+  #now;
+  #knowledge = /* @__PURE__ */ new Map();
+  #procedural = /* @__PURE__ */ new Map();
+  #status = null;
+  #nextId = 1;
+  constructor(options = {}) {
+    this.#knowledgeCap = positiveInteger(options.knowledgeCap, TASK_MEMORY_DEFAULT_KNOWLEDGE_CAP);
+    this.#proceduralCap = positiveInteger(options.proceduralCap, TASK_MEMORY_DEFAULT_PROCEDURAL_CAP);
+    this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  updateStatus(content) {
+    const timestamp = this.#timestamp();
+    const normalized = normalizeContent(content);
+    this.#status = this.#status === null ? this.#newEntry("status", normalized, timestamp) : { ...this.#status, content: normalized, lastTouchedAt: timestamp };
+    return cloneEntry(this.#status);
+  }
+  saveKnowledge(content, options = {}) {
+    return this.#save("knowledge", content, options.id);
+  }
+  saveProcedural(content, options = {}) {
+    return this.#save("procedural", content, options.id);
+  }
+  deleteEntry(id) {
+    if (this.#status?.id === id) {
+      this.#status = null;
+      return true;
+    }
+    return this.#knowledge.delete(id) || this.#procedural.delete(id);
+  }
+  /** Reset execution state when the composition root switches sessions. */
+  clear() {
+    this.#status = null;
+    this.#knowledge.clear();
+    this.#procedural.clear();
+    this.#nextId = 1;
+  }
+  /** Record attribution after an entry has contributed to a visible reminder. */
+  recordInjection(ids) {
+    for (const id of new Set(ids)) {
+      const entries = this.#knowledge.has(id) ? this.#knowledge : this.#procedural;
+      const entry = entries.get(id);
+      if (entry === void 0) continue;
+      const updated = { ...entry, injectionCount: entry.injectionCount + 1, lastTouchedAt: this.#timestamp() };
+      entries.set(id, updated);
+    }
+  }
+  /**
+   * Render only action-agent-visible classes under a conservative character
+   * token estimate. Status remains private even if a caller requests it.
+   */
+  render(budgetTokens, kinds = ["knowledge", "procedural"]) {
+    if (!Number.isFinite(budgetTokens) || budgetTokens <= 0) return "";
+    const allowed = new Set(kinds);
+    const entries = [...this.#knowledge.values(), ...this.#procedural.values()].filter((entry) => allowed.has(entry.kind)).sort(compareForRender);
+    let rendered = "";
+    for (const entry of entries) {
+      const line = `- [${entry.id}] ${entry.kind}: ${entry.content}`;
+      const candidate = rendered.length === 0 ? line : `${rendered}
+${line}`;
+      if (ceilChars(candidate.length) > budgetTokens) continue;
+      rendered = candidate;
+    }
+    return rendered;
+  }
+  /**
+   * Render the block handed back to the action agent after compaction, which is
+   * the one place status is visible.
+   *
+   * `render` refuses status because a mid-turn reminder must never expose the
+   * policy's private progress model as if the action agent had said it. That
+   * boundary is different: compaction destroyed the agent's own working state
+   * and this hands it back. Restoring knowledge alone restored nothing in the
+   * common case, because across ten live LLM steps the model wrote status in all
+   * ten and knowledge in two. Status leads for the same reason, and knowledge
+   * takes the remaining budget. Procedural stays out, unchanged.
+   */
+  renderRestoredState(budgetTokens) {
+    if (!Number.isFinite(budgetTokens) || budgetTokens <= 0) return "";
+    const status = this.#status;
+    const statusLine = status === null ? "" : `- [${status.id}] status: ${status.content}`;
+    if (statusLine.length > 0 && ceilChars(statusLine.length) > budgetTokens)
+      return this.render(budgetTokens, ["knowledge"]);
+    const remaining = statusLine.length === 0 ? budgetTokens : budgetTokens - ceilChars(statusLine.length);
+    const knowledge = this.render(remaining, ["knowledge"]);
+    if (statusLine.length === 0) return knowledge;
+    return knowledge.length === 0 ? statusLine : `${statusLine}
+${knowledge}`;
+  }
+  snapshot() {
+    return {
+      version: TASK_MEMORY_VERSION,
+      status: this.#status === null ? null : cloneEntry(this.#status),
+      knowledge: [...this.#knowledge.values()].sort(compareForSnapshot).map(cloneEntry),
+      procedural: [...this.#procedural.values()].sort(compareForSnapshot).map(cloneEntry)
+    };
+  }
+  #save(kind, content, id) {
+    const entries = this.#mapFor(kind);
+    const normalized = normalizeContent(content);
+    const timestamp = this.#timestamp();
+    let saved;
+    if (id === void 0) {
+      saved = this.#newEntry(kind, normalized, timestamp);
+    } else {
+      const existing = entries.get(id);
+      if (existing === void 0) throw new Error(`task memory entry not found: ${id}`);
+      saved = { ...existing, content: normalized, lastTouchedAt: timestamp };
+    }
+    entries.set(saved.id, saved);
+    this.#evictOldest(entries, kind === "knowledge" ? this.#knowledgeCap : this.#proceduralCap);
+    return cloneEntry(saved);
+  }
+  #newEntry(kind, content, timestamp) {
+    const prefix = kind === "status" ? "s" : kind === "knowledge" ? "k" : "p";
+    const id = `tm-${prefix}-${this.#nextId.toString(36)}`;
+    this.#nextId += 1;
+    return { id, kind, content, createdAt: timestamp, lastTouchedAt: timestamp, injectionCount: 0 };
+  }
+  #mapFor(kind) {
+    return kind === "knowledge" ? this.#knowledge : this.#procedural;
+  }
+  #evictOldest(entries, cap) {
+    while (entries.size > cap) {
+      const oldest = [...entries.values()].sort(compareForEviction)[0];
+      if (oldest === void 0) return;
+      entries.delete(oldest.id);
+    }
+  }
+  #timestamp() {
+    return this.#now().toISOString();
+  }
+};
+function normalizeContent(content) {
+  const normalized = content.replace(/\s+/gu, " ").trim();
+  if (normalized.length === 0) throw new Error("task memory content must not be empty");
+  return normalized.slice(0, TASK_MEMORY_CONTENT_MAX_CHARS).trimEnd();
+}
+function positiveInteger(value, fallback) {
+  return value !== void 0 && Number.isInteger(value) && value > 0 ? value : fallback;
+}
+function cloneEntry(entry) {
+  return { ...entry };
+}
+function compareForEviction(left, right) {
+  const byTouched = left.lastTouchedAt.localeCompare(right.lastTouchedAt);
+  if (byTouched !== 0) return byTouched;
+  const byCreated = left.createdAt.localeCompare(right.createdAt);
+  if (byCreated !== 0) return byCreated;
+  return left.id.localeCompare(right.id);
+}
+function compareForRender(left, right) {
+  const byTouched = right.lastTouchedAt.localeCompare(left.lastTouchedAt);
+  if (byTouched !== 0) return byTouched;
+  if (left.kind !== right.kind) return left.kind === "knowledge" ? -1 : 1;
+  return left.id.localeCompare(right.id);
+}
+function compareForSnapshot(left, right) {
+  const byCreated = left.createdAt.localeCompare(right.createdAt);
+  return byCreated !== 0 ? byCreated : left.id.localeCompare(right.id);
+}
+
+// src/domains/memory/task-memory-telemetry.ts
+init_esm_shims();
+import { appendFileSync, mkdirSync, renameSync, statSync } from "node:fs";
+import { join } from "node:path";
+var TASK_MEMORY_TELEMETRY_VERSION = 2;
+var TASK_MEMORY_TELEMETRY_MAX_BYTES = 1024 * 1024;
+var TASK_MEMORY_TELEMETRY_FILE = "steps.jsonl";
+function createTaskMemoryTelemetrySink(options = {}) {
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  return {
+    record(step) {
+      try {
+        const logDir = options.logDir ?? join(clioStateDir(), "memory");
+        const record = taskMemoryTelemetryRecord(step, now());
+        mkdirSync(logDir, { recursive: true });
+        const path = join(logDir, TASK_MEMORY_TELEMETRY_FILE);
+        try {
+          if (statSync(path).size > TASK_MEMORY_TELEMETRY_MAX_BYTES) renameSync(path, `${path}.1`);
+        } catch {
+        }
+        appendFileSync(path, `${JSON.stringify(record)}
+`);
+      } catch {
+      }
+    }
+  };
+}
+function taskMemoryTelemetryRecord(step, at) {
+  const input = nonNegativeInteger(step.inputTokens);
+  const output = nonNegativeInteger(step.outputTokens);
+  return {
+    version: TASK_MEMORY_TELEMETRY_VERSION,
+    at: at.toISOString(),
+    triggerReasons: [...new Set(step.triggerReasons)],
+    tier: step.tier,
+    bankDelta: step.bankDelta,
+    decision: step.decision,
+    reason: step.reason,
+    bankOperations: nonNegativeInteger(step.bankOperations),
+    droppedOperations: nonNegativeInteger(step.droppedOperations),
+    citedEntries: nonNegativeInteger(step.citedEntries),
+    tokenCost: { input, output, total: input + output },
+    latencyMs: nonNegativeFinite(step.latencyMs)
+  };
+}
+function taskMemoryBankDelta(before, after) {
+  return {
+    status: entryDelta(before.status === null ? [] : [before.status], after.status === null ? [] : [after.status]),
+    knowledge: entryDelta(before.knowledge, after.knowledge),
+    procedural: entryDelta(before.procedural, after.procedural)
+  };
+}
+function entryDelta(before, after) {
+  const old = new Map(before.map((entry) => [entry.id, entry]));
+  const next = new Map(after.map((entry) => [entry.id, entry]));
+  let added = 0;
+  let updated = 0;
+  let deleted = 0;
+  for (const [id, entry] of next) {
+    const previous = old.get(id);
+    if (previous === void 0) added += 1;
+    else if (!sameEntry(previous, entry)) updated += 1;
+  }
+  for (const id of old.keys()) {
+    if (!next.has(id)) deleted += 1;
+  }
+  return { added, updated, deleted };
+}
+function sameEntry(left, right) {
+  return left.content === right.content && left.createdAt === right.createdAt;
+}
+function nonNegativeInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : 0;
+}
+function nonNegativeFinite(value) {
+  return Number.isFinite(value) && value >= 0 ? value : 0;
+}
+
+// src/domains/memory/task-memory-policy.ts
+init_esm_shims();
+
+// src/domains/prompts/memory-intervention.ts
+init_esm_shims();
+var MEMORY_INTERVENTION_SYSTEM_PROMPT = `You maintain task execution memory for a separate action agent. You never act on the task yourself and you never call tools. You write notes into a memory bank and, rarely, pass one reminder back.
+
+Return exactly two lines and no markdown fences:
+<operations>[JSON operations]</operations>
+<no_intervention/>
+
+Or replace the second line with:
+<context_for_action>one concise reminder</context_for_action>
+
+The operations list holds memory writes only. It is never a list of tool calls, commands, files to read, or next steps. "op" must be exactly one of these four strings and no others:
+- {"op":"update_status","content":"one paragraph"}
+- {"op":"save_knowledge","content":"one stable task fact"}
+- {"op":"save_procedural","content":"one attempt, outcome, diagnosis, or fix"}
+- {"op":"delete","id":"existing entry id"}
+
+Any other "op" value discards that operation. Add "id" to a save only to overwrite an entry already listed in the task bank; omit "id" to record something new. Use at most eight operations, and use <operations>[]</operations> when nothing is worth recording.
+
+Worked example. Given a trajectory where the agent read three routing files and one build command failed twice, a correct response is:
+<operations>[{"op":"update_status","content":"Mapping the routing call chain; the build is still failing."},{"op":"save_knowledge","content":"Target selection runs through placement.ts before runtime-resolution.ts."},{"op":"save_procedural","content":"npm run build failed twice with the same TS2345; the edit did not address it."}]</operations>
+<no_intervention/>
+
+Second worked example. Given a trajectory where the same command failed twice and the bank already holds [tm-p-1] describing that failure, a correct response is:
+<operations>[{"op":"update_status","content":"The same build command has now failed twice with the same error."}]</operations>
+<context_for_action>[tm-p-1] this exact command already failed with this error; change the approach rather than running it again.</context_for_action>
+
+Status is your private progress model and must never appear in context_for_action. Default to <no_intervention/>. Intervene only to restore a relevant bank fact or prevent a repeated known failure. Cite supporting visible entries as [entry-id]. Never restate the latest observation, take over planning, give broad strategy, block a tool, or request continuation.`;
+function buildMemoryInterventionUserPrompt(input) {
+  return [
+    "Task:",
+    input.task.trim() || "(unknown)",
+    "",
+    "Task bank (status is intentionally omitted):",
+    input.bank.trim() || "(empty)",
+    "",
+    "Recent completed tool trajectory:",
+    input.trajectory.trim() || "[]"
+  ].join("\n");
+}
+
+// src/domains/memory/task-memory-policy.ts
+var TASK_MEMORY_POLICY_MAX_OPERATIONS = 8;
+var TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS = 18e4;
+var TASK_MEMORY_POLICY_MODEL_MAX_OUTPUT_TOKENS = 4e3;
+var TASK_PROMPT_MAX_CHARS = 2e3;
+var TRAJECTORY_PROMPT_MAX_CHARS = 4e3;
+function renderTrajectory(trajectory) {
+  let steps = [...trajectory];
+  let rendered = JSON.stringify(steps);
+  while (rendered.length > TRAJECTORY_PROMPT_MAX_CHARS && steps.length > 1) {
+    steps = steps.slice(1);
+    rendered = JSON.stringify(steps);
+  }
+  if (rendered.length > TRAJECTORY_PROMPT_MAX_CHARS && steps.length === 1) {
+    const only = steps[0];
+    if (only !== void 0) {
+      const room = Math.max(0, TRAJECTORY_PROMPT_MAX_CHARS - JSON.stringify([{ ...only, resultDigest: "" }]).length);
+      rendered = JSON.stringify([{ ...only, resultDigest: only.resultDigest.slice(0, room) }]);
+    }
+  }
+  return rendered;
+}
+async function runTaskMemoryPolicy(bank, client, input) {
+  const controller = new AbortController();
+  const timeoutMs = positiveInteger2(input.timeoutMs, TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS);
+  const timeoutMarker = /* @__PURE__ */ Symbol("task-memory-timeout");
+  let timer;
+  let userPrompt = "";
+  let rawResponse = "";
+  let clientError = null;
+  const settle = (decision, reason, parts = {}) => {
+    const result = {
+      decision,
+      reason,
+      bankOperations: parts.bankOperations ?? 0,
+      droppedOperations: parts.droppedOperations ?? 0,
+      reminder: parts.reminder ?? null,
+      inputTokens: parts.inputTokens ?? 0,
+      outputTokens: parts.outputTokens ?? 0
+    };
+    try {
+      input.onEnvelope?.({
+        systemPrompt: MEMORY_INTERVENTION_SYSTEM_PROMPT,
+        userPrompt,
+        response: rawResponse,
+        decision,
+        reason,
+        bankOperations: result.bankOperations,
+        droppedOperations: result.droppedOperations,
+        reminder: result.reminder,
+        error: clientError
+      });
+    } catch {
+    }
+    return result;
+  };
+  try {
+    userPrompt = buildMemoryInterventionUserPrompt({
+      task: input.task.slice(0, TASK_PROMPT_MAX_CHARS),
+      bank: bank.render(input.maxTokens),
+      trajectory: renderTrajectory(input.trajectory)
+    });
+    const completion = client.complete({
+      systemPrompt: MEMORY_INTERVENTION_SYSTEM_PROMPT,
+      userPrompt,
+      maxTokens: TASK_MEMORY_POLICY_MODEL_MAX_OUTPUT_TOKENS,
+      signal: controller.signal
+    });
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(() => resolve(timeoutMarker), timeoutMs);
+    });
+    const response = await Promise.race([completion, timeout]);
+    if (response === timeoutMarker) {
+      controller.abort();
+      void completion.catch(() => void 0);
+      return settle("timeout", "deadline");
+    }
+    rawResponse = typeof response.text === "string" ? response.text : "";
+    const usage = {
+      inputTokens: nonNegativeInteger2(response.inputTokens),
+      outputTokens: nonNegativeInteger2(response.outputTokens)
+    };
+    const read = readPolicyStep(rawResponse);
+    if (!read.ok) return settle("malformed", read.reason, { ...usage, droppedOperations: read.dropped });
+    const operations = resolveOperations(bank, read.step.operations);
+    applyOperations(bank, operations);
+    const counts = {
+      ...usage,
+      bankOperations: operations.length,
+      droppedOperations: read.dropped + (read.step.operations.length - operations.length)
+    };
+    if (read.step.context === null) return settle("silent", "model_silent", counts);
+    const reminder = withMemoryPrefix(read.step.context, input.maxTokens);
+    if (reminder.length === 0) return settle("gated", "over_budget", counts);
+    if (input.suppressIntervention === true) return settle("silent", "suppressed", counts);
+    if (reminder === input.previousReminder) return settle("silent", "duplicate_reminder", counts);
+    const citedIds = citedRenderableEntryIds(bank, reminder);
+    if (!input.deterministicTrigger && citedIds.length === 0) return settle("gated", "uncited", counts);
+    bank.recordInjection(citedIds);
+    return settle("injected", "intervened", { ...counts, reminder });
+  } catch (error) {
+    clientError = errorMessage(error);
+    return settle("silent", "client_error");
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+var OPERATIONS_OPEN = "<operations>";
+var OPERATIONS_CLOSE = "</operations>";
+var CONTEXT_OPEN = "<context_for_action>";
+var CONTEXT_CLOSE = "</context_for_action>";
+function cleanPolicyResponse(raw) {
+  return raw.replace(/<(think|thinking|reasoning|scratchpad)\b[^>]*>[\s\S]*?<\/\1\s*>/giu, " ").replace(/<(think|thinking|reasoning|scratchpad)\b[^>]*>[\s\S]*$/iu, " ").replace(/^[^\S\n]*```[^\n]*$/gmu, " ").trim();
+}
+function stripTagShapes(value) {
+  return value.replace(/<\/?[a-zA-Z][^>]*>/gu, " ");
+}
+function operationsEndIndex(text, from) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  let started = false;
+  for (let index = from; index < text.length; index += 1) {
+    const char = text[index];
+    if (inString) {
+      if (escaped) escaped = false;
+      else if (char === "\\") escaped = true;
+      else if (char === '"') inString = false;
+      continue;
+    }
+    if (char === '"') {
+      inString = true;
+      continue;
+    }
+    if (char === "[" || char === "{") {
+      depth += 1;
+      started = true;
+      continue;
+    }
+    if (char === "]" || char === "}") {
+      depth -= 1;
+      if (depth < 0) return -1;
+      if (depth === 0 && started) return index + 1;
+      continue;
+    }
+    if (!started && char !== void 0 && char.trim().length > 0) return -1;
+  }
+  return -1;
+}
+function readPolicyStep(response) {
+  const unparseable = { ok: false, reason: "unparseable", dropped: 0 };
+  if (typeof response !== "string" || response.length === 0) return unparseable;
+  const text = cleanPolicyResponse(response);
+  const opensAt = text.indexOf(OPERATIONS_OPEN);
+  if (opensAt === -1) return unparseable;
+  const listAt = opensAt + OPERATIONS_OPEN.length;
+  const listEndsAt = operationsEndIndex(text, listAt);
+  if (listEndsAt === -1) return unparseable;
+  const closesAt = text.indexOf(OPERATIONS_CLOSE, listEndsAt);
+  if (closesAt === -1) return unparseable;
+  let rawOperations;
+  try {
+    rawOperations = JSON.parse(text.slice(listAt, listEndsAt));
+  } catch {
+    return unparseable;
+  }
+  const read = readOperations(rawOperations);
+  if (read === null) return unparseable;
+  if (read.operations.length === 0 && read.dropped > 0) {
+    return { ok: false, reason: "all_operations_invalid", dropped: read.dropped };
+  }
+  return {
+    ok: true,
+    step: { operations: read.operations, context: readContext(text.slice(closesAt + OPERATIONS_CLOSE.length)) },
+    dropped: read.dropped
+  };
+}
+function readContext(tail) {
+  const contextAt = tail.indexOf(CONTEXT_OPEN);
+  const silenceAt = tail.search(/<no_intervention\s*\/?>/u);
+  if (contextAt === -1) return null;
+  if (silenceAt !== -1 && silenceAt < contextAt) return null;
+  const body = tail.slice(contextAt + CONTEXT_OPEN.length);
+  const closesAt = body.lastIndexOf(CONTEXT_CLOSE);
+  const context = stripTagShapes(closesAt === -1 ? body : body.slice(0, closesAt)).replace(/\s+/gu, " ").trim();
+  return context.length === 0 ? null : context;
+}
+function readOperations(value) {
+  if (!Array.isArray(value) || value.length > TASK_MEMORY_POLICY_MAX_OPERATIONS) return null;
+  const operations = [];
+  let dropped = 0;
+  for (const raw of value) {
+    if (!isRecord(raw) || typeof raw.op !== "string") return null;
+    switch (raw.op) {
+      case "update_status": {
+        if (!hasExactKeys(raw, ["op", "content"])) return null;
+        const content = boundedContent(raw.content);
+        if (content === null) return null;
+        operations.push({ op: raw.op, content });
+        break;
+      }
+      case "save_knowledge":
+      case "save_procedural": {
+        if (!hasExactKeys(raw, raw.id === void 0 ? ["op", "content"] : ["op", "content", "id"])) return null;
+        const content = boundedContent(raw.content);
+        if (content === null) return null;
+        if (raw.id !== void 0 && !nonEmptyString(raw.id)) return null;
+        const operation = { op: raw.op, content };
+        if (typeof raw.id === "string") operation.id = raw.id;
+        operations.push(operation);
+        break;
+      }
+      case "delete":
+        if (!hasExactKeys(raw, ["op", "id"]) || !nonEmptyString(raw.id)) return null;
+        operations.push({ op: raw.op, id: raw.id });
+        break;
+      default:
+        dropped += 1;
+        break;
+    }
+  }
+  return { operations, dropped };
+}
+function resolveOperations(bank, operations) {
+  const snapshot = bank.snapshot();
+  const classes = /* @__PURE__ */ new Map();
+  if (snapshot.status !== null) classes.set(snapshot.status.id, "status");
+  for (const entry of snapshot.knowledge) classes.set(entry.id, "knowledge");
+  for (const entry of snapshot.procedural) classes.set(entry.id, "procedural");
+  const resolved = [];
+  for (const operation of operations) {
+    switch (operation.op) {
+      case "update_status":
+        resolved.push(operation);
+        break;
+      case "save_knowledge":
+      case "save_procedural": {
+        const expected = operation.op === "save_knowledge" ? "knowledge" : "procedural";
+        if (operation.id !== void 0 && classes.get(operation.id) === expected) {
+          resolved.push(operation);
+          break;
+        }
+        resolved.push({ op: operation.op, content: operation.content });
+        break;
+      }
+      case "delete":
+        if (classes.delete(operation.id)) resolved.push(operation);
+        break;
+    }
+  }
+  return resolved;
+}
+function applyOperations(bank, operations) {
+  for (const operation of operations) {
+    switch (operation.op) {
+      case "update_status":
+        bank.updateStatus(operation.content);
+        break;
+      case "save_knowledge":
+        bank.saveKnowledge(operation.content, operation.id === void 0 ? {} : { id: operation.id });
+        break;
+      case "save_procedural":
+        bank.saveProcedural(operation.content, operation.id === void 0 ? {} : { id: operation.id });
+        break;
+      case "delete":
+        bank.deleteEntry(operation.id);
+        break;
+    }
+  }
+}
+function citedRenderableEntryIds(bank, reminder) {
+  const snapshot = bank.snapshot();
+  return [...snapshot.knowledge, ...snapshot.procedural].map((entry) => entry.id).filter((id) => reminder.includes(`[${id}]`));
+}
+function withMemoryPrefix(content, maxTokens) {
+  const prefixed = content.startsWith("Memory:") ? content : `Memory: ${content}`;
+  const maxChars = Math.max(0, maxTokens) * 4;
+  return prefixed.length <= maxChars ? prefixed : "";
+}
+function boundedContent(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.replace(/\s+/gu, " ").trim();
+  return normalized.length > 0 && normalized.length <= TASK_MEMORY_CONTENT_MAX_CHARS ? normalized : null;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function hasExactKeys(record, expected) {
+  const keys = Object.keys(record).sort();
+  return keys.length === expected.length && [...expected].sort().every((key, index) => keys[index] === key);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function positiveInteger2(value, fallback) {
+  return value !== void 0 && Number.isInteger(value) && value > 0 ? value : fallback;
+}
+function nonNegativeInteger2(value) {
+  return value !== void 0 && Number.isInteger(value) && value >= 0 ? value : 0;
+}
+function errorMessage(error) {
+  if (error instanceof Error) return error.message.length > 0 ? error.message : error.name;
+  return typeof error === "string" && error.length > 0 ? error : "an unknown client failure";
+}
+
+export {
+  TASK_MEMORY_DEFAULT_KNOWLEDGE_CAP,
+  TASK_MEMORY_DEFAULT_PROCEDURAL_CAP,
+  TASK_MEMORY_CONTENT_MAX_CHARS,
+  TaskMemoryBank,
+  TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS,
+  runTaskMemoryPolicy,
+  createTaskMemoryTelemetrySink,
+  taskMemoryBankDelta
+};
+//# sourceMappingURL=chunk-OAO4GE4M.js.map