@duetso/agent 0.2.6 → 0.3.0

package/dist/src/memory-store.js

@@ -0,0 +1,554 @@
+// src/memory/store/file.ts
+import { Buffer } from "node:buffer";
+import { basename } from "node:path";
+var MAX_TRAIN_RECORD_CONTENT_BYTES = 10 * 1024 * 1024;
+var SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var ID_SEGMENT_PATTERN = /^[A-Za-z0-9_-]+$/;
+var KEY_PATTERN = /^[A-Za-z][A-Za-z0-9]*$/;
+var NUMBER_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+var KNOWN_KEYS = [
+  "version",
+  "id",
+  "kind",
+  "createdAt",
+  "headline",
+  "model",
+  "fileCount",
+  "archiveId",
+  "priority",
+  "source",
+  "tags"
+];
+var KNOWN_KEY_ORDER = new Map(KNOWN_KEYS.map((key, index) => [key, index]));
+var parsedLineEndings = new WeakMap;
+function parseMemoryFile(text) {
+  const lineEnding = text.startsWith(`---\r
+`) ? `\r
+` : text.startsWith(`---
+`) ? `
+` : undefined;
+  if (!lineEnding)
+    throw new Error("Memory file must start with a frontmatter delimiter");
+  const closingDelimiter = `${lineEnding}---${lineEnding}`;
+  const closingIndex = text.indexOf(closingDelimiter, 3 + lineEnding.length);
+  if (closingIndex === -1)
+    throw new Error("Memory file is missing its closing delimiter");
+  const header = text.slice(3 + lineEnding.length, closingIndex);
+  const content = text.slice(closingIndex + closingDelimiter.length);
+  assertContent(content);
+  const values = new Map;
+  let lastKnownIndex = -1;
+  let sawUnknown = false;
+  for (const line of header.split(lineEnding)) {
+    const separator = line.indexOf(": ");
+    if (separator <= 0)
+      throw new Error(`Invalid frontmatter line: ${line}`);
+    const key = line.slice(0, separator);
+    const rawValue = line.slice(separator + 2);
+    if (!KEY_PATTERN.test(key))
+      throw new Error(`Invalid frontmatter key: ${key}`);
+    if (values.has(key))
+      throw new Error(`Duplicate frontmatter key: ${key}`);
+    if (key === "sourceFolder") {
+      throw new Error("sourceFolder is private archive metadata and cannot enter a memory file");
+    }
+    const knownIndex = KNOWN_KEY_ORDER.get(key);
+    if (knownIndex === undefined) {
+      sawUnknown = true;
+    } else {
+      if (sawUnknown || knownIndex <= lastKnownIndex) {
+        throw new Error(`Frontmatter key is out of canonical order: ${key}`);
+      }
+      lastKnownIndex = knownIndex;
+    }
+    values.set(key, parseScalar(rawValue));
+  }
+  const version = requireNumber(values, "version");
+  if (version !== 1)
+    throw new Error(`Unsupported memory file version: ${version}`);
+  const kind = requireString(values, "kind");
+  if (kind !== "train" && kind !== "note")
+    throw new Error(`Invalid memory kind: ${kind}`);
+  const createdAt = requireNumber(values, "createdAt");
+  if (!Number.isSafeInteger(createdAt) || createdAt < 0) {
+    throw new Error("createdAt must be a non-negative integer");
+  }
+  const fileCount = optionalNumber(values, "fileCount");
+  if (fileCount !== undefined && (!Number.isSafeInteger(fileCount) || fileCount < 0)) {
+    throw new Error("fileCount must be a non-negative integer");
+  }
+  const record = {
+    version: 1,
+    id: requireIdSegment(values, "id"),
+    kind,
+    createdAt,
+    ...optionalStringProperty(values, "headline"),
+    ...optionalStringProperty(values, "model"),
+    ...fileCount === undefined ? {} : { fileCount },
+    ...optionalIdSegmentProperty(values, "archiveId"),
+    ...optionalStringProperty(values, "priority"),
+    ...optionalStringProperty(values, "source"),
+    ...optionalStringArrayProperty(values, "tags"),
+    ...extraProperties(values),
+    content
+  };
+  parsedLineEndings.set(record, lineEnding);
+  return record;
+}
+function serializeMemoryFile(record) {
+  validateRecord(record);
+  const lineEnding = parsedLineEndings.get(record) ?? `
+`;
+  const fields = [
+    ["version", record.version],
+    ["id", record.id],
+    ["kind", record.kind],
+    ["createdAt", record.createdAt]
+  ];
+  appendOptional(fields, "headline", record.headline);
+  appendOptional(fields, "model", record.model);
+  appendOptional(fields, "fileCount", record.fileCount);
+  appendOptional(fields, "archiveId", record.archiveId);
+  appendOptional(fields, "priority", record.priority);
+  appendOptional(fields, "source", record.source);
+  appendOptional(fields, "tags", record.tags);
+  for (const [key, value] of Object.entries(record.extra ?? {})) {
+    if (!KEY_PATTERN.test(key) || KNOWN_KEY_ORDER.has(key) || key === "sourceFolder") {
+      throw new Error(`Invalid extra frontmatter key: ${key}`);
+    }
+    fields.push([key, value]);
+  }
+  const header = fields.map(([key, value]) => `${key}: ${serializeScalar(value)}`).join(lineEnding);
+  return `---${lineEnding}${header}${lineEnding}---${lineEnding}${record.content}`;
+}
+function slugFromFilename(name) {
+  if (basename(name) !== name || !name.endsWith(".md")) {
+    throw new Error(`Memory filename must be a bare .md filename: ${name}`);
+  }
+  const slug = name.slice(0, -3);
+  if (!SLUG_PATTERN.test(slug))
+    throw new Error(`Unsafe memory slug: ${slug}`);
+  return slug;
+}
+function parseScalar(rawValue) {
+  if (NUMBER_PATTERN.test(rawValue)) {
+    const value = Number(rawValue);
+    if (Number.isFinite(value) && String(value) === rawValue)
+      return value;
+  }
+  try {
+    const value = JSON.parse(rawValue);
+    if (typeof value === "string" && JSON.stringify(value) === rawValue)
+      return value;
+    if (Array.isArray(value) && value.every((item) => typeof item === "string") && `[${value.map((item) => JSON.stringify(item)).join(", ")}]` === rawValue) {
+      return value;
+    }
+  } catch {}
+  throw new Error(`Unsupported frontmatter scalar: ${rawValue}`);
+}
+function serializeScalar(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || /[eE]/.test(String(value))) {
+      throw new Error(`Frontmatter numbers must be finite decimals: ${value}`);
+    }
+    return String(value);
+  }
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+    return `[${value.map((item) => JSON.stringify(item)).join(", ")}]`;
+  }
+  throw new Error("Frontmatter values must be strings, numbers, or string arrays");
+}
+function requireNumber(values, key) {
+  const value = values.get(key);
+  if (typeof value !== "number")
+    throw new Error(`Frontmatter ${key} must be a number`);
+  return value;
+}
+function optionalNumber(values, key) {
+  const value = values.get(key);
+  if (value === undefined)
+    return;
+  if (typeof value !== "number")
+    throw new Error(`Frontmatter ${key} must be a number`);
+  return value;
+}
+function requireString(values, key) {
+  const value = values.get(key);
+  if (typeof value !== "string")
+    throw new Error(`Frontmatter ${key} must be a string`);
+  return value;
+}
+function requireNonBlankString(values, key) {
+  const value = requireString(values, key);
+  if (value.trim().length === 0)
+    throw new Error(`Frontmatter ${key} cannot be blank`);
+  return value;
+}
+function requireIdSegment(values, key) {
+  return assertIdSegment(key, requireNonBlankString(values, key));
+}
+function optionalIdSegmentProperty(values, key) {
+  if (!values.has(key))
+    return {};
+  return { [key]: requireIdSegment(values, key) };
+}
+function assertIdSegment(key, value) {
+  if (!ID_SEGMENT_PATTERN.test(value)) {
+    throw new Error(`Frontmatter ${key} must be a safe path segment: ${value}`);
+  }
+  return value;
+}
+function optionalStringProperty(values, key) {
+  if (!values.has(key))
+    return {};
+  return { [key]: requireNonBlankString(values, key) };
+}
+function optionalStringArrayProperty(values, key) {
+  const value = values.get(key);
+  if (value === undefined)
+    return {};
+  if (!Array.isArray(value) || value.some((item) => item.trim().length === 0)) {
+    throw new Error(`Frontmatter ${key} must be a string array without blank items`);
+  }
+  return { tags: value };
+}
+function extraProperties(values) {
+  const extra = Object.fromEntries(Array.from(values).filter(([key]) => !KNOWN_KEY_ORDER.has(key)));
+  return Object.keys(extra).length === 0 ? {} : { extra };
+}
+function appendOptional(fields, key, value) {
+  if (value !== undefined)
+    fields.push([key, value]);
+}
+function validateRecord(record) {
+  if (record.version !== 1)
+    throw new Error(`Unsupported memory file version: ${record.version}`);
+  if (record.id.trim().length === 0)
+    throw new Error("Frontmatter id cannot be blank");
+  assertIdSegment("id", record.id);
+  if (record.archiveId !== undefined)
+    assertIdSegment("archiveId", record.archiveId);
+  if (record.kind !== "train" && record.kind !== "note") {
+    throw new Error(`Invalid memory kind: ${String(record.kind)}`);
+  }
+  if (!Number.isSafeInteger(record.createdAt) || record.createdAt < 0) {
+    throw new Error("createdAt must be a non-negative integer");
+  }
+  if (record.fileCount !== undefined && (!Number.isSafeInteger(record.fileCount) || record.fileCount < 0)) {
+    throw new Error("fileCount must be a non-negative integer");
+  }
+  for (const [key, value] of Object.entries({
+    headline: record.headline,
+    model: record.model,
+    archiveId: record.archiveId,
+    priority: record.priority,
+    source: record.source
+  })) {
+    if (value !== undefined && value.trim().length === 0) {
+      throw new Error(`Frontmatter ${key} cannot be blank`);
+    }
+  }
+  if (record.tags?.some((tag) => tag.trim().length === 0)) {
+    throw new Error("Frontmatter tags cannot contain blank items");
+  }
+  assertContent(record.content);
+}
+function assertContent(content) {
+  if (content.trim().length === 0)
+    throw new Error("Memory content cannot be blank");
+  const bytes = Buffer.byteLength(content, "utf8");
+  if (bytes > MAX_TRAIN_RECORD_CONTENT_BYTES) {
+    throw new Error(`Memory content exceeds ${MAX_TRAIN_RECORD_CONTENT_BYTES} UTF-8 bytes`);
+  }
+}
+// src/memory/store/discovery.ts
+import { lstat } from "node:fs/promises";
+import { join } from "node:path";
+
+// src/lib/walk-ancestors.ts
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+function walkAncestors(cwd, home = homedir()) {
+  const resolvedHome = resolve(home);
+  const seen = new Set;
+  const result = [];
+  let current = resolve(cwd);
+  while (true) {
+    if (seen.has(current))
+      break;
+    seen.add(current);
+    if (current !== resolvedHome)
+      result.push(current);
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return result;
+}
+
+// src/memory/store/discovery.ts
+var MEMORY_ROOT_NAMES = [".duet", ".agents", ".claude"];
+async function discoverMemoryStores(cwd) {
+  const stores = [];
+  for (const ancestor of walkAncestors(cwd)) {
+    for (const rootName of MEMORY_ROOT_NAMES) {
+      const storeDir = join(ancestor, rootName, "memories");
+      const status = await lstat(storeDir).catch((error) => {
+        if (isNodeError(error, "ENOENT") || isNodeError(error, "ENOTDIR"))
+          return;
+        throw error;
+      });
+      if (!status)
+        continue;
+      if (status.isSymbolicLink())
+        throw new Error(`Memory stores cannot be symlinks: ${storeDir}`);
+      if (!status.isDirectory())
+        throw new Error(`Memory store is not a directory: ${storeDir}`);
+      stores.push(storeDir);
+    }
+  }
+  return stores;
+}
+function isNodeError(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+// src/memory/store/sources.ts
+import * as fileSystem from "node:fs/promises";
+import { join as join3, resolve as resolve2 } from "node:path";
+
+// src/memory/paths.ts
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+var DEFAULT_DUET_DIR = ".duet";
+var DEFAULT_DUET_HOME = join2(homedir2(), DEFAULT_DUET_DIR);
+var DEFAULT_SESSION_STORAGE_DIR = join2(DEFAULT_DUET_HOME, "sessions");
+var DEFAULT_MEMORY_DB_PATH = join2(DEFAULT_DUET_HOME, "memory.db");
+
+// src/memory/store/sources.ts
+async function resolveSources(flags, cwd) {
+  const explicitCount = flags.stores.length + flags.dbs.length;
+  if (explicitCount > 0) {
+    const stores2 = unique(flags.stores);
+    const dbs = unique(flags.dbs);
+    const selected = flags.stores[0] ?? flags.dbs[0];
+    const writeTarget = explicitCount === 1 && selected ? { kind: flags.stores.length === 1 ? "store" : "db", path: selected } : undefined;
+    return {
+      stores: stores2,
+      dbs,
+      ...writeTarget ? { writeTarget } : {}
+    };
+  }
+  const stores = await discoverMemoryStores(cwd);
+  return {
+    stores,
+    dbs: [DEFAULT_MEMORY_DB_PATH],
+    writeTarget: { kind: "store", path: await nearestAgentMemoryStore(cwd) }
+  };
+}
+function mergeListings(storeEntries, dbEntries) {
+  const winners = new Map;
+  for (const listing of storeEntries) {
+    for (const entry of listing.entries) {
+      if (!winners.has(entry.slug))
+        winners.set(entry.slug, { ...entry, store: listing.source });
+    }
+  }
+  for (const listing of dbEntries) {
+    for (const entry of listing.entries) {
+      if (!winners.has(entry.slug))
+        winners.set(entry.slug, { ...entry });
+    }
+  }
+  return Array.from(winners.values()).sort((left, right) => right.createdAt - left.createdAt);
+}
+async function nearestAgentMemoryStore(cwd) {
+  for (const ancestor of walkAncestors(cwd)) {
+    const agentRoot = join3(ancestor, ".agents");
+    const status = await fileSystem.lstat(agentRoot).catch((error) => {
+      if (isNodeError2(error, "ENOENT") || isNodeError2(error, "ENOTDIR"))
+        return;
+      throw error;
+    });
+    if (!status)
+      continue;
+    if (status.isSymbolicLink())
+      throw new Error(`Agent directories cannot be symlinks: ${agentRoot}`);
+    if (!status.isDirectory())
+      throw new Error(`Agent path is not a directory: ${agentRoot}`);
+    return join3(agentRoot, "memories");
+  }
+  return join3(resolve2(cwd), ".agents", "memories");
+}
+function unique(paths) {
+  return Array.from(new Set(paths));
+}
+function isNodeError2(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+// src/memory/store/store.ts
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import * as fileSystem2 from "node:fs/promises";
+import { basename as basename2, join as join4, resolve as resolve3 } from "node:path";
+async function listStore(dir) {
+  return listStoreWithInvalidPolicy(dir);
+}
+async function listStoreWithInvalidPolicy(dir, onInvalidEntry) {
+  const storeDir = await requireStoreDirectory(dir, false);
+  if (!storeDir)
+    return [];
+  const directoryEntries = await fileSystem2.readdir(storeDir, { withFileTypes: true });
+  const memoryEntries = directoryEntries.filter((entry) => entry.name.endsWith(".md")).sort((left, right) => left.name.localeCompare(right.name));
+  const loaded = await Promise.all(memoryEntries.map(async (entry) => {
+    const path = join4(storeDir, entry.name);
+    try {
+      if (entry.isSymbolicLink())
+        throw new Error(`Memory files cannot be symlinks: ${entry.name}`);
+      if (!entry.isFile())
+        throw new Error(`Memory entry is not a regular file: ${entry.name}`);
+      return await readEntry(storeDir, slugFromFilename(entry.name));
+    } catch (error) {
+      if (!onInvalidEntry)
+        throw error;
+      onInvalidEntry(path, error);
+      return;
+    }
+  }));
+  return loaded.filter((entry) => entry !== undefined);
+}
+async function readEntry(dir, slug) {
+  const safeSlug = assertSlug(slug);
+  const storeDir = await requireStoreDirectory(dir, false);
+  if (!storeDir)
+    throw new Error(`Memory store does not exist: ${resolve3(dir)}`);
+  return (await readParsedEntry(storeDir, safeSlug)).stored;
+}
+async function writeEntry(dir, record) {
+  const slug = assertSlug(record.slug);
+  const bytes = serializeMemoryFile(record);
+  const storeDir = await requireStoreDirectory(dir, true);
+  if (!storeDir)
+    throw new Error("Memory store could not be created");
+  const destination = join4(storeDir, `${slug}.md`);
+  await rejectSymlinkIfPresent(destination);
+  const temporary = join4(storeDir, `.${slug}.${randomUUID()}.tmp`);
+  const handle = await fileSystem2.open(temporary, "wx", 384);
+  try {
+    try {
+      await handle.writeFile(bytes, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await fileSystem2.rename(temporary, destination);
+  } catch (error) {
+    await fileSystem2.rm(temporary, { force: true });
+    throw error;
+  }
+  return toStoredMemory(storeDir, slug, record);
+}
+async function updateEntry(dir, slug, content) {
+  const safeSlug = assertSlug(slug);
+  const storeDir = await requireStoreDirectory(dir, false);
+  if (!storeDir)
+    throw new Error(`Memory store does not exist: ${resolve3(dir)}`);
+  const { record } = await readParsedEntry(storeDir, safeSlug);
+  record.content = content;
+  return writeEntry(storeDir, Object.assign(record, { slug: safeSlug }));
+}
+async function deleteEntry(dir, slug) {
+  const safeSlug = assertSlug(slug);
+  const storeDir = await requireStoreDirectory(dir, false);
+  if (!storeDir)
+    throw new Error(`Memory store does not exist: ${resolve3(dir)}`);
+  const { stored } = await readParsedEntry(storeDir, safeSlug);
+  const path = join4(storeDir, `${safeSlug}.md`);
+  await rejectSymlinkIfPresent(path);
+  await fileSystem2.unlink(path);
+  return stored;
+}
+async function readParsedEntry(storeDir, slug) {
+  const path = join4(storeDir, `${slug}.md`);
+  const status = await fileSystem2.lstat(path);
+  if (status.isSymbolicLink())
+    throw new Error(`Memory files cannot be symlinks: ${path}`);
+  if (!status.isFile())
+    throw new Error(`Memory entry is not a regular file: ${path}`);
+  const handle = await fileSystem2.open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  const text = await handle.readFile("utf8").finally(() => handle.close());
+  const record = parseMemoryFile(text);
+  return { stored: toStoredMemory(storeDir, slug, record), record };
+}
+function toStoredMemory(storeDir, slug, record) {
+  return {
+    slug,
+    storeDir,
+    id: record.id,
+    kind: record.kind,
+    createdAt: record.createdAt,
+    ...record.headline === undefined ? {} : { headline: record.headline },
+    ...record.model === undefined ? {} : { model: record.model },
+    ...record.fileCount === undefined ? {} : { fileCount: record.fileCount },
+    ...record.archiveId === undefined ? {} : { archiveId: record.archiveId },
+    content: record.content
+  };
+}
+function assertSlug(slug) {
+  if (basename2(slug) !== slug)
+    throw new Error(`Unsafe memory slug: ${slug}`);
+  return slugFromFilename(`${slug}.md`);
+}
+async function requireStoreDirectory(dir, create) {
+  const storeDir = resolve3(dir);
+  const status = await fileSystem2.lstat(storeDir).catch((error) => {
+    if (isNodeError3(error, "ENOENT"))
+      return;
+    throw error;
+  });
+  if (!status && create) {
+    await fileSystem2.mkdir(storeDir, { recursive: true, mode: 448 });
+    const createdStatus = await fileSystem2.lstat(storeDir);
+    if (!createdStatus.isDirectory() || createdStatus.isSymbolicLink()) {
+      throw new Error(`Memory store must be a real directory: ${storeDir}`);
+    }
+    return storeDir;
+  }
+  if (!status)
+    return;
+  if (status.isSymbolicLink())
+    throw new Error(`Memory stores cannot be symlinks: ${storeDir}`);
+  if (!status.isDirectory())
+    throw new Error(`Memory store is not a directory: ${storeDir}`);
+  return storeDir;
+}
+async function rejectSymlinkIfPresent(path) {
+  const status = await fileSystem2.lstat(path).catch((error) => {
+    if (isNodeError3(error, "ENOENT"))
+      return;
+    throw error;
+  });
+  if (status?.isSymbolicLink())
+    throw new Error(`Memory files cannot be symlinks: ${path}`);
+  if (status && !status.isFile())
+    throw new Error(`Memory entry is not a regular file: ${path}`);
+}
+function isNodeError3(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+export {
+  writeEntry,
+  updateEntry,
+  slugFromFilename,
+  serializeMemoryFile,
+  resolveSources,
+  readEntry,
+  parseMemoryFile,
+  mergeListings,
+  listStore,
+  discoverMemoryStores,
+  deleteEntry,
+  MAX_TRAIN_RECORD_CONTENT_BYTES
+};

package/dist/src/model-routing/advisor-context.d.ts

@@ -1,5 +1,19 @@
 import type { ImageContent, Message, Tool } from "@earendil-works/pi-ai";
 import type { AgentMessage, AgentState } from "@earendil-works/pi-agent-core";
+/**
+ * Soft total-input target above which the consultation pipeline compacts older
+ * work into observations. Paid repeated-run telemetry showed that forwarding
+ * larger raw transcripts costs the advisor more than it saves the observer.
+ * The hard model window remains the final safety ceiling.
+ */
+export declare const ADVISOR_INPUT_TARGET_TOKENS = 32000;
+/**
+ * Recent raw executor-message allowance kept beside compacted observations.
+ * The newest complete tool interaction remains protected even when it exceeds
+ * this target, so the allowance buys ordinary continuity without clipping the
+ * evidence the advisor was called to inspect.
+ */
+export declare const ADVISOR_RECENT_MESSAGE_TARGET_TOKENS = 8000;
 /** Minimal live-agent surface needed to capture the executor request faithfully. */
 export interface AdvisorContextSource {
     /** Current prompt, transcript, tools, and any partial assistant message. */
@@ -15,6 +29,13 @@ export interface AdvisorExecutorContext {
     messages: readonly Message[];
     /** Exact tool definitions available to the executor for the current turn. */
     tools: readonly Tool[];
+    /** Raw executor messages represented by observational context instead of repeated verbatim. */
+    compactedMessages?: number;
+}
+/** Optional advisor-only projection applied before conversion to provider messages. */
+export interface CaptureAdvisorContextOptions {
+    /** Replaces older history with normal observational context and a recent raw tail. */
+    transformMessages: (messages: AgentMessage[]) => Promise<AgentMessage[]>;
 }
 /** Inputs for fitting the executor context into the advisor model's real request window. */
 export interface BuildAdvisorContextInput {
@@ -35,10 +56,14 @@ export interface AdvisorContextMetadata {
     safetyMarginTokens: number;
     /** Maximum estimated tokens available to the quoted executor context. */
     inputLimitTokens: number;
+    /** Preferred total advisor input; the hard model limit remains a safety ceiling. */
+    inputTargetTokens: number;
     /** Heuristic token estimate including the shared coarse per-image charge. */
     estimatedInputTokens: number;
     /** Number of executor messages included in the serialized context. */
     includedMessages: number;
+    /** Raw executor messages represented by observational context rather than copied verbatim. */
+    compactedMessages: number;
     /** Number of older executor messages omitted at whole-message boundaries. */
     omittedMessages: number;
     /** True only when the advisor model's real window forced message omission. */
@@ -60,12 +85,13 @@ export interface AdvisorContext {
  * Tool execution normally starts after the assistant message is finalized; the
  * streaming fallback also preserves a partial turn for callers at other phases.
  */
-export declare function captureAdvisorExecutorContext(source: AdvisorContextSource): Promise<AdvisorExecutorContext>;
+export declare function captureAdvisorExecutorContext(source: AdvisorContextSource, options?: CaptureAdvisorContextOptions): Promise<AdvisorExecutorContext>;
 /**
- * Serialize the actual executor context without observer projection. When the
- * advisor model cannot fit it, remove only the oldest complete messages; tool
- * definitions, the resolved system prompt, and retained message structures
- * remain intact. Image bytes travel as matching multimodal attachments.
+ * Serialize the captured raw or observationally compacted executor context.
+ * When the advisor's hard model window still cannot fit it, remove only the
+ * oldest complete messages; tool definitions, the resolved system prompt, and
+ * retained message structures remain intact. Image bytes travel as matching
+ * multimodal attachments.
  */
 export declare function buildAdvisorContext(input: BuildAdvisorContextInput): AdvisorContext;
 //# sourceMappingURL=advisor-context.d.ts.map

package/dist/src/model-routing/advisor-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"advisor-context.d.ts","sourceRoot":"","sources":["../../../src/model-routing/advisor-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AAClF,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAQ9E,oFAAoF;AACpF,MAAM,WAAW,oBAAoB;IACnC,4EAA4E;IAC5E,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,cAAc,GAAG,UAAU,GAAG,OAAO,GAAG,kBAAkB,CAAC,CAAC;IACpF,8EAA8E;IAC9E,YAAY,EAAE,CAAC,QAAQ,EAAE,YAAY,EAAE,KAAK,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CAC5E;AAED,mEAAmE;AACnE,MAAM,WAAW,sBAAsB;IACrC,yDAAyD;IACzD,YAAY,EAAE,MAAM,CAAC;IACrB,mFAAmF;IACnF,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IAC7B,6EAA6E;IAC7E,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;CACxB;AAED,4FAA4F;AAC5F,MAAM,WAAW,wBAAwB;IACvC,2EAA2E;IAC3E,OAAO,EAAE,sBAAsB,CAAC;IAChC,oEAAoE;IACpE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oFAAoF;IACpF,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,wEAAwE;AACxE,MAAM,WAAW,sBAAsB;IACrC,mEAAmE;IACnE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,qEAAqE;IACrE,oBAAoB,EAAE,MAAM,CAAC;IAC7B,0FAA0F;IAC1F,kBAAkB,EAAE,MAAM,CAAC;IAC3B,yEAAyE;IACzE,gBAAgB,EAAE,MAAM,CAAC;IACzB,6EAA6E;IAC7E,oBAAoB,EAAE,MAAM,CAAC;IAC7B,sEAAsE;IACtE,gBAAgB,EAAE,MAAM,CAAC;IACzB,6EAA6E;IAC7E,eAAe,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,SAAS,EAAE,OAAO,CAAC;IACnB,mFAAmF;IACnF,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,+DAA+D;AAC/D,MAAM,WAAW,cAAc;IAC7B,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;IAChC,sEAAsE;IACtE,QAAQ,EAAE,sBAAsB,CAAC;CAClC;AAED;;;;GAIG;AACH,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,oBAAoB,GAC3B,OAAO,CAAC,sBAAsB,CAAC,CAejC;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,GAAG,cAAc,CAoDnF"}
+{"version":3,"file":"advisor-context.d.ts","sourceRoot":"","sources":["../../../src/model-routing/advisor-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAC;AACzE,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAQ9E;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,QAAS,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC,OAAQ,CAAC;AAE1D,oFAAoF;AACpF,MAAM,WAAW,oBAAoB;IACnC,4EAA4E;IAC5E,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,cAAc,GAAG,UAAU,GAAG,OAAO,GAAG,kBAAkB,CAAC,CAAC;IACpF,8EAA8E;IAC9E,YAAY,EAAE,CAAC,QAAQ,EAAE,YAAY,EAAE,KAAK,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CAC5E;AAED,mEAAmE;AACnE,MAAM,WAAW,sBAAsB;IACrC,yDAAyD;IACzD,YAAY,EAAE,MAAM,CAAC;IACrB,mFAAmF;IACnF,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IAC7B,6EAA6E;IAC7E,KAAK,EAAE,SAAS,IAAI,EAAE,CAAC;IACvB,+FAA+F;IAC/F,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,uFAAuF;AACvF,MAAM,WAAW,4BAA4B;IAC3C,sFAAsF;IACtF,iBAAiB,EAAE,CAAC,QAAQ,EAAE,YAAY,EAAE,KAAK,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;CAC1E;AAED,4FAA4F;AAC5F,MAAM,WAAW,wBAAwB;IACvC,2EAA2E;IAC3E,OAAO,EAAE,sBAAsB,CAAC;IAChC,oEAAoE;IACpE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oFAAoF;IACpF,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,wEAAwE;AACxE,MAAM,WAAW,sBAAsB;IACrC,mEAAmE;IACnE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,qEAAqE;IACrE,oBAAoB,EAAE,MAAM,CAAC;IAC7B,0FAA0F;IAC1F,kBAAkB,EAAE,MAAM,CAAC;IAC3B,yEAAyE;IACzE,gBAAgB,EAAE,MAAM,CAAC;IACzB,oFAAoF;IACpF,iBAAiB,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,oBAAoB,EAAE,MAAM,CAAC;IAC7B,sEAAsE;IACtE,gBAAgB,EAAE,MAAM,CAAC;IACzB,8FAA8F;IAC9F,iBAAiB,EAAE,MAAM,CAAC;IAC1B,6EAA6E;IAC7E,eAAe,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,SAAS,EAAE,OAAO,CAAC;IACnB,mFAAmF;IACnF,cAAc,EAAE,MAAM,CAAC;CACxB;AAED,+DAA+D;AAC/D,MAAM,WAAW,cAAc;IAC7B,uEAAuE;IACvE,IAAI,EAAE,MAAM,CAAC;IACb,iFAAiF;IACjF,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC;IAChC,sEAAsE;IACtE,QAAQ,EAAE,sBAAsB,CAAC;CAClC;AAED;;;;GAIG;AACH,wBAAsB,6BAA6B,CACjD,MAAM,EAAE,oBAAoB,EAC5B,OAAO,CAAC,EAAE,4BAA4B,GACrC,OAAO,CAAC,sBAAsB,CAAC,CAwBjC;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,wBAAwB,GAAG,cAAc,CA6DnF"}