@agent-native/core 0.52.0 → 0.54.0

package/dist/agent/observational-memory/prompts.js

@@ -0,0 +1,42 @@
+/**
+ * System prompts for the Observer and Reflector compaction passes.
+ *
+ * Both prompts insist on DATED output and preservation of task status, names,
+ * dates, and decisions — the facts a long autonomous run rots and loses. The
+ * compacted text replaces raw turns in the prompt, so it must stay dense,
+ * factual, and chronological rather than narrative.
+ */
+export const OBSERVER_SYSTEM_PROMPT = `You are the Observer for a long-running agent thread. You compress a span of raw conversation into a single DENSE, DATED observation log that will REPLACE those raw messages in future context.
+
+Rules:
+- Output a chronological, bulleted log. Prefix entries with a date/time when one is present in the source.
+- Preserve precisely: task status (what is done / in progress / blocked / decided), proper names (people, files, functions, repos, branches, IDs), exact dates, numbers, and decisions with their rationale.
+- Preserve unresolved questions, TODOs, and error states verbatim enough to act on later.
+- Drop pleasantries, restated context, and redundant tool chatter. Never invent facts.
+- Be terse. This is a memory record, not prose. No preamble, no summary-of-summary, just the log.`;
+export const REFLECTOR_SYSTEM_PROMPT = `You are the Reflector for a long-running agent thread. You condense an existing log of dated OBSERVATIONS into a smaller set of higher-level REFLECTIONS that will sit above the observations in future context.
+
+Rules:
+- Roll many low-level observations up into durable, higher-level statements: overall goal and current status, key decisions and why, stable facts (names, identifiers, constraints), and open threads.
+- Keep dates on anything time-sensitive. Keep proper names and identifiers exact.
+- Do not lose any still-open task, blocker, or unresolved decision.
+- Be terse and factual. Output a chronological/thematic bulleted list. No preamble.`;
+/**
+ * Build the Observer user prompt for a window of raw thread text.
+ */
+export function buildObserverPrompt(input) {
+    const prior = input.priorObservations?.trim()
+        ? `Existing observation log (for continuity — do NOT repeat it, only summarize the NEW messages below):\n${input.priorObservations.trim()}\n\n`
+        : "";
+    return `${prior}New raw messages to compress into the observation log (thread ${input.threadId}):\n\n${input.windowText}`;
+}
+/**
+ * Build the Reflector user prompt over the current observation log.
+ */
+export function buildReflectorPrompt(input) {
+    const prior = input.priorReflections?.trim()
+        ? `Existing reflections (for continuity — refine/extend, do not duplicate):\n${input.priorReflections.trim()}\n\n`
+        : "";
+    return `${prior}Observation log to condense into higher-level reflections (thread ${input.threadId}):\n\n${input.observationsText}`;
+}
+//# sourceMappingURL=prompts.js.map

package/dist/agent/observational-memory/prompts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.js","sourceRoot":"","sources":["../../../src/agent/observational-memory/prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,CAAC,MAAM,sBAAsB,GAAG;;;;;;;kGAO4D,CAAC;AAEnG,MAAM,CAAC,MAAM,uBAAuB,GAAG;;;;;;oFAM6C,CAAC;AAErF;;GAEG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAInC;IACC,MAAM,KAAK,GAAG,KAAK,CAAC,iBAAiB,EAAE,IAAI,EAAE;QAC3C,CAAC,CAAC,yGAAyG,KAAK,CAAC,iBAAiB,CAAC,IAAI,EAAE,MAAM;QAC/I,CAAC,CAAC,EAAE,CAAC;IACP,OAAO,GAAG,KAAK,iEAAiE,KAAK,CAAC,QAAQ,SAAS,KAAK,CAAC,UAAU,EAAE,CAAC;AAC5H,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAIpC;IACC,MAAM,KAAK,GAAG,KAAK,CAAC,gBAAgB,EAAE,IAAI,EAAE;QAC1C,CAAC,CAAC,6EAA6E,KAAK,CAAC,gBAAgB,CAAC,IAAI,EAAE,MAAM;QAClH,CAAC,CAAC,EAAE,CAAC;IACP,OAAO,GAAG,KAAK,qEAAqE,KAAK,CAAC,QAAQ,SAAS,KAAK,CAAC,gBAAgB,EAAE,CAAC;AACtI,CAAC","sourcesContent":["/**\n * System prompts for the Observer and Reflector compaction passes.\n *\n * Both prompts insist on DATED output and preservation of task status, names,\n * dates, and decisions — the facts a long autonomous run rots and loses. The\n * compacted text replaces raw turns in the prompt, so it must stay dense,\n * factual, and chronological rather than narrative.\n */\n\nexport const OBSERVER_SYSTEM_PROMPT = `You are the Observer for a long-running agent thread. You compress a span of raw conversation into a single DENSE, DATED observation log that will REPLACE those raw messages in future context.\n\nRules:\n- Output a chronological, bulleted log. Prefix entries with a date/time when one is present in the source.\n- Preserve precisely: task status (what is done / in progress / blocked / decided), proper names (people, files, functions, repos, branches, IDs), exact dates, numbers, and decisions with their rationale.\n- Preserve unresolved questions, TODOs, and error states verbatim enough to act on later.\n- Drop pleasantries, restated context, and redundant tool chatter. Never invent facts.\n- Be terse. This is a memory record, not prose. No preamble, no summary-of-summary, just the log.`;\n\nexport const REFLECTOR_SYSTEM_PROMPT = `You are the Reflector for a long-running agent thread. You condense an existing log of dated OBSERVATIONS into a smaller set of higher-level REFLECTIONS that will sit above the observations in future context.\n\nRules:\n- Roll many low-level observations up into durable, higher-level statements: overall goal and current status, key decisions and why, stable facts (names, identifiers, constraints), and open threads.\n- Keep dates on anything time-sensitive. Keep proper names and identifiers exact.\n- Do not lose any still-open task, blocker, or unresolved decision.\n- Be terse and factual. Output a chronological/thematic bulleted list. No preamble.`;\n\n/**\n * Build the Observer user prompt for a window of raw thread text.\n */\nexport function buildObserverPrompt(input: {\n  threadId: string;\n  windowText: string;\n  priorObservations?: string;\n}): string {\n  const prior = input.priorObservations?.trim()\n    ? `Existing observation log (for continuity — do NOT repeat it, only summarize the NEW messages below):\\n${input.priorObservations.trim()}\\n\\n`\n    : \"\";\n  return `${prior}New raw messages to compress into the observation log (thread ${input.threadId}):\\n\\n${input.windowText}`;\n}\n\n/**\n * Build the Reflector user prompt over the current observation log.\n */\nexport function buildReflectorPrompt(input: {\n  threadId: string;\n  observationsText: string;\n  priorReflections?: string;\n}): string {\n  const prior = input.priorReflections?.trim()\n    ? `Existing reflections (for continuity — refine/extend, do not duplicate):\\n${input.priorReflections.trim()}\\n\\n`\n    : \"\";\n  return `${prior}Observation log to condense into higher-level reflections (thread ${input.threadId}):\\n\\n${input.observationsText}`;\n}\n"]}

package/dist/agent/observational-memory/read.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Read API for Observational Memory.
+ *
+ * `buildObservationalContext` assembles the three tiers — reflections (highest
+ * level) + observations (dense) + the recent raw message tail — into a single
+ * structure ready to fold into a prompt. It is intentionally NOT wired into
+ * production-agent.ts here; see the exported seam note below and the package
+ * barrel export so the wire-up is one call later.
+ *
+ * Token-cheap by construction: a long thread is represented by its compacted
+ * tiers plus only the last N raw turns, instead of the entire transcript.
+ */
+import type { EngineMessage } from "../engine/types.js";
+import { type ObservationalMemoryConfig } from "./config.js";
+import type { ObservationalContext, ObservationalMemoryOwner } from "./types.js";
+export interface BuildObservationalContextOptions extends ObservationalMemoryOwner {
+    threadId: string;
+    /** The full, ordered thread messages — the recent tail is taken from here. */
+    messages: EngineMessage[];
+    config?: Partial<ObservationalMemoryConfig>;
+}
+/**
+ * Build the three-tier Observational Memory context for a thread. The returned
+ * tiers are ready to be injected into the turn's prompt assembly.
+ *
+ * This is consumed by the agent loop (`production-agent.ts`): when a thread has
+ * persisted observations/reflections, the older raw-message prefix (everything
+ * before `recentMessages`) is replaced with the `reflections` + `observations`
+ * text, `recentMessages` is kept verbatim, and a short "Observational Memory"
+ * block is prepended. Threads with no OM entries are left unchanged.
+ */
+/** True when this thread has at least one persisted observation or reflection. */
+export declare function hasObservationalMemory(context: ObservationalContext): boolean;
+/**
+ * Serialize the reflections + observations tiers into a single, clearly
+ * delimited prompt block. The recent-raw-message tail is NOT serialized here —
+ * it stays as verbatim engine messages — so this block represents only the
+ * compacted older history that replaces the raw prefix.
+ *
+ * Returns an empty string when there is nothing compacted yet, so callers can
+ * cheaply skip injection for short threads.
+ */
+export declare function serializeObservationalMemoryBlock(context: ObservationalContext): string;
+export declare function buildObservationalContext(options: BuildObservationalContextOptions): Promise<ObservationalContext>;
+//# sourceMappingURL=read.d.ts.map

package/dist/agent/observational-memory/read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.d.ts","sourceRoot":"","sources":["../../../src/agent/observational-memory/read.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACxD,OAAO,EAEL,KAAK,yBAAyB,EAC/B,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EACV,oBAAoB,EAEpB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,gCAAiC,SAAQ,wBAAwB;IAChF,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B,MAAM,CAAC,EAAE,OAAO,CAAC,yBAAyB,CAAC,CAAC;CAC7C;AAMD;;;;;;;;;GASG;AACH,kFAAkF;AAClF,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAE7E;AAED;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,oBAAoB,GAC5B,MAAM,CAuBR;AAED,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,gCAAgC,GACxC,OAAO,CAAC,oBAAoB,CAAC,CAwC/B"}

package/dist/agent/observational-memory/read.js

@@ -0,0 +1,97 @@
+/**
+ * Read API for Observational Memory.
+ *
+ * `buildObservationalContext` assembles the three tiers — reflections (highest
+ * level) + observations (dense) + the recent raw message tail — into a single
+ * structure ready to fold into a prompt. It is intentionally NOT wired into
+ * production-agent.ts here; see the exported seam note below and the package
+ * barrel export so the wire-up is one call later.
+ *
+ * Token-cheap by construction: a long thread is represented by its compacted
+ * tiers plus only the last N raw turns, instead of the entire transcript.
+ */
+import { resolveObservationalMemoryConfig, } from "./config.js";
+import { listObservationalMemory } from "./store.js";
+import { countWindowTokens } from "./message-text.js";
+function sumTokens(entries) {
+    return entries.reduce((acc, entry) => acc + (entry.tokenEstimate || 0), 0);
+}
+/**
+ * Build the three-tier Observational Memory context for a thread. The returned
+ * tiers are ready to be injected into the turn's prompt assembly.
+ *
+ * This is consumed by the agent loop (`production-agent.ts`): when a thread has
+ * persisted observations/reflections, the older raw-message prefix (everything
+ * before `recentMessages`) is replaced with the `reflections` + `observations`
+ * text, `recentMessages` is kept verbatim, and a short "Observational Memory"
+ * block is prepended. Threads with no OM entries are left unchanged.
+ */
+/** True when this thread has at least one persisted observation or reflection. */
+export function hasObservationalMemory(context) {
+    return context.reflections.length > 0 || context.observations.length > 0;
+}
+/**
+ * Serialize the reflections + observations tiers into a single, clearly
+ * delimited prompt block. The recent-raw-message tail is NOT serialized here —
+ * it stays as verbatim engine messages — so this block represents only the
+ * compacted older history that replaces the raw prefix.
+ *
+ * Returns an empty string when there is nothing compacted yet, so callers can
+ * cheaply skip injection for short threads.
+ */
+export function serializeObservationalMemoryBlock(context) {
+    if (!hasObservationalMemory(context))
+        return "";
+    const sections = [];
+    sections.push("[Observational Memory] The earlier part of this long conversation has been " +
+        "compacted into the dated reflections and observations below. Treat these " +
+        "as an authoritative record of what already happened — do not redo " +
+        "completed work, and trust the recorded decisions, names, dates, and " +
+        "status. The most recent turns follow verbatim after this block.");
+    if (context.reflections.length > 0) {
+        sections.push("## Reflections (highest-level)\n" +
+            context.reflections.map((entry) => entry.text).join("\n\n"));
+    }
+    if (context.observations.length > 0) {
+        sections.push("## Observations (dense, dated)\n" +
+            context.observations.map((entry) => entry.text).join("\n\n"));
+    }
+    return sections.join("\n\n");
+}
+export async function buildObservationalContext(options) {
+    const config = resolveObservationalMemoryConfig(options.config);
+    const owner = {
+        ownerEmail: options.ownerEmail,
+        orgId: options.orgId ?? null,
+    };
+    const [reflections, observations] = await Promise.all([
+        listObservationalMemory({
+            ...owner,
+            threadId: options.threadId,
+            tier: "reflection",
+        }),
+        listObservationalMemory({
+            ...owner,
+            threadId: options.threadId,
+            tier: "observation",
+        }),
+    ]);
+    const recentCount = Math.max(0, config.recentRawMessageCount);
+    const recentMessages = recentCount > 0 ? options.messages.slice(-recentCount) : [];
+    const recentTokens = await countWindowTokens(recentMessages);
+    const reflectionTokens = sumTokens(reflections);
+    const observationTokens = sumTokens(observations);
+    return {
+        threadId: options.threadId,
+        reflections,
+        observations,
+        recentMessages,
+        tokens: {
+            reflections: reflectionTokens,
+            observations: observationTokens,
+            recentMessages: recentTokens,
+            total: reflectionTokens + observationTokens + recentTokens,
+        },
+    };
+}
+//# sourceMappingURL=read.js.map

package/dist/agent/observational-memory/read.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"read.js","sourceRoot":"","sources":["../../../src/agent/observational-memory/read.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Read API for Observational Memory.\n *\n * `buildObservationalContext` assembles the three tiers — reflections (highest\n * level) + observations (dense) + the recent raw message tail — into a single\n * structure ready to fold into a prompt. It is intentionally NOT wired into\n * production-agent.ts here; see the exported seam note below and the package\n * barrel export so the wire-up is one call later.\n *\n * Token-cheap by construction: a long thread is represented by its compacted\n * tiers plus only the last N raw turns, instead of the entire transcript.\n */\n\nimport type { EngineMessage } from \"../engine/types.js\";\nimport {\n  resolveObservationalMemoryConfig,\n  type ObservationalMemoryConfig,\n} from \"./config.js\";\nimport { listObservationalMemory } from \"./store.js\";\nimport { countWindowTokens } from \"./message-text.js\";\nimport type {\n  ObservationalContext,\n  ObservationalMemoryEntry,\n  ObservationalMemoryOwner,\n} from \"./types.js\";\n\nexport interface BuildObservationalContextOptions extends ObservationalMemoryOwner {\n  threadId: string;\n  /** The full, ordered thread messages — the recent tail is taken from here. */\n  messages: EngineMessage[];\n  config?: Partial<ObservationalMemoryConfig>;\n}\n\nfunction sumTokens(entries: ObservationalMemoryEntry[]): number {\n  return entries.reduce((acc, entry) => acc + (entry.tokenEstimate || 0), 0);\n}\n\n/**\n * Build the three-tier Observational Memory context for a thread. The returned\n * tiers are ready to be injected into the turn's prompt assembly.\n *\n * This is consumed by the agent loop (`production-agent.ts`): when a thread has\n * persisted observations/reflections, the older raw-message prefix (everything\n * before `recentMessages`) is replaced with the `reflections` + `observations`\n * text, `recentMessages` is kept verbatim, and a short \"Observational Memory\"\n * block is prepended. Threads with no OM entries are left unchanged.\n */\n/** True when this thread has at least one persisted observation or reflection. */\nexport function hasObservationalMemory(context: ObservationalContext): boolean {\n  return context.reflections.length > 0 || context.observations.length > 0;\n}\n\n/**\n * Serialize the reflections + observations tiers into a single, clearly\n * delimited prompt block. The recent-raw-message tail is NOT serialized here —\n * it stays as verbatim engine messages — so this block represents only the\n * compacted older history that replaces the raw prefix.\n *\n * Returns an empty string when there is nothing compacted yet, so callers can\n * cheaply skip injection for short threads.\n */\nexport function serializeObservationalMemoryBlock(\n  context: ObservationalContext,\n): string {\n  if (!hasObservationalMemory(context)) return \"\";\n  const sections: string[] = [];\n  sections.push(\n    \"[Observational Memory] The earlier part of this long conversation has been \" +\n      \"compacted into the dated reflections and observations below. Treat these \" +\n      \"as an authoritative record of what already happened — do not redo \" +\n      \"completed work, and trust the recorded decisions, names, dates, and \" +\n      \"status. The most recent turns follow verbatim after this block.\",\n  );\n  if (context.reflections.length > 0) {\n    sections.push(\n      \"## Reflections (highest-level)\\n\" +\n        context.reflections.map((entry) => entry.text).join(\"\\n\\n\"),\n    );\n  }\n  if (context.observations.length > 0) {\n    sections.push(\n      \"## Observations (dense, dated)\\n\" +\n        context.observations.map((entry) => entry.text).join(\"\\n\\n\"),\n    );\n  }\n  return sections.join(\"\\n\\n\");\n}\n\nexport async function buildObservationalContext(\n  options: BuildObservationalContextOptions,\n): Promise<ObservationalContext> {\n  const config = resolveObservationalMemoryConfig(options.config);\n  const owner: ObservationalMemoryOwner = {\n    ownerEmail: options.ownerEmail,\n    orgId: options.orgId ?? null,\n  };\n\n  const [reflections, observations] = await Promise.all([\n    listObservationalMemory({\n      ...owner,\n      threadId: options.threadId,\n      tier: \"reflection\",\n    }),\n    listObservationalMemory({\n      ...owner,\n      threadId: options.threadId,\n      tier: \"observation\",\n    }),\n  ]);\n\n  const recentCount = Math.max(0, config.recentRawMessageCount);\n  const recentMessages =\n    recentCount > 0 ? options.messages.slice(-recentCount) : [];\n\n  const recentTokens = await countWindowTokens(recentMessages);\n  const reflectionTokens = sumTokens(reflections);\n  const observationTokens = sumTokens(observations);\n\n  return {\n    threadId: options.threadId,\n    reflections,\n    observations,\n    recentMessages,\n    tokens: {\n      reflections: reflectionTokens,\n      observations: observationTokens,\n      recentMessages: recentTokens,\n      total: reflectionTokens + observationTokens + recentTokens,\n    },\n  };\n}\n"]}

package/dist/agent/observational-memory/reflector.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The Reflector.
+ *
+ * When the persisted observation log itself exceeds the reflection token
+ * threshold, the Reflector runs ONE internal (tool-less) agent call to condense
+ * the observations into higher-level reflections, and persists a
+ * `tier: "reflection"` entry. Observations are kept (they remain the dense
+ * mid-tier); the reflection sits above them.
+ */
+import { type ObservationalMemoryConfig } from "./config.js";
+import { type InternalAgentRunFn } from "./internal-run.js";
+import type { ObservationalMemoryEntry, ObservationalMemoryOwner } from "./types.js";
+export interface RunReflectorOptions extends ObservationalMemoryOwner {
+    threadId: string;
+    config?: Partial<ObservationalMemoryConfig>;
+    /** Internal-run seam — defaults to the real one; injected in tests. */
+    runInternal?: InternalAgentRunFn;
+}
+export interface RunReflectorResult {
+    /** True when a reflection was produced and persisted. */
+    reflected: boolean;
+    entry?: ObservationalMemoryEntry;
+    /** Tokens in the observation log that was considered. */
+    observationLogTokens: number;
+}
+/**
+ * Condense the observation log into a reflection IF it exceeds the token
+ * threshold; otherwise no-op.
+ */
+export declare function runReflector(options: RunReflectorOptions): Promise<RunReflectorResult>;
+//# sourceMappingURL=reflector.d.ts.map

package/dist/agent/observational-memory/reflector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflector.d.ts","sourceRoot":"","sources":["../../../src/agent/observational-memory/reflector.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAEL,KAAK,yBAAyB,EAC/B,MAAM,aAAa,CAAC;AAMrB,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,mBAAoB,SAAQ,wBAAwB;IACnE,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC,yBAAyB,CAAC,CAAC;IAC5C,uEAAuE;IACvE,WAAW,CAAC,EAAE,kBAAkB,CAAC;CAClC;AAED,MAAM,WAAW,kBAAkB;IACjC,yDAAyD;IACzD,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,wBAAwB,CAAC;IACjC,yDAAyD;IACzD,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAChC,OAAO,EAAE,mBAAmB,GAC3B,OAAO,CAAC,kBAAkB,CAAC,CAmE7B"}

package/dist/agent/observational-memory/reflector.js

@@ -0,0 +1,76 @@
+/**
+ * The Reflector.
+ *
+ * When the persisted observation log itself exceeds the reflection token
+ * threshold, the Reflector runs ONE internal (tool-less) agent call to condense
+ * the observations into higher-level reflections, and persists a
+ * `tier: "reflection"` entry. Observations are kept (they remain the dense
+ * mid-tier); the reflection sits above them.
+ */
+import { countTextTokens } from "../context-xray/tokenize.js";
+import { resolveObservationalMemoryConfig, } from "./config.js";
+import { getObservationLogTokens, insertObservationalMemory, listObservationalMemory, } from "./store.js";
+import { runInternalAgentCall, } from "./internal-run.js";
+import { REFLECTOR_SYSTEM_PROMPT, buildReflectorPrompt } from "./prompts.js";
+/**
+ * Condense the observation log into a reflection IF it exceeds the token
+ * threshold; otherwise no-op.
+ */
+export async function runReflector(options) {
+    const config = resolveObservationalMemoryConfig(options.config);
+    const owner = {
+        ownerEmail: options.ownerEmail,
+        orgId: options.orgId ?? null,
+    };
+    const observationLogTokens = await getObservationLogTokens({
+        ...owner,
+        threadId: options.threadId,
+    });
+    if (observationLogTokens < config.reflectionTokenThreshold) {
+        return { reflected: false, observationLogTokens };
+    }
+    const observations = await listObservationalMemory({
+        ...owner,
+        threadId: options.threadId,
+        tier: "observation",
+    });
+    if (observations.length === 0) {
+        return { reflected: false, observationLogTokens };
+    }
+    const observationsText = observations.map((entry) => entry.text).join("\n\n");
+    const priorReflections = (await listObservationalMemory({
+        ...owner,
+        threadId: options.threadId,
+        tier: "reflection",
+    }))
+        .map((entry) => entry.text)
+        .join("\n\n");
+    const run = options.runInternal ?? runInternalAgentCall;
+    const reflectionText = await run({
+        systemPrompt: REFLECTOR_SYSTEM_PROMPT,
+        prompt: buildReflectorPrompt({
+            threadId: options.threadId,
+            observationsText,
+            priorReflections,
+        }),
+        maxOutputTokens: config.reflectionMaxOutputTokens,
+    });
+    if (!reflectionText.trim()) {
+        return { reflected: false, observationLogTokens };
+    }
+    const { tokens: tokenEstimate } = await countTextTokens(reflectionText);
+    const sourceStart = observations[0]?.sourceStartIndex ?? null;
+    const sourceEnd = observations[observations.length - 1]?.sourceEndIndex ?? null;
+    const entry = await insertObservationalMemory({
+        ...owner,
+        threadId: options.threadId,
+        tier: "reflection",
+        text: reflectionText,
+        tokenEstimate,
+        sourceStartIndex: sourceStart,
+        sourceEndIndex: sourceEnd,
+        sourceMessageCount: observations.length,
+    });
+    return { reflected: true, entry, observationLogTokens };
+}
+//# sourceMappingURL=reflector.js.map

package/dist/agent/observational-memory/reflector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflector.js","sourceRoot":"","sources":["../../../src/agent/observational-memory/reflector.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The Reflector.\n *\n * When the persisted observation log itself exceeds the reflection token\n * threshold, the Reflector runs ONE internal (tool-less) agent call to condense\n * the observations into higher-level reflections, and persists a\n * `tier: \"reflection\"` entry. Observations are kept (they remain the dense\n * mid-tier); the reflection sits above them.\n */\n\nimport { countTextTokens } from \"../context-xray/tokenize.js\";\nimport {\n  resolveObservationalMemoryConfig,\n  type ObservationalMemoryConfig,\n} from \"./config.js\";\nimport {\n  getObservationLogTokens,\n  insertObservationalMemory,\n  listObservationalMemory,\n} from \"./store.js\";\nimport {\n  runInternalAgentCall,\n  type InternalAgentRunFn,\n} from \"./internal-run.js\";\nimport { REFLECTOR_SYSTEM_PROMPT, buildReflectorPrompt } from \"./prompts.js\";\nimport type {\n  ObservationalMemoryEntry,\n  ObservationalMemoryOwner,\n} from \"./types.js\";\n\nexport interface RunReflectorOptions extends ObservationalMemoryOwner {\n  threadId: string;\n  config?: Partial<ObservationalMemoryConfig>;\n  /** Internal-run seam — defaults to the real one; injected in tests. */\n  runInternal?: InternalAgentRunFn;\n}\n\nexport interface RunReflectorResult {\n  /** True when a reflection was produced and persisted. */\n  reflected: boolean;\n  entry?: ObservationalMemoryEntry;\n  /** Tokens in the observation log that was considered. */\n  observationLogTokens: number;\n}\n\n/**\n * Condense the observation log into a reflection IF it exceeds the token\n * threshold; otherwise no-op.\n */\nexport async function runReflector(\n  options: RunReflectorOptions,\n): Promise<RunReflectorResult> {\n  const config = resolveObservationalMemoryConfig(options.config);\n  const owner: ObservationalMemoryOwner = {\n    ownerEmail: options.ownerEmail,\n    orgId: options.orgId ?? null,\n  };\n\n  const observationLogTokens = await getObservationLogTokens({\n    ...owner,\n    threadId: options.threadId,\n  });\n  if (observationLogTokens < config.reflectionTokenThreshold) {\n    return { reflected: false, observationLogTokens };\n  }\n\n  const observations = await listObservationalMemory({\n    ...owner,\n    threadId: options.threadId,\n    tier: \"observation\",\n  });\n  if (observations.length === 0) {\n    return { reflected: false, observationLogTokens };\n  }\n  const observationsText = observations.map((entry) => entry.text).join(\"\\n\\n\");\n\n  const priorReflections = (\n    await listObservationalMemory({\n      ...owner,\n      threadId: options.threadId,\n      tier: \"reflection\",\n    })\n  )\n    .map((entry) => entry.text)\n    .join(\"\\n\\n\");\n\n  const run = options.runInternal ?? runInternalAgentCall;\n  const reflectionText = await run({\n    systemPrompt: REFLECTOR_SYSTEM_PROMPT,\n    prompt: buildReflectorPrompt({\n      threadId: options.threadId,\n      observationsText,\n      priorReflections,\n    }),\n    maxOutputTokens: config.reflectionMaxOutputTokens,\n  });\n\n  if (!reflectionText.trim()) {\n    return { reflected: false, observationLogTokens };\n  }\n\n  const { tokens: tokenEstimate } = await countTextTokens(reflectionText);\n  const sourceStart = observations[0]?.sourceStartIndex ?? null;\n  const sourceEnd =\n    observations[observations.length - 1]?.sourceEndIndex ?? null;\n\n  const entry = await insertObservationalMemory({\n    ...owner,\n    threadId: options.threadId,\n    tier: \"reflection\",\n    text: reflectionText,\n    tokenEstimate,\n    sourceStartIndex: sourceStart,\n    sourceEndIndex: sourceEnd,\n    sourceMessageCount: observations.length,\n  });\n\n  return { reflected: true, entry, observationLogTokens };\n}\n"]}

package/dist/agent/observational-memory/schema.d.ts

@@ -0,0 +1,267 @@
+/**
+ * Observational Memory (OM) entries.
+ *
+ * A long-running agent thread is compacted in the background into a dated,
+ * three-tier context so it costs far fewer tokens and stays prompt-cache
+ * stable:
+ *
+ *   recent raw messages  →  dense "observations"  →  higher-level "reflections"
+ *
+ * Each row is ONE compaction artifact for a thread:
+ *
+ * - `tier = "observation"` — a dense, dated digest of a contiguous range of
+ *   thread messages (task status, names, dates, decisions preserved). Produced
+ *   by the Observer once a thread's unobserved messages exceed a token
+ *   threshold.
+ * - `tier = "reflection"` — a higher-level condensation OVER observations,
+ *   produced by the Reflector once the observation log itself grows past its
+ *   own threshold.
+ *
+ * The table is ownable (scoped reads/writes via `accessFilter`/`assertAccess`
+ * per the `security` skill) and dialect-agnostic (Drizzle helpers from
+ * `db/schema`, never raw SQLite types). The companion migrations live in
+ * `./migrations.ts` and are additive-only.
+ */
+export declare const observationalMemory: import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "observational_memory";
+    schema: undefined;
+    columns: {
+        ownerEmail: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "owner_email";
+            tableName: "observational_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        orgId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "org_id";
+            tableName: "observational_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        visibility: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "visibility";
+            tableName: "observational_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: "org" | "private" | "public";
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["private", "org", "public"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        id: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "id";
+            tableName: "observational_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        threadId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "thread_id";
+            tableName: "observational_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        tier: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "tier";
+            tableName: "observational_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: "observation" | "reflection";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["observation", "reflection"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        text: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "text";
+            tableName: "observational_memory";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        tokenEstimate: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "token_estimate";
+            tableName: "observational_memory";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sourceStartIndex: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_start_index";
+            tableName: "observational_memory";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sourceEndIndex: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_end_index";
+            tableName: "observational_memory";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sourceMessageCount: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "source_message_count";
+            tableName: "observational_memory";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "created_at";
+            tableName: "observational_memory";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "updated_at";
+            tableName: "observational_memory";
+            dataType: "number";
+            columnType: "SQLiteInteger";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "sqlite";
+}>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/agent/observational-memory/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/agent/observational-memory/schema.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqB9B,CAAC"}