forge-openclaw-plugin 0.2.7 → 0.2.10

package/dist/server/repositories/notes.js

@@ -0,0 +1,359 @@
+import { randomUUID } from "node:crypto";
+import { getDatabase } from "../db.js";
+import { recordActivityEvent } from "./activity-events.js";
+import { filterDeletedEntities, getDeletedEntityRecord, clearDeletedEntityRecord, isEntityDeleted, upsertDeletedEntityRecord } from "./deleted-entities.js";
+import { recordEventLog } from "./event-log.js";
+import { noteSchema, notesListQuerySchema, createNoteSchema, updateNoteSchema } from "../types.js";
+function normalizeAnchorKey(anchorKey) {
+    return anchorKey.trim().length > 0 ? anchorKey : null;
+}
+function normalizeLinks(links) {
+    const seen = new Set();
+    return links.filter((link) => {
+        const key = `${link.entityType}:${link.entityId}:${link.anchorKey ?? ""}`;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+function stripMarkdown(markdown) {
+    return markdown
+        .replace(/```[\s\S]*?```/g, (block) => block.replace(/```/g, "").trim())
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1")
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+        .replace(/^>\s?/gm, "")
+        .replace(/^#{1,6}\s+/gm, "")
+        .replace(/^[-*+]\s+/gm, "")
+        .replace(/^\d+\.\s+/gm, "")
+        .replace(/\*\*([^*]+)\*\*/g, "$1")
+        .replace(/\*([^*]+)\*/g, "$1")
+        .replace(/_([^_]+)_/g, "$1")
+        .replace(/~~([^~]+)~~/g, "$1")
+        .replace(/\r/g, "")
+        .trim();
+}
+function describeNote(note) {
+    const plain = note.contentPlain.trim() || stripMarkdown(note.contentMarkdown);
+    const compact = plain.replace(/\s+/g, " ").trim();
+    const title = compact.slice(0, 72) || "Note";
+    const subtitle = compact.length > 72 ? compact.slice(72, 168).trim() : "";
+    return { title, subtitle };
+}
+function buildFtsQuery(query) {
+    const tokens = query
+        .trim()
+        .split(/\s+/)
+        .map((token) => token.replace(/["*']/g, "").trim())
+        .filter(Boolean);
+    if (tokens.length === 0) {
+        return null;
+    }
+    return tokens.map((token) => `${token}*`).join(" AND ");
+}
+function getNoteRow(noteId) {
+    return getDatabase()
+        .prepare(`SELECT id, content_markdown, content_plain, author, source, created_at, updated_at
+       FROM notes
+       WHERE id = ?`)
+        .get(noteId);
+}
+function listLinkRowsForNotes(noteIds) {
+    if (noteIds.length === 0) {
+        return [];
+    }
+    const placeholders = noteIds.map(() => "?").join(", ");
+    return getDatabase()
+        .prepare(`SELECT note_id, entity_type, entity_id, anchor_key, created_at
+       FROM note_links
+       WHERE note_id IN (${placeholders})
+       ORDER BY created_at ASC`)
+        .all(...noteIds);
+}
+function mapLinks(rows) {
+    return rows.map((row) => ({
+        entityType: row.entity_type,
+        entityId: row.entity_id,
+        anchorKey: normalizeAnchorKey(row.anchor_key)
+    }));
+}
+function mapNote(row, linkRows) {
+    return noteSchema.parse({
+        id: row.id,
+        contentMarkdown: row.content_markdown,
+        contentPlain: row.content_plain,
+        author: row.author,
+        source: row.source,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        links: mapLinks(linkRows)
+    });
+}
+function upsertSearchRow(noteId, contentPlain, author) {
+    getDatabase().prepare(`DELETE FROM notes_fts WHERE note_id = ?`).run(noteId);
+    getDatabase()
+        .prepare(`INSERT INTO notes_fts (note_id, content_plain, author) VALUES (?, ?, ?)`)
+        .run(noteId, contentPlain, author ?? "");
+}
+function deleteSearchRow(noteId) {
+    getDatabase().prepare(`DELETE FROM notes_fts WHERE note_id = ?`).run(noteId);
+}
+function listAllNoteRows() {
+    return getDatabase()
+        .prepare(`SELECT id, content_markdown, content_plain, author, source, created_at, updated_at
+       FROM notes
+       ORDER BY created_at DESC`)
+        .all();
+}
+function findMatchingNoteIds(query) {
+    const ftsQuery = buildFtsQuery(query);
+    if (!ftsQuery) {
+        return new Set();
+    }
+    const rows = getDatabase()
+        .prepare(`SELECT note_id FROM notes_fts WHERE notes_fts MATCH ?`)
+        .all(ftsQuery);
+    return new Set(rows.map((row) => row.note_id));
+}
+function insertLinks(noteId, links, createdAt) {
+    const statement = getDatabase().prepare(`INSERT OR IGNORE INTO note_links (note_id, entity_type, entity_id, anchor_key, created_at)
+     VALUES (?, ?, ?, ?, ?)`);
+    for (const link of links) {
+        statement.run(noteId, link.entityType, link.entityId, link.anchorKey ?? "", createdAt);
+    }
+}
+function replaceLinks(noteId, links, createdAt) {
+    getDatabase().prepare(`DELETE FROM note_links WHERE note_id = ?`).run(noteId);
+    insertLinks(noteId, links, createdAt);
+}
+function listNoteLinks(noteId) {
+    return getDatabase()
+        .prepare(`SELECT note_id, entity_type, entity_id, anchor_key, created_at
+       FROM note_links
+       WHERE note_id = ?
+       ORDER BY created_at ASC`)
+        .all(noteId);
+}
+function recordNoteActivity(note, eventType, title, context) {
+    for (const link of note.links) {
+        recordActivityEvent({
+            entityType: link.entityType,
+            entityId: link.entityId,
+            eventType,
+            title,
+            description: note.contentPlain,
+            actor: note.author ?? context.actor ?? null,
+            source: context.source,
+            metadata: {
+                noteId: note.id,
+                anchorKey: link.anchorKey ?? ""
+            }
+        });
+        recordEventLog({
+            eventKind: eventType,
+            entityType: link.entityType,
+            entityId: link.entityId,
+            actor: note.author ?? context.actor ?? null,
+            source: context.source,
+            metadata: {
+                noteId: note.id,
+                anchorKey: link.anchorKey ?? ""
+            }
+        });
+    }
+}
+export function getNoteById(noteId) {
+    if (isEntityDeleted("note", noteId)) {
+        return undefined;
+    }
+    const row = getNoteRow(noteId);
+    if (!row) {
+        return undefined;
+    }
+    return mapNote(row, listNoteLinks(noteId));
+}
+export function getNoteByIdIncludingDeleted(noteId) {
+    const row = getNoteRow(noteId);
+    if (!row) {
+        const deleted = getDeletedEntityRecord("note", noteId);
+        return deleted?.snapshot;
+    }
+    return mapNote(row, listNoteLinks(noteId));
+}
+export function listNotes(query = {}) {
+    const parsed = notesListQuerySchema.parse(query);
+    if (parsed.linkedEntityType &&
+        parsed.linkedEntityId &&
+        isEntityDeleted(parsed.linkedEntityType, parsed.linkedEntityId)) {
+        return [];
+    }
+    const matchingIds = parsed.query ? findMatchingNoteIds(parsed.query) : null;
+    const rows = listAllNoteRows();
+    const linksByNoteId = new Map();
+    for (const link of listLinkRowsForNotes(rows.map((row) => row.id))) {
+        const current = linksByNoteId.get(link.note_id) ?? [];
+        current.push(link);
+        linksByNoteId.set(link.note_id, current);
+    }
+    return filterDeletedEntities("note", rows
+        .filter((row) => (matchingIds ? matchingIds.has(row.id) : true))
+        .filter((row) => (parsed.author ? (row.author ?? "").toLowerCase().includes(parsed.author.toLowerCase()) : true))
+        .map((row) => mapNote(row, linksByNoteId.get(row.id) ?? []))
+        .filter((note) => parsed.linkedEntityType && parsed.linkedEntityId
+        ? note.links.some((link) => link.entityType === parsed.linkedEntityType &&
+            link.entityId === parsed.linkedEntityId &&
+            (parsed.anchorKey === undefined ? true : (link.anchorKey ?? null) === parsed.anchorKey))
+        : true)
+        .slice(0, parsed.limit ?? 100));
+}
+export function createNote(input, context) {
+    const parsed = createNoteSchema.parse({
+        ...input,
+        links: normalizeLinks(input.links)
+    });
+    const now = new Date().toISOString();
+    const id = `note_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
+    const contentPlain = stripMarkdown(parsed.contentMarkdown);
+    getDatabase()
+        .prepare(`INSERT INTO notes (id, content_markdown, content_plain, author, source, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`)
+        .run(id, parsed.contentMarkdown, contentPlain, parsed.author ?? context.actor ?? null, context.source, now, now);
+    insertLinks(id, parsed.links, now);
+    clearDeletedEntityRecord("note", id);
+    upsertSearchRow(id, contentPlain, parsed.author ?? context.actor ?? null);
+    const note = getNoteById(id);
+    recordNoteActivity(note, "note.created", "Note added", context);
+    return note;
+}
+export function createLinkedNotes(notes, entityLink, context) {
+    if (!notes || notes.length === 0) {
+        return [];
+    }
+    return notes.map((note) => createNote({
+        contentMarkdown: note.contentMarkdown,
+        author: note.author,
+        links: [entityLink, ...note.links]
+    }, context));
+}
+export function updateNote(noteId, input, context) {
+    const existing = getNoteByIdIncludingDeleted(noteId);
+    if (!existing) {
+        return undefined;
+    }
+    const patch = updateNoteSchema.parse({
+        ...input,
+        links: input.links ? normalizeLinks(input.links) : undefined
+    });
+    const nextMarkdown = patch.contentMarkdown ?? existing.contentMarkdown;
+    const nextPlain = stripMarkdown(nextMarkdown);
+    const nextAuthor = patch.author === undefined ? existing.author : patch.author;
+    const updatedAt = new Date().toISOString();
+    getDatabase()
+        .prepare(`UPDATE notes
+       SET content_markdown = ?, content_plain = ?, author = ?, updated_at = ?
+       WHERE id = ?`)
+        .run(nextMarkdown, nextPlain, nextAuthor, updatedAt, noteId);
+    if (patch.links) {
+        replaceLinks(noteId, patch.links, updatedAt);
+    }
+    const note = getNoteByIdIncludingDeleted(noteId);
+    if (note.links.length > 0) {
+        clearDeletedEntityRecord("note", noteId);
+    }
+    else {
+        const details = describeNote(note);
+        upsertDeletedEntityRecord({
+            entityType: "note",
+            entityId: note.id,
+            title: details.title,
+            subtitle: details.subtitle,
+            snapshot: note,
+            deleteReason: "Note no longer has any linked entities.",
+            context
+        });
+    }
+    upsertSearchRow(noteId, nextPlain, nextAuthor);
+    recordNoteActivity(note, "note.updated", "Note updated", context);
+    return getNoteById(noteId);
+}
+export function deleteNote(noteId, context) {
+    const existing = getNoteByIdIncludingDeleted(noteId);
+    if (!existing) {
+        return undefined;
+    }
+    getDatabase().prepare(`DELETE FROM note_links WHERE note_id = ?`).run(noteId);
+    getDatabase().prepare(`DELETE FROM notes WHERE id = ?`).run(noteId);
+    deleteSearchRow(noteId);
+    recordNoteActivity(existing, "note.deleted", "Note deleted", context);
+    return existing;
+}
+export function buildNotesSummaryByEntity() {
+    const rows = getDatabase()
+        .prepare(`SELECT
+         note_links.entity_type AS entity_type,
+         note_links.entity_id AS entity_id,
+         notes.id AS note_id,
+         notes.created_at AS created_at
+       FROM note_links
+       INNER JOIN notes ON notes.id = note_links.note_id
+       LEFT JOIN deleted_entities
+         ON deleted_entities.entity_type = 'note'
+        AND deleted_entities.entity_id = notes.id
+       WHERE deleted_entities.entity_id IS NULL
+       ORDER BY notes.created_at DESC`)
+        .all();
+    return rows.reduce((acc, row) => {
+        const key = `${row.entity_type}:${row.entity_id}`;
+        const current = acc[key];
+        if (!current) {
+            acc[key] = {
+                count: 1,
+                latestNoteId: row.note_id,
+                latestCreatedAt: row.created_at
+            };
+            return acc;
+        }
+        current.count += 1;
+        if (!current.latestCreatedAt || row.created_at > current.latestCreatedAt) {
+            current.latestCreatedAt = row.created_at;
+            current.latestNoteId = row.note_id;
+        }
+        return acc;
+    }, {});
+}
+export function unlinkNotesForEntity(entityType, entityId, context) {
+    const noteIds = getDatabase()
+        .prepare(`SELECT DISTINCT note_id FROM note_links WHERE entity_type = ? AND entity_id = ?`)
+        .all(entityType, entityId);
+    if (noteIds.length === 0) {
+        return;
+    }
+    getDatabase()
+        .prepare(`DELETE FROM note_links WHERE entity_type = ? AND entity_id = ?`)
+        .run(entityType, entityId);
+    for (const row of noteIds) {
+        const remaining = getDatabase()
+            .prepare(`SELECT COUNT(*) AS count FROM note_links WHERE note_id = ?`)
+            .get(row.note_id);
+        if (remaining.count > 0) {
+            clearDeletedEntityRecord("note", row.note_id);
+            continue;
+        }
+        const note = getNoteByIdIncludingDeleted(row.note_id);
+        if (!note) {
+            continue;
+        }
+        const details = describeNote(note);
+        upsertDeletedEntityRecord({
+            entityType: "note",
+            entityId: note.id,
+            title: details.title,
+            subtitle: details.subtitle,
+            snapshot: { ...note, links: [] },
+            deleteReason: `All links were removed when ${entityType} ${entityId} was deleted.`,
+            context
+        });
+    }
+}

package/dist/server/repositories/projects.js

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { getDatabase, runInTransaction } from "../db.js";
 import { recordActivityEvent } from "./activity-events.js";
 import { filterDeletedEntities, isEntityDeleted } from "./deleted-entities.js";
+import { createLinkedNotes } from "./notes.js";
 import { assertGoalExists } from "../services/relations.js";
 import { getGoalById } from "./goals.js";
 import { pruneLinkedEntityReferences } from "./psyche.js";
@@ -90,6 +91,7 @@ export function createProject(input, activity) {
          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
             .run(id, parsed.goalId, parsed.title, parsed.description, parsed.status, parsed.themeColor, parsed.targetPoints, now, now);
         const project = getProjectById(id);
+        createLinkedNotes(parsed.notes, { entityType: "project", entityId: project.id, anchorKey: null }, activity ?? { source: "ui", actor: null });
         if (activity) {
             recordActivityEvent({
                 entityType: "project",
@@ -185,11 +187,6 @@ export function deleteProject(projectId, activity) {
     }
     return runInTransaction(() => {
         pruneLinkedEntityReferences("project", projectId);
-        getDatabase()
-            .prepare(`DELETE FROM entity_comments
-         WHERE entity_type = 'project'
-           AND entity_id = ?`)
-            .run(projectId);
         getDatabase()
             .prepare(`DELETE FROM projects WHERE id = ?`)
             .run(projectId);

package/dist/server/repositories/psyche.js

@@ -3,6 +3,7 @@ import { getDatabase, runInTransaction } from "../db.js";
 import { recordActivityEvent } from "./activity-events.js";
 import { filterDeletedEntities, filterDeletedIds, isEntityDeleted } from "./deleted-entities.js";
 import { recordEventLog } from "./event-log.js";
+import { unlinkNotesForEntity } from "./notes.js";
 import { recordPsycheClarityReward, recordPsycheReflectionReward } from "./rewards.js";
 import { behaviorPatternSchema, behaviorSchema, beliefEntrySchema, createBehaviorPatternSchema, createBehaviorSchema, createBeliefEntrySchema, createEmotionDefinitionSchema, createEventTypeSchema, createModeGuideSessionSchema, createModeProfileSchema, createPsycheValueSchema, createTriggerReportSchema, domainSchema, emotionDefinitionSchema, eventTypeSchema, modeFamilySchema, modeGuideResultSchema, modeGuideSessionSchema, modeProfileSchema, modeTimelineEntrySchema, psycheValueSchema, schemaCatalogEntrySchema, triggerReportSchema, updateBehaviorPatternSchema, updateBehaviorSchema, updateBeliefEntrySchema, updateEmotionDefinitionSchema, updateEventTypeSchema, updateModeGuideSessionSchema, updateModeProfileSchema, updatePsycheValueSchema, updateTriggerReportSchema } from "../psyche-types.js";
 const PSYCHE_DOMAIN_ID = "domain_psyche";
@@ -312,12 +313,8 @@ function mapCreateUpdateContext(input) {
 function getRow(sql, id) {
     return getDatabase().prepare(sql).get(id);
 }
-function deleteEntityComments(entityType, entityId) {
-    getDatabase()
-        .prepare(`DELETE FROM entity_comments
-       WHERE entity_type = ?
-         AND entity_id = ?`)
-        .run(entityType, entityId);
+function unlinkEntityNotes(entityType, entityId) {
+    unlinkNotesForEntity(entityType, entityId, { source: "system", actor: null });
 }
 function rewriteJsonColumn(table, column, transform) {
     const rows = getDatabase()
@@ -453,7 +450,7 @@ export function deleteEventType(eventTypeId, context) {
         return undefined;
     }
     return runInTransaction(() => {
-        deleteEntityComments("event_type", eventTypeId);
+        unlinkEntityNotes("event_type", eventTypeId);
         getDatabase()
             .prepare(`DELETE FROM event_types WHERE id = ?`)
             .run(eventTypeId);
@@ -549,7 +546,7 @@ export function deleteEmotionDefinition(emotionId, context) {
     }
     return runInTransaction(() => {
         nullifyTriggerEmotionReferences(emotionId);
-        deleteEntityComments("emotion_definition", emotionId);
+        unlinkEntityNotes("emotion_definition", emotionId);
         getDatabase()
             .prepare(`DELETE FROM emotion_definitions WHERE id = ?`)
             .run(emotionId);
@@ -662,7 +659,7 @@ export function deletePsycheValue(valueId, context) {
         removeIdFromStringArrayColumn("belief_entries", "linked_value_ids_json", valueId);
         removeIdFromStringArrayColumn("mode_profiles", "linked_value_ids_json", valueId);
         removeIdFromStringArrayColumn("trigger_reports", "linked_value_ids_json", valueId);
-        deleteEntityComments("psyche_value", valueId);
+        unlinkEntityNotes("psyche_value", valueId);
         getDatabase()
             .prepare(`DELETE FROM psyche_values WHERE id = ?`)
             .run(valueId);
@@ -780,7 +777,7 @@ export function deleteBehaviorPattern(patternId, context) {
         removeIdFromStringArrayColumn("psyche_behaviors", "linked_pattern_ids_json", patternId);
         removeIdFromStringArrayColumn("mode_profiles", "linked_pattern_ids_json", patternId);
         removeIdFromStringArrayColumn("trigger_reports", "linked_pattern_ids_json", patternId);
-        deleteEntityComments("behavior_pattern", patternId);
+        unlinkEntityNotes("behavior_pattern", patternId);
         getDatabase()
             .prepare(`DELETE FROM behavior_patterns WHERE id = ?`)
             .run(patternId);
@@ -888,7 +885,7 @@ export function deleteBehavior(behaviorId, context) {
         removeIdFromStringArrayColumn("mode_profiles", "linked_behavior_ids_json", behaviorId);
         removeIdFromStringArrayColumn("trigger_reports", "linked_behavior_ids_json", behaviorId);
         nullifyTriggerBehaviorReferences(behaviorId);
-        deleteEntityComments("behavior", behaviorId);
+        unlinkEntityNotes("behavior", behaviorId);
         getDatabase()
             .prepare(`DELETE FROM psyche_behaviors WHERE id = ?`)
             .run(behaviorId);
@@ -995,7 +992,7 @@ export function deleteBeliefEntry(beliefId, context) {
         removeIdFromStringArrayColumn("behavior_patterns", "linked_belief_ids_json", beliefId);
         removeIdFromStringArrayColumn("trigger_reports", "linked_belief_ids_json", beliefId);
         nullifyTriggerThoughtBeliefReferences(beliefId);
-        deleteEntityComments("belief_entry", beliefId);
+        unlinkEntityNotes("belief_entry", beliefId);
         getDatabase()
             .prepare(`DELETE FROM belief_entries WHERE id = ?`)
             .run(beliefId);
@@ -1104,7 +1101,7 @@ export function deleteModeProfile(modeId, context) {
         removeIdFromStringArrayColumn("belief_entries", "linked_mode_ids_json", modeId);
         removeIdFromStringArrayColumn("trigger_reports", "linked_mode_ids_json", modeId);
         nullifyTriggerTimelineModeReferences(modeId);
-        deleteEntityComments("mode_profile", modeId);
+        unlinkEntityNotes("mode_profile", modeId);
         getDatabase()
             .prepare(`DELETE FROM mode_profiles WHERE id = ?`)
             .run(modeId);
@@ -1338,7 +1335,7 @@ export function deleteTriggerReport(reportId, context) {
     }
     return runInTransaction(() => {
         removeIdFromStringArrayColumn("belief_entries", "linked_report_ids_json", reportId);
-        deleteEntityComments("trigger_report", reportId);
+        unlinkEntityNotes("trigger_report", reportId);
         getDatabase()
             .prepare(`DELETE FROM trigger_reports WHERE id = ?`)
             .run(reportId);

package/dist/server/repositories/task-runs.js

@@ -3,6 +3,7 @@ import { getDatabase, runInTransaction } from "../db.js";
 import { HttpError } from "../errors.js";
 import { computeWorkTime } from "../services/work-time.js";
 import { recordActivityEvent } from "./activity-events.js";
+import { createLinkedNotes } from "./notes.js";
 import { recordTaskRunCompletionReward, recordTaskRunProgressRewards, recordTaskRunStartReward } from "./rewards.js";
 import { getTaskById, updateTaskInTransaction } from "./tasks.js";
 import { taskRunClaimSchema, taskRunSchema } from "../types.js";
@@ -477,6 +478,7 @@ function finishTaskRun(taskRunId, nextStatus, timestampColumn, input, now, activ
                 });
             }
         }
+        createLinkedNotes(input.closeoutNote ? [input.closeoutNote] : [], { entityType: "task", entityId: run.taskId, anchorKey: null }, { source: activity.source, actor: input.actor ?? run.actor });
         return run;
     });
 }

package/dist/server/repositories/tasks.js

@@ -4,6 +4,8 @@ import { runInTransaction } from "../db.js";
 import { HttpError } from "../errors.js";
 import { recordActivityEvent } from "./activity-events.js";
 import { filterDeletedEntities, filterDeletedIds, isEntityDeleted } from "./deleted-entities.js";
+import { getGoalById } from "./goals.js";
+import { createLinkedNotes } from "./notes.js";
 import { ensureDefaultProjectForGoal, getProjectById } from "./projects.js";
 import { pruneLinkedEntityReferences } from "./psyche.js";
 import { awardTaskCompletionReward, reverseLatestTaskCompletionReward } from "./rewards.js";
@@ -59,19 +61,24 @@ function normalizeCompletedAt(status, existingCompletedAt) {
     return null;
 }
 function resolveProjectAndGoalIds(input, current) {
-    const requestedGoalId = input.goalId === undefined ? current?.goalId ?? null : input.goalId;
+    const currentGoalId = current?.goalId && getGoalById(current.goalId) ? current.goalId : null;
+    const currentProject = current?.projectId ? getProjectById(current.projectId) ?? null : null;
+    const currentProjectGoalId = currentProject?.goalId && getGoalById(currentProject.goalId) ? currentProject.goalId : null;
+    const currentProjectId = currentProject?.id ?? null;
+    const requestedGoalId = input.goalId === undefined ? currentGoalId : input.goalId;
     const goalChangedWithoutProjectOverride = current !== undefined && input.goalId !== undefined && input.goalId !== current.goalId && input.projectId === undefined;
-    const requestedProjectId = input.projectId === undefined ? (goalChangedWithoutProjectOverride ? null : current?.projectId ?? null) : input.projectId;
+    const requestedProjectId = input.projectId === undefined ? (goalChangedWithoutProjectOverride ? null : currentProjectId) : input.projectId;
     if (requestedProjectId) {
         const project = getProjectById(requestedProjectId);
         if (!project) {
             throw new HttpError(404, "project_not_found", `Project ${requestedProjectId} does not exist`);
         }
-        if (requestedGoalId && project.goalId !== requestedGoalId) {
+        const projectGoalId = getGoalById(project.goalId) ? project.goalId : null;
+        if (requestedGoalId && projectGoalId && project.goalId !== requestedGoalId) {
             throw new HttpError(409, "project_goal_mismatch", `Project ${requestedProjectId} does not belong to goal ${requestedGoalId}`);
         }
         return {
-            goalId: project.goalId,
+            goalId: projectGoalId,
             projectId: project.id
         };
     }
@@ -184,6 +191,9 @@ function updateTaskRecord(current, input, activity) {
             reverseLatestTaskCompletionReward(updated, activity);
         }
     }
+    if (updated) {
+        createLinkedNotes(input.notes, { entityType: "task", entityId: updated.id, anchorKey: null }, activity ?? { source: "ui", actor: null });
+    }
     return updated;
 }
 function fingerprintTaskCreate(input) {
@@ -201,7 +211,12 @@ function fingerprintTaskCreate(input) {
         energy: input.energy,
         points: input.points,
         sortOrder: input.sortOrder ?? null,
-        tagIds: input.tagIds
+        tagIds: input.tagIds,
+        notes: input.notes.map((note) => ({
+            contentMarkdown: note.contentMarkdown,
+            author: note.author,
+            links: note.links
+        }))
     }))
         .digest("hex");
 }
@@ -245,6 +260,7 @@ function insertTaskRecord(input, activity) {
             awardTaskCompletionReward(task, activity);
         }
     }
+    createLinkedNotes(input.notes, { entityType: "task", entityId: task.id, anchorKey: null }, activity ?? { source: "ui", actor: null });
     return task;
 }
 export function listTasks(filters = {}) {
@@ -382,11 +398,6 @@ export function deleteTask(taskId, activity) {
     }
     return runInTransaction(() => {
         pruneLinkedEntityReferences("task", taskId);
-        getDatabase()
-            .prepare(`DELETE FROM entity_comments
-         WHERE entity_type = 'task'
-           AND entity_id = ?`)
-            .run(taskId);
         getDatabase()
             .prepare(`DELETE FROM tasks WHERE id = ?`)
             .run(taskId);

package/dist/server/seed-demo.js

@@ -0,0 +1,11 @@
+import { seedDemoDataIntoRuntime } from "./demo-data.js";
+const explicitDataRoot = process.argv[2];
+try {
+    const summary = await seedDemoDataIntoRuntime(explicitDataRoot);
+    console.log(`Seeded Forge demo data into ${summary.databasePath}`);
+    console.log(`Counts: goals=${summary.counts.goals}, projects=${summary.counts.projects}, tasks=${summary.counts.tasks}, task_runs=${summary.counts.task_runs}`);
+}
+catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+}

package/dist/server/services/dashboard.js

@@ -1,5 +1,6 @@
 import { listGoals } from "../repositories/goals.js";
 import { listActivityEvents } from "../repositories/activity-events.js";
+import { buildNotesSummaryByEntity } from "../repositories/notes.js";
 import { listTagsByIds, listTags } from "../repositories/tags.js";
 import { listTasks } from "../repositories/tasks.js";
 import { buildAchievementSignals, buildGamificationProfile, buildMilestoneRewards } from "./gamification.js";
@@ -153,6 +154,7 @@ export function getDashboard() {
     const achievements = buildAchievementSignals(goals, tasks, now);
     const milestoneRewards = buildMilestoneRewards(goals, tasks, now);
     const recentActivity = listActivityEvents({ limit: 12 });
+    const notesSummaryByEntity = buildNotesSummaryByEntity();
     return dashboardPayloadSchema.parse({
         stats,
         goals: goalCards,
@@ -165,6 +167,7 @@ export function getDashboard() {
         gamification,
         achievements,
         milestoneRewards,
-        recentActivity
+        recentActivity,
+        notesSummaryByEntity
     });
 }