@agent-native/core 0.52.0 → 0.53.0

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

@@ -0,0 +1,99 @@
+/**
+ * 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);
+}
+/**
+ * SEAM (deferred wire-up): build the three-tier Observational Memory context
+ * for a thread. The returned tiers are ready to be injected into the turn's
+ * prompt assembly.
+ *
+ * TODO(charlie-merge): inject buildObservationalContext output into the turn
+ * context assembly in production-agent.ts once the lazy-skill context changes
+ * land. The intended shape: replace the older raw-message prefix (everything
+ * before `recentMessages`) with the `reflections` + `observations` text, keep
+ * `recentMessages` verbatim, and prepend a short "Observational Memory" system
+ * section. This module deliberately does not edit production-agent.ts.
+ */
+/** 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 * SEAM (deferred wire-up): build the three-tier Observational Memory context\n * for a thread. The returned tiers are ready to be injected into the turn's\n * prompt assembly.\n *\n * TODO(charlie-merge): inject buildObservationalContext output into the turn\n * context assembly in production-agent.ts once the lazy-skill context changes\n * land. The intended shape: replace the older raw-message prefix (everything\n * before `recentMessages`) with the `reflections` + `observations` text, keep\n * `recentMessages` verbatim, and prepend a short \"Observational Memory\" system\n * section. This module deliberately does not edit production-agent.ts.\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"}

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

@@ -0,0 +1,48 @@
+import { table, text, integer, ownableColumns } from "../../db/schema.js";
+/**
+ * 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 const observationalMemory = table("observational_memory", {
+    id: text("id").primaryKey(),
+    threadId: text("thread_id").notNull(),
+    /** Which tier this entry belongs to. */
+    tier: text("tier", { enum: ["observation", "reflection"] }).notNull(),
+    /** The dated, compacted text content of this entry. */
+    text: text("text").notNull(),
+    /** Estimated token count of `text` (used for the reflection threshold). */
+    tokenEstimate: integer("token_estimate").notNull().default(0),
+    /**
+     * Inclusive index range of the source thread messages this entry summarizes.
+     * For observations these are indices into the flattened thread-message array;
+     * for reflections they span the observation indices that were folded.
+     */
+    sourceStartIndex: integer("source_start_index"),
+    sourceEndIndex: integer("source_end_index"),
+    /** How many source messages/observations this entry covers. */
+    sourceMessageCount: integer("source_message_count").notNull().default(0),
+    createdAt: integer("created_at").notNull(),
+    updatedAt: integer("updated_at").notNull(),
+    ...ownableColumns(),
+});
+//# sourceMappingURL=schema.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/agent/observational-memory/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,KAAK,CAAC,sBAAsB,EAAE;IAC/D,EAAE,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,EAAE;IAC3B,QAAQ,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC,OAAO,EAAE;IACrC,wCAAwC;IACxC,IAAI,EAAE,IAAI,CAAC,MAAM,EAAE,EAAE,IAAI,EAAE,CAAC,aAAa,EAAE,YAAY,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE;IACrE,uDAAuD;IACvD,IAAI,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE;IAC5B,2EAA2E;IAC3E,aAAa,EAAE,OAAO,CAAC,gBAAgB,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IAC7D;;;;OAIG;IACH,gBAAgB,EAAE,OAAO,CAAC,oBAAoB,CAAC;IAC/C,cAAc,EAAE,OAAO,CAAC,kBAAkB,CAAC;IAC3C,+DAA+D;IAC/D,kBAAkB,EAAE,OAAO,CAAC,sBAAsB,CAAC,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC;IACxE,SAAS,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,OAAO,EAAE;IAC1C,SAAS,EAAE,OAAO,CAAC,YAAY,CAAC,CAAC,OAAO,EAAE;IAC1C,GAAG,cAAc,EAAE;CACpB,CAAC,CAAC","sourcesContent":["import { table, text, integer, ownableColumns } from \"../../db/schema.js\";\n\n/**\n * Observational Memory (OM) entries.\n *\n * A long-running agent thread is compacted in the background into a dated,\n * three-tier context so it costs far fewer tokens and stays prompt-cache\n * stable:\n *\n *   recent raw messages  →  dense \"observations\"  →  higher-level \"reflections\"\n *\n * Each row is ONE compaction artifact for a thread:\n *\n * - `tier = \"observation\"` — a dense, dated digest of a contiguous range of\n *   thread messages (task status, names, dates, decisions preserved). Produced\n *   by the Observer once a thread's unobserved messages exceed a token\n *   threshold.\n * - `tier = \"reflection\"` — a higher-level condensation OVER observations,\n *   produced by the Reflector once the observation log itself grows past its\n *   own threshold.\n *\n * The table is ownable (scoped reads/writes via `accessFilter`/`assertAccess`\n * per the `security` skill) and dialect-agnostic (Drizzle helpers from\n * `db/schema`, never raw SQLite types). The companion migrations live in\n * `./migrations.ts` and are additive-only.\n */\nexport const observationalMemory = table(\"observational_memory\", {\n  id: text(\"id\").primaryKey(),\n  threadId: text(\"thread_id\").notNull(),\n  /** Which tier this entry belongs to. */\n  tier: text(\"tier\", { enum: [\"observation\", \"reflection\"] }).notNull(),\n  /** The dated, compacted text content of this entry. */\n  text: text(\"text\").notNull(),\n  /** Estimated token count of `text` (used for the reflection threshold). */\n  tokenEstimate: integer(\"token_estimate\").notNull().default(0),\n  /**\n   * Inclusive index range of the source thread messages this entry summarizes.\n   * For observations these are indices into the flattened thread-message array;\n   * for reflections they span the observation indices that were folded.\n   */\n  sourceStartIndex: integer(\"source_start_index\"),\n  sourceEndIndex: integer(\"source_end_index\"),\n  /** How many source messages/observations this entry covers. */\n  sourceMessageCount: integer(\"source_message_count\").notNull().default(0),\n  createdAt: integer(\"created_at\").notNull(),\n  updatedAt: integer(\"updated_at\").notNull(),\n  ...ownableColumns(),\n});\n"]}

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

@@ -0,0 +1,52 @@
+/**
+ * Persistence for Observational Memory entries.
+ *
+ * Owner-scoped throughout: every read and write takes an `ownerEmail` and the
+ * SQL always filters by it, so the ownable table is never read or written
+ * cross-owner (per the `security` skill). Dialect-agnostic — only `getDbExec()`
+ * and parameterized SQL, never raw SQLite/Postgres types or string interpolation
+ * of user data.
+ *
+ * `ensureTable()` lazily creates the table on first use (the same belt-and-
+ * suspenders pattern as `chat-threads/store.ts`), so OM works in tests and at
+ * runtime even before the migration plugin is registered.
+ */
+import type { ObservationalMemoryEntry, ObservationalMemoryOwner, ObservationalMemoryTier } from "./types.js";
+/** Reset the cached ensureTable promise — test-only seam. */
+export declare function __resetObservationalMemoryTableCache(): void;
+export interface InsertObservationalMemoryInput extends ObservationalMemoryOwner {
+    threadId: string;
+    tier: ObservationalMemoryTier;
+    text: string;
+    tokenEstimate: number;
+    sourceStartIndex?: number | null;
+    sourceEndIndex?: number | null;
+    sourceMessageCount?: number;
+    visibility?: "private" | "org" | "public";
+}
+/** Insert one OM entry, returning the persisted row. */
+export declare function insertObservationalMemory(input: InsertObservationalMemoryInput): Promise<ObservationalMemoryEntry>;
+export interface ListObservationalMemoryOptions extends ObservationalMemoryOwner {
+    threadId: string;
+    /** When set, only entries of this tier are returned. */
+    tier?: ObservationalMemoryTier;
+}
+/**
+ * List a thread's OM entries for an owner, oldest → newest. Always
+ * owner-scoped; `org_id` is matched too when supplied so org-visible rows
+ * don't leak across orgs.
+ */
+export declare function listObservationalMemory(options: ListObservationalMemoryOptions): Promise<ObservationalMemoryEntry[]>;
+/**
+ * The highest source-message index already folded into an observation for this
+ * thread/owner, or -1 if none. The Observer uses this to know which messages
+ * are still unobserved.
+ */
+export declare function getObservedThroughIndex(options: ObservationalMemoryOwner & {
+    threadId: string;
+}): Promise<number>;
+/** Sum the token estimates of a thread's observation entries for an owner. */
+export declare function getObservationLogTokens(options: ObservationalMemoryOwner & {
+    threadId: string;
+}): Promise<number>;
+//# sourceMappingURL=store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/agent/observational-memory/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACxB,uBAAuB,EACxB,MAAM,YAAY,CAAC;AA0CpB,6DAA6D;AAC7D,wBAAgB,oCAAoC,IAAI,IAAI,CAE3D;AAqDD,MAAM,WAAW,8BAA+B,SAAQ,wBAAwB;IAC9E,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,uBAAuB,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,UAAU,CAAC,EAAE,SAAS,GAAG,KAAK,GAAG,QAAQ,CAAC;CAC3C;AAED,wDAAwD;AACxD,wBAAsB,yBAAyB,CAC7C,KAAK,EAAE,8BAA8B,GACpC,OAAO,CAAC,wBAAwB,CAAC,CAyCnC;AAED,MAAM,WAAW,8BAA+B,SAAQ,wBAAwB;IAC9E,QAAQ,EAAE,MAAM,CAAC;IACjB,wDAAwD;IACxD,IAAI,CAAC,EAAE,uBAAuB,CAAC;CAChC;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,8BAA8B,GACtC,OAAO,CAAC,wBAAwB,EAAE,CAAC,CAiBrC;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,wBAAwB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GACvD,OAAO,CAAC,MAAM,CAAC,CAejB;AAED,8EAA8E;AAC9E,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,wBAAwB,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GACvD,OAAO,CAAC,MAAM,CAAC,CAcjB"}