@mndrk/agx 2.0.26 → 2.0.32

package/cloud-runtime/standalone/lib/stream-multiplexer.ts

@@ -6,18 +6,33 @@ import { saveMessages, setReaction, saveLogs } from "./history-store";
 import { parseReactionSignals } from "./reaction-protocol";
 import { getAttachmentMeta } from "./attachment-store";
 import { getSQLiteDb } from "./sqlite-query-adapter";
-import { readSelf, buildReflectionPrompt, writeSelf } from "./mesh-core/self";
-import { readJournal, appendJournal } from "./mesh-core/journal";
+import {
+  readSelf,
+  writeSelf,
+  readReflectionState,
+  writeReflectionState,
+  buildStructuredReflectionPrompt,
+  type AgentReflectionMemoryDraft,
+} from "./mesh-core/self";
+import { readJournal, readJournalSince, appendJournal } from "./mesh-core/journal";
 import { readIdentity, getTeamSelves, listAgents, ensureAgent } from "./mesh-core/agent";
 import { appendReaction } from "./mesh-core/reactions";
 import { logActivity } from "./mesh-core/activity";
 import type { MeshReactionType } from "./mesh-core/types";
+import { listKnowledgeEntries, storeKnowledgeEntries, type KnowledgeEvidence } from "./knowledge-store";
+import { randomUUID, createHash } from "crypto";
 
 /** Per-agent message counter for reflection cadence */
 const agentMessageCounts = new Map<string, number>();
 const reflectionQueues = new Map<string, Promise<void>>();
 const REFLECTION_CADENCE = 10;
 
+function isKnowledgeEvidence(
+  value: KnowledgeEvidence | null,
+): value is KnowledgeEvidence {
+  return value !== null;
+}
+
 function seedFromIdentityText(identity: string | undefined, name: string): string {
   const raw = String(identity || "").trim();
   if (!raw) return `I am ${name}. I evolve through experience and collaboration.`;
@@ -124,41 +139,113 @@ async function runReflection(p: Participant): Promise<void> {
   if (!identity) return;
 
   const currentSelf = readSelf(p.id);
-  const recentEntries = readJournal(p.id, 10);
+  const reflectionState = readReflectionState(p.id);
+  const recentEntries = readJournalSince(p.id, reflectionState?.lastProcessedJournalId)
+    .filter((entry) => entry.type === "post");
+  if (recentEntries.length === 0) return;
   const teamSelves = getTeamSelves(p.id);
   const newVersion = (currentSelf?.version ?? 0) + 1;
-
-  const reflectionPrompt = buildReflectionPrompt(
+  const existingMemories = listKnowledgeEntries({ scope: "agent", subjectId: p.id, limit: 50 });
+  const reflectionPrompt = buildStructuredReflectionPrompt(
     identity,
     currentSelf,
     recentEntries,
-    teamSelves
+    teamSelves,
+    existingMemories,
   );
 
-  // Call the LLM to produce a new self-model snapshot
-  let newSelfContent = "";
+  let reflectionRaw = "";
   await runCliResponse({
     provider: p.provider,
     model: p.model,
-    systemContext: `You are performing a self-modeling exercise. Output ONLY the updated self-model text — no greetings, no preamble, no markdown fences, no commentary. Write in first person as ${p.name}. Focus on specialization, comparative fit, strengths, gaps, and next direction. Keep it concise (under 200 words).`,
+    systemContext: `You are performing a self-modeling exercise. Output ONLY raw JSON matching the requested schema. No markdown fences, no commentary.`,
     prompt: reflectionPrompt,
     signal: undefined,
-    onDelta: (chunk) => { newSelfContent += chunk; },
+    onDelta: (chunk) => { reflectionRaw += chunk; },
   });
 
-  newSelfContent = newSelfContent.trim();
+  const cleaned = reflectionRaw.trim()
+    .replace(/^```(?:json)?\s*/i, "")
+    .replace(/\s*```\s*$/, "")
+    .trim();
+  let parsed: { self_model?: string; memories?: AgentReflectionMemoryDraft[] } | null = null;
+  try {
+    parsed = JSON.parse(cleaned) as { self_model?: string; memories?: AgentReflectionMemoryDraft[] };
+  } catch {
+    parsed = null;
+  }
+
+  const newSelfContent = parsed?.self_model?.trim() || "";
   if (!newSelfContent) return;
 
-  // Write the updated self-model
+  const memoryDrafts = Array.isArray(parsed?.memories)
+    ? parsed!.memories
+        .slice(0, 3)
+        .map((memory) => ({
+          scope: "agent" as const,
+          subjectId: p.id,
+          sourceType: "reflection" as const,
+          sourceId: recentEntries[recentEntries.length - 1]?.id || `reflection:${p.id}:${newVersion}`,
+          kind: memory.kind,
+          title: String(memory.title ?? "").trim(),
+          body: String(memory.body ?? "").trim(),
+          confidence: memory.confidence,
+          durability: memory.durability,
+          tags: memory.tags,
+          evidence: Array.isArray(memory.evidence)
+            ? memory.evidence
+                .map((item) => {
+                  const note = String(item?.note ?? "").trim();
+                  const id = typeof item?.id === "string" ? item.id.trim() : "";
+                  return note ? (id ? { id, note } : { note }) : null;
+                })
+                .filter(isKnowledgeEvidence)
+            : [],
+          metadata: {
+            reflection_window_start: recentEntries[0]?.id ?? null,
+            reflection_window_end: recentEntries[recentEntries.length - 1]?.id ?? null,
+            self_version: newVersion,
+          },
+        }))
+        .filter((memory) => memory.title && memory.body)
+    : [];
+
+  const insertedKnowledge = storeKnowledgeEntries(memoryDrafts);
   writeSelf(p.id, newSelfContent, newVersion);
+  writeReflectionState(p.id, {
+    lastProcessedJournalId: recentEntries[recentEntries.length - 1]?.id ?? reflectionState?.lastProcessedJournalId ?? null,
+    updatedAt: new Date().toISOString(),
+  });
+
+  if (insertedKnowledge > 0) {
+    const db = getSQLiteDb();
+    const stmt = db.prepare(
+      `INSERT OR IGNORE INTO agent_memory (id, agent_id, task_id, memory_type, content, content_hash, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`
+    );
+    const reflectionTaskId = `reflection:${p.id}:${recentEntries[recentEntries.length - 1]?.id ?? newVersion}`;
+    const now = Date.now();
+    for (const memory of memoryDrafts) {
+      const memoryType =
+        memory.kind === "decision"
+          ? "decision"
+          : memory.kind === "gotcha" || memory.kind === "constraint"
+            ? "gotcha"
+            : memory.kind === "outcome"
+              ? "outcome"
+              : "pattern";
+      const contentHash = createHash("sha256").update(memory.body.trim()).digest("hex");
+      stmt.run(randomUUID(), p.id, reflectionTaskId, memoryType, memory.body.trim(), contentHash, now);
+    }
+  }
 
   // Append reflection journal entry
   appendJournal(p.id, {
     t: new Date().toISOString(),
     type: "reflection",
     observation: `Reflected after ${REFLECTION_CADENCE} messages`,
-    judgement: "Updated self-model from recent evidence and team comparison",
-    delta: `self-model updated to v${newVersion}`,
+    judgement: "Updated self-model from incremental journal evidence and deduped agent memories",
+    delta: `self-model updated to v${newVersion}${insertedKnowledge > 0 ? `; stored ${insertedKnowledge} agent memories` : ""}`,
     threads: [],
     selfVersion: newVersion,
     body: newSelfContent,

package/cloud-runtime/standalone/lib/task-context.ts

@@ -2,6 +2,7 @@ import { createHash } from "crypto";
 import { createAdminDbClient } from "./db-adapter";
 import { getSQLiteDb } from "./sqlite-query-adapter";
 import { listResolvedRepoKnowledge } from "./repo-knowledge";
+import { getKnowledgeNote } from "./knowledge-notes";
 import { resolveMemoryAgentId } from "./memory-extractor";
 import {
   Learning,
@@ -315,7 +316,8 @@ async function resolveProjectContext(task: Task, _projectLearnings: Learning[]):
     return null;
   }
 
-  const projectKnowledge = await getProjectMemory(projectWithRepos.id);
+  const projectKnowledge = await getProjectMemory(projectWithRepos.id, "human");
+  const projectSystemNote = getKnowledgeNote("project", projectWithRepos.id);
 
   if (projectWithRepos.repos.length > 0) {
     const repoKnowledge = listResolvedRepoKnowledge(projectWithRepos.repos);
@@ -345,9 +347,10 @@ async function resolveProjectContext(task: Task, _projectLearnings: Learning[]):
   return {
     project: projectWithRepos,
     repos: projectWithRepos.repos ?? [],
-    learnings: projectKnowledge.map((entry) =>
-      entry.producer === "system" ? `[System-generated] ${entry.content}` : entry.content
-    ),
+    learnings: [
+      ...projectKnowledge.map((entry) => entry.content),
+      ...(projectSystemNote?.content ? [`[System-generated] ${projectSystemNote.content}`] : []),
+    ],
   };
 }
 

package/cloud-runtime/standalone/lib/thread-knowledge-runs.ts

@@ -0,0 +1,227 @@
+import { randomUUID } from "crypto";
+import { getSQLiteDb } from "./sqlite-query-adapter";
+
+export type ThreadKnowledgeScope = "repo" | "project";
+export type ThreadKnowledgeRunStatus = "running" | "completed" | "failed";
+
+export interface ThreadKnowledgeRun {
+  id: string;
+  threadId: string;
+  rootMessageId: string;
+  status: ThreadKnowledgeRunStatus;
+  requestedScopes: ThreadKnowledgeScope[];
+  repoInsertedCount: number;
+  projectInsertedCount: number;
+  error: string | null;
+  createdAt: string;
+  updatedAt: string;
+  completedAt: string | null;
+}
+
+function parseScopes(raw: string | null): ThreadKnowledgeScope[] {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter((value): value is ThreadKnowledgeScope => value === "repo" || value === "project");
+  } catch {
+    return [];
+  }
+}
+
+function mapRow(row: {
+  id: string;
+  thread_id: string;
+  root_message_id: string;
+  status: ThreadKnowledgeRunStatus;
+  requested_scopes: string | null;
+  repo_inserted_count: number;
+  project_inserted_count: number;
+  error: string | null;
+  created_at: string;
+  updated_at: string;
+  completed_at: string | null;
+}): ThreadKnowledgeRun {
+  return {
+    id: row.id,
+    threadId: row.thread_id,
+    rootMessageId: row.root_message_id,
+    status: row.status,
+    requestedScopes: parseScopes(row.requested_scopes),
+    repoInsertedCount: Number(row.repo_inserted_count ?? 0),
+    projectInsertedCount: Number(row.project_inserted_count ?? 0),
+    error: row.error ?? null,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    completedAt: row.completed_at ?? null,
+  };
+}
+
+export function getLatestThreadKnowledgeRun(rootMessageId: string): ThreadKnowledgeRun | null {
+  const db = getSQLiteDb();
+  const row = db
+    .prepare(
+      `SELECT id, thread_id, root_message_id, status, requested_scopes,
+              repo_inserted_count, project_inserted_count, error,
+              created_at, updated_at, completed_at
+       FROM thread_knowledge_runs
+       WHERE root_message_id = ?
+       ORDER BY created_at DESC
+       LIMIT 1`
+    )
+    .get(rootMessageId) as {
+    id: string;
+    thread_id: string;
+    root_message_id: string;
+    status: ThreadKnowledgeRunStatus;
+    requested_scopes: string | null;
+    repo_inserted_count: number;
+    project_inserted_count: number;
+    error: string | null;
+    created_at: string;
+    updated_at: string;
+    completed_at: string | null;
+  } | undefined;
+
+  return row ? mapRow(row) : null;
+}
+
+export function startThreadKnowledgeRun(input: {
+  threadId: string;
+  rootMessageId: string;
+  scopes: ThreadKnowledgeScope[];
+}): { run: ThreadKnowledgeRun; reused: boolean } {
+  const db = getSQLiteDb();
+  const now = new Date().toISOString();
+  const tx = db.transaction((args: {
+    threadId: string;
+    rootMessageId: string;
+    scopes: ThreadKnowledgeScope[];
+  }): { run: ThreadKnowledgeRun; reused: boolean } => {
+    const existing = db
+      .prepare(
+        `SELECT id, thread_id, root_message_id, status, requested_scopes,
+                repo_inserted_count, project_inserted_count, error,
+                created_at, updated_at, completed_at
+         FROM thread_knowledge_runs
+         WHERE root_message_id = ? AND status = 'running'
+         ORDER BY created_at DESC
+         LIMIT 1`
+      )
+      .get(args.rootMessageId) as {
+      id: string;
+      thread_id: string;
+      root_message_id: string;
+      status: ThreadKnowledgeRunStatus;
+      requested_scopes: string | null;
+      repo_inserted_count: number;
+      project_inserted_count: number;
+      error: string | null;
+      created_at: string;
+      updated_at: string;
+      completed_at: string | null;
+    } | undefined;
+
+    if (existing) {
+      return { run: mapRow(existing), reused: true };
+    }
+
+    const id = randomUUID();
+    const requestedScopes = Array.from(new Set(args.scopes));
+    db.prepare(
+      `INSERT INTO thread_knowledge_runs (
+        id, thread_id, root_message_id, status, requested_scopes,
+        repo_inserted_count, project_inserted_count, error,
+        created_at, updated_at, completed_at
+      ) VALUES (?, ?, ?, 'running', ?, 0, 0, NULL, ?, ?, NULL)`
+    ).run(id, args.threadId, args.rootMessageId, JSON.stringify(requestedScopes), now, now);
+
+    const created = db
+      .prepare(
+        `SELECT id, thread_id, root_message_id, status, requested_scopes,
+                repo_inserted_count, project_inserted_count, error,
+                created_at, updated_at, completed_at
+         FROM thread_knowledge_runs
+         WHERE id = ?`
+      )
+      .get(id) as {
+      id: string;
+      thread_id: string;
+      root_message_id: string;
+      status: ThreadKnowledgeRunStatus;
+      requested_scopes: string | null;
+      repo_inserted_count: number;
+      project_inserted_count: number;
+      error: string | null;
+      created_at: string;
+      updated_at: string;
+      completed_at: string | null;
+    };
+
+    return { run: mapRow(created), reused: false };
+  });
+
+  return tx(input);
+}
+
+export function completeThreadKnowledgeRun(input: {
+  runId: string;
+  repoInsertedCount: number;
+  projectInsertedCount: number;
+}): ThreadKnowledgeRun | null {
+  const db = getSQLiteDb();
+  const now = new Date().toISOString();
+  db.prepare(
+    `UPDATE thread_knowledge_runs
+     SET status = 'completed',
+         repo_inserted_count = ?,
+         project_inserted_count = ?,
+         error = NULL,
+         updated_at = ?,
+         completed_at = ?
+     WHERE id = ?`
+  ).run(input.repoInsertedCount, input.projectInsertedCount, now, now, input.runId);
+  return getThreadKnowledgeRunById(input.runId);
+}
+
+export function failThreadKnowledgeRun(runId: string, error: string): ThreadKnowledgeRun | null {
+  const db = getSQLiteDb();
+  const now = new Date().toISOString();
+  db.prepare(
+    `UPDATE thread_knowledge_runs
+     SET status = 'failed',
+         error = ?,
+         updated_at = ?,
+         completed_at = ?
+     WHERE id = ?`
+  ).run(error.trim().slice(0, 1000) || "Thread knowledge extraction failed", now, now, runId);
+  return getThreadKnowledgeRunById(runId);
+}
+
+function getThreadKnowledgeRunById(runId: string): ThreadKnowledgeRun | null {
+  const db = getSQLiteDb();
+  const row = db
+    .prepare(
+      `SELECT id, thread_id, root_message_id, status, requested_scopes,
+              repo_inserted_count, project_inserted_count, error,
+              created_at, updated_at, completed_at
+       FROM thread_knowledge_runs
+       WHERE id = ?
+       LIMIT 1`
+    )
+    .get(runId) as {
+    id: string;
+    thread_id: string;
+    root_message_id: string;
+    status: ThreadKnowledgeRunStatus;
+    requested_scopes: string | null;
+    repo_inserted_count: number;
+    project_inserted_count: number;
+    error: string | null;
+    created_at: string;
+    updated_at: string;
+    completed_at: string | null;
+  } | undefined;
+
+  return row ? mapRow(row) : null;
+}