[{"_1":2,"_178":-5,"_179":-5},"loaderData",{"_3":4,"_92":93},"root",{"_5":6,"_35":36,"_65":66},"ctx",{"_7":8,"_23":-5,"_24":25,"_26":27,"_28":20,"_29":20,"_30":20,"_31":32,"_33":20,"_34":20},"auth",{"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20,"_21":22},"sessionClaims","sessionId","sessionStatus","userId","actor","orgId","orgRole","orgSlug","orgPermissions","factorVerificationAge","isAuthenticated",false,"tokenType","session_token","user","preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","notificationCount",0,"flagDenols","isTeamOrgMember","ENV",{"_37":38,"_39":40,"_41":42,"_43":44,"_45":46,"_47":48,"_49":50,"_51":52,"_53":54,"_55":56,"_57":58,"_59":60,"_61":62,"_63":64},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","VAL_RUNTIME_NAME","prod","RENDER_GIT_COMMIT","adff7c7aeabd218801703bcdcaac3a168cba1c7b","RENDER_GIT_BRANCH","main","CLERK_PUBLISHABLE_KEY","pk_live_Y2xlcmsudmFsLnRvd24k","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","API_URL","https://api.val.town","clerkState",{"_67":68},"__internal_clerk_state",{"_69":70,"_71":46,"_72":73,"_74":73,"_75":20,"_76":73,"_77":73,"_78":73,"_79":73,"_80":81,"_90":20,"_91":20},"__clerk_ssr_state",{"_21":22,"_9":-5,"_10":-5,"_11":-5,"_12":-5,"_13":-5,"_14":-5,"_15":-5,"_16":-5,"_17":-5,"_18":-5,"_19":20},"__publishableKey","__proxyUrl","","__domain","__isSatellite","__signInUrl","__signUpUrl","__afterSignInUrl","__afterSignUpUrl","__clerk_debug",{"_82":20,"_19":20,"_83":73,"_84":85,"_86":73,"_87":46,"_88":20,"_89":73},"isSignedIn","proxyUrl","reason","session-token-and-uat-missing","message","publishableKey","isSatellite","domain","__telemetryDisabled","__telemetryDebug","routes/embed.x.$handle.$name.$",{"_94":95,"_96":97,"_98":99,"_100":101,"_153":154,"_175":176,"_177":-5},"handle","lightweight","name","stainlessTodoSweeper","path","backend/controllers/todoSaveController.ts","project",{"_102":103,"_96":97,"_104":105,"_106":-5,"_107":20,"_108":109,"_110":-5,"_111":-5,"_12":112,"_113":114,"_115":116,"_117":-5,"_118":-5,"_119":32,"_14":120,"_121":122,"_123":122,"_124":125,"_126":125,"_127":125,"_128":122,"_129":122,"_23":130,"_133":134,"_136":137,"_152":20},"id","0e73aa44-eb39-11f0-ad09-42dde27851f2","createdAt",["D",1767729073647],"deletedAt","legacyEnvVars","privacy","public","description","imageUrl","449588c0-326d-11f0-a80c-0741f032ef73","pinnedFileId","019b94dd-0e2e-7454-ae2d-536264a931a8","pinPreview",true,"pinMigrated","screenshotVersion","likeCount","65f1d616-c14b-419c-88a0-e2308cab925b","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm",{"_94":95,"_131":132},"profileImageUrl","https://imagedelivery.net/iHX6Ovru0O7AjmyT5yZRoA/aa289d5e-22db-464f-ba88-7288e2183b00/square512","org",{"_94":95,"_135":132,"_12":112},"avatar","branch",{"_138":139,"_96":44,"_102":140,"_141":103,"_142":143,"_144":145,"_146":109,"_147":148,"_149":120,"_150":97,"_151":95},"version",10,"0e785760-eb39-11f0-ad09-42dde27851f2","projectId","forkedBranchId","1cb4d65c-b360-11f0-bc6f-0224a6c84d84","forkedBranchVersion",262,"forkedProjectPrivacy","forkedProjectId","1cb13b14-b360-11f0-bc6f-0224a6c84d84","forkedProjectOrgId","projectName","userHandle","isOwned","file",{"_102":155,"_96":156,"_157":158,"_159":160,"_161":140,"_162":139,"_163":116,"_104":164,"_138":165,"_166":167,"_168":169,"_170":20,"_171":-5,"_98":172},"e8345cc8-ecac-11f0-8fab-42dde27851f2","todoSaveController.ts","fileId","019b94dd-0e2e-7454-ae2c-6a1cde7c1963","parentId","019b94dd-0e2e-7454-ae2c-6ce419d5794b","branchId","branchVersion","latest",["D",1767888782266],5,"fileType","script","content","import * as notionService from '../services/notion/index.ts';\nimport * as blobService from '../services/blobService.ts';\nimport * as aiService from '../services/aiService.ts';\nimport { discoverRelationProperties, getDatabasePageIds, getPropertyType } from '../services/notion/relations.ts';\nimport { getStatusPropertyInfo, type StatusPropertyInfo } from '../services/notion/databases.ts';\nimport { findUserByName, findUserById } from '../services/notion/users.ts';\nimport type { TodoSaveResult, ReducedNotionBlock, RelationPropertyMapping, RelationMatchResult, ResolvedOwner, SummaryResult } from '../../shared/types.ts';\nimport { extractFirstEmoji } from '../utils/emojiUtils.ts';\nimport { getBlockBackgroundColor } from '../utils/blockUtils.ts';\nimport { mapReducedBlockToProperties, extractPageIdFromUrl, reduceNotionBlock } from '../utils/notionUtils.ts';\nimport { extractBlockIdFromKey } from '../utils/blobUtils.ts';\nimport { disambiguateProjectsByGroup, type ProjectWithDates } from '../utils/projectUtils.ts';\nimport { TODOS_PROPERTIES } from '../utils/notionConfig.ts';\nimport { traverseParentsForOwnerCandidates, validateOwnerClaim, type PageNameEntry } from '../utils/contextUtils.ts';\n\n/**\n * Enhance Notion API errors with helpful context about property type mismatches\n */\nfunction enhanceNotionError(error: string): string {\n // Check if this looks like a property type validation error\n if (error.includes('body.properties.') && error.includes('should be')) {\n // Extract property name from error like \"body.properties.Due date.date should be...\"\n const propertyMatch = error.match(/body\\.properties\\.([^.]+)/);\n const propertyName = propertyMatch?.[1] || 'unknown';\n\n return `Property type mismatch for \"${propertyName}\". ` +\n `Check that the column type in your Notion database matches what the code expects. ` +\n `Original error: ${error}`;\n }\n\n // Check for validation errors\n if (error.includes('validation') || error.includes('Invalid')) {\n return `Notion API validation error. This may indicate a property type mismatch ` +\n `between your database schema and the code. Original error: ${error}`;\n }\n\n return error;\n}\n\n// Type for project with all details needed for matching\ntype ProjectWithDetails = {\n id: string;\n name: string;\n groupName: string | null;\n dateStart: string | null;\n dateEnd: string | null;\n lastEditedTime: string;\n};\n\n/**\n * Page name entry for fuzzy matching\n */\ntype PageNameEntry = {\n id: string;\n name: string;\n nameLower: string; // Pre-computed lowercase for matching\n};\n\n/**\n * Relation schema cache - initialized once per save operation\n * Contains discovered relations and their target database page IDs\n */\ntype RelationCache = {\n // Discovered relations from todos database schema\n relations: RelationPropertyMapping[];\n // Map of targetDatabaseId -> Set of page IDs in that database\n targetDbPageIds: Map>;\n // Project details for AI matching (only for project relations)\n projectsWithDetails: Map;\n // Page names for fuzzy matching (only for configured fuzzyMatch relations)\n // Map of propertyName -> array of page name entries\n fuzzyMatchNames: Map;\n // Owner property configuration (detected at runtime)\n ownerPropertyType: 'people' | 'relation' | null;\n ownerTargetDbId?: string; // Only populated if owner is relation type\n // Status property configuration for checkbox sync (detected at runtime)\n statusInfo: StatusPropertyInfo | null;\n};\n\n/**\n * Initialize relation cache by discovering relations from todos database schema\n *\n * @param todosDbId - Todos database ID\n * @returns Relation cache or null if discovery fails\n */\nasync function initializeRelationCache(todosDbId: string): Promise {\n // Discover relation properties from todos database schema\n const relationsResult = await discoverRelationProperties(todosDbId);\n\n if (!relationsResult.success) {\n console.warn(`Failed to discover relations: ${relationsResult.error}`);\n return null;\n }\n\n const cache: RelationCache = {\n relations: relationsResult.relations,\n targetDbPageIds: new Map(),\n projectsWithDetails: new Map(),\n fuzzyMatchNames: new Map(),\n ownerPropertyType: null,\n ownerTargetDbId: undefined,\n statusInfo: null\n };\n\n // Detect Owner property type for runtime owner resolution\n if (TODOS_PROPERTIES.owner) {\n const ownerTypeResult = await getPropertyType(todosDbId, TODOS_PROPERTIES.owner);\n if (ownerTypeResult.success && ownerTypeResult.propertyType) {\n if (ownerTypeResult.propertyType === 'people') {\n cache.ownerPropertyType = 'people';\n } else if (ownerTypeResult.propertyType === 'relation') {\n cache.ownerPropertyType = 'relation';\n cache.ownerTargetDbId = ownerTypeResult.relationTargetDbId || undefined;\n\n // If Owner is a relation, ensure we have fuzzy match names for its target DB\n if (cache.ownerTargetDbId) {\n const namesResult = await notionService.getDatabasePageNames(cache.ownerTargetDbId);\n if (namesResult.success && !cache.fuzzyMatchNames.has(TODOS_PROPERTIES.owner)) {\n const entries: PageNameEntry[] = namesResult.pages.map(p => ({\n id: p.id,\n name: p.name,\n nameLower: p.name.toLowerCase()\n }));\n cache.fuzzyMatchNames.set(TODOS_PROPERTIES.owner, entries);\n console.log(`Owner relation names loaded: ${entries.map(e => e.name).join(', ')}`);\n }\n }\n }\n console.log(`Owner property \"${TODOS_PROPERTIES.owner}\" is type: ${cache.ownerPropertyType}`);\n }\n }\n\n // Detect Status property configuration for checkbox sync\n if (TODOS_PROPERTIES.status) {\n const statusResult = await getStatusPropertyInfo(todosDbId, TODOS_PROPERTIES.status);\n if (statusResult.success && statusResult.data) {\n cache.statusInfo = statusResult.data;\n const doneInfo = statusResult.data.doneName ? ` (done=\"${statusResult.data.doneName}\")` : '';\n console.log(`Status property \"${TODOS_PROPERTIES.status}\" is type: ${statusResult.data.type}${doneInfo}`);\n } else {\n console.warn(`⚠ Status property \"${TODOS_PROPERTIES.status}\": ${statusResult.error}`);\n }\n }\n\n // For each relation, fetch the target database's page IDs\n for (const relation of relationsResult.relations) {\n // Get page IDs from target database\n const pageIdsResult = await getDatabasePageIds(relation.targetDatabaseId);\n if (pageIdsResult.success) {\n cache.targetDbPageIds.set(\n relation.targetDatabaseId,\n new Set(pageIdsResult.pageIds)\n );\n }\n\n // For project relations, also fetch full details for AI matching\n if (relation.isProjectRelation) {\n const detailsResult = await notionService.getProjectsWithDetails(relation.targetDatabaseId);\n if (detailsResult.success) {\n cache.projectsWithDetails.set(relation.targetDatabaseId, detailsResult.projects);\n }\n }\n }\n\n // Load page names for fuzzy match relations\n const fuzzyMatchConfig = TODOS_PROPERTIES.fuzzyMatch || [];\n for (const propertyName of fuzzyMatchConfig) {\n // Find the relation in discovered schema\n const relation = relationsResult.relations.find(r => r.propertyName === propertyName);\n\n if (!relation) {\n console.warn(`⚠ Fuzzy match relation \"${propertyName}\" not found in database schema - skipping`);\n continue;\n }\n\n // Fetch page names from target database\n const namesResult = await notionService.getDatabasePageNames(relation.targetDatabaseId);\n if (namesResult.success) {\n const entries: PageNameEntry[] = namesResult.pages.map(p => ({\n id: p.id,\n name: p.name,\n nameLower: p.name.toLowerCase()\n }));\n cache.fuzzyMatchNames.set(propertyName, entries);\n }\n }\n\n // Log discovered relations\n console.log(`Discovered ${cache.relations.length} relation(s):`);\n for (const rel of cache.relations) {\n const pageCount = cache.targetDbPageIds.get(rel.targetDatabaseId)?.size || 0;\n const fuzzyCount = cache.fuzzyMatchNames.get(rel.propertyName)?.length;\n const extras = [\n rel.isProjectRelation ? 'project' : null,\n rel.isSingleSelect ? 'limit:1' : null,\n fuzzyCount !== undefined ? `fuzzy: ${fuzzyCount} names` : null\n ].filter(Boolean).join(', ');\n console.log(` - ${rel.propertyName} → ${pageCount} pages${extras ? ` (${extras})` : ''}`);\n }\n\n return cache;\n}\n\n/**\n * Match a block to relations dynamically\n *\n * Strategies (in priority order):\n * 1. Explicit mention mapping - @mention a page, check its parent DB against relation targets\n * 2. Contextual mapping - Source page's DB matches a relation target\n * 3. Fuzzy name matching - Check todo text and parent blocks for name matches (configured relations)\n * 4. AI fuzzy matching (project relations only) - Semantic matching with date disambiguation\n * 5. Parent block traversal (project relations only) - Apply 1-4 to parent blocks\n *\n * @param blockData - Reduced block with enriched link_mentions\n * @param cache - Relation cache\n * @returns Array of relation match results\n */\nasync function matchBlockToRelations(\n blockData: ReducedNotionBlock,\n cache: RelationCache | null\n): Promise {\n if (!cache || cache.relations.length === 0) {\n return [];\n }\n\n const results: RelationMatchResult[] = [];\n const matchedMentionPageIds = new Set();\n\n // Strategy 1: Explicit mention mapping\n // Check each link mention's parentDatabaseId against relation targets\n for (const linkMention of blockData.link_mentions || []) {\n if (!linkMention.pageId || !linkMention.parentDatabaseId) continue;\n\n // Find which relation this mention's parent DB matches\n for (const relation of cache.relations) {\n if (linkMention.parentDatabaseId === relation.targetDatabaseId) {\n // Verify the page exists in the target database\n const targetPageIds = cache.targetDbPageIds.get(relation.targetDatabaseId);\n if (targetPageIds?.has(linkMention.pageId)) {\n // This mention matches this relation\n let existingResult = results.find(r => r.propertyName === relation.propertyName);\n if (!existingResult) {\n existingResult = { propertyName: relation.propertyName, pageIds: [], matchType: 'mention', isSingleSelect: relation.isSingleSelect };\n results.push(existingResult);\n }\n if (!existingResult.pageIds.includes(linkMention.pageId)) {\n existingResult.pageIds.push(linkMention.pageId);\n }\n matchedMentionPageIds.add(linkMention.pageId);\n }\n break; // A mention can only match one relation\n }\n }\n }\n\n // Strategy 2: Contextual mapping (source page's DB)\n if (blockData.source_page_database_id) {\n for (const relation of cache.relations) {\n if (blockData.source_page_database_id === relation.targetDatabaseId) {\n // Source page is in this relation's target DB\n const sourcePageId = extractPageIdFromUrl(blockData.page_url || '');\n if (sourcePageId) {\n // Check if we already have matches for this relation\n let existingResult = results.find(r => r.propertyName === relation.propertyName);\n if (!existingResult) {\n existingResult = { propertyName: relation.propertyName, pageIds: [], matchType: 'contextual', isSingleSelect: relation.isSingleSelect };\n results.push(existingResult);\n }\n if (!existingResult.pageIds.includes(sourcePageId)) {\n existingResult.pageIds.push(sourcePageId);\n }\n }\n }\n }\n }\n\n // Strategy 3: Fuzzy name matching (configured relations only)\n // Check todo text and parent blocks for names matching pages in configured relations\n if (cache.fuzzyMatchNames.size > 0) {\n const alreadyMatchedRelations = new Set(results.map(r => r.propertyName));\n const fuzzyResults = await fuzzyMatchRelations(blockData, cache, alreadyMatchedRelations);\n results.push(...fuzzyResults);\n }\n\n // Strategy 4 & 5: AI matching + Parent traversal (project relations only)\n for (const relation of cache.relations) {\n if (!relation.isProjectRelation) continue;\n\n // Skip if we already have matches for this relation from strategies 1-3\n const existingResult = results.find(r => r.propertyName === relation.propertyName);\n if (existingResult && existingResult.pageIds.length > 0) {\n continue;\n }\n\n const projectsWithDetails = cache.projectsWithDetails.get(relation.targetDatabaseId) || [];\n const projectPageIds = cache.targetDbPageIds.get(relation.targetDatabaseId) || new Set();\n\n if (projectsWithDetails.length === 0) continue;\n\n // Try AI matching on the block itself\n let matchedProjectIds = await matchBlockToProjects(\n blockData,\n projectPageIds,\n projectsWithDetails\n );\n\n // Strategy 4: Parent traversal if no match\n if (matchedProjectIds.length === 0 && blockData.parent_id) {\n matchedProjectIds = await traverseParentsForProjectMatch(\n blockData.parent_id,\n blockData.date_mentions,\n projectPageIds,\n projectsWithDetails\n );\n }\n\n if (matchedProjectIds.length > 0) {\n results.push({\n propertyName: relation.propertyName,\n pageIds: matchedProjectIds,\n matchType: 'ai',\n isSingleSelect: relation.isSingleSelect\n });\n }\n }\n\n return results;\n}\n\n/**\n * Traverse parent blocks to find project matches\n * Used only for project-type relations\n *\n * @param startParentId - Starting parent block ID\n * @param todoDueDates - Todo's due dates (used for date disambiguation)\n * @param projectPageIds - Set of known project page IDs\n * @param projectsWithDetails - Array of projects with details for AI matching\n * @returns Array of matched project IDs\n */\nasync function traverseParentsForProjectMatch(\n startParentId: string,\n todoDueDates: string[] | undefined,\n projectPageIds: Set,\n projectsWithDetails: ProjectWithDetails[]\n): Promise {\n let currentParentId: string | null = startParentId;\n const maxDepth = 5; // Prevent infinite loops\n\n for (let depth = 0; depth < maxDepth && currentParentId; depth++) {\n // Fetch parent block from Notion\n const parentResult = await notionService.getBlock(currentParentId);\n if (!parentResult.success || !parentResult.data) {\n break;\n }\n\n const parentBlock = parentResult.data;\n\n // Reduce parent block and apply matching strategies 1-3\n const parentReduced = reduceNotionBlock(parentBlock);\n\n const parentMatches = await matchBlockToProjects(\n {\n ...parentReduced,\n date_mentions: todoDueDates // Use todo's due date\n },\n projectPageIds,\n projectsWithDetails\n );\n\n if (parentMatches.length > 0) {\n return parentMatches;\n }\n\n // Move up to next parent (if it's a block, not a page)\n const parentParent = (parentBlock as any).parent;\n currentParentId = parentParent?.type === 'block_id' ? parentParent.block_id : null;\n }\n\n return [];\n}\n\n/**\n * Find fuzzy name matches in text, grouped by the matching word\n * Returns a map of word → matching page entries\n * This allows disambiguation only when the SAME word matches multiple contacts\n *\n * Uses EXACT word matching (not substring) to avoid false positives like:\n * - \"is\" matching \"chrIS pollara\"\n * - \"also\" matching \"als\" in \"Jillian Als\"\n *\n * @param text - Text to search (todo content or parent block content)\n * @param names - Array of page name entries to match against\n * @returns Map of word → matching page entries\n */\nfunction findFuzzyMatches(text: string, names: PageNameEntry[]): Map {\n const textLower = text.toLowerCase();\n const textWords = textLower.split(/\\s+/).filter(w => w.length >= 2); // Skip very short words\n\n const matchesByWord = new Map();\n\n for (const textWord of textWords) {\n for (const entry of names) {\n const nameWords = entry.nameLower.split(/\\s+/);\n\n // Check if any text word EXACTLY matches any name word\n // \"alex\" matches \"alex johnson\" ✓\n // \"is\" does NOT match \"chris pollara\" ✓\n const matched = nameWords.some(nameWord =>\n nameWord.length >= 2 && textWord === nameWord\n );\n\n if (matched) {\n if (!matchesByWord.has(textWord)) {\n matchesByWord.set(textWord, []);\n }\n // Avoid duplicates within same word\n const wordMatches = matchesByWord.get(textWord)!;\n if (!wordMatches.some(e => e.id === entry.id)) {\n wordMatches.push(entry);\n }\n }\n }\n }\n\n return matchesByWord;\n}\n\n/**\n * Apply fuzzy name matching for configured relations\n * Checks todo text and parent blocks for name matches\n * Groups matches by source word - only disambiguates when same word matches multiple contacts\n *\n * @param blockData - Reduced block data\n * @param cache - Relation cache with fuzzyMatchNames\n * @param alreadyMatchedRelations - Set of relation property names already matched by other strategies\n * @returns Array of relation match results\n */\nasync function fuzzyMatchRelations(\n blockData: ReducedNotionBlock,\n cache: RelationCache,\n alreadyMatchedRelations: Set\n): Promise {\n const results: RelationMatchResult[] = [];\n\n // Process each configured fuzzy match relation\n for (const [propertyName, names] of cache.fuzzyMatchNames.entries()) {\n // Skip if already matched by explicit mention or contextual mapping\n if (alreadyMatchedRelations.has(propertyName)) {\n continue;\n }\n\n if (names.length === 0) continue;\n\n // Build search text from todo and preceding heading (for context)\n const searchText = [\n blockData.todo_string,\n blockData.preceding_heading\n ].filter(Boolean).join(' ');\n\n // First, check the combined search text\n let matchesByWord = findFuzzyMatches(searchText, names);\n\n // If no match in todo text, check parent blocks\n if (matchesByWord.size === 0 && blockData.parent_id) {\n matchesByWord = await traverseParentsForFuzzyMatch(blockData.parent_id, names);\n }\n\n if (matchesByWord.size === 0) continue;\n\n // Process each word's matches separately\n // This allows \"Alex to talk to Jordan\" to match BOTH Alex and Jordan\n const allPageIds: string[] = [];\n\n for (const [word, wordMatches] of matchesByWord) {\n if (wordMatches.length === 1) {\n // Single match for this word - use it\n allPageIds.push(wordMatches[0].id);\n } else if (wordMatches.length > 1) {\n // True ambiguity - same word matches multiple contacts (e.g., \"John\" matches John Smith and John Doe)\n const disambiguatedId = await aiService.disambiguateFuzzyMatch(\n searchText,\n wordMatches.map(m => ({ id: m.id, name: m.name }))\n );\n if (disambiguatedId) {\n allPageIds.push(disambiguatedId);\n }\n }\n }\n\n // Deduplicate and add to results\n const uniqueIds = [...new Set(allPageIds)];\n if (uniqueIds.length > 0) {\n // Look up relation config for isSingleSelect\n const relationConfig = cache.relations.find(r => r.propertyName === propertyName);\n results.push({\n propertyName,\n pageIds: uniqueIds,\n matchType: 'mention',\n isSingleSelect: relationConfig?.isSingleSelect ?? false\n });\n }\n }\n\n return results;\n}\n\n/**\n * Traverse parent blocks to find fuzzy name matches\n *\n * @param startParentId - Starting parent block ID\n * @param names - Array of page name entries to match against\n * @returns Map of word → matching page entries (empty map if none found)\n */\nasync function traverseParentsForFuzzyMatch(\n startParentId: string,\n names: PageNameEntry[]\n): Promise> {\n let currentParentId: string | null = startParentId;\n const maxDepth = 5;\n\n for (let depth = 0; depth < maxDepth && currentParentId; depth++) {\n const parentResult = await notionService.getBlock(currentParentId);\n if (!parentResult.success || !parentResult.data) {\n break;\n }\n\n const parentBlock = parentResult.data;\n const parentReduced = reduceNotionBlock(parentBlock);\n\n const matchesByWord = findFuzzyMatches(parentReduced.todo_string, names);\n if (matchesByWord.size > 0) {\n return matchesByWord;\n }\n\n // Move up to next parent\n const parentParent = (parentBlock as any).parent;\n currentParentId = parentParent?.type === 'block_id' ? parentParent.block_id : null;\n }\n\n return new Map();\n}\n\n/**\n * Helper to match a block to projects using strategies 1, 2, and 3\n *\n * @param blockData - Block data with link_mentions, page_url, todo_string, and date_mentions\n * @param projectPageIds - Set of known project page IDs\n * @param projectsWithDetails - Array of projects with names, dates for AI matching\n * @returns Array of matched project IDs\n */\nasync function matchBlockToProjects(\n blockData: { link_mentions?: Array<{ url: string }>; page_url?: string; todo_string: string; date_mentions?: string[] },\n projectPageIds: Set,\n projectsWithDetails: ProjectWithDetails[]\n): Promise {\n const matchedProjectIds: string[] = [];\n\n // Strategy 1: Check link_mentions for project references\n if (projectPageIds.size > 0 && blockData.link_mentions?.length) {\n for (const link of blockData.link_mentions) {\n const mentionedPageId = extractPageIdFromUrl(link.url);\n if (mentionedPageId) {\n const normalizedId = mentionedPageId.replace(/-/g, '');\n if (projectPageIds.has(normalizedId)) {\n matchedProjectIds.push(normalizedId);\n }\n }\n }\n }\n\n // Strategy 2: Check if page_url is a project\n if (matchedProjectIds.length === 0 && blockData.page_url && projectPageIds.size > 0) {\n const sourcePageId = extractPageIdFromUrl(blockData.page_url);\n if (sourcePageId) {\n const normalizedId = sourcePageId.replace(/-/g, '');\n if (projectPageIds.has(normalizedId)) {\n matchedProjectIds.push(normalizedId);\n }\n }\n }\n\n // Strategy 3: AI fuzzy matching (with group disambiguation)\n if (matchedProjectIds.length === 0 && projectsWithDetails.length > 0) {\n const aiMatch = await aiService.matchTodoToProject(\n blockData.todo_string,\n projectsWithDetails\n );\n\n if (aiMatch) {\n if (aiMatch.startsWith('GROUP:')) {\n // AI matched a group, not a specific project - disambiguate using due date\n const groupName = aiMatch.substring(6);\n const todoDueDate = blockData.date_mentions?.[0] || null;\n\n const result = disambiguateProjectsByGroup(\n groupName,\n projectsWithDetails,\n todoDueDate\n );\n\n if (result.needsAiDisambiguation && result.candidates) {\n // Multiple overlapping date ranges - use AI to pick\n const bestProjectId = await aiService.disambiguateOverlappingProjects(\n blockData.todo_string,\n result.candidates\n );\n matchedProjectIds.push(bestProjectId);\n } else if (result.projectId) {\n matchedProjectIds.push(result.projectId);\n }\n } else {\n // AI matched a specific project - trust its semantic choice\n matchedProjectIds.push(aiMatch);\n }\n }\n }\n\n return matchedProjectIds;\n}\n\n/**\n * Try to resolve owner directly from heading (pre-AI deterministic check)\n *\n * If the heading matches a name in the owner database, returns the resolved owner\n * without needing AI involvement. This ensures heading-based ownership is deterministic.\n *\n * @param heading - The preceding heading text (e.g., \"### Alex\")\n * @param cache - Relation cache with owner property info\n * @returns Resolved owner or null if no match\n */\nasync function tryResolveOwnerFromHeading(\n heading: string | null,\n cache: RelationCache | null\n): Promise<{ resolved: ResolvedOwner; ownerName: string } | null> {\n if (!heading || !cache || !cache.ownerPropertyType) {\n return null;\n }\n\n // Clean heading (remove markdown heading markers)\n const cleanHeading = heading.replace(/^#+\\s*/, '').trim().toLowerCase();\n if (!cleanHeading) {\n return null;\n }\n\n console.log(`tryResolveOwnerFromHeading: checking heading \"${cleanHeading}\" against ${cache.ownerPropertyType} type`);\n\n if (cache.ownerPropertyType === 'people') {\n // Check workspace users\n const userResult = await findUserByName(cleanHeading);\n if (userResult.success && userResult.user) {\n console.log(`tryResolveOwnerFromHeading: matched heading to user \"${userResult.user.name}\"`);\n return {\n resolved: { type: 'people', value: [{ id: userResult.user.id }] },\n ownerName: userResult.user.name\n };\n }\n } else if (cache.ownerPropertyType === 'relation') {\n // Check pages in owner relation's target database\n const ownerNames = cache.fuzzyMatchNames.get(TODOS_PROPERTIES.owner);\n if (ownerNames && ownerNames.length > 0) {\n // Look for exact or close match\n for (const entry of ownerNames) {\n // Exact match\n if (entry.nameLower === cleanHeading) {\n console.log(`tryResolveOwnerFromHeading: exact match to \"${entry.name}\"`);\n return {\n resolved: { type: 'relation', value: [{ id: entry.id }] },\n ownerName: entry.name\n };\n }\n // Any word match (heading \"Bryce\" matches \"Steel: Bryce Sullivan\")\n const entryWords = entry.nameLower.split(/\\s+/);\n if (entryWords.some(word => word === cleanHeading)) {\n console.log(`tryResolveOwnerFromHeading: word match to \"${entry.name}\"`);\n return {\n resolved: { type: 'relation', value: [{ id: entry.id }] },\n ownerName: entry.name\n };\n }\n }\n } else {\n console.log(`tryResolveOwnerFromHeading: no owner names loaded for \"${TODOS_PROPERTIES.owner}\"`);\n }\n }\n\n console.log(`tryResolveOwnerFromHeading: no match found for heading \"${cleanHeading}\"`);\n return null;\n}\n\n/**\n * Resolve owner from AI summary to appropriate property format\n *\n * Handles both Person and Relation property types:\n * - Person: Match against @mentions (have user IDs) or workspace users\n * - Relation: Match against pages in target database\n *\n * @param summaryResult - Structured result from AI summary generation\n * @param reducedBlock - Block data with people_mentions\n * @param cache - Relation cache with owner property info\n * @returns Resolved owner or null if no match\n */\nasync function resolveOwner(\n summaryResult: SummaryResult,\n reducedBlock: ReducedNotionBlock,\n cache: RelationCache | null\n): Promise {\n // No owner name extracted from summary\n if (!summaryResult.ownerName) {\n console.log('resolveOwner: No ownerName in summaryResult');\n return null;\n }\n\n // No cache or owner property not detected\n if (!cache || !cache.ownerPropertyType) {\n console.log(`resolveOwner: No cache (${!cache}) or ownerPropertyType (${cache?.ownerPropertyType})`);\n return null;\n }\n\n console.log(`resolveOwner: ownerName=\"${summaryResult.ownerName}\", ownerSource=\"${summaryResult.ownerSource}\", propertyType=\"${cache.ownerPropertyType}\"`);\n\n const ownerNameLower = summaryResult.ownerName.toLowerCase().trim();\n\n if (cache.ownerPropertyType === 'people') {\n // Try to match against existing @mentions first (they have user IDs)\n if (reducedBlock.people_mentions && reducedBlock.people_mentions.length > 0) {\n for (const mention of reducedBlock.people_mentions) {\n if (!mention.name) continue;\n\n const mentionNameLower = mention.name.toLowerCase();\n // Check for exact or partial match\n if (mentionNameLower === ownerNameLower ||\n mentionNameLower.startsWith(ownerNameLower) ||\n mentionNameLower.split(' ')[0] === ownerNameLower) {\n return {\n type: 'people',\n value: [{ id: mention.id }]\n };\n }\n }\n }\n\n // Try author if ownerSource is 'heading' and no @mention match\n // (Author is often the owner when they're taking notes about someone else)\n if (summaryResult.ownerSource === 'heading' && reducedBlock.author?.id) {\n console.log(`resolveOwner: Checking author (id=${reducedBlock.author.id}) for heading-based owner`);\n // Look up author's name from cached workspace users (author.name is null in blob)\n const authorLookup = await findUserById(reducedBlock.author.id);\n console.log(`resolveOwner: Author lookup result: success=${authorLookup.success}, user=${authorLookup.user?.name || 'null'}, error=${authorLookup.error}`);\n if (authorLookup.success && authorLookup.user) {\n const authorNameLower = authorLookup.user.name.toLowerCase();\n const matches = authorNameLower === ownerNameLower ||\n authorNameLower.startsWith(ownerNameLower) ||\n authorNameLower.split(' ')[0] === ownerNameLower;\n console.log(`resolveOwner: Author name \"${authorLookup.user.name}\" vs ownerName \"${summaryResult.ownerName}\" - match=${matches}`);\n if (matches) {\n return {\n type: 'people',\n value: [{ id: reducedBlock.author.id }]\n };\n }\n }\n } else {\n console.log(`resolveOwner: Skipping author check (ownerSource=${summaryResult.ownerSource}, author.id=${reducedBlock.author?.id})`);\n }\n\n // Try workspace users lookup\n console.log(`resolveOwner: Trying findUserByName(\"${summaryResult.ownerName}\")`);\n const userResult = await findUserByName(summaryResult.ownerName);\n console.log(`resolveOwner: findUserByName result: success=${userResult.success}, user=${userResult.user?.name || 'null'}, error=${userResult.error}`);\n if (userResult.success && userResult.user) {\n return {\n type: 'people',\n value: [{ id: userResult.user.id }]\n };\n }\n\n // No match found for person type\n console.warn(`resolveOwner: Could not resolve owner \"${summaryResult.ownerName}\" to a Notion user`);\n return null;\n\n } else if (cache.ownerPropertyType === 'relation') {\n // Match against pages in the owner relation's target database\n const ownerNames = cache.fuzzyMatchNames.get(TODOS_PROPERTIES.owner);\n if (!ownerNames || ownerNames.length === 0) {\n console.warn('No page names loaded for Owner relation target database');\n return null;\n }\n\n // Find matching page(s)\n const matches: PageNameEntry[] = [];\n for (const entry of ownerNames) {\n // Check if owner name matches any word in page name (or vice versa)\n const entryWords = entry.nameLower.split(/\\s+/);\n const ownerWords = ownerNameLower.split(/\\s+/);\n\n // Exact match\n if (entry.nameLower === ownerNameLower) {\n matches.push(entry);\n continue;\n }\n\n // Partial match: any owner word matches any page name word\n const hasMatch = ownerWords.some(ow =>\n entryWords.some(ew => ew === ow || ew.startsWith(ow) || ow.startsWith(ew))\n );\n if (hasMatch) {\n matches.push(entry);\n }\n }\n\n if (matches.length === 0) {\n console.warn(`Could not resolve owner \"${summaryResult.ownerName}\" to a page in Owner relation`);\n return null;\n }\n\n if (matches.length === 1) {\n return {\n type: 'relation',\n value: [{ id: matches[0].id }]\n };\n }\n\n // Multiple matches - use AI disambiguation\n const disambiguatedId = await aiService.disambiguateFuzzyMatch(\n reducedBlock.todo_string,\n matches.map(m => ({ id: m.id, name: m.name }))\n );\n\n if (disambiguatedId) {\n return {\n type: 'relation',\n value: [{ id: disambiguatedId }]\n };\n }\n\n // Fallback to first match if disambiguation fails\n return {\n type: 'relation',\n value: [{ id: matches[0].id }]\n };\n }\n\n return null;\n}\n\n/**\n * Process todo save: Read blobs and sync to Notion database\n * Creates new pages or updates existing pages based on timestamp comparison\n *\n * Status handling:\n * - CREATE: Sets Status to \"Not started\" for new pages\n * - UPDATE: Does NOT modify Status (preserves user changes)\n */\nexport async function processTodoSave(): Promise {\n // Get database ID from environment\n const databaseId = Deno.env.get('TODOS_DB_ID');\n\n if (!databaseId) {\n return {\n success: false,\n totalBlobs: 0,\n pagesCreated: 0,\n pagesUpdated: 0,\n pagesSkipped: 0,\n pagesFailed: 0,\n failures: [],\n error: \"Missing TODOS_DB_ID environment variable\",\n details: \"Set TODOS_DB_ID to the Notion database ID where todos should be saved\"\n };\n }\n\n\n // Initialize relation cache - auto-discovers all relations from todos database schema\n const relationCache = await initializeRelationCache(databaseId);\n\n // List all todo blobs\n const blobsResult = await blobService.listBlocksByCategory('todo');\n\n if (!blobsResult.success || !blobsResult.keys) {\n return {\n success: false,\n totalBlobs: 0,\n pagesCreated: 0,\n pagesUpdated: 0,\n pagesSkipped: 0,\n pagesFailed: 0,\n failures: [],\n error: \"Failed to list blobs\",\n details: blobsResult.error || undefined\n };\n }\n\n const blobKeys = blobsResult.keys;\n\n let pagesCreated = 0;\n let pagesUpdated = 0;\n let pagesSkipped = 0;\n let pagesFailed = 0;\n const failures: Array<{ blockId: string; error: string }> = [];\n\n // Process each blob\n for (const key of blobKeys) {\n const blockId = extractBlockIdFromKey(key);\n\n try {\n // Get blob content\n const blobContentResult = await blobService.getBlockFromBlob('todo', blockId);\n\n if (!blobContentResult.success || !blobContentResult.data) {\n throw new Error(`Failed to get blob content: ${blobContentResult.error}`);\n }\n\n const reducedBlock: ReducedNotionBlock = blobContentResult.data;\n\n // OPTIMIZATION: Skip if already synced\n if (reducedBlock.sync_metadata?.synced === true) {\n pagesSkipped++;\n continue;\n }\n\n // NOTE: No validation needed here - all blobs are guaranteed valid\n // Validation happens during search phase (todoController.ts)\n // Only blocks with people_mentions AND date_mentions are saved to blob storage\n\n // Dynamic relation matching - handles all relations including projects\n // Strategies: 1) Explicit mentions, 2) Contextual, 3) AI matching, 4) Parent traversal\n const relationMatches = await matchBlockToRelations(reducedBlock, relationCache);\n\n // Generate AI-interpreted v2 todo\n // Gather context from block data and relation matches\n let matchedProjectName: string | null = null;\n const matchedContactNames: string[] = [];\n\n // Get project name from relation matches\n if (TODOS_PROPERTIES.projects && relationCache) {\n const projectMatch = relationMatches.find(r => r.propertyName === TODOS_PROPERTIES.projects);\n if (projectMatch && projectMatch.pageIds.length > 0) {\n const projectId = projectMatch.pageIds[0];\n // Look up project name in cache\n for (const [, projects] of relationCache.projectsWithDetails) {\n const project = projects.find(p => p.id === projectId);\n if (project) {\n matchedProjectName = project.name;\n break;\n }\n }\n }\n }\n\n // Get ALL contact names from fuzzy match relations (supports multiple contacts)\n const fuzzyMatchRelationNames = TODOS_PROPERTIES.fuzzyMatch || [];\n if (fuzzyMatchRelationNames.length > 0 && relationCache) {\n for (const relationName of fuzzyMatchRelationNames) {\n const contactMatch = relationMatches.find(r => r.propertyName === relationName);\n if (contactMatch && contactMatch.pageIds.length > 0) {\n // Look up ALL contact names in cache\n const names = relationCache.fuzzyMatchNames.get(relationName);\n if (names) {\n for (const contactId of contactMatch.pageIds) {\n const contact = names.find(n => n.id === contactId);\n if (contact && !matchedContactNames.includes(contact.name)) {\n matchedContactNames.push(contact.name);\n }\n }\n }\n }\n }\n }\n\n // =======================================================================\n // OWNER RESOLUTION (see backend/utils/contextUtils.ts for full documentation)\n // =======================================================================\n // Priority: 1. Heading match → 2. Contacts → 3. @mentions → 4. Parent blocks\n // AI only suggests owner; we validate claims against actual context.\n // If NO candidates exist anywhere, owner stays null (prevents hallucination).\n // =======================================================================\n\n // Step 1: PRE-AI CHECK - Try to resolve owner directly from heading (deterministic)\n console.log(`Owner resolution for block: heading=\"${reducedBlock.preceding_heading || 'none'}\", contacts=[${matchedContactNames.join(', ')}]`);\n const headingOwnerResult = await tryResolveOwnerFromHeading(\n reducedBlock.preceding_heading || null,\n relationCache\n );\n\n // Step 2: Check if there are any valid owner candidates from the block itself\n let hasOwnerCandidates =\n headingOwnerResult !== null ||\n matchedContactNames.length > 0 ||\n (reducedBlock.people_mentions?.length ?? 0) > 0;\n\n // Step 3: If no candidates in block, check parent blocks\n let parentOwnerCandidates: Array<{ name: string; source: string; id?: string }> = [];\n if (!hasOwnerCandidates && reducedBlock.parent_id && relationCache) {\n // Get owner names for parent traversal\n const ownerNames = relationCache.fuzzyMatchNames.get(TODOS_PROPERTIES.owner) || [];\n parentOwnerCandidates = await traverseParentsForOwnerCandidates(\n reducedBlock.parent_id,\n ownerNames as PageNameEntry[]\n );\n if (parentOwnerCandidates.length > 0) {\n hasOwnerCandidates = true;\n console.log(`Found owner candidates in parent blocks: ${parentOwnerCandidates.map(c => c.name).join(', ')}`);\n }\n }\n\n const summaryResult = await aiService.generateSummary({\n todoString: reducedBlock.todo_string,\n precedingHeading: reducedBlock.preceding_heading || null,\n peopleMentions: reducedBlock.people_mentions || [],\n dateMentions: reducedBlock.date_mentions || [],\n matchedProject: matchedProjectName,\n matchedContacts: matchedContactNames,\n sourcePage: null // Could extract from page_url but keeping simple for now\n });\n\n // Step 4: Resolve owner based on candidates found\n let resolvedOwner: ResolvedOwner | null = null;\n\n if (!hasOwnerCandidates) {\n // No owner candidates anywhere - leave owner null to prevent AI hallucination\n console.log('No owner candidates (heading/contacts/mentions/parents) - skipping owner resolution');\n } else if (headingOwnerResult) {\n // Heading matched an owner - use it directly (most reliable, deterministic)\n resolvedOwner = headingOwnerResult.resolved;\n console.log(`Owner resolved from heading: \"${headingOwnerResult.ownerName}\"`);\n } else if (parentOwnerCandidates.length > 0) {\n // Found candidates in parent blocks - use first one\n const parentCandidate = parentOwnerCandidates[0];\n if (parentCandidate.id && relationCache?.ownerPropertyType === 'relation') {\n resolvedOwner = { type: 'relation', value: [{ id: parentCandidate.id }] };\n console.log(`Owner resolved from parent block: \"${parentCandidate.name}\"`);\n } else if (parentCandidate.id && relationCache?.ownerPropertyType === 'people') {\n resolvedOwner = { type: 'people', value: [{ id: parentCandidate.id }] };\n console.log(`Owner resolved from parent @mention: \"${parentCandidate.name}\"`);\n }\n } else if (summaryResult.ownerName) {\n // Step 5: POST-AI VALIDATION - Verify AI's claim against actual context\n const isValidClaim = validateOwnerClaim(\n summaryResult.ownerName,\n summaryResult.ownerSource,\n reducedBlock.preceding_heading || null,\n matchedContactNames,\n reducedBlock.people_mentions || []\n );\n\n if (isValidClaim) {\n // AI's determination is valid - resolve it\n resolvedOwner = await resolveOwner(summaryResult, reducedBlock, relationCache);\n } else {\n // AI claimed a source but name doesn't match - reject\n console.warn(`Rejecting AI owner \"${summaryResult.ownerName}\" (source: ${summaryResult.ownerSource}) - doesn't match actual context`);\n resolvedOwner = null;\n }\n }\n\n // Log final owner result\n if (resolvedOwner) {\n console.log(`Final owner: type=${resolvedOwner.type}, id=${resolvedOwner.value[0]?.id}`);\n } else {\n console.log(`Final owner: null`);\n }\n\n // Map to Notion properties with dynamic relation matches, resolved owner, and status info\n const properties = mapReducedBlockToProperties(reducedBlock, relationMatches, summaryResult.summary, resolvedOwner, relationCache?.statusInfo);\n\n // Extract emoji from todo_string for page icon\n const emoji = extractFirstEmoji(reducedBlock.todo_string);\n const icon = emoji ? { type: \"emoji\", emoji: emoji } : undefined;\n\n // OPTIMIZATION: Use cached page ID if available (fallback to old field name for existing blobs)\n const cachedPageId = reducedBlock.sync_metadata?.target_page_id || reducedBlock.sync_metadata?.notion_page_id;\n let pageId: string | null = null;\n\n if (cachedPageId) {\n // We have a cached page ID - update directly without query\n const updateResult = await notionService.updateNotionPage(cachedPageId, properties, icon);\n\n if (updateResult.success) {\n pagesUpdated++;\n pageId = cachedPageId;\n } else if (updateResult.error?.includes('archived')) {\n // Page was archived - clear cache and skip (user intentionally archived it)\n const projectName = key.split('--')[0];\n const fullKey = `${projectName}--todo--${blockId}`;\n await blobService.updateBlobSyncMetadata(fullKey, {\n synced: true, // Mark synced to prevent retry\n target_page_id: undefined, // Clear cached ID\n archived: true // Flag as archived\n });\n pagesSkipped++;\n continue;\n } else {\n throw new Error(`Failed to update page: ${enhanceNotionError(updateResult.error || 'Unknown error')}`);\n }\n } else {\n // No cached page ID - query database to check if page exists\n const existingPageResult = await notionService.queryDatabaseByBlockId(databaseId, blockId);\n\n if (!existingPageResult.success) {\n throw new Error(`Failed to query database: ${existingPageResult.error}`);\n }\n\n if (existingPageResult.data) {\n // Page exists but we don't have cached ID - just cache it, don't update\n // This handles race conditions where another sync just created the page\n pageId = existingPageResult.data.id;\n pagesSkipped++;\n } else {\n // Page doesn't exist - create new\n const createResult = await notionService.createNotionPage(databaseId, properties, icon);\n\n if (createResult.success) {\n pagesCreated++;\n pageId = createResult.data?.id || null;\n\n // Add callout if source block has children\n if (pageId && reducedBlock.has_children && reducedBlock.block_url) {\n const calloutResult = await notionService.appendHasChildrenCallout(pageId, reducedBlock.block_url);\n if (!calloutResult.success) {\n console.warn(`⚠ Failed to add children callout: ${calloutResult.error}`);\n }\n }\n\n // Set block background color on first sync\n // (Only on create, not update, to avoid infinite sync loop)\n const bgColor = getBlockBackgroundColor();\n if (bgColor) {\n const colorResult = await notionService.updateBlockColor(blockId, bgColor);\n if (!colorResult.success) {\n console.warn(`⚠ Failed to set block color: ${colorResult.error}`);\n }\n }\n } else {\n throw new Error(`Failed to create page: ${enhanceNotionError(createResult.error || 'Unknown error')}`);\n }\n }\n }\n\n // Mark blob as synced on success\n if (pageId) {\n const projectName = key.split('--')[0];\n const fullKey = `${projectName}--todo--${blockId}`;\n\n const updateMetadataResult = await blobService.updateBlobSyncMetadata(fullKey, {\n synced: true,\n target_page_id: pageId\n });\n\n if (!updateMetadataResult.success) {\n console.warn(`⚠ Failed to update sync metadata: ${updateMetadataResult.error}`);\n }\n }\n } catch (err: any) {\n pagesFailed++;\n failures.push({\n blockId: blockId,\n error: err.message\n });\n }\n }\n\n return {\n success: true,\n totalBlobs: blobKeys.length,\n pagesCreated,\n pagesUpdated,\n pagesSkipped,\n pagesFailed,\n failures\n };\n}\n","deleted","label",[173,174,156],"backend","controllers","permalink","https://www.val.town/x/lightweight/stainlessTodoSweeper/code/backend/controllers/todoSaveController.ts","extension","actionData","errors"]