takos-control 1.0.0

package/src/application/services/memory-graph/claim-store.ts

@@ -0,0 +1,306 @@
+import type { D1Database } from '../../../shared/types/bindings.ts';
+import type {
+  Claim,
+  ClaimInsert,
+  Evidence,
+  EvidenceInsert,
+  ClaimEdge,
+  ClaimEdgeInsert,
+  ClaimPath,
+  ClaimStatus,
+} from './graph-models';
+
+function claimBindParams(claim: ClaimInsert, now: string) {
+  return [
+    claim.id,
+    claim.accountId,
+    claim.claimType,
+    claim.subject,
+    claim.predicate,
+    claim.object,
+    claim.confidence ?? 0.5,
+    claim.status ?? 'active',
+    claim.supersededBy ?? null,
+    claim.sourceRunId ?? null,
+    now,
+    now,
+  ] as const;
+}
+
+const INSERT_CLAIM_SQL =
+  `INSERT INTO memory_claims (id, account_id, claim_type, subject, predicate, object, confidence, status, superseded_by, source_run_id, created_at, updated_at)
+   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+
+const UPSERT_CLAIM_SQL =
+  `${INSERT_CLAIM_SQL}
+   ON CONFLICT(id) DO UPDATE SET
+     claim_type = excluded.claim_type,
+     subject = excluded.subject,
+     predicate = excluded.predicate,
+     object = excluded.object,
+     confidence = excluded.confidence,
+     status = excluded.status,
+     superseded_by = excluded.superseded_by,
+     source_run_id = excluded.source_run_id,
+     updated_at = excluded.updated_at`;
+
+export async function insertClaim(db: D1Database, claim: ClaimInsert): Promise<void> {
+  await db.prepare(INSERT_CLAIM_SQL).bind(...claimBindParams(claim, new Date().toISOString())).run();
+}
+
+export async function upsertClaim(db: D1Database, claim: ClaimInsert): Promise<void> {
+  await db.prepare(UPSERT_CLAIM_SQL).bind(...claimBindParams(claim, new Date().toISOString())).run();
+}
+
+export async function getActiveClaims(
+  db: D1Database,
+  accountId: string,
+  limit: number = 50,
+): Promise<Claim[]> {
+  const result = await db.prepare(
+    `SELECT id, account_id, claim_type, subject, predicate, object, confidence, status, superseded_by, source_run_id, created_at, updated_at
+     FROM memory_claims
+     WHERE account_id = ? AND status = 'active'
+     ORDER BY confidence DESC, updated_at DESC
+     LIMIT ?`
+  ).bind(accountId, limit).all();
+
+  return (result.results ?? []).map(rowToClaim);
+}
+
+export async function searchClaims(
+  db: D1Database,
+  accountId: string,
+  query: string,
+  limit: number = 10,
+): Promise<Claim[]> {
+  const pattern = `%${query}%`;
+  const result = await db.prepare(
+    `SELECT id, account_id, claim_type, subject, predicate, object, confidence, status, superseded_by, source_run_id, created_at, updated_at
+     FROM memory_claims
+     WHERE account_id = ? AND status = 'active'
+       AND (subject LIKE ? OR predicate LIKE ? OR object LIKE ?)
+     ORDER BY confidence DESC
+     LIMIT ?`
+  ).bind(accountId, pattern, pattern, pattern, limit).all();
+
+  return (result.results ?? []).map(rowToClaim);
+}
+
+export async function updateClaimStatus(
+  db: D1Database,
+  claimId: string,
+  status: ClaimStatus,
+  supersededBy?: string,
+): Promise<void> {
+  const now = new Date().toISOString();
+  await db.prepare(
+    `UPDATE memory_claims SET status = ?, superseded_by = ?, updated_at = ? WHERE id = ?`
+  ).bind(status, supersededBy ?? null, now, claimId).run();
+}
+
+function rowToClaim(row: Record<string, unknown>): Claim {
+  return {
+    id: row.id as string,
+    accountId: row.account_id as string,
+    claimType: row.claim_type as Claim['claimType'],
+    subject: row.subject as string,
+    predicate: row.predicate as string,
+    object: row.object as string,
+    confidence: row.confidence as number,
+    status: row.status as Claim['status'],
+    supersededBy: (row.superseded_by as string) || null,
+    sourceRunId: (row.source_run_id as string) || null,
+    createdAt: row.created_at as string,
+    updatedAt: row.updated_at as string,
+  };
+}
+
+export async function insertEvidence(db: D1Database, evidence: EvidenceInsert): Promise<void> {
+  const now = new Date().toISOString();
+  await db.prepare(
+    `INSERT INTO memory_evidence (id, account_id, claim_id, kind, source_type, source_ref, content, trust, taint, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).bind(
+    evidence.id,
+    evidence.accountId,
+    evidence.claimId,
+    evidence.kind,
+    evidence.sourceType,
+    evidence.sourceRef ?? null,
+    evidence.content.slice(0, 2048),
+    evidence.trust ?? 0.7,
+    evidence.taint ?? null,
+    now,
+  ).run();
+}
+
+export async function getEvidenceForClaim(
+  db: D1Database,
+  claimId: string,
+  limit: number = 20,
+): Promise<Evidence[]> {
+  const result = await db.prepare(
+    `SELECT id, account_id, claim_id, kind, source_type, source_ref, content, trust, taint, created_at
+     FROM memory_evidence
+     WHERE claim_id = ?
+     ORDER BY trust DESC, created_at DESC
+     LIMIT ?`
+  ).bind(claimId, limit).all();
+
+  return (result.results ?? []).map(rowToEvidence);
+}
+
+export async function countEvidenceForClaims(
+  db: D1Database,
+  claimIds: string[],
+): Promise<Map<string, number>> {
+  const counts = new Map<string, number>();
+  if (claimIds.length === 0) return counts;
+
+  for (let i = 0; i < claimIds.length; i += 20) {
+    const batch = claimIds.slice(i, i + 20);
+    const placeholders = batch.map(() => '?').join(',');
+    const result = await db.prepare(
+      `SELECT claim_id, COUNT(*) as cnt FROM memory_evidence WHERE claim_id IN (${placeholders}) GROUP BY claim_id`
+    ).bind(...batch).all();
+
+    for (const row of result.results ?? []) {
+      counts.set(row.claim_id as string, row.cnt as number);
+    }
+  }
+
+  return counts;
+}
+
+function rowToEvidence(row: Record<string, unknown>): Evidence {
+  return {
+    id: row.id as string,
+    accountId: row.account_id as string,
+    claimId: row.claim_id as string,
+    kind: row.kind as Evidence['kind'],
+    sourceType: row.source_type as Evidence['sourceType'],
+    sourceRef: (row.source_ref as string) || null,
+    content: row.content as string,
+    trust: row.trust as number,
+    taint: (row.taint as string) || null,
+    createdAt: row.created_at as string,
+  };
+}
+
+export async function insertEdge(db: D1Database, edge: ClaimEdgeInsert): Promise<void> {
+  const now = new Date().toISOString();
+  await db.prepare(
+    `INSERT INTO memory_claim_edges (id, account_id, source_claim_id, target_claim_id, relation, weight, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`
+  ).bind(
+    edge.id,
+    edge.accountId,
+    edge.sourceClaimId,
+    edge.targetClaimId,
+    edge.relation,
+    edge.weight ?? 1.0,
+    now,
+  ).run();
+}
+
+export async function getEdgesFrom(
+  db: D1Database,
+  claimId: string,
+): Promise<ClaimEdge[]> {
+  const result = await db.prepare(
+    `SELECT id, account_id, source_claim_id, target_claim_id, relation, weight, created_at
+     FROM memory_claim_edges
+     WHERE source_claim_id = ?`
+  ).bind(claimId).all();
+
+  return (result.results ?? []).map(rowToEdge);
+}
+
+export async function getEdgesTo(
+  db: D1Database,
+  claimId: string,
+): Promise<ClaimEdge[]> {
+  const result = await db.prepare(
+    `SELECT id, account_id, source_claim_id, target_claim_id, relation, weight, created_at
+     FROM memory_claim_edges
+     WHERE target_claim_id = ?`
+  ).bind(claimId).all();
+
+  return (result.results ?? []).map(rowToEdge);
+}
+
+function rowToEdge(row: Record<string, unknown>): ClaimEdge {
+  return {
+    id: row.id as string,
+    accountId: row.account_id as string,
+    sourceClaimId: row.source_claim_id as string,
+    targetClaimId: row.target_claim_id as string,
+    relation: row.relation as ClaimEdge['relation'],
+    weight: row.weight as number,
+    createdAt: row.created_at as string,
+  };
+}
+
+export async function insertPath(db: D1Database, path: ClaimPath): Promise<void> {
+  await db.prepare(
+    `INSERT INTO memory_paths (id, account_id, start_claim_id, end_claim_id, hop_count, path_claims, path_relations, path_summary, min_confidence, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).bind(
+    path.id,
+    path.accountId,
+    path.startClaimId,
+    path.endClaimId,
+    path.hopCount,
+    JSON.stringify(path.pathClaims),
+    JSON.stringify(path.pathRelations),
+    path.pathSummary,
+    path.minConfidence,
+    path.createdAt,
+  ).run();
+}
+
+export async function getPathsForClaim(
+  db: D1Database,
+  accountId: string,
+  claimId: string,
+  limit: number = 10,
+): Promise<ClaimPath[]> {
+  const result = await db.prepare(
+    `SELECT id, account_id, start_claim_id, end_claim_id, hop_count, path_claims, path_relations, path_summary, min_confidence, created_at
+     FROM memory_paths
+     WHERE account_id = ? AND (start_claim_id = ? OR end_claim_id = ?)
+     ORDER BY min_confidence DESC
+     LIMIT ?`
+  ).bind(accountId, claimId, claimId, limit).all();
+
+  return (result.results ?? []).map(rowToPath);
+}
+
+export async function deletePathsForAccount(db: D1Database, accountId: string): Promise<void> {
+  await db.prepare(
+    `DELETE FROM memory_paths WHERE account_id = ?`
+  ).bind(accountId).run();
+}
+
+export async function countPathsForAccount(db: D1Database, accountId: string): Promise<number> {
+  const result = await db.prepare(
+    `SELECT COUNT(*) as cnt FROM memory_paths WHERE account_id = ?`
+  ).bind(accountId).first();
+  return (result?.cnt as number) ?? 0;
+}
+
+function rowToPath(row: Record<string, unknown>): ClaimPath {
+  return {
+    id: row.id as string,
+    accountId: row.account_id as string,
+    startClaimId: row.start_claim_id as string,
+    endClaimId: row.end_claim_id as string,
+    hopCount: row.hop_count as number,
+    pathClaims: (() => { try { return JSON.parse(row.path_claims as string); } catch { return []; } })(),
+    pathRelations: (() => { try { return JSON.parse(row.path_relations as string); } catch { return []; } })(),
+    pathSummary: (row.path_summary as string) || null,
+    minConfidence: row.min_confidence as number,
+    createdAt: row.created_at as string,
+  };
+}

package/src/application/services/memory-graph/graph-models.ts

@@ -0,0 +1,119 @@
+export type ClaimType = 'fact' | 'preference' | 'decision' | 'observation';
+export type ClaimStatus = 'active' | 'superseded' | 'retracted';
+
+export interface Claim {
+  id: string;
+  accountId: string;
+  claimType: ClaimType;
+  subject: string;
+  predicate: string;
+  object: string;
+  confidence: number;
+  status: ClaimStatus;
+  supersededBy: string | null;
+  sourceRunId: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface ClaimInsert {
+  id: string;
+  accountId: string;
+  claimType: ClaimType;
+  subject: string;
+  predicate: string;
+  object: string;
+  confidence?: number;
+  status?: ClaimStatus;
+  supersededBy?: string | null;
+  sourceRunId?: string | null;
+}
+
+export type EvidenceKind = 'supports' | 'contradicts' | 'context';
+export type EvidenceSourceType = 'tool_result' | 'user_message' | 'agent_inference' | 'memory_recall';
+
+export interface Evidence {
+  id: string;
+  accountId: string;
+  claimId: string;
+  kind: EvidenceKind;
+  sourceType: EvidenceSourceType;
+  sourceRef: string | null;
+  content: string;
+  trust: number;
+  taint: string | null;
+  createdAt: string;
+}
+
+export interface EvidenceInsert {
+  id: string;
+  accountId: string;
+  claimId: string;
+  kind: EvidenceKind;
+  sourceType: EvidenceSourceType;
+  sourceRef?: string | null;
+  content: string;
+  trust?: number;
+  taint?: string | null;
+}
+
+export type ClaimRelation = 'depends_on' | 'contradicts' | 'supports' | 'supersedes' | 'related_to';
+
+export interface ClaimEdge {
+  id: string;
+  accountId: string;
+  sourceClaimId: string;
+  targetClaimId: string;
+  relation: ClaimRelation;
+  weight: number;
+  createdAt: string;
+}
+
+export interface ClaimEdgeInsert {
+  id: string;
+  accountId: string;
+  sourceClaimId: string;
+  targetClaimId: string;
+  relation: ClaimRelation;
+  weight?: number;
+}
+
+export interface ClaimPath {
+  id: string;
+  accountId: string;
+  startClaimId: string;
+  endClaimId: string;
+  hopCount: number;
+  pathClaims: string[];
+  pathRelations: string[];
+  pathSummary: string | null;
+  minConfidence: number;
+  createdAt: string;
+}
+
+export interface ActivationBundle {
+  claim: Claim;
+  evidenceCount: number;
+  paths: ClaimPath[];
+}
+
+export interface ActivationResult {
+  bundles: ActivationBundle[];
+  segment: string;
+  hasContent: boolean;
+}
+
+export interface ToolObservation {
+  toolName: string;
+  arguments: Record<string, unknown>;
+  result: string;
+  error?: string;
+  timestamp: number;
+  duration?: number;
+}
+
+export interface ToolObserver {
+  observe(record: ToolObservation): void;
+  getOverlayClaims(): Claim[];
+  getOverlayEvidence(): Evidence[];
+}

package/src/application/services/memory-graph/memory-graph-runtime.ts

@@ -0,0 +1,220 @@
+import type { D1Database } from '../../../shared/types/bindings.ts';
+import type { Env, IndexJobQueueMessage } from '../../../shared/types';
+import { INDEX_QUEUE_MESSAGE_VERSION } from '../../../shared/types';
+import type { AgentContext } from '../agent/agent-models';
+import type { ActivationResult, Claim, Evidence, ToolObserver } from './graph-models';
+import { RunOverlay } from './overlay';
+import {
+  getActiveClaims,
+  getPathsForClaim,
+  countEvidenceForClaims,
+  upsertClaim,
+  insertEvidence,
+} from './claim-store';
+import { buildActivationBundles, renderActivationSegment } from './activation';
+import { createToolObserver } from './observer';
+import { generateId } from '../../../shared/utils';
+import { logWarn } from '../../../shared/utils/logger';
+
+const EMPTY_ACTIVATION: ActivationResult = { bundles: [], segment: '', hasContent: false };
+
+export interface AgentMemoryBackend {
+  bootstrap(): Promise<ActivationResult>;
+  finalize(input: {
+    claims: Claim[];
+    evidence: Evidence[];
+  }): Promise<void>;
+}
+
+export class AgentMemoryRuntime {
+  private db: D1Database;
+  private context: AgentContext;
+  private env: Env;
+  private overlay = new RunOverlay();
+  private cachedActivation: ActivationResult | null = null;
+  private lastOverlayClaimCount = 0;
+  private lastOverlayEvidenceCount = 0;
+  private overlayActivationCache: ActivationResult | null = null;
+  private backend?: AgentMemoryBackend;
+
+  constructor(db: D1Database, context: AgentContext, env: Env, backend?: AgentMemoryBackend) {
+    this.db = db;
+    this.context = context;
+    this.env = env;
+    this.backend = backend;
+  }
+
+  async bootstrap(): Promise<ActivationResult> {
+    if (this.backend) {
+      try {
+        this.cachedActivation = await this.backend.bootstrap();
+        return this.cachedActivation;
+      } catch (err) {
+        logWarn('Remote memory graph bootstrap failed, continuing without activation', {
+          module: 'memory-graph',
+          detail: err,
+        });
+        this.cachedActivation = EMPTY_ACTIVATION;
+        return this.cachedActivation;
+      }
+    }
+
+    try {
+      const claims = await getActiveClaims(this.db, this.context.spaceId, 50);
+      if (claims.length === 0) {
+        this.cachedActivation = EMPTY_ACTIVATION;
+        return this.cachedActivation;
+      }
+
+      const claimIds = claims.map(c => c.id);
+      const topClaims = claims.slice(0, 20);
+
+      const [evidenceCounts, pathsArrays] = await Promise.all([
+        countEvidenceForClaims(this.db, claimIds),
+        Promise.all(
+          topClaims.map(c => getPathsForClaim(this.db, this.context.spaceId, c.id, 5)),
+        ),
+      ]);
+
+      const pathsByClaim = new Map<string, typeof pathsArrays[0]>();
+      for (let i = 0; i < topClaims.length; i++) {
+        if (pathsArrays[i].length > 0) {
+          pathsByClaim.set(topClaims[i].id, pathsArrays[i]);
+        }
+      }
+
+      const bundles = buildActivationBundles(claims, evidenceCounts, pathsByClaim);
+      this.cachedActivation = renderActivationSegment(bundles);
+      return this.cachedActivation;
+    } catch (err) {
+      logWarn('Memory graph bootstrap failed, continuing without activation', {
+        module: 'memory-graph',
+        detail: err,
+      });
+      this.cachedActivation = EMPTY_ACTIVATION;
+      return this.cachedActivation;
+    }
+  }
+
+  beforeModel(): ActivationResult {
+    const currentOverlayClaims = this.overlay.claimCount;
+    const currentOverlayEvidence = this.overlay.evidenceCount;
+
+    // Fast path: no overlay changes since last call (check both claims and evidence)
+    if (
+      currentOverlayClaims === this.lastOverlayClaimCount &&
+      currentOverlayEvidence === this.lastOverlayEvidenceCount &&
+      this.overlayActivationCache
+    ) {
+      return this.overlayActivationCache;
+    }
+
+    // Fast path: no overlay data at all
+    if (currentOverlayClaims === 0 && currentOverlayEvidence === 0) {
+      return this.cachedActivation ?? EMPTY_ACTIVATION;
+    }
+
+    // Merge bootstrap claims with overlay claims
+    const bootstrapClaims = this.cachedActivation?.bundles.map(b => b.claim) ?? [];
+    const overlayClaims = this.overlay.getAllClaims();
+
+    // Overlay claims take priority (by subject match), then sort by confidence desc
+    const claimMap = new Map<string, Claim>();
+    for (const c of bootstrapClaims) {
+      claimMap.set(c.id, c);
+    }
+    // Track superseded claim IDs to transfer their evidence counts
+    const supersededMap = new Map<string, string>(); // oldId -> newId
+    for (const c of overlayClaims) {
+      // Overlay claims may supersede bootstrap claims with same subject+predicate
+      const existingKey = [...claimMap.values()].find(
+        e => e.subject === c.subject && e.predicate === c.predicate,
+      );
+      if (existingKey) {
+        supersededMap.set(existingKey.id, c.id);
+        claimMap.delete(existingKey.id);
+      }
+      claimMap.set(c.id, c);
+    }
+
+    const merged = [...claimMap.values()]
+      .sort((a, b) => b.confidence - a.confidence)
+      .slice(0, 50);
+
+    // Build evidence counts from bootstrap + overlay, transferring counts for superseded claims
+    const evidenceCounts = new Map<string, number>();
+    if (this.cachedActivation) {
+      for (const bundle of this.cachedActivation.bundles) {
+        const targetId = supersededMap.get(bundle.claim.id) ?? bundle.claim.id;
+        evidenceCounts.set(targetId, (evidenceCounts.get(targetId) ?? 0) + bundle.evidenceCount);
+      }
+    }
+    const overlayEvidence = this.overlay.getAllEvidence();
+    for (const ev of overlayEvidence) {
+      evidenceCounts.set(ev.claimId, (evidenceCounts.get(ev.claimId) ?? 0) + 1);
+    }
+
+    const bundles = buildActivationBundles(merged, evidenceCounts, new Map());
+    this.overlayActivationCache = renderActivationSegment(bundles);
+    this.lastOverlayClaimCount = currentOverlayClaims;
+    this.lastOverlayEvidenceCount = currentOverlayEvidence;
+
+    return this.overlayActivationCache;
+  }
+
+  createToolObserver(): ToolObserver {
+    return createToolObserver(this.context.spaceId, this.context.runId, this.overlay);
+  }
+
+  async finalize(): Promise<void> {
+    try {
+      if (this.backend) {
+        const claims = this.overlay.getAllClaims();
+        const evidence = this.overlay.getAllEvidence();
+        if (claims.length > 0 || evidence.length > 0) {
+          await this.backend.finalize({ claims, evidence });
+          this.overlay.clear();
+        }
+        await this.enqueuePathBuildJob();
+        return;
+      }
+
+      await this.flushOverlay();
+      await this.enqueuePathBuildJob();
+    } catch (err) {
+      logWarn('Memory graph finalize failed', { module: 'memory-graph', detail: err });
+    }
+  }
+
+  private async flushOverlay(): Promise<void> {
+    const claims = this.overlay.getAllClaims();
+    const evidence = this.overlay.getAllEvidence();
+
+    if (claims.length === 0 && evidence.length === 0) return;
+
+    for (const claim of claims) await upsertClaim(this.db, claim);
+    for (const ev of evidence) await insertEvidence(this.db, ev);
+
+    this.overlay.clear();
+  }
+
+  private async enqueuePathBuildJob(): Promise<void> {
+    if (!this.env.INDEX_QUEUE) return;
+
+    try {
+      await this.env.INDEX_QUEUE.send({
+        version: INDEX_QUEUE_MESSAGE_VERSION,
+        jobId: generateId(),
+        spaceId: this.context.spaceId,
+        type: 'memory_build_paths',
+        targetId: this.context.runId,
+        timestamp: Date.now(),
+      } satisfies IndexJobQueueMessage);
+    } catch (err) {
+      logWarn('Failed to enqueue memory_build_paths job', {
+        module: 'memory-graph',
+        detail: err,
+      });
+    }
+  }
+}