@redaksjon/protokoll 0.0.12 → 0.0.13

package/dist/agentic/executor.js

@@ -12,6 +12,8 @@ const create = (reasoning, ctx)=>{
             resolvedEntities: new Map(),
             confidence: 0
         };
+        // Make resolvedEntities available to tools so they can avoid re-asking
+        ctx.resolvedEntities = state.resolvedEntities;
         const toolsUsed = [];
         const contextChanges = [];
         let iterations = 0;
@@ -98,7 +100,7 @@ Remember: preserve ALL content, only fix transcription errors.`;
                     logger.debug('Executing tool: %s', toolCall.name);
                     toolsUsed.push(toolCall.name);
                     try {
-                        var _result_data, _result_data1;
+                        var _result_data, _result_data_routingDecision, _result_data1, _result_data2, _result_data_project_routing, _result_data_project, _result_data3;
                         const result = await registry.executeTool(toolCall.name, toolCall.arguments);
                         // Format result for the model
                         const resultStr = JSON.stringify(result.data || {
@@ -112,40 +114,49 @@ Remember: preserve ALL content, only fix transcription errors.`;
                         });
                         logger.debug('Tool %s result: %s', toolCall.name, result.success ? 'success' : 'failed');
                         // Handle results that need user input
-                        if (result.needsUserInput && ctx.interactiveMode && ctx.interactiveInstance) {
-                            var _result_data2, _result_data3, _result_data4, _result_data5;
+                        // Check if interactive handler is available (not gated by interactiveMode flag)
+                        if (result.needsUserInput && ctx.interactiveInstance) {
+                            var _result_data4, _result_data5, _result_data6, _result_data7;
                             logger.info('Interactive: %s requires clarification', toolCall.name);
                             const termName = String(toolCall.arguments.name || toolCall.arguments.term || '');
                             const clarification = await ctx.interactiveInstance.handleClarification({
-                                type: ((_result_data2 = result.data) === null || _result_data2 === void 0 ? void 0 : _result_data2.clarificationType) || 'general',
-                                term: ((_result_data3 = result.data) === null || _result_data3 === void 0 ? void 0 : _result_data3.term) || termName,
+                                type: ((_result_data4 = result.data) === null || _result_data4 === void 0 ? void 0 : _result_data4.clarificationType) || 'general',
+                                term: ((_result_data5 = result.data) === null || _result_data5 === void 0 ? void 0 : _result_data5.term) || termName,
                                 context: result.userPrompt || '',
-                                suggestion: (_result_data4 = result.data) === null || _result_data4 === void 0 ? void 0 : _result_data4.suggestion,
-                                options: (_result_data5 = result.data) === null || _result_data5 === void 0 ? void 0 : _result_data5.options
+                                suggestion: (_result_data6 = result.data) === null || _result_data6 === void 0 ? void 0 : _result_data6.suggestion,
+                                options: (_result_data7 = result.data) === null || _result_data7 === void 0 ? void 0 : _result_data7.options
                             });
                             if (clarification.response) {
-                                var _result_data6;
+                                var _result_data8, _result_data9;
                                 state.resolvedEntities.set(termName, clarification.response);
                                 logger.info('Clarified: %s -> %s', termName, clarification.response);
-                                // Handle new project creation
-                                if (((_result_data6 = result.data) === null || _result_data6 === void 0 ? void 0 : _result_data6.clarificationType) === 'new_project' && clarification.response.trim()) {
-                                    const projectPath = clarification.response.trim();
-                                    // Only create if user provided a path (not just pressed Enter)
-                                    if (projectPath && projectPath !== termName) {
-                                        const projectId = termName.toLowerCase().replace(/\s+/g, '-');
+                                // Handle new project/term wizard response
+                                if (((_result_data8 = result.data) === null || _result_data8 === void 0 ? void 0 : _result_data8.clarificationType) === 'new_project' && clarification.additionalInfo) {
+                                    var _result_data10;
+                                    const wizardResult = clarification.additionalInfo;
+                                    const knownProjects = (_result_data10 = result.data) === null || _result_data10 === void 0 ? void 0 : _result_data10.knownProjects;
+                                    if (wizardResult.action === 'create') {
+                                        // CREATE NEW PROJECT
+                                        const projectName = wizardResult.projectName || termName;
+                                        const projectId = projectName.toLowerCase().replace(/\s+/g, '-');
+                                        const projectDestination = wizardResult.destination;
                                         const newProject = {
                                             id: projectId,
-                                            name: termName,
+                                            name: projectName,
                                             type: 'project',
-                                            description: `Auto-created from transcript mentioning "${termName}"`,
+                                            description: wizardResult.description || `Project for "${projectName}"`,
                                             classification: {
                                                 context_type: 'work',
                                                 explicit_phrases: [
-                                                    termName.toLowerCase()
-                                                ]
+                                                    termName.toLowerCase(),
+                                                    projectName.toLowerCase()
+                                                ].filter((v, i, a)=>a.indexOf(v) === i)
                                             },
                                             routing: {
-                                                destination: projectPath,
+                                                // Only include destination if explicitly provided - otherwise uses global default
+                                                ...projectDestination && {
+                                                    destination: projectDestination
+                                                },
                                                 structure: 'month',
                                                 filename_options: [
                                                     'date',
@@ -157,39 +168,431 @@ Remember: preserve ALL content, only fix transcription errors.`;
                                         };
                                         try {
                                             await ctx.contextInstance.saveEntity(newProject);
-                                            logger.info('Created new project: %s -> %s', termName, projectPath);
-                                            // Record the context change
+                                            await ctx.contextInstance.reload(); // Reload so subsequent searches find this entity
+                                            logger.info('Created new project: %s%s', projectName, projectDestination ? ` -> ${projectDestination}` : ' (using default destination)');
                                             contextChanges.push({
                                                 entityType: 'project',
                                                 entityId: projectId,
-                                                entityName: termName,
+                                                entityName: projectName,
                                                 action: 'created',
                                                 details: {
-                                                    destination: projectPath,
-                                                    routing: newProject.routing
+                                                    ...projectDestination && {
+                                                        destination: projectDestination
+                                                    },
+                                                    description: wizardResult.description,
+                                                    triggeredByTerm: termName
                                                 }
                                             });
-                                            // Update routing to use new project
-                                            state.routeDecision = {
-                                                projectId,
-                                                destination: {
-                                                    path: projectPath,
-                                                    structure: 'month'
+                                            // Update routing if destination was specified
+                                            if (projectDestination) {
+                                                state.routeDecision = {
+                                                    projectId,
+                                                    destination: {
+                                                        path: projectDestination,
+                                                        structure: 'month'
+                                                    },
+                                                    confidence: 1.0,
+                                                    signals: [
+                                                        {
+                                                            type: 'explicit_phrase',
+                                                            value: termName,
+                                                            weight: 1.0
+                                                        }
+                                                    ],
+                                                    reasoning: `User created new project "${projectName}" routing to ${projectDestination}`
+                                                };
+                                            }
+                                        } catch (error) {
+                                            logger.warn('Failed to save new project: %s', error);
+                                        }
+                                    } else if (wizardResult.action === 'link' && typeof wizardResult.linkedProjectIndex === 'number') {
+                                        // LINK TO EXISTING PROJECT
+                                        if (knownProjects && wizardResult.linkedProjectIndex < knownProjects.length) {
+                                            var _linkedProject_classification, _linkedProject_classification1, _linkedProject_routing, _linkedProject_routing1, _linkedProject_routing2;
+                                            const linkedProject = knownProjects[wizardResult.linkedProjectIndex];
+                                            // Add the term as an alias
+                                            const existingPhrases = ((_linkedProject_classification = linkedProject.classification) === null || _linkedProject_classification === void 0 ? void 0 : _linkedProject_classification.explicit_phrases) || [];
+                                            const updatedPhrases = [
+                                                ...existingPhrases,
+                                                termName.toLowerCase()
+                                            ].filter((v, i, a)=>a.indexOf(v) === i); // dedupe
+                                            const updatedProject = {
+                                                ...linkedProject,
+                                                type: 'project',
+                                                // Add term description to project notes if provided
+                                                notes: wizardResult.termDescription ? `${linkedProject.description || ''}\n\n${termName}: ${wizardResult.termDescription}`.trim() : linkedProject.description,
+                                                classification: {
+                                                    ...linkedProject.classification,
+                                                    context_type: ((_linkedProject_classification1 = linkedProject.classification) === null || _linkedProject_classification1 === void 0 ? void 0 : _linkedProject_classification1.context_type) || 'work',
+                                                    explicit_phrases: updatedPhrases
                                                 },
-                                                confidence: 1.0,
-                                                signals: [
-                                                    {
-                                                        type: 'explicit_phrase',
-                                                        value: termName,
-                                                        weight: 1.0
+                                                routing: {
+                                                    // Preserve existing destination (or omit if not set)
+                                                    ...((_linkedProject_routing = linkedProject.routing) === null || _linkedProject_routing === void 0 ? void 0 : _linkedProject_routing.destination) && {
+                                                        destination: linkedProject.routing.destination
+                                                    },
+                                                    structure: ((_linkedProject_routing1 = linkedProject.routing) === null || _linkedProject_routing1 === void 0 ? void 0 : _linkedProject_routing1.structure) || 'month',
+                                                    filename_options: ((_linkedProject_routing2 = linkedProject.routing) === null || _linkedProject_routing2 === void 0 ? void 0 : _linkedProject_routing2.filename_options) || [
+                                                        'date',
+                                                        'time'
+                                                    ]
+                                                }
+                                            };
+                                            try {
+                                                var _linkedProject_routing3;
+                                                await ctx.contextInstance.saveEntity(updatedProject);
+                                                await ctx.contextInstance.reload(); // Reload so subsequent searches find this entity
+                                                logger.info('Linked "%s" to project "%s"', termName, linkedProject.name);
+                                                contextChanges.push({
+                                                    entityType: 'project',
+                                                    entityId: linkedProject.id,
+                                                    entityName: linkedProject.name,
+                                                    action: 'updated',
+                                                    details: {
+                                                        addedAlias: termName,
+                                                        termDescription: wizardResult.termDescription,
+                                                        explicit_phrases: updatedPhrases
                                                     }
-                                                ],
-                                                reasoning: `User created new project "${termName}" routing to ${projectPath}`
+                                                });
+                                                // Update routing to use the linked project
+                                                if ((_linkedProject_routing3 = linkedProject.routing) === null || _linkedProject_routing3 === void 0 ? void 0 : _linkedProject_routing3.destination) {
+                                                    state.routeDecision = {
+                                                        projectId: linkedProject.id,
+                                                        destination: {
+                                                            path: linkedProject.routing.destination,
+                                                            structure: 'month'
+                                                        },
+                                                        confidence: 1.0,
+                                                        signals: [
+                                                            {
+                                                                type: 'explicit_phrase',
+                                                                value: termName,
+                                                                weight: 1.0
+                                                            }
+                                                        ],
+                                                        reasoning: `User linked "${termName}" to existing project "${linkedProject.name}"`
+                                                    };
+                                                }
+                                            } catch (error) {
+                                                logger.warn('Failed to update project with alias: %s', error);
+                                            }
+                                        }
+                                    } else if (wizardResult.action === 'term') {
+                                        var _wizardResult_createdProject;
+                                        // CREATE NEW TERM ENTITY
+                                        const termNameFinal = wizardResult.termName || termName;
+                                        const termId = termNameFinal.toLowerCase().replace(/\s+/g, '-');
+                                        // Get project IDs from indices
+                                        const projectIds = [];
+                                        if (wizardResult.termProjects && knownProjects) {
+                                            for (const idx of wizardResult.termProjects){
+                                                if (idx >= 0 && idx < knownProjects.length) {
+                                                    projectIds.push(knownProjects[idx].id);
+                                                }
+                                            }
+                                        }
+                                        // Handle nested project creation from term wizard
+                                        if (((_wizardResult_createdProject = wizardResult.createdProject) === null || _wizardResult_createdProject === void 0 ? void 0 : _wizardResult_createdProject.action) === 'create' && wizardResult.createdProject.projectName) {
+                                            const projectName = wizardResult.createdProject.projectName;
+                                            const projectId = projectName.toLowerCase().replace(/\s+/g, '-');
+                                            const projectDestination = wizardResult.createdProject.destination;
+                                            const newProject = {
+                                                id: projectId,
+                                                name: projectName,
+                                                type: 'project',
+                                                description: wizardResult.createdProject.description || `Project for "${projectName}"`,
+                                                classification: {
+                                                    context_type: 'work',
+                                                    explicit_phrases: [
+                                                        projectName.toLowerCase(),
+                                                        termNameFinal.toLowerCase()
+                                                    ].filter((v, i, a)=>a.indexOf(v) === i)
+                                                },
+                                                routing: {
+                                                    // Only include destination if explicitly provided - otherwise uses global default
+                                                    ...projectDestination && {
+                                                        destination: projectDestination
+                                                    },
+                                                    structure: 'month',
+                                                    filename_options: [
+                                                        'date',
+                                                        'time',
+                                                        'subject'
+                                                    ]
+                                                },
+                                                active: true
                                             };
+                                            try {
+                                                await ctx.contextInstance.saveEntity(newProject);
+                                                await ctx.contextInstance.reload(); // Reload so subsequent searches find this entity
+                                                logger.info('Created new project from term wizard: %s%s', projectName, projectDestination ? ` -> ${projectDestination}` : ' (using default destination)');
+                                                // Add the new project to the projectIds list for term association
+                                                projectIds.push(projectId);
+                                                contextChanges.push({
+                                                    entityType: 'project',
+                                                    entityId: projectId,
+                                                    entityName: projectName,
+                                                    action: 'created',
+                                                    details: {
+                                                        ...projectDestination && {
+                                                            destination: projectDestination
+                                                        },
+                                                        description: wizardResult.createdProject.description,
+                                                        createdForTerm: termNameFinal
+                                                    }
+                                                });
+                                                // Update routing to use the new project (if destination was specified)
+                                                if (projectDestination) {
+                                                    state.routeDecision = {
+                                                        projectId,
+                                                        destination: {
+                                                            path: projectDestination,
+                                                            structure: 'month'
+                                                        },
+                                                        confidence: 1.0,
+                                                        signals: [
+                                                            {
+                                                                type: 'explicit_phrase',
+                                                                value: termNameFinal,
+                                                                weight: 1.0
+                                                            }
+                                                        ],
+                                                        reasoning: `User created project "${projectName}" for term "${termNameFinal}"`
+                                                    };
+                                                }
+                                            } catch (error) {
+                                                logger.warn('Failed to save new project from term wizard: %s', error);
+                                            }
+                                        }
+                                        const newTerm = {
+                                            id: termId,
+                                            name: termNameFinal,
+                                            type: 'term',
+                                            expansion: wizardResult.termExpansion,
+                                            notes: wizardResult.termDescription,
+                                            projects: projectIds.length > 0 ? projectIds : undefined,
+                                            sounds_like: [
+                                                termName.toLowerCase()
+                                            ]
+                                        };
+                                        try {
+                                            await ctx.contextInstance.saveEntity(newTerm);
+                                            await ctx.contextInstance.reload(); // Reload so subsequent searches find this entity
+                                            logger.info('Created new term: %s (projects: %s)', termNameFinal, projectIds.length > 0 ? projectIds.join(', ') : 'none');
+                                            contextChanges.push({
+                                                entityType: 'term',
+                                                entityId: termId,
+                                                entityName: termNameFinal,
+                                                action: 'created',
+                                                details: {
+                                                    expansion: wizardResult.termExpansion,
+                                                    projects: projectIds,
+                                                    description: wizardResult.termDescription
+                                                }
+                                            });
+                                            // If term has associated projects and we haven't set routing yet, use the first one
+                                            if (projectIds.length > 0 && !state.routeDecision) {
+                                                // For newly created project, we already set routing above
+                                                // For existing projects, look them up
+                                                if (knownProjects) {
+                                                    var _primaryProject_routing;
+                                                    const primaryProject = knownProjects.find((p)=>p.id === projectIds[0]);
+                                                    if (primaryProject === null || primaryProject === void 0 ? void 0 : (_primaryProject_routing = primaryProject.routing) === null || _primaryProject_routing === void 0 ? void 0 : _primaryProject_routing.destination) {
+                                                        state.routeDecision = {
+                                                            projectId: primaryProject.id,
+                                                            destination: {
+                                                                path: primaryProject.routing.destination,
+                                                                structure: 'month'
+                                                            },
+                                                            confidence: 1.0,
+                                                            signals: [
+                                                                {
+                                                                    type: 'explicit_phrase',
+                                                                    value: termNameFinal,
+                                                                    weight: 1.0
+                                                                }
+                                                            ],
+                                                            reasoning: `User created term "${termNameFinal}" associated with project "${primaryProject.name}"`
+                                                        };
+                                                    }
+                                                }
+                                            }
                                         } catch (error) {
-                                            logger.warn('Failed to save new project: %s', error);
+                                            logger.warn('Failed to save new term: %s', error);
+                                        }
+                                    } else if (wizardResult.action === 'ignore' && wizardResult.ignoredTerm) {
+                                        // IGNORE - add term to ignore list so user won't be asked again
+                                        const ignoredTermName = wizardResult.ignoredTerm;
+                                        const ignoredId = ignoredTermName.toLowerCase().replace(/[^a-z0-9]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+                                        const newIgnored = {
+                                            id: ignoredId,
+                                            name: ignoredTermName,
+                                            type: 'ignored',
+                                            ignoredAt: new Date().toISOString()
+                                        };
+                                        try {
+                                            await ctx.contextInstance.saveEntity(newIgnored);
+                                            await ctx.contextInstance.reload();
+                                            logger.info('Added to ignore list: %s', ignoredTermName);
+                                            contextChanges.push({
+                                                entityType: 'ignored',
+                                                entityId: ignoredId,
+                                                entityName: ignoredTermName,
+                                                action: 'created',
+                                                details: {
+                                                    reason: 'User chose to ignore this term'
+                                                }
+                                            });
+                                        } catch (error) {
+                                            logger.warn('Failed to save ignored term: %s', error);
                                         }
                                     }
+                                // 'skip' action - do nothing
+                                }
+                                // Handle new person wizard response
+                                if (((_result_data9 = result.data) === null || _result_data9 === void 0 ? void 0 : _result_data9.clarificationType) === 'new_person' && clarification.additionalInfo) {
+                                    var _result_data11;
+                                    const personWizardResult = clarification.additionalInfo;
+                                    const knownProjects = (_result_data11 = result.data) === null || _result_data11 === void 0 ? void 0 : _result_data11.knownProjects;
+                                    if (personWizardResult.action === 'create') {
+                                        var _personWizardResult_createdProject;
+                                        let linkedProjectId;
+                                        // First, handle any nested project creation
+                                        if (((_personWizardResult_createdProject = personWizardResult.createdProject) === null || _personWizardResult_createdProject === void 0 ? void 0 : _personWizardResult_createdProject.action) === 'create' && personWizardResult.createdProject.projectName) {
+                                            const projectName = personWizardResult.createdProject.projectName;
+                                            const projectId = projectName.toLowerCase().replace(/\s+/g, '-');
+                                            const projectDestination = personWizardResult.createdProject.destination;
+                                            const newProject = {
+                                                id: projectId,
+                                                name: projectName,
+                                                type: 'project',
+                                                description: personWizardResult.createdProject.description || `Project for "${projectName}"`,
+                                                classification: {
+                                                    context_type: 'work',
+                                                    explicit_phrases: [
+                                                        projectName.toLowerCase()
+                                                    ]
+                                                },
+                                                routing: {
+                                                    // Only include destination if explicitly provided - otherwise uses global default
+                                                    ...projectDestination && {
+                                                        destination: projectDestination
+                                                    },
+                                                    structure: 'month',
+                                                    filename_options: [
+                                                        'date',
+                                                        'time',
+                                                        'subject'
+                                                    ]
+                                                },
+                                                active: true
+                                            };
+                                            try {
+                                                await ctx.contextInstance.saveEntity(newProject);
+                                                await ctx.contextInstance.reload(); // Reload so subsequent searches find this entity
+                                                logger.info('Created new project from person wizard: %s%s', projectName, projectDestination ? ` -> ${projectDestination}` : ' (using default destination)');
+                                                linkedProjectId = projectId;
+                                                contextChanges.push({
+                                                    entityType: 'project',
+                                                    entityId: projectId,
+                                                    entityName: projectName,
+                                                    action: 'created',
+                                                    details: {
+                                                        ...projectDestination && {
+                                                            destination: projectDestination
+                                                        },
+                                                        description: personWizardResult.createdProject.description,
+                                                        createdForPerson: personWizardResult.personName
+                                                    }
+                                                });
+                                                // Update routing to use the new project (if destination was specified)
+                                                if (projectDestination) {
+                                                    state.routeDecision = {
+                                                        projectId,
+                                                        destination: {
+                                                            path: projectDestination,
+                                                            structure: 'month'
+                                                        },
+                                                        confidence: 1.0,
+                                                        signals: [
+                                                            {
+                                                                type: 'explicit_phrase',
+                                                                value: projectName,
+                                                                weight: 1.0
+                                                            }
+                                                        ],
+                                                        reasoning: `User created project "${projectName}" for person "${personWizardResult.personName}"`
+                                                    };
+                                                }
+                                            } catch (error) {
+                                                logger.warn('Failed to save new project from person wizard: %s', error);
+                                            }
+                                        } else if (typeof personWizardResult.linkedProjectIndex === 'number' && knownProjects) {
+                                            // User linked to existing project
+                                            if (personWizardResult.linkedProjectIndex < knownProjects.length) {
+                                                var _linkedProject_routing4;
+                                                const linkedProject = knownProjects[personWizardResult.linkedProjectIndex];
+                                                linkedProjectId = linkedProject.id;
+                                                // Update routing to use the linked project
+                                                if ((_linkedProject_routing4 = linkedProject.routing) === null || _linkedProject_routing4 === void 0 ? void 0 : _linkedProject_routing4.destination) {
+                                                    state.routeDecision = {
+                                                        projectId: linkedProject.id,
+                                                        destination: {
+                                                            path: linkedProject.routing.destination,
+                                                            structure: 'month'
+                                                        },
+                                                        confidence: 1.0,
+                                                        signals: [
+                                                            {
+                                                                type: 'explicit_phrase',
+                                                                value: personWizardResult.personName || termName,
+                                                                weight: 1.0
+                                                            }
+                                                        ],
+                                                        reasoning: `User linked person "${personWizardResult.personName}" to project "${linkedProject.name}"`
+                                                    };
+                                                }
+                                            }
+                                        }
+                                        // Now save the person
+                                        const personName = personWizardResult.personName || termName;
+                                        const personId = personName.toLowerCase().replace(/\s+/g, '-');
+                                        const newPerson = {
+                                            id: personId,
+                                            name: personName,
+                                            type: 'person',
+                                            organization: personWizardResult.organization,
+                                            notes: personWizardResult.notes,
+                                            projects: linkedProjectId ? [
+                                                linkedProjectId
+                                            ] : [],
+                                            sounds_like: [
+                                                termName.toLowerCase()
+                                            ]
+                                        };
+                                        try {
+                                            await ctx.contextInstance.saveEntity(newPerson);
+                                            await ctx.contextInstance.reload(); // Reload so subsequent searches find this entity
+                                            logger.info('Created new person: %s (org: %s, project: %s)', personName, personWizardResult.organization || 'none', linkedProjectId || 'none');
+                                            // Update resolved entities with correct name
+                                            state.resolvedEntities.set(termName, personName);
+                                            contextChanges.push({
+                                                entityType: 'person',
+                                                entityId: personId,
+                                                entityName: personName,
+                                                action: 'created',
+                                                details: {
+                                                    organization: personWizardResult.organization,
+                                                    linkedProject: linkedProjectId,
+                                                    notes: personWizardResult.notes,
+                                                    heardAs: termName
+                                                }
+                                            });
+                                        } catch (error) {
+                                            logger.warn('Failed to save new person: %s', error);
+                                        }
+                                    }
+                                // 'skip' action - do nothing
                                 }
                             }
                         }
@@ -197,8 +600,37 @@ Remember: preserve ALL content, only fix transcription errors.`;
                         if ((_result_data = result.data) === null || _result_data === void 0 ? void 0 : _result_data.person) {
                             state.resolvedEntities.set(result.data.person.name, result.data.suggestion);
                         }
-                        if ((_result_data1 = result.data) === null || _result_data1 === void 0 ? void 0 : _result_data1.destination) {
-                            state.routeDecision = result.data;
+                        // Capture routing from route_note tool
+                        if ((_result_data1 = result.data) === null || _result_data1 === void 0 ? void 0 : (_result_data_routingDecision = _result_data1.routingDecision) === null || _result_data_routingDecision === void 0 ? void 0 : _result_data_routingDecision.destination) {
+                            const routingDecision = result.data.routingDecision;
+                            state.routeDecision = {
+                                projectId: routingDecision.projectId,
+                                destination: routingDecision.destination,
+                                confidence: routingDecision.confidence || 1.0,
+                                signals: routingDecision.signals,
+                                reasoning: routingDecision.reasoning || 'Determined by route_note tool'
+                            };
+                        }
+                        // Capture routing from lookup_project when project has routing config
+                        if (((_result_data2 = result.data) === null || _result_data2 === void 0 ? void 0 : _result_data2.found) && ((_result_data3 = result.data) === null || _result_data3 === void 0 ? void 0 : (_result_data_project = _result_data3.project) === null || _result_data_project === void 0 ? void 0 : (_result_data_project_routing = _result_data_project.routing) === null || _result_data_project_routing === void 0 ? void 0 : _result_data_project_routing.destination)) {
+                            const project = result.data.project;
+                            state.routeDecision = {
+                                projectId: project.id,
+                                destination: {
+                                    path: project.routing.destination,
+                                    structure: project.routing.structure || 'month'
+                                },
+                                confidence: 1.0,
+                                signals: [
+                                    {
+                                        type: 'explicit_phrase',
+                                        value: project.name,
+                                        weight: 1.0
+                                    }
+                                ],
+                                reasoning: `Matched project "${project.name}" with routing to ${project.routing.destination}`
+                            };
+                            logger.debug('Captured routing from project lookup: %s -> %s', project.name, project.routing.destination);
                         }
                     } catch (error) {
                         logger.error('Tool execution failed', {