forge-openclaw-plugin 0.2.3 → 0.2.7

package/dist/server/repositories/deleted-entities.js

@@ -0,0 +1,192 @@
+import { getDatabase } from "../db.js";
+import { activitySourceSchema, crudEntityTypeSchema, deletedEntityRecordSchema, settingsBinPayloadSchema } from "../types.js";
+function mapDeletedEntity(row) {
+    return deletedEntityRecordSchema.parse({
+        entityType: row.entity_type,
+        entityId: row.entity_id,
+        title: row.title,
+        subtitle: row.subtitle,
+        deletedAt: row.deleted_at,
+        deletedByActor: row.deleted_by_actor,
+        deletedSource: row.deleted_source,
+        deleteReason: row.delete_reason,
+        snapshot: JSON.parse(row.snapshot_json)
+    });
+}
+function listDeletedEntityRows(entityType) {
+    if (entityType) {
+        return getDatabase()
+            .prepare(`SELECT entity_type, entity_id, title, subtitle, deleted_at, deleted_by_actor, deleted_source, delete_reason, snapshot_json
+         FROM deleted_entities
+         WHERE entity_type = ?
+         ORDER BY deleted_at DESC`)
+            .all(entityType);
+    }
+    return getDatabase()
+        .prepare(`SELECT entity_type, entity_id, title, subtitle, deleted_at, deleted_by_actor, deleted_source, delete_reason, snapshot_json
+       FROM deleted_entities
+       ORDER BY deleted_at DESC`)
+        .all();
+}
+export function getDeletedEntityRecord(entityType, entityId) {
+    const row = getDatabase()
+        .prepare(`SELECT entity_type, entity_id, title, subtitle, deleted_at, deleted_by_actor, deleted_source, delete_reason, snapshot_json
+       FROM deleted_entities
+       WHERE entity_type = ? AND entity_id = ?`)
+        .get(entityType, entityId);
+    return row ? mapDeletedEntity(row) : undefined;
+}
+export function listDeletedEntities() {
+    return listDeletedEntityRows().map(mapDeletedEntity);
+}
+export function getDeletedEntityIdSet(entityType) {
+    const rows = getDatabase()
+        .prepare(`SELECT entity_id FROM deleted_entities WHERE entity_type = ?`)
+        .all(entityType);
+    return new Set(rows.map((row) => row.entity_id));
+}
+export function isEntityDeleted(entityType, entityId) {
+    const row = getDatabase()
+        .prepare(`SELECT 1
+       FROM deleted_entities
+       WHERE entity_type = ? AND entity_id = ?
+       LIMIT 1`)
+        .get(entityType, entityId);
+    return Boolean(row);
+}
+export function filterDeletedEntities(entityType, items) {
+    if (items.length === 0) {
+        return items;
+    }
+    const deletedIds = getDeletedEntityIdSet(entityType);
+    if (deletedIds.size === 0) {
+        return items;
+    }
+    return items.filter((item) => !deletedIds.has(item.id));
+}
+export function filterDeletedIds(entityType, ids) {
+    if (ids.length === 0) {
+        return ids;
+    }
+    const deletedIds = getDeletedEntityIdSet(entityType);
+    if (deletedIds.size === 0) {
+        return ids;
+    }
+    return ids.filter((id) => !deletedIds.has(id));
+}
+export function upsertDeletedEntityRecord(input) {
+    const entityType = crudEntityTypeSchema.parse(input.entityType);
+    const deletedAt = new Date().toISOString();
+    getDatabase()
+        .prepare(`INSERT INTO deleted_entities (
+        entity_type, entity_id, title, subtitle, deleted_at, deleted_by_actor, deleted_source, delete_reason, snapshot_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(entity_type, entity_id) DO UPDATE SET
+        title = excluded.title,
+        subtitle = excluded.subtitle,
+        deleted_at = excluded.deleted_at,
+        deleted_by_actor = excluded.deleted_by_actor,
+        deleted_source = excluded.deleted_source,
+        delete_reason = excluded.delete_reason,
+        snapshot_json = excluded.snapshot_json`)
+        .run(entityType, input.entityId, input.title, input.subtitle ?? "", deletedAt, input.context.actor ?? null, activitySourceSchema.parse(input.context.source), input.deleteReason ?? "", JSON.stringify(input.snapshot));
+}
+export function restoreDeletedEntityRecord(entityType, entityId) {
+    const existing = getDeletedEntityRecord(entityType, entityId);
+    if (!existing) {
+        return undefined;
+    }
+    getDatabase()
+        .prepare(`DELETE FROM deleted_entities WHERE entity_type = ? AND entity_id = ?`)
+        .run(entityType, entityId);
+    return existing;
+}
+export function clearDeletedEntityRecord(entityType, entityId) {
+    getDatabase()
+        .prepare(`DELETE FROM deleted_entities WHERE entity_type = ? AND entity_id = ?`)
+        .run(entityType, entityId);
+}
+export function cascadeSoftDeleteAnchoredCollaboration(parentEntityType, parentEntityId, context, deleteReason = "") {
+    const commentRows = getDatabase()
+        .prepare(`SELECT id, body, author, source, created_at, updated_at
+       FROM entity_comments
+       WHERE entity_type = ? AND entity_id = ?`)
+        .all(parentEntityType, parentEntityId);
+    for (const row of commentRows) {
+        upsertDeletedEntityRecord({
+            entityType: "comment",
+            entityId: row.id,
+            title: row.body.slice(0, 72) || "Comment",
+            subtitle: `Comment on ${parentEntityType.replaceAll("_", " ")}`,
+            snapshot: {
+                id: row.id,
+                entityType: parentEntityType,
+                entityId: parentEntityId,
+                body: row.body,
+                author: row.author,
+                source: row.source,
+                createdAt: row.created_at,
+                updatedAt: row.updated_at
+            },
+            deleteReason,
+            context
+        });
+    }
+    const insightRows = getDatabase()
+        .prepare(`SELECT id, title, summary, created_at, updated_at
+       FROM insights
+       WHERE entity_type = ? AND entity_id = ?`)
+        .all(parentEntityType, parentEntityId);
+    for (const row of insightRows) {
+        upsertDeletedEntityRecord({
+            entityType: "insight",
+            entityId: row.id,
+            title: row.title,
+            subtitle: row.summary,
+            snapshot: {
+                id: row.id,
+                entityType: parentEntityType,
+                entityId: parentEntityId,
+                title: row.title,
+                summary: row.summary,
+                createdAt: row.created_at,
+                updatedAt: row.updated_at
+            },
+            deleteReason,
+            context
+        });
+    }
+}
+export function restoreAnchoredCollaboration(parentEntityType, parentEntityId) {
+    getDatabase()
+        .prepare(`DELETE FROM deleted_entities
+       WHERE entity_type = 'comment'
+         AND entity_id IN (
+           SELECT id
+           FROM entity_comments
+           WHERE entity_type = ? AND entity_id = ?
+         )`)
+        .run(parentEntityType, parentEntityId);
+    getDatabase()
+        .prepare(`DELETE FROM deleted_entities
+       WHERE entity_type = 'insight'
+         AND entity_id IN (
+           SELECT id
+           FROM insights
+           WHERE entity_type = ? AND entity_id = ?
+         )`)
+        .run(parentEntityType, parentEntityId);
+}
+export function buildSettingsBinPayload() {
+    const items = listDeletedEntities();
+    const counts = items.reduce((acc, item) => {
+        acc[item.entityType] = (acc[item.entityType] ?? 0) + 1;
+        return acc;
+    }, {});
+    return settingsBinPayloadSchema.parse({
+        generatedAt: new Date().toISOString(),
+        totalCount: items.length,
+        countsByEntityType: counts,
+        records: items
+    });
+}

package/dist/server/repositories/domains.js

@@ -0,0 +1,30 @@
+import { getDatabase } from "../db.js";
+import { domainSchema } from "../psyche-types.js";
+function mapDomain(row) {
+    return domainSchema.parse({
+        id: row.id,
+        slug: row.slug,
+        title: row.title,
+        description: row.description,
+        themeColor: row.theme_color,
+        sensitive: row.sensitive === 1,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+    });
+}
+export function listDomains() {
+    const rows = getDatabase()
+        .prepare(`SELECT id, slug, title, description, theme_color, sensitive, created_at, updated_at
+       FROM domains
+       ORDER BY sensitive DESC, title`)
+        .all();
+    return rows.map(mapDomain);
+}
+export function getDomainBySlug(slug) {
+    const row = getDatabase()
+        .prepare(`SELECT id, slug, title, description, theme_color, sensitive, created_at, updated_at
+       FROM domains
+       WHERE slug = ?`)
+        .get(slug);
+    return row ? mapDomain(row) : undefined;
+}

package/dist/server/repositories/event-log.js

@@ -0,0 +1,64 @@
+import { randomUUID } from "node:crypto";
+import { getDatabase } from "../db.js";
+import { eventLogEntrySchema } from "../types.js";
+function mapEvent(row) {
+    return eventLogEntrySchema.parse({
+        id: row.id,
+        eventKind: row.event_kind,
+        entityType: row.entity_type,
+        entityId: row.entity_id,
+        actor: row.actor,
+        source: row.source,
+        causedByEventId: row.caused_by_event_id,
+        metadata: JSON.parse(row.metadata_json),
+        createdAt: row.created_at
+    });
+}
+export function recordEventLog(input, now = new Date()) {
+    const event = eventLogEntrySchema.parse({
+        id: `log_${randomUUID().replaceAll("-", "").slice(0, 10)}`,
+        eventKind: input.eventKind,
+        entityType: input.entityType,
+        entityId: input.entityId,
+        actor: input.actor ?? null,
+        source: input.source,
+        causedByEventId: input.causedByEventId ?? null,
+        metadata: input.metadata ?? {},
+        createdAt: now.toISOString()
+    });
+    getDatabase()
+        .prepare(`INSERT INTO event_log (
+        id, event_kind, entity_type, entity_id, actor, source, caused_by_event_id, metadata_json, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(event.id, event.eventKind, event.entityType, event.entityId, event.actor, event.source, event.causedByEventId, JSON.stringify(event.metadata), event.createdAt);
+    return event;
+}
+export function listEventLog(filters = {}) {
+    const whereClauses = [];
+    const params = [];
+    if (filters.entityType) {
+        whereClauses.push("entity_type = ?");
+        params.push(filters.entityType);
+    }
+    if (filters.entityId) {
+        whereClauses.push("entity_id = ?");
+        params.push(filters.entityId);
+    }
+    if (filters.eventKind) {
+        whereClauses.push("event_kind = ?");
+        params.push(filters.eventKind);
+    }
+    const whereSql = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+    const limitSql = filters.limit ? "LIMIT ?" : "";
+    if (filters.limit) {
+        params.push(filters.limit);
+    }
+    const rows = getDatabase()
+        .prepare(`SELECT id, event_kind, entity_type, entity_id, actor, source, caused_by_event_id, metadata_json, created_at
+       FROM event_log
+       ${whereSql}
+       ORDER BY created_at DESC
+       ${limitSql}`)
+        .all(...params);
+    return rows.map(mapEvent);
+}

package/dist/server/repositories/goals.js

@@ -0,0 +1,159 @@
+import { randomUUID } from "node:crypto";
+import { getDatabase, runInTransaction } from "../db.js";
+import { recordActivityEvent } from "./activity-events.js";
+import { filterDeletedEntities, filterDeletedIds, isEntityDeleted } from "./deleted-entities.js";
+import { assertGoalRelations } from "../services/relations.js";
+import { pruneLinkedEntityReferences } from "./psyche.js";
+import { goalSchema } from "../types.js";
+function readGoalTagIds(goalId) {
+    const rows = getDatabase()
+        .prepare(`SELECT tag_id FROM goal_tags WHERE goal_id = ? ORDER BY tag_id`)
+        .all(goalId);
+    return filterDeletedIds("tag", rows.map((row) => row.tag_id));
+}
+function mapGoal(row) {
+    return goalSchema.parse({
+        id: row.id,
+        title: row.title,
+        description: row.description,
+        horizon: row.horizon,
+        status: row.status,
+        targetPoints: row.target_points,
+        themeColor: row.theme_color,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        tagIds: readGoalTagIds(row.id)
+    });
+}
+function replaceGoalTags(goalId, tagIds) {
+    const database = getDatabase();
+    database.prepare(`DELETE FROM goal_tags WHERE goal_id = ?`).run(goalId);
+    const insert = database.prepare(`INSERT INTO goal_tags (goal_id, tag_id) VALUES (?, ?)`);
+    for (const tagId of tagIds) {
+        insert.run(goalId, tagId);
+    }
+}
+export function listGoals() {
+    const rows = getDatabase()
+        .prepare(`SELECT id, title, description, horizon, status, target_points, theme_color, created_at, updated_at
+       FROM goals
+       ORDER BY created_at`)
+        .all();
+    return filterDeletedEntities("goal", rows.map(mapGoal));
+}
+export function createGoal(input, activity) {
+    return runInTransaction(() => {
+        assertGoalRelations(input);
+        const now = new Date().toISOString();
+        const id = `goal_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
+        getDatabase()
+            .prepare(`INSERT INTO goals (id, title, description, horizon, status, target_points, theme_color, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(id, input.title, input.description, input.horizon, input.status, input.targetPoints, input.themeColor, now, now);
+        replaceGoalTags(id, input.tagIds);
+        const goal = getGoalById(id);
+        if (activity) {
+            recordActivityEvent({
+                entityType: "goal",
+                entityId: goal.id,
+                eventType: "goal_created",
+                title: `Goal created: ${goal.title}`,
+                description: `Target set to ${goal.targetPoints} points.`,
+                actor: activity.actor ?? null,
+                source: activity.source,
+                metadata: {
+                    horizon: goal.horizon,
+                    status: goal.status,
+                    targetPoints: goal.targetPoints
+                }
+            });
+        }
+        return goal;
+    });
+}
+export function updateGoal(goalId, input, activity) {
+    const current = getGoalById(goalId);
+    if (!current) {
+        return undefined;
+    }
+    return runInTransaction(() => {
+        const next = {
+            ...current,
+            ...input,
+            updatedAt: new Date().toISOString(),
+            tagIds: input.tagIds ?? current.tagIds
+        };
+        assertGoalRelations(next);
+        getDatabase()
+            .prepare(`UPDATE goals
+         SET title = ?, description = ?, horizon = ?, status = ?, target_points = ?, theme_color = ?, updated_at = ?
+         WHERE id = ?`)
+            .run(next.title, next.description, next.horizon, next.status, next.targetPoints, next.themeColor, next.updatedAt, goalId);
+        replaceGoalTags(goalId, next.tagIds);
+        const goal = getGoalById(goalId);
+        if (goal && activity) {
+            const statusChanged = current.status !== goal.status;
+            recordActivityEvent({
+                entityType: "goal",
+                entityId: goal.id,
+                eventType: statusChanged ? "goal_status_changed" : "goal_updated",
+                title: statusChanged ? `Goal ${goal.status}: ${goal.title}` : `Goal updated: ${goal.title}`,
+                description: statusChanged ? `Goal status moved from ${current.status} to ${goal.status}.` : "Goal details were edited.",
+                actor: activity.actor ?? null,
+                source: activity.source,
+                metadata: {
+                    previousStatus: current.status,
+                    status: goal.status,
+                    targetPoints: goal.targetPoints,
+                    previousTargetPoints: current.targetPoints
+                }
+            });
+        }
+        return goal;
+    });
+}
+export function getGoalById(goalId) {
+    if (isEntityDeleted("goal", goalId)) {
+        return undefined;
+    }
+    const row = getDatabase()
+        .prepare(`SELECT id, title, description, horizon, status, target_points, theme_color, created_at, updated_at
+       FROM goals
+       WHERE id = ?`)
+        .get(goalId);
+    return row ? mapGoal(row) : undefined;
+}
+export function deleteGoal(goalId, activity) {
+    const current = getGoalById(goalId);
+    if (!current) {
+        return undefined;
+    }
+    return runInTransaction(() => {
+        pruneLinkedEntityReferences("goal", goalId);
+        getDatabase()
+            .prepare(`DELETE FROM entity_comments
+         WHERE entity_type = 'goal'
+           AND entity_id = ?`)
+            .run(goalId);
+        getDatabase()
+            .prepare(`DELETE FROM goals WHERE id = ?`)
+            .run(goalId);
+        if (activity) {
+            recordActivityEvent({
+                entityType: "goal",
+                entityId: current.id,
+                eventType: "goal_deleted",
+                title: `Goal deleted: ${current.title}`,
+                description: "Goal removed from the system.",
+                actor: activity.actor ?? null,
+                source: activity.source,
+                metadata: {
+                    horizon: current.horizon,
+                    status: current.status,
+                    targetPoints: current.targetPoints
+                }
+            });
+        }
+        return current;
+    });
+}

package/dist/server/repositories/projects.js

@@ -0,0 +1,214 @@
+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 { assertGoalExists } from "../services/relations.js";
+import { getGoalById } from "./goals.js";
+import { pruneLinkedEntityReferences } from "./psyche.js";
+import { createProjectSchema, projectSchema, updateProjectSchema } from "../types.js";
+function getDefaultProjectTemplate(goal) {
+    switch (goal.title) {
+        case "Build a durable body and calm energy":
+            return {
+                title: "Energy Foundation Sprint",
+                description: "Build the routines, scheduling, and recovery rhythm that make consistent physical energy possible."
+            };
+        case "Ship meaningful creative work every week":
+            return {
+                title: "Weekly Creative Shipping System",
+                description: "Create a repeatable system for deep work, reviews, and visible weekly output."
+            };
+        case "Strengthen shared life systems":
+            return {
+                title: "Shared Life Admin Reset",
+                description: "Reduce friction in logistics, planning, and recurring obligations that support shared life."
+            };
+        default:
+            return {
+                title: `${goal.title}: Active Project`,
+                description: "Concrete workstream under this life goal so tasks, evidence, and progress have a clear home."
+            };
+    }
+}
+function mapProject(row) {
+    return projectSchema.parse({
+        id: row.id,
+        goalId: row.goal_id,
+        title: row.title,
+        description: row.description,
+        status: row.status,
+        themeColor: row.theme_color,
+        targetPoints: row.target_points,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+    });
+}
+export function listProjects(filters = {}) {
+    const whereClauses = [];
+    const params = [];
+    if (filters.goalId) {
+        whereClauses.push("goal_id = ?");
+        params.push(filters.goalId);
+    }
+    if (filters.status) {
+        whereClauses.push("status = ?");
+        params.push(filters.status);
+    }
+    const whereSql = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+    const limitSql = filters.limit ? "LIMIT ?" : "";
+    if (filters.limit) {
+        params.push(filters.limit);
+    }
+    const rows = getDatabase()
+        .prepare(`SELECT id, goal_id, title, description, status, theme_color, target_points, created_at, updated_at
+       FROM projects
+       ${whereSql}
+       ORDER BY created_at ASC
+       ${limitSql}`)
+        .all(...params);
+    return filterDeletedEntities("project", rows.map(mapProject));
+}
+export function getProjectById(projectId) {
+    if (isEntityDeleted("project", projectId)) {
+        return undefined;
+    }
+    const row = getDatabase()
+        .prepare(`SELECT id, goal_id, title, description, status, theme_color, target_points, created_at, updated_at
+       FROM projects
+       WHERE id = ?`)
+        .get(projectId);
+    return row ? mapProject(row) : undefined;
+}
+export function createProject(input, activity) {
+    return runInTransaction(() => {
+        const parsed = createProjectSchema.parse(input);
+        assertGoalExists(parsed.goalId);
+        const now = new Date().toISOString();
+        const id = `project_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
+        getDatabase()
+            .prepare(`INSERT INTO projects (id, goal_id, title, description, status, theme_color, target_points, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(id, parsed.goalId, parsed.title, parsed.description, parsed.status, parsed.themeColor, parsed.targetPoints, now, now);
+        const project = getProjectById(id);
+        if (activity) {
+            recordActivityEvent({
+                entityType: "project",
+                entityId: project.id,
+                eventType: "project_created",
+                title: `Project created: ${project.title}`,
+                description: "A new path was added under a life goal.",
+                actor: activity.actor ?? null,
+                source: activity.source,
+                metadata: {
+                    goalId: project.goalId,
+                    status: project.status,
+                    targetPoints: project.targetPoints
+                }
+            });
+        }
+        return project;
+    });
+}
+export function updateProject(projectId, input, activity) {
+    const current = getProjectById(projectId);
+    if (!current) {
+        return undefined;
+    }
+    return runInTransaction(() => {
+        const parsed = updateProjectSchema.parse(input);
+        const nextGoalId = parsed.goalId ?? current.goalId;
+        assertGoalExists(nextGoalId);
+        const next = {
+            goalId: nextGoalId,
+            title: parsed.title ?? current.title,
+            description: parsed.description ?? current.description,
+            status: parsed.status ?? current.status,
+            themeColor: parsed.themeColor ?? current.themeColor,
+            targetPoints: parsed.targetPoints ?? current.targetPoints,
+            updatedAt: new Date().toISOString()
+        };
+        getDatabase()
+            .prepare(`UPDATE projects
+         SET goal_id = ?, title = ?, description = ?, status = ?, theme_color = ?, target_points = ?, updated_at = ?
+         WHERE id = ?`)
+            .run(next.goalId, next.title, next.description, next.status, next.themeColor, next.targetPoints, next.updatedAt, projectId);
+        // Keep legacy task.goal_id aligned with the project's parent goal.
+        getDatabase()
+            .prepare(`UPDATE tasks SET goal_id = ?, updated_at = ? WHERE project_id = ?`)
+            .run(next.goalId, next.updatedAt, projectId);
+        const project = getProjectById(projectId);
+        if (project && activity) {
+            recordActivityEvent({
+                entityType: "project",
+                entityId: project.id,
+                eventType: current.status !== project.status ? "project_status_changed" : "project_updated",
+                title: current.status !== project.status ? `Project ${project.status}: ${project.title}` : `Project updated: ${project.title}`,
+                description: "Project details were updated.",
+                actor: activity.actor ?? null,
+                source: activity.source,
+                metadata: {
+                    goalId: project.goalId,
+                    previousGoalId: current.goalId,
+                    status: project.status,
+                    previousStatus: current.status
+                }
+            });
+        }
+        return project;
+    });
+}
+export function ensureDefaultProjectForGoal(goalId) {
+    assertGoalExists(goalId);
+    const existing = listProjects({ goalId, limit: 1 })[0];
+    if (existing) {
+        return existing;
+    }
+    return runInTransaction(() => {
+        const goal = getGoalById(goalId);
+        if (!goal) {
+            throw new Error(`Goal ${goalId} is missing`);
+        }
+        const template = getDefaultProjectTemplate(goal);
+        const now = new Date().toISOString();
+        const id = `project_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
+        getDatabase()
+            .prepare(`INSERT INTO projects (id, goal_id, title, description, status, theme_color, target_points, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(id, goalId, template.title, template.description, goal.status === "completed" ? "completed" : goal.status === "paused" ? "paused" : "active", goal.themeColor, Math.max(100, Math.round(goal.targetPoints / 2)), now, now);
+        return getProjectById(id);
+    });
+}
+export function deleteProject(projectId, activity) {
+    const current = getProjectById(projectId);
+    if (!current) {
+        return undefined;
+    }
+    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);
+        if (activity) {
+            recordActivityEvent({
+                entityType: "project",
+                entityId: current.id,
+                eventType: "project_deleted",
+                title: `Project deleted: ${current.title}`,
+                description: "Project removed from the system.",
+                actor: activity.actor ?? null,
+                source: activity.source,
+                metadata: {
+                    goalId: current.goalId,
+                    status: current.status,
+                    targetPoints: current.targetPoints
+                }
+            });
+        }
+        return current;
+    });
+}