forge-openclaw-plugin 0.2.18 → 0.2.19

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

@@ -114,6 +114,8 @@ export function cascadeSoftDeleteAnchoredCollaboration(parentEntityType, parentE
          notes.content_plain AS content_plain,
          notes.author AS author,
          notes.source AS source,
+         notes.tags_json AS tags_json,
+         notes.destroy_at AS destroy_at,
          notes.created_at AS created_at,
          notes.updated_at AS updated_at
        FROM notes
@@ -145,18 +147,24 @@ export function cascadeSoftDeleteAnchoredCollaboration(parentEntityType, parentE
             linksByNoteId.set(link.note_id, current);
         }
         for (const row of noteRows) {
-            const compact = (row.content_plain || row.content_markdown).replace(/\s+/g, " ").trim();
+            const compact = (row.content_plain || row.content_markdown)
+                .replace(/\s+/g, " ")
+                .trim();
             upsertDeletedEntityRecord({
                 entityType: "note",
                 entityId: row.id,
                 title: compact.slice(0, 72) || "Note",
-                subtitle: compact.length > 72 ? compact.slice(72, 168).trim() : `Linked to ${parentEntityType.replaceAll("_", " ")}`,
+                subtitle: compact.length > 72
+                    ? compact.slice(72, 168).trim()
+                    : `Linked to ${parentEntityType.replaceAll("_", " ")}`,
                 snapshot: {
                     id: row.id,
                     contentMarkdown: row.content_markdown,
                     contentPlain: row.content_plain,
                     author: row.author,
                     source: row.source,
+                    tags: JSON.parse(row.tags_json),
+                    destroyAt: row.destroy_at,
                     createdAt: row.created_at,
                     updatedAt: row.updated_at,
                     links: linksByNoteId.get(row.id) ?? []

package/dist/server/repositories/notes.js

@@ -18,6 +18,53 @@ function normalizeLinks(links) {
         return true;
     });
 }
+function normalizeTags(tags) {
+    if (!tags) {
+        return [];
+    }
+    const seen = new Set();
+    return tags
+        .map((tag) => tag.trim())
+        .filter(Boolean)
+        .filter((tag) => {
+        const normalized = tag.toLowerCase();
+        if (seen.has(normalized)) {
+            return false;
+        }
+        seen.add(normalized);
+        return true;
+    });
+}
+function parseTagsJson(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed)
+            ? normalizeTags(parsed.filter((value) => typeof value === "string"))
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+function noteMatchesTextTerm(note, term) {
+    const normalized = term.trim().toLowerCase();
+    if (!normalized) {
+        return false;
+    }
+    return note.tags.some((tag) => tag.toLowerCase().includes(normalized));
+}
+function cleanupExpiredNotes() {
+    const expiredRows = getDatabase()
+        .prepare(`SELECT id
+       FROM notes
+       WHERE destroy_at IS NOT NULL
+         AND destroy_at != ''
+         AND destroy_at <= ?`)
+        .all(new Date().toISOString());
+    for (const row of expiredRows) {
+        deleteNoteInternal(row.id, { source: "system", actor: null }, "Ephemeral note expired");
+    }
+}
 function stripMarkdown(markdown) {
     return markdown
         .replace(/```[\s\S]*?```/g, (block) => block.replace(/```/g, "").trim())
@@ -55,7 +102,7 @@ function buildFtsQuery(query) {
 }
 function getNoteRow(noteId) {
     return getDatabase()
-        .prepare(`SELECT id, content_markdown, content_plain, author, source, created_at, updated_at
+        .prepare(`SELECT id, content_markdown, content_plain, author, source, tags_json, destroy_at, created_at, updated_at
        FROM notes
        WHERE id = ?`)
         .get(noteId);
@@ -86,6 +133,8 @@ function mapNote(row, linkRows) {
         contentPlain: row.content_plain,
         author: row.author,
         source: row.source,
+        tags: parseTagsJson(row.tags_json),
+        destroyAt: row.destroy_at,
         createdAt: row.created_at,
         updatedAt: row.updated_at,
         links: mapLinks(linkRows)
@@ -102,7 +151,7 @@ function deleteSearchRow(noteId) {
 }
 function listAllNoteRows() {
     return getDatabase()
-        .prepare(`SELECT id, content_markdown, content_plain, author, source, created_at, updated_at
+        .prepare(`SELECT id, content_markdown, content_plain, author, source, tags_json, destroy_at, created_at, updated_at
        FROM notes
        ORDER BY created_at DESC`)
         .all();
@@ -117,6 +166,19 @@ function findMatchingNoteIds(query) {
         .all(ftsQuery);
     return new Set(rows.map((row) => row.note_id));
 }
+function findMatchingNoteIdsForTextTerms(terms) {
+    const normalizedTerms = terms.map((term) => term.trim()).filter(Boolean);
+    if (normalizedTerms.length === 0) {
+        return null;
+    }
+    const matches = new Set();
+    for (const term of normalizedTerms) {
+        for (const noteId of findMatchingNoteIds(term)) {
+            matches.add(noteId);
+        }
+    }
+    return matches;
+}
 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 (?, ?, ?, ?, ?)`);
@@ -164,7 +226,10 @@ function recordNoteActivity(note, eventType, title, context) {
         });
     }
 }
-export function getNoteById(noteId) {
+export function getNoteById(noteId, options = {}) {
+    if (!options.skipCleanup) {
+        cleanupExpiredNotes();
+    }
     if (isEntityDeleted("note", noteId)) {
         return undefined;
     }
@@ -174,7 +239,10 @@ export function getNoteById(noteId) {
     }
     return mapNote(row, listNoteLinks(noteId));
 }
-export function getNoteByIdIncludingDeleted(noteId) {
+export function getNoteByIdIncludingDeleted(noteId, options = {}) {
+    if (!options.skipCleanup) {
+        cleanupExpiredNotes();
+    }
     const row = getNoteRow(noteId);
     if (!row) {
         const deleted = getDeletedEntityRecord("note", noteId);
@@ -183,13 +251,26 @@ export function getNoteByIdIncludingDeleted(noteId) {
     return mapNote(row, listNoteLinks(noteId));
 }
 export function listNotes(query = {}) {
+    cleanupExpiredNotes();
     const parsed = notesListQuerySchema.parse(query);
-    if (parsed.linkedEntityType &&
-        parsed.linkedEntityId &&
-        isEntityDeleted(parsed.linkedEntityType, parsed.linkedEntityId)) {
+    const linkedFilters = [
+        ...(parsed.linkedEntityType && parsed.linkedEntityId
+            ? [
+                {
+                    entityType: parsed.linkedEntityType,
+                    entityId: parsed.linkedEntityId
+                }
+            ]
+            : []),
+        ...parsed.linkedTo
+    ];
+    if (linkedFilters.some((filter) => isEntityDeleted(filter.entityType, filter.entityId))) {
         return [];
     }
-    const matchingIds = parsed.query ? findMatchingNoteIds(parsed.query) : null;
+    const matchingIds = findMatchingNoteIdsForTextTerms([
+        ...(parsed.query ? [parsed.query] : []),
+        ...parsed.textTerms
+    ]);
     const rows = listAllNoteRows();
     const linksByNoteId = new Map();
     for (const link of listLinkRowsForNotes(rows.map((row) => row.id))) {
@@ -198,32 +279,63 @@ export function listNotes(query = {}) {
         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))
+        .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))
+        .filter((note) => {
+        if (!matchingIds) {
+            return true;
+        }
+        return (matchingIds.has(note.id) ||
+            parsed.textTerms.some((term) => noteMatchesTextTerm(note, term)) ||
+            (parsed.query ? noteMatchesTextTerm(note, parsed.query) : false));
+    })
+        .filter((note) => linkedFilters.length > 0
+        ? note.links.some((link) => linkedFilters.some((filter) => link.entityType === filter.entityType &&
+            link.entityId === filter.entityId &&
+            (parsed.anchorKey === undefined
+                ? true
+                : (link.anchorKey ?? null) === parsed.anchorKey)))
+        : true)
+        .filter((note) => parsed.tags.length > 0
+        ? parsed.tags.every((filterTag) => note.tags.some((noteTag) => noteTag.toLowerCase() === filterTag.toLowerCase()))
         : true)
+        .filter((note) => {
+        if (!parsed.updatedFrom && !parsed.updatedTo) {
+            return true;
+        }
+        const updatedDate = note.updatedAt.slice(0, 10);
+        if (parsed.updatedFrom && updatedDate < parsed.updatedFrom) {
+            return false;
+        }
+        if (parsed.updatedTo && updatedDate > parsed.updatedTo) {
+            return false;
+        }
+        return true;
+    })
         .slice(0, parsed.limit ?? 100));
 }
 export function createNote(input, context) {
+    cleanupExpiredNotes();
     const parsed = createNoteSchema.parse({
         ...input,
-        links: normalizeLinks(input.links)
+        links: normalizeLinks(input.links),
+        tags: normalizeTags(input.tags)
     });
     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);
+        .prepare(`INSERT INTO notes (id, content_markdown, content_plain, author, source, tags_json, destroy_at, created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(id, parsed.contentMarkdown, contentPlain, parsed.author ?? context.actor ?? null, context.source, JSON.stringify(parsed.tags), parsed.destroyAt, now, now);
     insertLinks(id, parsed.links, now);
     clearDeletedEntityRecord("note", id);
     upsertSearchRow(id, contentPlain, parsed.author ?? context.actor ?? null);
-    const note = getNoteById(id);
+    const note = getNoteById(id, { skipCleanup: true });
     recordNoteActivity(note, "note.created", "Note added", context);
     return note;
 }
@@ -234,31 +346,37 @@ export function createLinkedNotes(notes, entityLink, context) {
     return notes.map((note) => createNote({
         contentMarkdown: note.contentMarkdown,
         author: note.author,
+        tags: note.tags,
+        destroyAt: note.destroyAt,
         links: [entityLink, ...note.links]
     }, context));
 }
 export function updateNote(noteId, input, context) {
-    const existing = getNoteByIdIncludingDeleted(noteId);
+    cleanupExpiredNotes();
+    const existing = getNoteByIdIncludingDeleted(noteId, { skipCleanup: true });
     if (!existing) {
         return undefined;
     }
     const patch = updateNoteSchema.parse({
         ...input,
-        links: input.links ? normalizeLinks(input.links) : undefined
+        links: input.links ? normalizeLinks(input.links) : undefined,
+        tags: input.tags ? normalizeTags(input.tags) : undefined
     });
     const nextMarkdown = patch.contentMarkdown ?? existing.contentMarkdown;
     const nextPlain = stripMarkdown(nextMarkdown);
     const nextAuthor = patch.author === undefined ? existing.author : patch.author;
+    const nextTags = patch.tags ?? existing.tags;
+    const nextDestroyAt = patch.destroyAt === undefined ? existing.destroyAt : patch.destroyAt;
     const updatedAt = new Date().toISOString();
     getDatabase()
         .prepare(`UPDATE notes
-       SET content_markdown = ?, content_plain = ?, author = ?, updated_at = ?
+       SET content_markdown = ?, content_plain = ?, author = ?, tags_json = ?, destroy_at = ?, updated_at = ?
        WHERE id = ?`)
-        .run(nextMarkdown, nextPlain, nextAuthor, updatedAt, noteId);
+        .run(nextMarkdown, nextPlain, nextAuthor, JSON.stringify(nextTags), nextDestroyAt, updatedAt, noteId);
     if (patch.links) {
         replaceLinks(noteId, patch.links, updatedAt);
     }
-    const note = getNoteByIdIncludingDeleted(noteId);
+    const note = getNoteByIdIncludingDeleted(noteId, { skipCleanup: true });
     if (note.links.length > 0) {
         clearDeletedEntityRecord("note", noteId);
     }
@@ -275,21 +393,34 @@ export function updateNote(noteId, input, context) {
         });
     }
     upsertSearchRow(noteId, nextPlain, nextAuthor);
+    if (nextDestroyAt && Date.parse(nextDestroyAt) <= Date.now()) {
+        deleteNoteInternal(noteId, { source: "system", actor: null }, "Ephemeral note expired");
+        return undefined;
+    }
     recordNoteActivity(note, "note.updated", "Note updated", context);
     return getNoteById(noteId);
 }
-export function deleteNote(noteId, context) {
-    const existing = getNoteByIdIncludingDeleted(noteId);
+function deleteNoteInternal(noteId, context, title) {
+    const existing = getNoteRow(noteId)
+        ? mapNote(getNoteRow(noteId), listNoteLinks(noteId))
+        : getDeletedEntityRecord("note", noteId)?.snapshot;
     if (!existing) {
         return undefined;
     }
+    clearDeletedEntityRecord("note", noteId);
     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);
+    clearDeletedEntityRecord("note", noteId);
+    recordNoteActivity(existing, "note.deleted", title, context);
     return existing;
 }
+export function deleteNote(noteId, context) {
+    cleanupExpiredNotes();
+    return deleteNoteInternal(noteId, context, "Note deleted");
+}
 export function buildNotesSummaryByEntity() {
+    cleanupExpiredNotes();
     const rows = getDatabase()
         .prepare(`SELECT
          note_links.entity_type AS entity_type,
@@ -302,8 +433,9 @@ export function buildNotesSummaryByEntity() {
          ON deleted_entities.entity_type = 'note'
         AND deleted_entities.entity_id = notes.id
        WHERE deleted_entities.entity_id IS NULL
+         AND (notes.destroy_at IS NULL OR notes.destroy_at = '' OR notes.destroy_at > ?)
        ORDER BY notes.created_at DESC`)
-        .all();
+        .all(new Date().toISOString());
     return rows.reduce((acc, row) => {
         const key = `${row.entity_type}:${row.entity_id}`;
         const current = acc[key];
@@ -324,6 +456,7 @@ export function buildNotesSummaryByEntity() {
     }, {});
 }
 export function unlinkNotesForEntity(entityType, entityId, context) {
+    cleanupExpiredNotes();
     const noteIds = getDatabase()
         .prepare(`SELECT DISTINCT note_id FROM note_links WHERE entity_type = ? AND entity_id = ?`)
         .all(entityType, entityId);

package/dist/server/repositories/projects.js

@@ -6,7 +6,8 @@ import { createLinkedNotes } from "./notes.js";
 import { assertGoalExists } from "../services/relations.js";
 import { getGoalById } from "./goals.js";
 import { pruneLinkedEntityReferences } from "./psyche.js";
-import { createProjectSchema, projectSchema, updateProjectSchema } from "../types.js";
+import { listTasks, updateTaskInTransaction } from "./tasks.js";
+import { calendarSchedulingRulesSchema, createProjectSchema, projectSchema, updateProjectSchema } from "../types.js";
 function getDefaultProjectTemplate(goal) {
     switch (goal.title) {
         case "Build a durable body and calm energy":
@@ -40,10 +41,18 @@ function mapProject(row) {
         status: row.status,
         themeColor: row.theme_color,
         targetPoints: row.target_points,
+        schedulingRules: calendarSchedulingRulesSchema.parse(JSON.parse(row.scheduling_rules_json || "{}")),
         createdAt: row.created_at,
         updatedAt: row.updated_at
     });
 }
+function completeLinkedProjectTasks(projectId, activity) {
+    const openTasks = listTasks({ projectId }).filter((task) => task.status !== "done");
+    for (const task of openTasks) {
+        updateTaskInTransaction(task.id, { status: "done" }, activity);
+    }
+    return openTasks.length;
+}
 export function listProjects(filters = {}) {
     const whereClauses = [];
     const params = [];
@@ -62,6 +71,7 @@ export function listProjects(filters = {}) {
     }
     const rows = getDatabase()
         .prepare(`SELECT id, goal_id, title, description, status, theme_color, target_points, created_at, updated_at
+       , scheduling_rules_json
        FROM projects
        ${whereSql}
        ORDER BY created_at ASC
@@ -75,6 +85,7 @@ export function getProjectById(projectId) {
     }
     const row = getDatabase()
         .prepare(`SELECT id, goal_id, title, description, status, theme_color, target_points, created_at, updated_at
+       , scheduling_rules_json
        FROM projects
        WHERE id = ?`)
         .get(projectId);
@@ -87,9 +98,9 @@ export function createProject(input, activity) {
         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);
+            .prepare(`INSERT INTO projects (id, goal_id, title, description, status, theme_color, target_points, scheduling_rules_json, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(id, parsed.goalId, parsed.title, parsed.description, parsed.status, parsed.themeColor, parsed.targetPoints, JSON.stringify(parsed.schedulingRules), now, now);
         const project = getProjectById(id);
         createLinkedNotes(parsed.notes, { entityType: "project", entityId: project.id, anchorKey: null }, activity ?? { source: "ui", actor: null });
         if (activity) {
@@ -127,32 +138,42 @@ export function updateProject(projectId, input, activity) {
             status: parsed.status ?? current.status,
             themeColor: parsed.themeColor ?? current.themeColor,
             targetPoints: parsed.targetPoints ?? current.targetPoints,
+            schedulingRules: parsed.schedulingRules ?? current.schedulingRules,
             updatedAt: new Date().toISOString()
         };
         getDatabase()
             .prepare(`UPDATE projects
-         SET goal_id = ?, title = ?, description = ?, status = ?, theme_color = ?, target_points = ?, updated_at = ?
+         SET goal_id = ?, title = ?, description = ?, status = ?, theme_color = ?, target_points = ?, scheduling_rules_json = ?, updated_at = ?
          WHERE id = ?`)
-            .run(next.goalId, next.title, next.description, next.status, next.themeColor, next.targetPoints, next.updatedAt, projectId);
+            .run(next.goalId, next.title, next.description, next.status, next.themeColor, next.targetPoints, JSON.stringify(next.schedulingRules), 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 completedLinkedTaskCount = current.status !== "completed" && next.status === "completed"
+            ? completeLinkedProjectTasks(projectId, activity)
+            : 0;
         const project = getProjectById(projectId);
         if (project && activity) {
+            const statusChanged = current.status !== project.status;
             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.",
+                eventType: statusChanged ? "project_status_changed" : "project_updated",
+                title: statusChanged ? `Project ${project.status}: ${project.title}` : `Project updated: ${project.title}`,
+                description: statusChanged && project.status === "completed"
+                    ? `Project finished and auto-completed ${completedLinkedTaskCount} linked unfinished task${completedLinkedTaskCount === 1 ? "" : "s"}.`
+                    : statusChanged
+                        ? `Project status changed from ${current.status} to ${project.status}.`
+                        : "Project details were updated.",
                 actor: activity.actor ?? null,
                 source: activity.source,
                 metadata: {
                     goalId: project.goalId,
                     previousGoalId: current.goalId,
                     status: project.status,
-                    previousStatus: current.status
+                    previousStatus: current.status,
+                    completedLinkedTaskCount
                 }
             });
         }
@@ -174,9 +195,20 @@ export function ensureDefaultProjectForGoal(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, 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);
+            .prepare(`INSERT INTO projects (id, goal_id, title, description, status, theme_color, target_points, scheduling_rules_json, 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)), JSON.stringify({
+            allowWorkBlockKinds: [],
+            blockWorkBlockKinds: [],
+            allowCalendarIds: [],
+            blockCalendarIds: [],
+            allowEventTypes: [],
+            blockEventTypes: [],
+            allowEventKeywords: [],
+            blockEventKeywords: [],
+            allowAvailability: [],
+            blockAvailability: []
+        }), now, now);
         return getProjectById(id);
     });
 }

package/dist/server/repositories/rewards.js

@@ -1,7 +1,7 @@
 import { randomUUID } from "node:crypto";
 import { getDatabase } from "../db.js";
 import { recordEventLog } from "./event-log.js";
-import { createManualRewardGrantSchema, rewardLedgerEventSchema, rewardRuleSchema, sessionEventSchema, updateRewardRuleSchema } from "../types.js";
+import { createManualRewardGrantSchema, workAdjustmentEntityTypeSchema, rewardLedgerEventSchema, rewardRuleSchema, sessionEventSchema, updateRewardRuleSchema } from "../types.js";
 const DEFAULT_RULES = [
     {
         id: "reward_rule_task_completion",
@@ -107,6 +107,14 @@ const DEFAULT_RULES = [
         description: "Reward giving a recurring mode enough shape to recognize it later.",
         config: { fixedXp: 4 }
     },
+    {
+        id: "reward_rule_weekly_review_completed",
+        family: "alignment",
+        code: "weekly_review_completed",
+        title: "Weekly review completed",
+        description: "Reward closing the current weekly review cycle and turning it into explicit evidence.",
+        config: { fixedXp: 250 }
+    },
     {
         id: "reward_rule_session_dwell",
         family: "ambient",
@@ -194,6 +202,17 @@ export function getRewardRuleById(ruleId) {
 function getRuleByCode(code) {
     return listRewardRules().find((rule) => rule.code === code);
 }
+export function getTaskRunProgressRewardCadence() {
+    ensureDefaultRewardRules();
+    const rule = getRuleByCode("task_run_progress");
+    const intervalMinutes = Math.max(1, Number(rule?.config.intervalMinutes ?? 10));
+    return {
+        rule,
+        intervalMinutes,
+        intervalSeconds: intervalMinutes * 60,
+        fixedXp: Number(rule?.config.fixedXp ?? 4)
+    };
+}
 export function updateRewardRule(ruleId, input, activity) {
     ensureDefaultRewardRules();
     const current = getRewardRuleById(ruleId);
@@ -279,6 +298,17 @@ export function listRewardLedger(filters = {}) {
         .all(...params);
     return rows.map(mapLedger);
 }
+export function getRewardLedgerEventById(rewardId) {
+    ensureDefaultRewardRules();
+    const row = getDatabase()
+        .prepare(`SELECT
+         id, rule_id, event_log_id, entity_type, entity_id, actor, source, delta_xp, reason_title, reason_summary,
+         reversible_group, reversed_by_reward_id, metadata_json, created_at
+       FROM reward_ledger
+       WHERE id = ?`)
+        .get(rewardId);
+    return row ? mapLedger(row) : null;
+}
 export function getTotalXp() {
     ensureDefaultRewardRules();
     const row = getDatabase().prepare(`SELECT COALESCE(SUM(delta_xp), 0) AS total FROM reward_ledger`).get();
@@ -537,11 +567,7 @@ export function recordTaskRunStartReward(taskRunId, taskId, actor, source) {
     });
 }
 export function recordTaskRunProgressRewards(taskRunId, taskId, actor, source, creditedSeconds) {
-    ensureDefaultRewardRules();
-    const rule = getRuleByCode("task_run_progress");
-    const intervalMinutes = Math.max(1, Number(rule?.config.intervalMinutes ?? 10));
-    const intervalSeconds = intervalMinutes * 60;
-    const fixedXp = Number(rule?.config.fixedXp ?? 4);
+    const { rule, intervalMinutes, intervalSeconds, fixedXp } = getTaskRunProgressRewardCadence();
     const earnedBuckets = Math.floor(Math.max(0, creditedSeconds) / intervalSeconds);
     if (earnedBuckets <= 0) {
         return [];
@@ -593,6 +619,55 @@ export function recordTaskRunProgressRewards(taskRunId, taskId, actor, source, c
     }
     return rewards;
 }
+export function recordWorkAdjustmentReward(input) {
+    const { rule, intervalMinutes, intervalSeconds, fixedXp } = getTaskRunProgressRewardCadence();
+    const entityType = workAdjustmentEntityTypeSchema.parse(input.entityType);
+    const previousBuckets = Math.floor(Math.max(0, input.previousCreditedSeconds) / intervalSeconds);
+    const nextBuckets = Math.floor(Math.max(0, input.nextCreditedSeconds) / intervalSeconds);
+    const bucketDelta = nextBuckets - previousBuckets;
+    if (bucketDelta === 0) {
+        return null;
+    }
+    const deltaXp = bucketDelta * fixedXp;
+    const direction = bucketDelta > 0 ? "added" : "removed";
+    const appliedMinutes = Math.abs(input.appliedDeltaMinutes);
+    const eventLog = recordEventLog({
+        eventKind: "reward.work_adjustment",
+        entityType,
+        entityId: input.entityId,
+        actor: input.actor ?? null,
+        source: input.source,
+        metadata: {
+            adjustmentId: input.adjustmentId,
+            requestedDeltaMinutes: input.requestedDeltaMinutes,
+            appliedDeltaMinutes: input.appliedDeltaMinutes,
+            bucketDelta,
+            deltaXp
+        }
+    });
+    return insertLedgerEvent({
+        ruleId: rule?.id ?? null,
+        eventLogId: eventLog.id,
+        entityType,
+        entityId: input.entityId,
+        actor: input.actor ?? null,
+        source: input.source,
+        deltaXp,
+        reasonTitle: bucketDelta > 0 ? "Manual work minutes added" : "Manual work minutes removed",
+        reasonSummary: `${appliedMinutes} manual minute${appliedMinutes === 1 ? "" : "s"} ${direction}, shifting ${Math.abs(bucketDelta)} ${intervalMinutes}-minute reward bucket${Math.abs(bucketDelta) === 1 ? "" : "s"} for ${input.targetTitle}.`,
+        reversibleGroup: `work_adjustment:${entityType}:${input.entityId}:${input.adjustmentId}`,
+        metadata: {
+            adjustmentId: input.adjustmentId,
+            requestedDeltaMinutes: input.requestedDeltaMinutes,
+            appliedDeltaMinutes: input.appliedDeltaMinutes,
+            previousCreditedSeconds: input.previousCreditedSeconds,
+            nextCreditedSeconds: input.nextCreditedSeconds,
+            bucketDelta,
+            intervalMinutes,
+            rewardCategory: "manual_work_adjustment"
+        }
+    });
+}
 export function recordSessionEvent(input, activity, now = new Date()) {
     ensureDefaultRewardRules();
     const sessionEvent = sessionEventSchema.parse({
@@ -695,6 +770,39 @@ export function recordHabitCheckInReward(habit, status, dateKey, activity) {
         }
     });
 }
+export function recordWeeklyReviewCompletionReward(input, activity) {
+    ensureDefaultRewardRules();
+    const rule = getRuleByCode("weekly_review_completed");
+    const deltaXp = Math.max(0, Number(rule?.config.fixedXp ?? input.rewardXp));
+    const eventLog = recordEventLog({
+        eventKind: "reward.weekly_review_completed",
+        entityType: "system",
+        entityId: input.weekKey,
+        actor: activity.actor ?? null,
+        source: activity.source,
+        metadata: {
+            weekKey: input.weekKey,
+            windowLabel: input.windowLabel,
+            deltaXp
+        }
+    });
+    return insertLedgerEvent({
+        ruleId: rule?.id ?? null,
+        eventLogId: eventLog.id,
+        entityType: "system",
+        entityId: input.weekKey,
+        actor: activity.actor ?? null,
+        source: activity.source,
+        deltaXp,
+        reasonTitle: rule?.title ?? "Weekly review completed",
+        reasonSummary: `Closed the review for ${input.windowLabel}.`,
+        reversibleGroup: `weekly_review_completed:${input.weekKey}`,
+        metadata: {
+            weekKey: input.weekKey,
+            windowLabel: input.windowLabel
+        }
+    });
+}
 export function listSessionEvents(limit = 50) {
     const rows = getDatabase()
         .prepare(`SELECT id, session_id, event_type, actor, source, metrics_json, created_at