forge-openclaw-plugin 0.2.19 → 0.2.21

package/dist/server/preferences-types.js

@@ -0,0 +1,368 @@
+import { z } from "zod";
+import { crudEntityTypeSchema, userSummarySchema } from "./types.js";
+const trimmedString = z.string().trim();
+const nonEmptyTrimmedString = trimmedString.min(1);
+export const preferenceDomainSchema = z.enum([
+    "projects",
+    "tasks",
+    "strategies",
+    "habits",
+    "calendar",
+    "sleep",
+    "sports",
+    "activities",
+    "food",
+    "places",
+    "countries",
+    "fashion",
+    "people",
+    "media",
+    "tools",
+    "custom"
+]);
+export const preferenceCatalogSourceSchema = z.enum(["seeded", "custom"]);
+export const preferenceContextShareModeSchema = z.enum([
+    "shared",
+    "isolated",
+    "blended"
+]);
+export const preferenceJudgmentOutcomeSchema = z.enum([
+    "left",
+    "right",
+    "tie",
+    "skip"
+]);
+export const preferenceSignalTypeSchema = z.enum([
+    "favorite",
+    "veto",
+    "must_have",
+    "bookmark",
+    "neutral",
+    "compare_later"
+]);
+export const preferenceDimensionIdSchema = z.enum([
+    "novelty",
+    "simplicity",
+    "rigor",
+    "aesthetics",
+    "depth",
+    "structure",
+    "familiarity",
+    "surprise"
+]);
+export const preferenceItemStatusSchema = z.enum([
+    "liked",
+    "disliked",
+    "uncertain",
+    "vetoed",
+    "bookmarked",
+    "favorite",
+    "must_have",
+    "neutral"
+]);
+export const preferenceDimensionVectorSchema = z.object({
+    novelty: z.number().min(-1).max(1).default(0),
+    simplicity: z.number().min(-1).max(1).default(0),
+    rigor: z.number().min(-1).max(1).default(0),
+    aesthetics: z.number().min(-1).max(1).default(0),
+    depth: z.number().min(-1).max(1).default(0),
+    structure: z.number().min(-1).max(1).default(0),
+    familiarity: z.number().min(-1).max(1).default(0),
+    surprise: z.number().min(-1).max(1).default(0)
+});
+export const preferenceLinkedEntitySchema = z.object({
+    entityType: crudEntityTypeSchema,
+    entityId: nonEmptyTrimmedString
+});
+export const preferenceProfileSchema = z.object({
+    id: z.string(),
+    userId: nonEmptyTrimmedString,
+    domain: preferenceDomainSchema,
+    defaultContextId: z.string().nullable(),
+    modelVersion: nonEmptyTrimmedString,
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    user: userSummarySchema.nullable().optional()
+});
+export const preferenceContextSchema = z.object({
+    id: z.string(),
+    profileId: nonEmptyTrimmedString,
+    name: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    shareMode: preferenceContextShareModeSchema,
+    active: z.boolean(),
+    isDefault: z.boolean(),
+    decayDays: z.number().int().min(7).max(365),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const preferenceItemSchema = z.object({
+    id: z.string(),
+    profileId: nonEmptyTrimmedString,
+    label: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    tags: z.array(nonEmptyTrimmedString).default([]),
+    featureWeights: preferenceDimensionVectorSchema,
+    sourceEntityType: crudEntityTypeSchema.nullable().optional(),
+    sourceEntityId: z.string().nullable().optional(),
+    linkedEntity: preferenceLinkedEntitySchema.nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).default({}),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const preferenceCatalogItemSchema = z.object({
+    id: z.string(),
+    catalogId: nonEmptyTrimmedString,
+    label: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    tags: z.array(nonEmptyTrimmedString).default([]),
+    featureWeights: preferenceDimensionVectorSchema,
+    position: z.number().int().min(0),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const preferenceCatalogSchema = z.object({
+    id: z.string(),
+    profileId: nonEmptyTrimmedString,
+    domain: preferenceDomainSchema,
+    slug: nonEmptyTrimmedString,
+    title: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    source: preferenceCatalogSourceSchema,
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    items: z.array(preferenceCatalogItemSchema).default([])
+});
+export const pairwiseJudgmentSchema = z.object({
+    id: z.string(),
+    profileId: nonEmptyTrimmedString,
+    contextId: nonEmptyTrimmedString,
+    userId: nonEmptyTrimmedString,
+    leftItemId: nonEmptyTrimmedString,
+    rightItemId: nonEmptyTrimmedString,
+    outcome: preferenceJudgmentOutcomeSchema,
+    strength: z.number().min(0.5).max(2),
+    responseTimeMs: z.number().int().nullable(),
+    source: nonEmptyTrimmedString,
+    reasonTags: z.array(nonEmptyTrimmedString).default([]),
+    createdAt: z.string()
+});
+export const absoluteSignalSchema = z.object({
+    id: z.string(),
+    profileId: nonEmptyTrimmedString,
+    contextId: nonEmptyTrimmedString,
+    userId: nonEmptyTrimmedString,
+    itemId: nonEmptyTrimmedString,
+    signalType: preferenceSignalTypeSchema,
+    strength: z.number().min(0.5).max(2),
+    source: nonEmptyTrimmedString,
+    createdAt: z.string()
+});
+export const preferenceItemScoreSchema = z.object({
+    id: z.string(),
+    profileId: nonEmptyTrimmedString,
+    contextId: nonEmptyTrimmedString,
+    itemId: nonEmptyTrimmedString,
+    latentScore: z.number(),
+    confidence: z.number().min(0).max(1),
+    uncertainty: z.number().min(0).max(1),
+    evidenceCount: z.number().int().min(0),
+    pairwiseWins: z.number().int().min(0),
+    pairwiseLosses: z.number().int().min(0),
+    pairwiseTies: z.number().int().min(0),
+    signalCount: z.number().int().min(0),
+    conflictCount: z.number().int().min(0),
+    status: preferenceItemStatusSchema,
+    dominantDimensions: z.array(preferenceDimensionIdSchema).default([]),
+    explanation: z.array(trimmedString).default([]),
+    manualStatus: preferenceItemStatusSchema.nullable().optional(),
+    manualScore: z.number().nullable().optional(),
+    confidenceLock: z.number().min(0).max(1).nullable().optional(),
+    bookmarked: z.boolean(),
+    compareLater: z.boolean(),
+    frozen: z.boolean(),
+    lastInferredAt: z.string(),
+    lastJudgmentAt: z.string().nullable(),
+    updatedAt: z.string(),
+    item: preferenceItemSchema.optional()
+});
+export const preferenceDimensionSummarySchema = z.object({
+    id: z.string(),
+    profileId: nonEmptyTrimmedString,
+    contextId: nonEmptyTrimmedString,
+    dimensionId: preferenceDimensionIdSchema,
+    leaning: z.number().min(-1).max(1),
+    confidence: z.number().min(0).max(1),
+    movement: z.number().min(-1).max(1),
+    contextSensitivity: z.number().min(0).max(1),
+    evidenceCount: z.number().int().min(0),
+    updatedAt: z.string()
+});
+export const preferenceSnapshotSchema = z.object({
+    id: z.string(),
+    profileId: nonEmptyTrimmedString,
+    contextId: nonEmptyTrimmedString,
+    summaryMetrics: z.record(z.string(), z.unknown()),
+    serializedModelState: z.record(z.string(), z.unknown()),
+    createdAt: z.string()
+});
+export const preferenceMapPointSchema = z.object({
+    itemId: nonEmptyTrimmedString,
+    label: nonEmptyTrimmedString,
+    x: z.number(),
+    y: z.number(),
+    score: z.number(),
+    confidence: z.number().min(0).max(1),
+    uncertainty: z.number().min(0).max(1),
+    status: preferenceItemStatusSchema,
+    clusterKey: trimmedString,
+    tags: z.array(nonEmptyTrimmedString).default([]),
+    sourceEntityType: crudEntityTypeSchema.nullable().optional(),
+    sourceEntityId: z.string().nullable().optional()
+});
+export const preferenceComparePairSchema = z.object({
+    left: preferenceItemSchema,
+    right: preferenceItemSchema,
+    rationale: z.array(trimmedString).default([]),
+    score: z.number()
+});
+export const preferenceWorkspacePayloadSchema = z.object({
+    profile: preferenceProfileSchema,
+    selectedContext: preferenceContextSchema,
+    contexts: z.array(preferenceContextSchema),
+    catalogs: z.array(preferenceCatalogSchema),
+    dimensions: z.array(preferenceDimensionSummarySchema),
+    scores: z.array(preferenceItemScoreSchema),
+    map: z.array(preferenceMapPointSchema),
+    history: z.object({
+        judgments: z.array(pairwiseJudgmentSchema),
+        signals: z.array(absoluteSignalSchema),
+        snapshots: z.array(preferenceSnapshotSchema),
+        staleItemIds: z.array(nonEmptyTrimmedString).default([]),
+        flippedItemIds: z.array(nonEmptyTrimmedString).default([])
+    }),
+    compare: z.object({
+        nextPair: preferenceComparePairSchema.nullable(),
+        pendingCount: z.number().int().min(0),
+        candidateCount: z.number().int().min(0)
+    }),
+    summary: z.object({
+        totalItems: z.number().int().min(0),
+        likedCount: z.number().int().min(0),
+        dislikedCount: z.number().int().min(0),
+        uncertainCount: z.number().int().min(0),
+        bookmarkedCount: z.number().int().min(0),
+        vetoedCount: z.number().int().min(0),
+        averageConfidence: z.number().min(0).max(1),
+        pendingComparisons: z.number().int().min(0)
+    }),
+    libraries: z.object({
+        totalCatalogs: z.number().int().min(0),
+        totalCatalogItems: z.number().int().min(0),
+        seededCatalogCount: z.number().int().min(0),
+        customCatalogCount: z.number().int().min(0)
+    })
+});
+export const preferenceWorkspaceQuerySchema = z.object({
+    userId: nonEmptyTrimmedString.optional(),
+    domain: preferenceDomainSchema.optional(),
+    contextId: nonEmptyTrimmedString.optional()
+});
+export const createPreferenceContextSchema = z.object({
+    userId: nonEmptyTrimmedString,
+    domain: preferenceDomainSchema,
+    name: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    shareMode: preferenceContextShareModeSchema.default("blended"),
+    active: z.boolean().default(true),
+    isDefault: z.boolean().default(false),
+    decayDays: z.number().int().min(7).max(365).default(90)
+});
+export const updatePreferenceContextSchema = createPreferenceContextSchema
+    .omit({ userId: true, domain: true })
+    .partial();
+export const mergePreferenceContextsSchema = z.object({
+    sourceContextId: nonEmptyTrimmedString,
+    targetContextId: nonEmptyTrimmedString
+});
+export const createPreferenceItemSchema = z.object({
+    userId: nonEmptyTrimmedString,
+    domain: preferenceDomainSchema,
+    label: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    tags: z.array(nonEmptyTrimmedString).default([]),
+    featureWeights: preferenceDimensionVectorSchema.default({}),
+    sourceEntityType: crudEntityTypeSchema.nullable().optional(),
+    sourceEntityId: z.string().nullable().optional(),
+    metadata: z.record(z.string(), z.unknown()).default({}),
+    queueForCompare: z.boolean().default(true)
+});
+export const updatePreferenceItemSchema = createPreferenceItemSchema
+    .omit({ userId: true, domain: true })
+    .partial();
+export const createPreferenceCatalogSchema = z.object({
+    userId: nonEmptyTrimmedString,
+    domain: preferenceDomainSchema,
+    title: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    slug: trimmedString.optional()
+});
+export const updatePreferenceCatalogSchema = createPreferenceCatalogSchema
+    .omit({ userId: true, domain: true })
+    .partial();
+export const createPreferenceCatalogItemSchema = z.object({
+    catalogId: nonEmptyTrimmedString,
+    label: nonEmptyTrimmedString,
+    description: trimmedString.default(""),
+    tags: z.array(nonEmptyTrimmedString).default([]),
+    featureWeights: preferenceDimensionVectorSchema.default({}),
+    position: z.number().int().min(0).optional()
+});
+export const updatePreferenceCatalogItemSchema = createPreferenceCatalogItemSchema
+    .omit({ catalogId: true })
+    .partial();
+export const enqueueEntityPreferenceItemSchema = z.object({
+    userId: nonEmptyTrimmedString,
+    domain: preferenceDomainSchema,
+    entityType: crudEntityTypeSchema,
+    entityId: nonEmptyTrimmedString,
+    label: trimmedString.optional(),
+    description: trimmedString.optional(),
+    tags: z.array(nonEmptyTrimmedString).default([])
+});
+export const submitPairwiseJudgmentSchema = z.object({
+    userId: nonEmptyTrimmedString,
+    domain: preferenceDomainSchema,
+    contextId: nonEmptyTrimmedString,
+    leftItemId: nonEmptyTrimmedString,
+    rightItemId: nonEmptyTrimmedString,
+    outcome: preferenceJudgmentOutcomeSchema,
+    strength: z.number().min(0.5).max(2).default(1),
+    responseTimeMs: z.number().int().nullable().optional(),
+    reasonTags: z.array(nonEmptyTrimmedString).default([])
+});
+export const submitAbsoluteSignalSchema = z.object({
+    userId: nonEmptyTrimmedString,
+    domain: preferenceDomainSchema,
+    contextId: nonEmptyTrimmedString,
+    itemId: nonEmptyTrimmedString,
+    signalType: preferenceSignalTypeSchema,
+    strength: z.number().min(0.5).max(2).default(1)
+});
+export const updatePreferenceScoreSchema = z.object({
+    userId: nonEmptyTrimmedString,
+    domain: preferenceDomainSchema,
+    contextId: nonEmptyTrimmedString,
+    manualStatus: preferenceItemStatusSchema.nullable().optional(),
+    manualScore: z.number().nullable().optional(),
+    confidenceLock: z.number().min(0).max(1).nullable().optional(),
+    bookmarked: z.boolean().optional(),
+    compareLater: z.boolean().optional(),
+    frozen: z.boolean().optional()
+});
+export const startPreferenceGameSchema = z.object({
+    userId: nonEmptyTrimmedString,
+    domain: preferenceDomainSchema,
+    contextId: nonEmptyTrimmedString.optional(),
+    catalogId: nonEmptyTrimmedString.optional()
+});

package/dist/server/psyche-types.js

@@ -1,7 +1,13 @@
 import { z } from "zod";
+import { userSummarySchema } from "./types.js";
 const trimmedString = z.string().trim();
 const nonEmptyTrimmedString = trimmedString.min(1);
 const uniqueStringArraySchema = z.array(nonEmptyTrimmedString);
+const optionalOwnedUserIdSchema = z.string().trim().min(1).nullable().optional();
+const ownedEntityFieldsSchema = {
+    userId: optionalOwnedUserIdSchema,
+    user: userSummarySchema.nullable().optional()
+};
 export const triggerReportStatusSchema = z.enum(["draft", "reviewed", "integrated"]);
 export const behaviorKindSchema = z.enum(["away", "committed", "recovery"]);
 export const beliefTypeSchema = z.enum(["absolute", "conditional"]);
@@ -42,7 +48,8 @@ export const eventTypeSchema = z.object({
     description: trimmedString,
     system: z.boolean(),
     createdAt: z.string(),
-    updatedAt: z.string()
+    updatedAt: z.string(),
+    ...ownedEntityFieldsSchema
 });
 export const emotionDefinitionSchema = z.object({
     id: z.string(),
@@ -52,7 +59,8 @@ export const emotionDefinitionSchema = z.object({
     category: trimmedString,
     system: z.boolean(),
     createdAt: z.string(),
-    updatedAt: z.string()
+    updatedAt: z.string(),
+    ...ownedEntityFieldsSchema
 });
 export const psycheValueSchema = z.object({
     id: z.string(),
@@ -66,7 +74,8 @@ export const psycheValueSchema = z.object({
     linkedTaskIds: uniqueStringArraySchema.default([]),
     committedActions: z.array(trimmedString).default([]),
     createdAt: z.string(),
-    updatedAt: z.string()
+    updatedAt: z.string(),
+    ...ownedEntityFieldsSchema
 });
 export const behaviorPatternSchema = z.object({
     id: z.string(),
@@ -84,7 +93,8 @@ export const behaviorPatternSchema = z.object({
     linkedModeIds: uniqueStringArraySchema.default([]),
     linkedBeliefIds: uniqueStringArraySchema.default([]),
     createdAt: z.string(),
-    updatedAt: z.string()
+    updatedAt: z.string(),
+    ...ownedEntityFieldsSchema
 });
 export const behaviorSchema = z.object({
     id: z.string(),
@@ -103,7 +113,8 @@ export const behaviorSchema = z.object({
     linkedSchemaIds: uniqueStringArraySchema.default([]),
     linkedModeIds: uniqueStringArraySchema.default([]),
     createdAt: z.string(),
-    updatedAt: z.string()
+    updatedAt: z.string(),
+    ...ownedEntityFieldsSchema
 });
 export const beliefEntrySchema = z.object({
     id: z.string(),
@@ -121,7 +132,8 @@ export const beliefEntrySchema = z.object({
     linkedModeIds: uniqueStringArraySchema.default([]),
     linkedReportIds: uniqueStringArraySchema.default([]),
     createdAt: z.string(),
-    updatedAt: z.string()
+    updatedAt: z.string(),
+    ...ownedEntityFieldsSchema
 });
 export const modeProfileSchema = z.object({
     id: z.string(),
@@ -142,7 +154,8 @@ export const modeProfileSchema = z.object({
     linkedBehaviorIds: uniqueStringArraySchema.default([]),
     linkedValueIds: uniqueStringArraySchema.default([]),
     createdAt: z.string(),
-    updatedAt: z.string()
+    updatedAt: z.string(),
+    ...ownedEntityFieldsSchema
 });
 export const modeTimelineEntrySchema = z.object({
     id: z.string(),
@@ -168,7 +181,8 @@ export const modeGuideSessionSchema = z.object({
     answers: z.array(modeGuideAnswerSchema),
     results: z.array(modeGuideResultSchema),
     createdAt: z.string(),
-    updatedAt: z.string()
+    updatedAt: z.string(),
+    ...ownedEntityFieldsSchema
 });
 export const triggerEmotionSchema = z.object({
     id: z.string(),
@@ -222,7 +236,8 @@ export const triggerReportSchema = z.object({
     modeTimeline: z.array(modeTimelineEntrySchema).default([]),
     nextMoves: z.array(trimmedString).default([]),
     createdAt: z.string(),
-    updatedAt: z.string()
+    updatedAt: z.string(),
+    ...ownedEntityFieldsSchema
 });
 export const schemaPressureEntrySchema = z.object({
     schemaId: z.string(),
@@ -251,7 +266,8 @@ export const createPsycheValueSchema = z.object({
     linkedGoalIds: uniqueStringArraySchema.default([]),
     linkedProjectIds: uniqueStringArraySchema.default([]),
     linkedTaskIds: uniqueStringArraySchema.default([]),
-    committedActions: z.array(trimmedString).default([])
+    committedActions: z.array(trimmedString).default([]),
+    userId: optionalOwnedUserIdSchema
 });
 export const updatePsycheValueSchema = createPsycheValueSchema.partial();
 export const createBehaviorPatternSchema = z.object({
@@ -266,7 +282,8 @@ export const createBehaviorPatternSchema = z.object({
     linkedSchemaLabels: z.array(trimmedString).default([]),
     linkedModeLabels: z.array(trimmedString).default([]),
     linkedModeIds: uniqueStringArraySchema.default([]),
-    linkedBeliefIds: uniqueStringArraySchema.default([])
+    linkedBeliefIds: uniqueStringArraySchema.default([]),
+    userId: optionalOwnedUserIdSchema
 });
 export const updateBehaviorPatternSchema = createBehaviorPatternSchema.partial();
 export const createBehaviorSchema = z.object({
@@ -282,7 +299,8 @@ export const createBehaviorSchema = z.object({
     linkedPatternIds: uniqueStringArraySchema.default([]),
     linkedValueIds: uniqueStringArraySchema.default([]),
     linkedSchemaIds: uniqueStringArraySchema.default([]),
-    linkedModeIds: uniqueStringArraySchema.default([])
+    linkedModeIds: uniqueStringArraySchema.default([]),
+    userId: optionalOwnedUserIdSchema
 });
 export const updateBehaviorSchema = createBehaviorSchema.partial();
 export const createBeliefEntrySchema = z.object({
@@ -297,7 +315,8 @@ export const createBeliefEntrySchema = z.object({
     linkedValueIds: uniqueStringArraySchema.default([]),
     linkedBehaviorIds: uniqueStringArraySchema.default([]),
     linkedModeIds: uniqueStringArraySchema.default([]),
-    linkedReportIds: uniqueStringArraySchema.default([])
+    linkedReportIds: uniqueStringArraySchema.default([]),
+    userId: optionalOwnedUserIdSchema
 });
 export const updateBeliefEntrySchema = createBeliefEntrySchema.partial();
 export const createModeProfileSchema = z.object({
@@ -315,23 +334,27 @@ export const createModeProfileSchema = z.object({
     firstAppearanceAt: trimmedString.nullable().default(null),
     linkedPatternIds: uniqueStringArraySchema.default([]),
     linkedBehaviorIds: uniqueStringArraySchema.default([]),
-    linkedValueIds: uniqueStringArraySchema.default([])
+    linkedValueIds: uniqueStringArraySchema.default([]),
+    userId: optionalOwnedUserIdSchema
 });
 export const updateModeProfileSchema = createModeProfileSchema.partial();
 export const createModeGuideSessionSchema = z.object({
     summary: nonEmptyTrimmedString,
-    answers: z.array(modeGuideAnswerSchema).min(1)
+    answers: z.array(modeGuideAnswerSchema).min(1),
+    userId: optionalOwnedUserIdSchema
 });
 export const updateModeGuideSessionSchema = createModeGuideSessionSchema.partial();
 export const createEventTypeSchema = z.object({
     label: nonEmptyTrimmedString,
-    description: trimmedString.default("")
+    description: trimmedString.default(""),
+    userId: optionalOwnedUserIdSchema
 });
 export const updateEventTypeSchema = createEventTypeSchema.partial();
 export const createEmotionDefinitionSchema = z.object({
     label: nonEmptyTrimmedString,
     description: trimmedString.default(""),
-    category: trimmedString.default("")
+    category: trimmedString.default(""),
+    userId: optionalOwnedUserIdSchema
 });
 export const updateEmotionDefinitionSchema = createEmotionDefinitionSchema.partial();
 export const createTriggerReportSchema = z.object({
@@ -361,6 +384,7 @@ export const createTriggerReportSchema = z.object({
     modeOverlays: z.array(trimmedString).default([]),
     schemaLinks: z.array(trimmedString).default([]),
     modeTimeline: z.array(modeTimelineEntrySchema.omit({ id: true }).extend({ id: z.string().optional() })).default([]),
-    nextMoves: z.array(trimmedString).default([])
+    nextMoves: z.array(trimmedString).default([]),
+    userId: optionalOwnedUserIdSchema
 });
 export const updateTriggerReportSchema = createTriggerReportSchema.partial();

package/dist/server/repositories/activity-events.js

@@ -1,8 +1,45 @@
 import { randomUUID } from "node:crypto";
 import { getDatabase, runInTransaction } from "../db.js";
+import { getEntityOwner } from "./entity-ownership.js";
 import { recordEventLog } from "./event-log.js";
 import { activityEventSchema } from "../types.js";
+function resolveActivityOwner(row) {
+    if (row.entity_type === "task_run") {
+        const taskRunRow = getDatabase()
+            .prepare(`SELECT task_id FROM task_runs WHERE id = ?`)
+            .get(row.entity_id);
+        if (taskRunRow) {
+            const user = getEntityOwner("task", taskRunRow.task_id);
+            return { userId: user?.id ?? null, user };
+        }
+    }
+    if (row.entity_type === "work_block") {
+        const user = getEntityOwner("work_block_template", row.entity_id);
+        return { userId: user?.id ?? null, user };
+    }
+    if (row.entity_type === "system") {
+        const metadata = JSON.parse(row.metadata_json);
+        const correctedEntityType = typeof metadata.correctedEntityType === "string"
+            ? metadata.correctedEntityType
+            : null;
+        const correctedEntityId = typeof metadata.correctedEntityId === "string"
+            ? metadata.correctedEntityId
+            : null;
+        if (correctedEntityType && correctedEntityId) {
+            const mappedEntityType = correctedEntityType === "work_block"
+                ? "work_block_template"
+                : correctedEntityType;
+            const user = getEntityOwner(mappedEntityType, correctedEntityId);
+            return { userId: user?.id ?? null, user };
+        }
+    }
+    const rawEntityType = row.entity_type;
+    const mappedEntityType = rawEntityType === "work_block" ? "work_block_template" : rawEntityType;
+    const user = getEntityOwner(mappedEntityType, row.entity_id);
+    return { userId: user?.id ?? null, user };
+}
 function mapActivityEvent(row) {
+    const owner = resolveActivityOwner(row);
     return activityEventSchema.parse({
         id: row.id,
         entityType: row.entity_type,
@@ -13,7 +50,9 @@ function mapActivityEvent(row) {
         actor: row.actor,
         source: row.source,
         metadata: JSON.parse(row.metadata_json),
-        createdAt: row.created_at
+        createdAt: row.created_at,
+        userId: owner.userId,
+        user: owner.user
     });
 }
 export function recordActivityEvent(input, now = new Date()) {
@@ -80,9 +119,14 @@ export function listActivityEvents(filters = {}) {
        ORDER BY created_at DESC
        ${limitSql}`)
         .all(...params);
-    return rows.map(mapActivityEvent);
+    const events = rows.map(mapActivityEvent);
+    if (!filters.userIds || filters.userIds.length === 0) {
+        return events;
+    }
+    const allowed = new Set(filters.userIds);
+    return events.filter((event) => event.userId !== null && allowed.has(event.userId));
 }
-export function listActivityEventsForTask(taskId, limit = 25) {
+export function listActivityEventsForTask(taskId, limit = 25, userIds) {
     const rows = getDatabase()
         .prepare(`SELECT
          activity_events.id,
@@ -112,7 +156,12 @@ export function listActivityEventsForTask(taskId, limit = 25) {
        ORDER BY activity_events.created_at DESC
        LIMIT ?`)
         .all(taskId, taskId, limit);
-    return rows.map(mapActivityEvent);
+    const events = rows.map(mapActivityEvent);
+    if (!userIds || userIds.length === 0) {
+        return events;
+    }
+    const allowed = new Set(userIds);
+    return events.filter((event) => event.userId !== null && allowed.has(event.userId));
 }
 export function getActivityEventById(eventId) {
     const row = getDatabase()