@mndrk/agx 2.0.25 → 2.0.32

package/cloud-runtime/standalone/lib/knowledge-notes.ts

@@ -0,0 +1,251 @@
+import { randomUUID } from "crypto";
+import { getSQLiteDb } from "./sqlite-query-adapter";
+import { listKnowledgeEntries, type KnowledgeScope, type KnowledgeSourceType } from "./knowledge-store";
+
+export type KnowledgeNoteScope = KnowledgeScope;
+
+export interface KnowledgeNote {
+  id: string;
+  scope: KnowledgeNoteScope;
+  subjectId: string;
+  content: string;
+  changeSummary: string | null;
+  sourceType: KnowledgeSourceType;
+  sourceId: string;
+  metadata: Record<string, unknown>;
+  version: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface UpsertKnowledgeNoteInput {
+  scope: KnowledgeNoteScope;
+  subjectId: string;
+  content: string;
+  changeSummary?: string | null;
+  sourceType: KnowledgeSourceType;
+  sourceId: string;
+  metadata?: Record<string, unknown>;
+}
+
+function parseJsonObject(raw: string | null): Record<string, unknown> {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function normalizeContent(content: string): string {
+  return content
+    .replace(/\r\n/g, "\n")
+    .split("\n")
+    .map((line) => line.replace(/\s+$/g, ""))
+    .join("\n")
+    .trim();
+}
+
+function mapRow(row: {
+  id: string;
+  scope: KnowledgeNoteScope;
+  subject_id: string;
+  content: string;
+  change_summary: string | null;
+  source_type: KnowledgeSourceType;
+  source_id: string;
+  metadata: string | null;
+  version: number;
+  created_at: string;
+  updated_at: string;
+}): KnowledgeNote {
+  return {
+    id: row.id,
+    scope: row.scope,
+    subjectId: row.subject_id,
+    content: row.content,
+    changeSummary: row.change_summary ?? null,
+    sourceType: row.source_type,
+    sourceId: row.source_id,
+    metadata: parseJsonObject(row.metadata),
+    version: Number(row.version ?? 1),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+function getKnowledgeNoteRow(scope: KnowledgeNoteScope, subjectId: string) {
+  const db = getSQLiteDb();
+  return db
+    .prepare(
+      `SELECT id, scope, subject_id, content, change_summary, source_type, source_id,
+              metadata, version, created_at, updated_at
+       FROM knowledge_notes
+       WHERE scope = ? AND subject_id = ?
+       LIMIT 1`
+    )
+    .get(scope, subjectId) as {
+    id: string;
+    scope: KnowledgeNoteScope;
+    subject_id: string;
+    content: string;
+    change_summary: string | null;
+    source_type: KnowledgeSourceType;
+    source_id: string;
+    metadata: string | null;
+    version: number;
+    created_at: string;
+    updated_at: string;
+  } | undefined;
+}
+
+function listLegacySystemStatements(scope: KnowledgeNoteScope, subjectId: string): string[] {
+  const db = getSQLiteDb();
+  if (scope === "repo") {
+    const systemRepoRows = db
+      .prepare(
+        `SELECT content
+         FROM repo_knowledge
+         WHERE repo_id = ? AND producer = 'system'
+         ORDER BY created_at ASC`
+      )
+      .all(subjectId) as Array<{ content: string }>;
+    const entryBodies = listKnowledgeEntries({ scope: "repo", subjectId, limit: 100 })
+      .map((entry) => entry.body.trim());
+    return [...systemRepoRows.map((row) => row.content.trim()), ...entryBodies].filter(Boolean);
+  }
+
+  if (scope === "project") {
+    const systemProjectRows = db
+      .prepare(
+        `SELECT content
+         FROM project_memory
+         WHERE project_id = ? AND producer = 'system'
+         ORDER BY created_at ASC`
+      )
+      .all(subjectId) as Array<{ content: string }>;
+    const entryBodies = listKnowledgeEntries({ scope: "project", subjectId, limit: 100 })
+      .map((entry) => entry.body.trim());
+    return [...systemProjectRows.map((row) => row.content.trim()), ...entryBodies].filter(Boolean);
+  }
+
+  const agentRows = db
+    .prepare(
+      `SELECT content
+       FROM agent_memory
+       WHERE agent_id = ?
+       ORDER BY created_at ASC
+       LIMIT 100`
+    )
+    .all(subjectId) as Array<{ content: string }>;
+  const entryBodies = listKnowledgeEntries({ scope: "agent", subjectId, limit: 100 })
+    .map((entry) => entry.body.trim());
+  return [...agentRows.map((row) => row.content.trim()), ...entryBodies].filter(Boolean);
+}
+
+function synthesizeLegacyNoteContent(scope: KnowledgeNoteScope, subjectId: string): string {
+  const unique = Array.from(new Set(listLegacySystemStatements(scope, subjectId)));
+  if (unique.length === 0) return "";
+  return unique.map((line) => `- ${line.replace(/^\-\s*/, "")}`).join("\n");
+}
+
+function ensureKnowledgeNote(scope: KnowledgeNoteScope, subjectId: string): KnowledgeNote | null {
+  const existing = getKnowledgeNoteRow(scope, subjectId);
+  if (existing) return mapRow(existing);
+
+  const synthesized = synthesizeLegacyNoteContent(scope, subjectId);
+  if (!synthesized) return null;
+
+  const db = getSQLiteDb();
+  const now = new Date().toISOString();
+  const id = randomUUID();
+  db.prepare(
+    `INSERT INTO knowledge_notes (
+      id, scope, subject_id, content, change_summary, source_type, source_id, metadata, version, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, 'task_completion', 'legacy-synthesis', ?, 1, ?, ?)`
+  ).run(
+    id,
+    scope,
+    subjectId,
+    synthesized,
+    "Initial note synthesized from existing system knowledge",
+    JSON.stringify({ synthesized_from_legacy: true }),
+    now,
+    now,
+  );
+  db.prepare(
+    `INSERT INTO knowledge_note_versions (
+      id, note_id, version, content, change_summary, source_type, source_id, metadata, created_at
+    ) VALUES (?, ?, 1, ?, ?, 'task_completion', 'legacy-synthesis', ?, ?)`
+  ).run(
+    randomUUID(),
+    id,
+    synthesized,
+    "Initial note synthesized from existing system knowledge",
+    JSON.stringify({ synthesized_from_legacy: true }),
+    now,
+  );
+
+  const created = getKnowledgeNoteRow(scope, subjectId);
+  return created ? mapRow(created) : null;
+}
+
+export function getKnowledgeNote(scope: KnowledgeNoteScope, subjectId: string): KnowledgeNote | null {
+  const trimmedSubjectId = subjectId.trim();
+  if (!trimmedSubjectId) return null;
+  return ensureKnowledgeNote(scope, trimmedSubjectId);
+}
+
+export function upsertKnowledgeNote(input: UpsertKnowledgeNoteInput): { note: KnowledgeNote; changed: boolean } {
+  const db = getSQLiteDb();
+  const subjectId = input.subjectId.trim();
+  const sourceId = input.sourceId.trim();
+  const content = normalizeContent(input.content);
+  const changeSummary = input.changeSummary?.trim() || null;
+  if (!subjectId || !sourceId) {
+    throw new Error("subjectId and sourceId are required");
+  }
+
+  const existing = ensureKnowledgeNote(input.scope, subjectId);
+  if (existing && normalizeContent(existing.content) === content) {
+    return { note: existing, changed: false };
+  }
+
+  const now = new Date().toISOString();
+  const metadata = JSON.stringify(input.metadata ?? {});
+
+  if (!existing) {
+    const id = randomUUID();
+    db.prepare(
+      `INSERT INTO knowledge_notes (
+        id, scope, subject_id, content, change_summary, source_type, source_id, metadata, version, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?)`
+    ).run(id, input.scope, subjectId, content, changeSummary, input.sourceType, sourceId, metadata, now, now);
+    db.prepare(
+      `INSERT INTO knowledge_note_versions (
+        id, note_id, version, content, change_summary, source_type, source_id, metadata, created_at
+      ) VALUES (?, ?, 1, ?, ?, ?, ?, ?, ?)`
+    ).run(randomUUID(), id, content, changeSummary, input.sourceType, sourceId, metadata, now);
+    const created = getKnowledgeNote(input.scope, subjectId);
+    if (!created) throw new Error("Failed to read created knowledge note");
+    return { note: created, changed: true };
+  }
+
+  const nextVersion = existing.version + 1;
+  db.prepare(
+    `UPDATE knowledge_notes
+     SET content = ?, change_summary = ?, source_type = ?, source_id = ?, metadata = ?, version = ?, updated_at = ?
+     WHERE id = ?`
+  ).run(content, changeSummary, input.sourceType, sourceId, metadata, nextVersion, now, existing.id);
+  db.prepare(
+    `INSERT INTO knowledge_note_versions (
+      id, note_id, version, content, change_summary, source_type, source_id, metadata, created_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(randomUUID(), existing.id, nextVersion, content, changeSummary, input.sourceType, sourceId, metadata, now);
+  const updated = getKnowledgeNote(input.scope, subjectId);
+  if (!updated) throw new Error("Failed to read updated knowledge note");
+  return { note: updated, changed: true };
+}

package/cloud-runtime/standalone/lib/knowledge-store.ts

@@ -0,0 +1,233 @@
+import { createHash, randomUUID } from "crypto";
+import { getSQLiteDb } from "./sqlite-query-adapter";
+
+export type KnowledgeScope = "agent" | "repo" | "project";
+export type KnowledgeSourceType = "reflection" | "thread_transition" | "task_completion";
+export type KnowledgeKind =
+  | "outcome"
+  | "decision"
+  | "pattern"
+  | "gotcha"
+  | "preference"
+  | "constraint"
+  | "convention"
+  | "lesson";
+
+export interface KnowledgeEvidence {
+  id?: string;
+  note: string;
+}
+
+export interface KnowledgeEntry {
+  id: string;
+  scope: KnowledgeScope;
+  subjectId: string;
+  sourceType: KnowledgeSourceType;
+  sourceId: string;
+  kind: KnowledgeKind;
+  title: string;
+  body: string;
+  confidence: number | null;
+  durability: number | null;
+  tags: string[];
+  evidence: KnowledgeEvidence[];
+  metadata: Record<string, unknown>;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface KnowledgeDraft {
+  scope: KnowledgeScope;
+  subjectId: string;
+  sourceType: KnowledgeSourceType;
+  sourceId: string;
+  kind: KnowledgeKind;
+  title: string;
+  body: string;
+  confidence?: number | null;
+  durability?: number | null;
+  tags?: string[];
+  evidence?: KnowledgeEvidence[];
+  metadata?: Record<string, unknown>;
+}
+
+function clampUnitNumber(value: unknown): number | null {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  return Math.max(0, Math.min(1, value));
+}
+
+function parseJsonArray<T>(raw: string | null): T[] {
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? (parsed as T[]) : [];
+  } catch {
+    return [];
+  }
+}
+
+function parseJsonObject(raw: string | null): Record<string, unknown> {
+  if (!raw) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? (parsed as Record<string, unknown>)
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function normalizeTags(tags?: string[]): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const tag of tags ?? []) {
+    const trimmed = String(tag ?? "").trim().toLowerCase();
+    if (!trimmed || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    result.push(trimmed);
+  }
+  return result;
+}
+
+function normalizeEvidence(evidence?: KnowledgeEvidence[]): KnowledgeEvidence[] {
+  const result: KnowledgeEvidence[] = [];
+  for (const item of evidence ?? []) {
+    const note = String(item?.note ?? "").trim();
+    const id = typeof item?.id === "string" ? item.id.trim() : "";
+    if (!note) continue;
+    result.push(id ? { id, note } : { note });
+  }
+  return result;
+}
+
+function mapRow(row: {
+  id: string;
+  scope: KnowledgeScope;
+  subject_id: string;
+  source_type: KnowledgeSourceType;
+  source_id: string;
+  kind: KnowledgeKind;
+  title: string;
+  body: string;
+  confidence: number | null;
+  durability: number | null;
+  tags: string | null;
+  evidence: string | null;
+  metadata: string | null;
+  created_at: string;
+  updated_at: string;
+}): KnowledgeEntry {
+  return {
+    id: row.id,
+    scope: row.scope,
+    subjectId: row.subject_id,
+    sourceType: row.source_type,
+    sourceId: row.source_id,
+    kind: row.kind,
+    title: row.title,
+    body: row.body,
+    confidence: clampUnitNumber(row.confidence),
+    durability: clampUnitNumber(row.durability),
+    tags: parseJsonArray<string>(row.tags),
+    evidence: parseJsonArray<KnowledgeEvidence>(row.evidence),
+    metadata: parseJsonObject(row.metadata),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+export function listKnowledgeEntries(input: {
+  scope: KnowledgeScope;
+  subjectId: string;
+  limit?: number;
+}): KnowledgeEntry[] {
+  const db = getSQLiteDb();
+  const rows = db
+    .prepare(
+      `SELECT id, scope, subject_id, source_type, source_id, kind, title, body,
+              confidence, durability, tags, evidence, metadata, created_at, updated_at
+       FROM knowledge_entries
+       WHERE scope = ? AND subject_id = ?
+       ORDER BY updated_at DESC, created_at DESC
+       LIMIT ?`
+    )
+    .all(input.scope, input.subjectId, input.limit ?? 50) as Array<{
+    id: string;
+    scope: KnowledgeScope;
+    subject_id: string;
+    source_type: KnowledgeSourceType;
+    source_id: string;
+    kind: KnowledgeKind;
+    title: string;
+    body: string;
+    confidence: number | null;
+    durability: number | null;
+    tags: string | null;
+    evidence: string | null;
+    metadata: string | null;
+    created_at: string;
+    updated_at: string;
+  }>;
+  return rows.map(mapRow);
+}
+
+export function storeKnowledgeEntries(drafts: KnowledgeDraft[]): number {
+  if (drafts.length === 0) return 0;
+
+  const db = getSQLiteDb();
+  const now = new Date().toISOString();
+  const existingStmt = db.prepare(
+    `SELECT id
+     FROM knowledge_entries
+     WHERE scope = ? AND subject_id = ? AND content_hash = ?
+     LIMIT 1`
+  );
+  const insertStmt = db.prepare(
+    `INSERT INTO knowledge_entries (
+      id, scope, subject_id, source_type, source_id, kind, title, body,
+      confidence, durability, tags, evidence, metadata, content_hash, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  );
+
+  let inserted = 0;
+  const tx = db.transaction((entries: KnowledgeDraft[]) => {
+    for (const draft of entries) {
+      const subjectId = draft.subjectId.trim();
+      const title = draft.title.trim();
+      const body = draft.body.trim();
+      const sourceId = draft.sourceId.trim();
+      if (!subjectId || !title || !body || !sourceId) continue;
+
+      const contentHash = createHash("sha256")
+        .update(`${draft.scope}\n${subjectId}\n${body}`)
+        .digest("hex");
+
+      const existing = existingStmt.get(draft.scope, subjectId, contentHash) as { id: string } | undefined;
+      if (existing) continue;
+
+      insertStmt.run(
+        randomUUID(),
+        draft.scope,
+        subjectId,
+        draft.sourceType,
+        sourceId,
+        draft.kind,
+        title,
+        body,
+        clampUnitNumber(draft.confidence),
+        clampUnitNumber(draft.durability),
+        JSON.stringify(normalizeTags(draft.tags)),
+        JSON.stringify(normalizeEvidence(draft.evidence)),
+        JSON.stringify(draft.metadata ?? {}),
+        contentHash,
+        now,
+        now,
+      );
+      inserted += 1;
+    }
+  });
+
+  tx(drafts);
+  return inserted;
+}

package/cloud-runtime/standalone/lib/memory-extractor.ts

@@ -1,6 +1,8 @@
 import { createHash, randomUUID } from "crypto";
 import { runCliResponse } from "./cli-runner";
 import { getSQLiteDb } from "./sqlite-query-adapter";
+import { storeKnowledgeEntries } from "./knowledge-store";
+import { getKnowledgeNote, upsertKnowledgeNote } from "./knowledge-notes";
 
 export interface ExtractedMemory {
   memory_type: "outcome" | "decision" | "pattern" | "gotcha";
@@ -14,7 +16,9 @@ interface TaskContext {
 }
 
 export interface ExtractedProjectKnowledge {
-  content: string;
+  updated_note: string;
+  change_summary?: string;
+  no_change?: boolean;
 }
 
 interface ResolveMemoryAgentIdInput {
@@ -39,24 +43,28 @@ Each memory must be:
 Return ONLY a JSON array. Return [] if nothing worth remembering.
 Do not wrap in markdown code blocks. Just raw JSON.`;
 
-const PROJECT_KNOWLEDGE_PROMPT = `You are a project knowledge extractor for a task execution system.
-Given a completed or failed task, extract 0-2 concise project-scoped knowledge entries worth keeping.
-
-Each entry must be:
-{ "content": "one concise sentence" }
-
-Only include information that is likely useful across future work in the same project:
-- workflows, conventions, recurring constraints
-- stable gotchas or environment realities
-- reusable project-specific practices
+const PROJECT_KNOWLEDGE_PROMPT = `You are maintaining a living project knowledge note for a task execution system.
+Given the current project note and a completed or failed task, decide whether the note should change.
 
-Do not include:
-- repo-specific durable truths that belong in repo knowledge
-- one-off task status updates
-- vague summaries
+Return ONLY a JSON object:
+{
+  "updated_note": "full revised note in concise markdown",
+  "change_summary": "short summary of what changed",
+  "no_change": false
+}
 
-Return ONLY a JSON array. Return [] if nothing project-scoped is worth keeping.
-Do not wrap in markdown code blocks. Just raw JSON.`;
+Rules:
+- Revise the current note instead of appending isolated bullets.
+- Write like a person's living project notes, not an extracted fact list.
+- The note should help someone understand what the project is, what it does, what has been decided, and what lessons now shape future work.
+- Prefer short sections and narrative paragraphs in markdown. Bullets are fine only when they genuinely improve clarity.
+- Preserve strong existing content when still valid.
+- Merge duplicate ideas, sharpen wording, and remove stale or unsupported claims.
+- Only include project-scoped knowledge likely useful across future work in the same project.
+- Do not include repo-specific durable truths that belong in repo knowledge.
+- Avoid generic filler and avoid sounding like an audit log.
+- If nothing project-scoped changed, return {"no_change": true}.
+- Do not wrap in markdown code blocks. Just raw JSON.`;
 
 export async function extractMemories(ctx: TaskContext): Promise<ExtractedMemory[]> {
   const taskDescription = [
@@ -125,21 +133,22 @@ function parseProjectKnowledgeResponse(raw: string): ExtractedProjectKnowledge[]
 
   try {
     const parsed = JSON.parse(cleaned);
-    if (!Array.isArray(parsed)) return [];
-    const unique = new Set<string>();
-    const result: ExtractedProjectKnowledge[] = [];
-    for (const entry of parsed) {
-      const content =
-        typeof entry === "object" && entry !== null && typeof (entry as any).content === "string"
-          ? (entry as any).content.trim()
-          : "";
-      if (!content) continue;
-      if (unique.has(content)) continue;
-      unique.add(content);
-      result.push({ content });
-      if (result.length >= 2) break;
-    }
-    return result;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return [];
+    const updatedNote =
+      typeof (parsed as any).updated_note === "string"
+        ? (parsed as any).updated_note.trim()
+        : "";
+    const noChange = Boolean((parsed as any).no_change);
+    if (noChange) return [];
+    if (!updatedNote) return [];
+    return [{
+      updated_note: updatedNote,
+      change_summary:
+        typeof (parsed as any).change_summary === "string"
+          ? (parsed as any).change_summary.trim()
+          : undefined,
+      no_change: false,
+    }];
   } catch {
     console.warn("[project-knowledge] Failed to parse LLM response:", cleaned.slice(0, 200));
     return [];
@@ -201,6 +210,23 @@ export async function storeMemories(
     if (result.changes > 0) inserted++;
   }
 
+  if (inserted > 0) {
+    storeKnowledgeEntries(
+      memories.map((mem) => ({
+        scope: "agent",
+        subjectId: agentId,
+        sourceType: "task_completion",
+        sourceId: taskId,
+        kind: mem.memory_type,
+        title: mem.content.trim().slice(0, 80),
+        body: mem.content.trim(),
+        confidence: 0.7,
+        durability: 0.6,
+        metadata: { task_id: taskId },
+      }))
+    );
+  }
+
   return inserted;
 }
 
@@ -231,7 +257,10 @@ async function resolveProjectId(projectIdOrSlug?: string | null): Promise<string
   return project?.id ?? null;
 }
 
-export async function extractProjectKnowledge(ctx: TaskContext): Promise<ExtractedProjectKnowledge[]> {
+export async function extractProjectKnowledge(
+  ctx: TaskContext,
+  currentNote: string,
+): Promise<ExtractedProjectKnowledge[]> {
   const taskDescription = [
     `Goal: ${ctx.goal}`,
     `Status: ${ctx.status}`,
@@ -242,7 +271,7 @@ export async function extractProjectKnowledge(ctx: TaskContext): Promise<Extract
     .filter(Boolean)
     .join("\n");
 
-  const prompt = `${PROJECT_KNOWLEDGE_PROMPT}\n\nTask:\n${taskDescription}`;
+  const prompt = `${PROJECT_KNOWLEDGE_PROMPT}\n\nCurrent note:\n${currentNote || "(empty)"}\n\nTask:\n${taskDescription}`;
 
   let raw = "";
   try {
@@ -268,31 +297,18 @@ export async function storeProjectKnowledge(
   entries: ExtractedProjectKnowledge[],
 ): Promise<number> {
   if (entries.length === 0) return 0;
-
-  const db = getSQLiteDb();
-  const existingContents = new Set(
-    (
-      db
-        .prepare("SELECT content FROM project_memory WHERE project_id = ? AND producer = 'system'")
-        .all(projectId) as Array<{ content: string }>
-    ).map((row) => row.content.trim())
-  );
-  const insert = db.prepare(
-    `INSERT INTO project_memory (id, project_id, content, source, producer, created_at)
-     VALUES (?, ?, ?, ?, 'system', ?)`
-  );
-
-  let inserted = 0;
-  const now = new Date().toISOString();
-  for (const entry of entries) {
-    const content = entry.content.trim();
-    if (!content || existingContents.has(content)) continue;
-    insert.run(randomUUID(), projectId, content, `task:${taskId}`, now);
-    existingContents.add(content);
-    inserted++;
-  }
-
-  return inserted;
+  const entry = entries[0];
+  if (!entry || !entry.updated_note?.trim()) return 0;
+  const result = upsertKnowledgeNote({
+    scope: "project",
+    subjectId: projectId,
+    content: entry.updated_note.trim(),
+    changeSummary: entry.change_summary,
+    sourceType: "task_completion",
+    sourceId: taskId,
+    metadata: { task_id: taskId },
+  });
+  return result.changed ? 1 : 0;
 }
 
 export async function extractAndStoreProjectKnowledge(
@@ -303,7 +319,7 @@ export async function extractAndStoreProjectKnowledge(
   const projectId = await resolveProjectId(projectIdOrSlug);
   if (!projectId) return;
 
-  const knowledge = await extractProjectKnowledge(ctx);
+  const knowledge = await extractProjectKnowledge(ctx, getKnowledgeNote("project", projectId)?.content ?? "");
   if (knowledge.length === 0) return;
 
   const inserted = await storeProjectKnowledge(projectId, taskId, knowledge);