titan-agent 6.3.5 → 6.4.0

package/dist/agent/autoSkillGen.js

@@ -1,14 +1,15 @@
 #!/usr/bin/env node
 import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from "fs";
 import { join } from "path";
-import { homedir } from "os";
 import { createHash } from "crypto";
 import { getRecentTrajectories, getSequenceSignature, countMatchingTrajectories } from "./trajectoryLogger.js";
 import { classifyTaskType } from "../memory/learning.js";
 import { loadConfig } from "../config/config.js";
 import logger from "../utils/logger.js";
+import { TITAN_SKILLS_DIR } from "../utils/constants.js";
+import { processTrajectoryForLearningReview, renderLearningPatternGuidance } from "./learningCurator.js";
 const COMPONENT = "AutoSkillGen";
-const SKILLS_DIR = join(homedir(), ".titan", "workspace", "skills");
+const SKILLS_DIR = TITAN_SKILLS_DIR;
 const MIN_SUCCESSES = 3;
 function skillHash(taskType, toolSequence) {
   return createHash("md5").update(`${taskType}:${toolSequence.join(",")}`).digest("hex").slice(0, 8);
@@ -19,6 +20,24 @@ function skillDirName(taskType, toolSequence) {
 function skillPath(taskType, toolSequence) {
   return join(SKILLS_DIR, skillDirName(taskType, toolSequence), "SKILL.md");
 }
+function frontmatterArray(values) {
+  return `[${values.map((v) => JSON.stringify(v)).join(", ")}]`;
+}
+function parseFrontmatterArray(value) {
+  if (!value) return [];
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return [];
+  return trimmed.slice(1, -1).split(",").map((v) => v.trim().replace(/^["']|["']$/g, "")).filter(Boolean);
+}
+function parseFrontmatterScalar(fm, key) {
+  const match = fm.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+  return match?.[1]?.trim() ?? "";
+}
+function parseFrontmatterNumber(fm, key) {
+  const raw = parseFrontmatterScalar(fm, key);
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
 function shouldGenerateSkill(trajectory) {
   if (!trajectory.success || trajectory.toolSequence.length < 2) return false;
   const path = skillPath(trajectory.taskType, trajectory.toolSequence);
@@ -28,10 +47,7 @@ function shouldGenerateSkill(trajectory) {
 }
 async function generateSkillContent(trajectory) {
   try {
-    const config = loadConfig();
-    const aliases = config.agent.modelAliases;
-    const fastModel = aliases?.fast || "ollama/qwen3.5:cloud";
-    const llmContent = await generateSkillWithLLM(trajectory, fastModel);
+    const llmContent = await generateSkillWithLLM(trajectory, resolveSkillGenerationModel());
     if (llmContent && llmContent.length > 200) {
       logger.info(COMPONENT, `LLM-enhanced skill generated (${llmContent.length} chars) for ${trajectory.taskType}`);
       return llmContent;
@@ -41,6 +57,11 @@ async function generateSkillContent(trajectory) {
   }
   return generateSkillTemplate(trajectory);
 }
+function resolveSkillGenerationModel() {
+  const config = loadConfig();
+  const agent = config.agent;
+  return agent.modelAliases?.fast || agent.modelAliases?.reasoning || agent.model || "fast";
+}
 async function generateSkillWithLLM(trajectory, model) {
   const { chat } = await import("../providers/router.js");
   const matchingTrajectories = getRecentTrajectories(50, {
@@ -84,6 +105,11 @@ description: <one-line description>
 version: 1.0.0
 author: TITAN AutoSkill
 category: auto-generated
+taskType: ${trajectory.taskType}
+toolSequence: ${frontmatterArray(trajectory.toolSequence)}
+successCount: ${matchingTrajectories.length}
+avgRounds: ${avgRounds}
+generatedAt: <ISO timestamp>
 ---
 
 Keep it concise \u2014 under 60 lines total. No filler.`;
@@ -113,6 +139,11 @@ description: Auto-generated skill for ${trajectory.taskType} tasks using ${traje
 version: 1.0.0
 author: TITAN AutoSkill
 category: auto-generated
+taskType: ${trajectory.taskType}
+toolSequence: ${frontmatterArray(trajectory.toolSequence)}
+successCount: ${matchingTrajectories.length}
+avgRounds: ${avgRounds}
+generatedAt: ${(/* @__PURE__ */ new Date()).toISOString()}
 ---
 
 # ${trajectory.taskType} Task Pattern
@@ -170,22 +201,23 @@ function findMatchingSkills(message, taskType) {
         const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
         if (!fmMatch) continue;
         const fm = fmMatch[1];
-        const descMatch = fm.match(/description:\s*(.+)/);
-        const description = descMatch?.[1] || "";
-        if (!dir.includes(taskType) && !description.toLowerCase().includes(taskType)) continue;
+        const description = parseFrontmatterScalar(fm, "description");
+        const skillTaskType = parseFrontmatterScalar(fm, "taskType") || taskType;
+        if (skillTaskType !== taskType && !dir.includes(taskType) && !description.toLowerCase().includes(taskType)) continue;
         const toolMatches = content.match(/\*\*(\w+)\*\*/g);
-        const toolSequence = toolMatches ? toolMatches.map((m) => m.replace(/\*\*/g, "")).filter((t) => !["Success", "Average", "Generated", "When"].includes(t)) : [];
+        const legacyToolSequence = toolMatches ? toolMatches.map((m) => m.replace(/\*\*/g, "")).filter((t) => !["Success", "Average", "Generated", "When"].includes(t)) : [];
+        const toolSequence = parseFrontmatterArray(parseFrontmatterScalar(fm, "toolSequence"));
         const successMatch = content.match(/(\d+) successful runs/);
         const roundsMatch = content.match(/Average rounds.*?(\d+)/);
         results.push({
           name: dir,
           description,
-          taskType,
-          toolSequence,
+          taskType: skillTaskType,
+          toolSequence: toolSequence.length > 0 ? toolSequence : legacyToolSequence,
           triggerPatterns: [taskType],
-          successCount: successMatch ? parseInt(successMatch[1]) : 0,
-          avgRounds: roundsMatch ? parseInt(roundsMatch[1]) : 0,
-          generatedAt: ""
+          successCount: parseFrontmatterNumber(fm, "successCount") || (successMatch ? parseInt(successMatch[1]) : 0),
+          avgRounds: parseFrontmatterNumber(fm, "avgRounds") || (roundsMatch ? parseInt(roundsMatch[1]) : 0),
+          generatedAt: parseFrontmatterScalar(fm, "generatedAt")
         });
       } catch {
       }
@@ -197,11 +229,16 @@ function findMatchingSkills(message, taskType) {
 function getSkillGuidance(message) {
   const taskType = classifyTaskType(message);
   const skills = findMatchingSkills(message, taskType);
-  if (skills.length === 0) return null;
+  const learningPatternGuidance = renderLearningPatternGuidance(taskType);
+  if (skills.length === 0) return learningPatternGuidance;
   const best = skills.sort((a, b) => b.successCount - a.successCount)[0];
-  return `For similar ${best.taskType} tasks, a proven approach: ${best.toolSequence.join(" \u2192 ")} (${best.successCount} successful runs, ~${best.avgRounds} rounds). Auto-generated from past trajectories.`;
+  const skillGuidance = `For similar ${best.taskType} tasks, a proven approach: ${best.toolSequence.join(" \u2192 ")} (${best.successCount} successful runs, ~${best.avgRounds} rounds). Auto-generated from past trajectories.`;
+  return learningPatternGuidance ? `${skillGuidance}
+
+${learningPatternGuidance}` : skillGuidance;
 }
 function processTrajectoryForSkills(trajectory) {
+  processTrajectoryForLearningReview(trajectory);
   if (shouldGenerateSkill(trajectory)) {
     saveGeneratedSkill(trajectory).catch((err) => {
       logger.warn(COMPONENT, `Auto-skill generation failed: ${err.message}`);
@@ -213,6 +250,7 @@ export {
   generateSkillContent,
   getSkillGuidance,
   processTrajectoryForSkills,
+  resolveSkillGenerationModel,
   saveGeneratedSkill,
   shouldGenerateSkill
 };

package/dist/agent/autoSkillGen.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/agent/autoSkillGen.ts"],"sourcesContent":["/**\n * TITAN — Auto-Skill Generation from Trajectories\n *\n * When a task type + tool sequence succeeds 3+ times, auto-generates a SKILL.md\n * at ~/.titan/workspace/skills/auto-{taskType}-{hash}/SKILL.md.\n *\n * On future tasks, matching skills are surfaced as guidance in the system prompt.\n * Inspired by Hermes skill_manager_tool.py.\n */\nimport { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';\nimport { join, basename } from 'path';\nimport { homedir } from 'os';\nimport { createHash } from 'crypto';\nimport { getRecentTrajectories, getSequenceSignature, countMatchingTrajectories, type TaskTrajectory } from './trajectoryLogger.js';\nimport { classifyTaskType } from '../memory/learning.js';\nimport { loadConfig } from '../config/config.js';\nimport logger from '../utils/logger.js';\n\nconst COMPONENT = 'AutoSkillGen';\nconst SKILLS_DIR = join(homedir(), '.titan', 'workspace', 'skills');\nconst MIN_SUCCESSES = 3; // Minimum successful runs before generating a skill\n\n// ── Types ─────────────────────────────────────────────────────────\nexport interface GeneratedSkill {\n    name: string;\n    description: string;\n    taskType: string;\n    toolSequence: string[];\n    triggerPatterns: string[];\n    successCount: number;\n    avgRounds: number;\n    generatedAt: string;\n}\n\n// ── Helpers ───────────────────────────────────────────────────────\nfunction skillHash(taskType: string, toolSequence: string[]): string {\n    return createHash('md5')\n        .update(`${taskType}:${toolSequence.join(',')}`)\n        .digest('hex')\n        .slice(0, 8);\n}\n\nfunction skillDirName(taskType: string, toolSequence: string[]): string {\n    return `auto-${taskType}-${skillHash(taskType, toolSequence)}`;\n}\n\nfunction skillPath(taskType: string, toolSequence: string[]): string {\n    return join(SKILLS_DIR, skillDirName(taskType, toolSequence), 'SKILL.md');\n}\n\n// ── Core Functions ────────────────────────────────────────────────\n\n/**\n * Check if a skill should be generated for this trajectory.\n * Returns true if 3+ successful trajectories exist with the same\n * taskType + toolSequence and no auto-skill already exists.\n */\nexport function shouldGenerateSkill(trajectory: TaskTrajectory): boolean {\n    if (!trajectory.success || trajectory.toolSequence.length < 2) return false;\n\n    // Check if auto-skill already exists\n    const path = skillPath(trajectory.taskType, trajectory.toolSequence);\n    if (existsSync(path)) return false;\n\n    // Count matching successful trajectories\n    const count = countMatchingTrajectories(trajectory.taskType, trajectory.toolSequence);\n    return count >= MIN_SUCCESSES;\n}\n\n/**\n * Generate a SKILL.md file content from a trajectory using the LLM.\n *\n * Competitive gap fix (Hermes): Hermes generates rich skills with edge cases,\n * verification steps, and failure modes via LLM. TITAN was template-only.\n * Now we send the trajectory to the `fast` model alias for rich generation,\n * with automatic fallback to the template if the LLM call fails.\n */\nexport async function generateSkillContent(trajectory: TaskTrajectory): Promise<string> {\n    // Try LLM-enhanced generation first\n    try {\n        const config = loadConfig();\n        const aliases = (config.agent as Record<string, unknown>).modelAliases as Record<string, string> | undefined;\n        const fastModel = aliases?.fast || 'ollama/qwen3.5:cloud';\n\n        const llmContent = await generateSkillWithLLM(trajectory, fastModel);\n        if (llmContent && llmContent.length > 200) {\n            logger.info(COMPONENT, `LLM-enhanced skill generated (${llmContent.length} chars) for ${trajectory.taskType}`);\n            return llmContent;\n        }\n    } catch (err) {\n        logger.warn(COMPONENT, `LLM skill generation failed, falling back to template: ${(err as Error).message}`);\n    }\n\n    // Fallback: template-based generation (original behavior)\n    return generateSkillTemplate(trajectory);\n}\n\n/**\n * LLM-enhanced skill generation — sends the trajectory to the fast model\n * and gets back a rich SKILL.md with edge cases, pitfalls, and verification.\n */\nasync function generateSkillWithLLM(trajectory: TaskTrajectory, model: string): Promise<string> {\n    // Dynamic import to avoid circular dependency at module load\n    const { chat } = await import('../providers/router.js');\n\n    const matchingTrajectories = getRecentTrajectories(50, {\n        taskType: trajectory.taskType,\n        success: true,\n    }).filter(t => getSequenceSignature(t.toolSequence) === getSequenceSignature(trajectory.toolSequence));\n\n    const avgRounds = matchingTrajectories.length > 0\n        ? Math.round(matchingTrajectories.reduce((sum, t) => sum + t.rounds, 0) / matchingTrajectories.length)\n        : trajectory.rounds;\n\n    const toolDetails = trajectory.toolSequence.map((tool, i) => {\n        const detail = trajectory.toolDetails[i];\n        const argsPreview = detail\n            ? JSON.stringify(detail.args).slice(0, 200)\n            : '{}';\n        const resultPreview = detail?.resultSnippet || '';\n        return `Step ${i + 1}: ${tool}(${argsPreview})${resultPreview ? ` → ${resultPreview.slice(0, 100)}` : ''}`;\n    }).join('\\n');\n\n    const prompt = `You are a skill documentation writer for the TITAN AI agent framework.\n\nA task has been completed successfully ${matchingTrajectories.length} times using this tool sequence.\nWrite a reusable SKILL.md that future agents can follow.\n\n## Task Details\n- **Task type**: ${trajectory.taskType}\n- **User request**: ${trajectory.task.slice(0, 300)}\n- **Tool sequence**: ${trajectory.toolSequence.join(' → ')}\n- **Rounds**: ${avgRounds} average\n- **Duration**: ${Math.round(trajectory.durationMs / 1000)}s\n\n## Tool Call Details\n${toolDetails}\n\n## Required Output Format\nWrite a SKILL.md with YAML frontmatter. Include these sections:\n1. **Trigger Patterns** — when should this skill be applied (2-4 bullet points)\n2. **Procedure** — step-by-step with the exact tool sequence and key arguments\n3. **Common Pitfalls** — what goes wrong and how to avoid it (2-3 items)\n4. **Verification** — how to confirm the task succeeded (1-2 checks)\n5. **Statistics** — success count, avg rounds, avg duration\n\nStart with:\n---\nname: ${skillDirName(trajectory.taskType, trajectory.toolSequence)}\ndescription: <one-line description>\nversion: 1.0.0\nauthor: TITAN AutoSkill\ncategory: auto-generated\n---\n\nKeep it concise — under 60 lines total. No filler.`;\n\n    const response = await chat({\n        model,\n        messages: [{ role: 'user', content: prompt }],\n        temperature: 0.3,\n        maxTokens: 1500,\n    });\n\n    return response.content || '';\n}\n\n/**\n * Template-based skill generation (original behavior, used as fallback).\n */\nfunction generateSkillTemplate(trajectory: TaskTrajectory): string {\n    const matchingTrajectories = getRecentTrajectories(50, {\n        taskType: trajectory.taskType,\n        success: true,\n    }).filter(t => getSequenceSignature(t.toolSequence) === getSequenceSignature(trajectory.toolSequence));\n\n    const avgRounds = matchingTrajectories.length > 0\n        ? Math.round(matchingTrajectories.reduce((sum, t) => sum + t.rounds, 0) / matchingTrajectories.length)\n        : trajectory.rounds;\n\n    const avgDurationMs = matchingTrajectories.length > 0\n        ? Math.round(matchingTrajectories.reduce((sum, t) => sum + t.durationMs, 0) / matchingTrajectories.length)\n        : trajectory.durationMs;\n\n    const steps = trajectory.toolSequence.map((tool, i) => {\n        const detail = trajectory.toolDetails[i];\n        const argsPreview = detail\n            ? Object.keys(detail.args).slice(0, 3).join(', ')\n            : '';\n        return `${i + 1}. **${tool}**${argsPreview ? ` — args: ${argsPreview}` : ''}`;\n    }).join('\\n');\n\n    return `---\nname: ${skillDirName(trajectory.taskType, trajectory.toolSequence)}\ndescription: Auto-generated skill for ${trajectory.taskType} tasks using ${trajectory.toolSequence.join(' → ')}\nversion: 1.0.0\nauthor: TITAN AutoSkill\ncategory: auto-generated\n---\n\n# ${trajectory.taskType} Task Pattern\n\nProven tool sequence for this type of task:\n\n${steps}\n\n## Statistics\n- **Success rate**: ${matchingTrajectories.length} successful runs\n- **Average rounds**: ${avgRounds}\n- **Average duration**: ${Math.round(avgDurationMs / 1000)}s\n- **Generated**: ${new Date().toISOString()}\n\n## When to use\nApply this sequence when the user asks for a ${trajectory.taskType} task that involves ${trajectory.toolSequence.slice(0, 3).join(', ')}.\n`;\n}\n\n/**\n * Save a generated skill to disk.\n */\nexport async function saveGeneratedSkill(trajectory: TaskTrajectory): Promise<GeneratedSkill | null> {\n    try {\n        const dirPath = join(SKILLS_DIR, skillDirName(trajectory.taskType, trajectory.toolSequence));\n        const filePath = join(dirPath, 'SKILL.md');\n\n        if (!existsSync(dirPath)) {\n            mkdirSync(dirPath, { recursive: true });\n        }\n\n        const content = await generateSkillContent(trajectory);\n        writeFileSync(filePath, content, 'utf-8');\n\n        const skill: GeneratedSkill = {\n            name: skillDirName(trajectory.taskType, trajectory.toolSequence),\n            description: `Auto-generated skill for ${trajectory.taskType} tasks`,\n            taskType: trajectory.taskType,\n            toolSequence: trajectory.toolSequence,\n            triggerPatterns: [trajectory.taskType],\n            successCount: countMatchingTrajectories(trajectory.taskType, trajectory.toolSequence),\n            avgRounds: trajectory.rounds,\n            generatedAt: new Date().toISOString(),\n        };\n\n        logger.info(COMPONENT, `Generated auto-skill: ${skill.name} (${skill.toolSequence.join(' → ')})`);\n        return skill;\n    } catch (err) {\n        logger.warn(COMPONENT, `Failed to save auto-skill: ${(err as Error).message}`);\n        return null;\n    }\n}\n\n/**\n * Find auto-generated skills matching a message and task type.\n */\nexport function findMatchingSkills(message: string, taskType: string): GeneratedSkill[] {\n    if (!existsSync(SKILLS_DIR)) return [];\n\n    const results: GeneratedSkill[] = [];\n    try {\n        const dirs = readdirSync(SKILLS_DIR).filter(d => d.startsWith('auto-'));\n        for (const dir of dirs) {\n            const skillFile = join(SKILLS_DIR, dir, 'SKILL.md');\n            if (!existsSync(skillFile)) continue;\n\n            try {\n                const content = readFileSync(skillFile, 'utf-8');\n                // Parse frontmatter\n                const fmMatch = content.match(/^---\\n([\\s\\S]*?)\\n---/);\n                if (!fmMatch) continue;\n\n                const fm = fmMatch[1];\n                const descMatch = fm.match(/description:\\s*(.+)/);\n                const description = descMatch?.[1] || '';\n\n                // Check if this skill matches the task type\n                if (!dir.includes(taskType) && !description.toLowerCase().includes(taskType)) continue;\n\n                // Parse tool sequence from the skill content\n                const toolMatches = content.match(/\\*\\*(\\w+)\\*\\*/g);\n                const toolSequence = toolMatches\n                    ? toolMatches.map(m => m.replace(/\\*\\*/g, '')).filter(t => !['Success', 'Average', 'Generated', 'When'].includes(t))\n                    : [];\n\n                const successMatch = content.match(/(\\d+) successful runs/);\n                const roundsMatch = content.match(/Average rounds.*?(\\d+)/);\n\n                results.push({\n                    name: dir,\n                    description,\n                    taskType,\n                    toolSequence,\n                    triggerPatterns: [taskType],\n                    successCount: successMatch ? parseInt(successMatch[1]) : 0,\n                    avgRounds: roundsMatch ? parseInt(roundsMatch[1]) : 0,\n                    generatedAt: '',\n                });\n            } catch { /* skip malformed skill files */ }\n        }\n    } catch { /* skills dir read error */ }\n\n    return results;\n}\n\n/**\n * Get skill guidance string for injection into the system prompt.\n * Returns null if no matching skills found.\n */\nexport function getSkillGuidance(message: string): string | null {\n    const taskType = classifyTaskType(message);\n    const skills = findMatchingSkills(message, taskType);\n\n    if (skills.length === 0) return null;\n\n    const best = skills.sort((a, b) => b.successCount - a.successCount)[0];\n    return `For similar ${best.taskType} tasks, a proven approach: ${best.toolSequence.join(' → ')} (${best.successCount} successful runs, ~${best.avgRounds} rounds). Auto-generated from past trajectories.`;\n}\n\n/**\n * Process a trajectory: log it, check if a skill should be generated, generate if so.\n * This is the main entry point called from agent.ts after each task.\n * Runs async (LLM call for rich skill generation) but fire-and-forget — never blocks the agent response.\n */\nexport function processTrajectoryForSkills(trajectory: TaskTrajectory): void {\n    if (shouldGenerateSkill(trajectory)) {\n        // Fire-and-forget: don't block the agent response on skill generation\n        saveGeneratedSkill(trajectory).catch(err => {\n            logger.warn(COMPONENT, `Auto-skill generation failed: ${(err as Error).message}`);\n        });\n    }\n}\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../../src/agent/autoSkillGen.ts"],"sourcesContent":["/**\n * TITAN — Auto-Skill Generation from Trajectories\n *\n * When a task type + tool sequence succeeds 3+ times, auto-generates a SKILL.md\n * under TITAN_HOME/workspace/skills/auto-{taskType}-{hash}/SKILL.md.\n *\n * On future tasks, matching skills are surfaced as guidance in the system prompt.\n * Inspired by Hermes skill_manager_tool.py.\n */\nimport { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync } from 'fs';\nimport { join } from 'path';\nimport { createHash } from 'crypto';\nimport { getRecentTrajectories, getSequenceSignature, countMatchingTrajectories, type TaskTrajectory } from './trajectoryLogger.js';\nimport { classifyTaskType } from '../memory/learning.js';\nimport { loadConfig } from '../config/config.js';\nimport logger from '../utils/logger.js';\nimport { TITAN_SKILLS_DIR } from '../utils/constants.js';\nimport { processTrajectoryForLearningReview, renderLearningPatternGuidance } from './learningCurator.js';\n\nconst COMPONENT = 'AutoSkillGen';\nconst SKILLS_DIR = TITAN_SKILLS_DIR;\nconst MIN_SUCCESSES = 3; // Minimum successful runs before generating a skill\n\n// ── Types ─────────────────────────────────────────────────────────\nexport interface GeneratedSkill {\n    name: string;\n    description: string;\n    taskType: string;\n    toolSequence: string[];\n    triggerPatterns: string[];\n    successCount: number;\n    avgRounds: number;\n    generatedAt: string;\n}\n\n// ── Helpers ───────────────────────────────────────────────────────\nfunction skillHash(taskType: string, toolSequence: string[]): string {\n    return createHash('md5')\n        .update(`${taskType}:${toolSequence.join(',')}`)\n        .digest('hex')\n        .slice(0, 8);\n}\n\nfunction skillDirName(taskType: string, toolSequence: string[]): string {\n    return `auto-${taskType}-${skillHash(taskType, toolSequence)}`;\n}\n\nfunction skillPath(taskType: string, toolSequence: string[]): string {\n    return join(SKILLS_DIR, skillDirName(taskType, toolSequence), 'SKILL.md');\n}\n\nfunction frontmatterArray(values: string[]): string {\n    return `[${values.map(v => JSON.stringify(v)).join(', ')}]`;\n}\n\nfunction parseFrontmatterArray(value: string | undefined): string[] {\n    if (!value) return [];\n    const trimmed = value.trim();\n    if (!trimmed.startsWith('[') || !trimmed.endsWith(']')) return [];\n    return trimmed\n        .slice(1, -1)\n        .split(',')\n        .map(v => v.trim().replace(/^[\"']|[\"']$/g, ''))\n        .filter(Boolean);\n}\n\nfunction parseFrontmatterScalar(fm: string, key: string): string {\n    const match = fm.match(new RegExp(`^${key}:\\\\s*(.+)$`, 'm'));\n    return match?.[1]?.trim() ?? '';\n}\n\nfunction parseFrontmatterNumber(fm: string, key: string): number {\n    const raw = parseFrontmatterScalar(fm, key);\n    const parsed = Number.parseInt(raw, 10);\n    return Number.isFinite(parsed) ? parsed : 0;\n}\n\n// ── Core Functions ────────────────────────────────────────────────\n\n/**\n * Check if a skill should be generated for this trajectory.\n * Returns true if 3+ successful trajectories exist with the same\n * taskType + toolSequence and no auto-skill already exists.\n */\nexport function shouldGenerateSkill(trajectory: TaskTrajectory): boolean {\n    if (!trajectory.success || trajectory.toolSequence.length < 2) return false;\n\n    // Check if auto-skill already exists\n    const path = skillPath(trajectory.taskType, trajectory.toolSequence);\n    if (existsSync(path)) return false;\n\n    // Count matching successful trajectories\n    const count = countMatchingTrajectories(trajectory.taskType, trajectory.toolSequence);\n    return count >= MIN_SUCCESSES;\n}\n\n/**\n * Generate a SKILL.md file content from a trajectory using the LLM.\n *\n * Competitive gap fix (Hermes): Hermes generates rich skills with edge cases,\n * verification steps, and failure modes via LLM. TITAN was template-only.\n * Now we send the trajectory to the `fast` model alias for rich generation,\n * with automatic fallback to the template if the LLM call fails.\n */\nexport async function generateSkillContent(trajectory: TaskTrajectory): Promise<string> {\n    // Try LLM-enhanced generation first\n    try {\n        const llmContent = await generateSkillWithLLM(trajectory, resolveSkillGenerationModel());\n        if (llmContent && llmContent.length > 200) {\n            logger.info(COMPONENT, `LLM-enhanced skill generated (${llmContent.length} chars) for ${trajectory.taskType}`);\n            return llmContent;\n        }\n    } catch (err) {\n        logger.warn(COMPONENT, `LLM skill generation failed, falling back to template: ${(err as Error).message}`);\n    }\n\n    // Fallback: template-based generation (original behavior)\n    return generateSkillTemplate(trajectory);\n}\n\nexport function resolveSkillGenerationModel(): string {\n    const config = loadConfig();\n    const agent = config.agent as {\n        model?: string;\n        modelAliases?: Record<string, string>;\n    };\n\n    return agent.modelAliases?.fast\n        || agent.modelAliases?.reasoning\n        || agent.model\n        || 'fast';\n}\n\n/**\n * LLM-enhanced skill generation — sends the trajectory to the fast model\n * and gets back a rich SKILL.md with edge cases, pitfalls, and verification.\n */\nasync function generateSkillWithLLM(trajectory: TaskTrajectory, model: string): Promise<string> {\n    // Dynamic import to avoid circular dependency at module load\n    const { chat } = await import('../providers/router.js');\n\n    const matchingTrajectories = getRecentTrajectories(50, {\n        taskType: trajectory.taskType,\n        success: true,\n    }).filter(t => getSequenceSignature(t.toolSequence) === getSequenceSignature(trajectory.toolSequence));\n\n    const avgRounds = matchingTrajectories.length > 0\n        ? Math.round(matchingTrajectories.reduce((sum, t) => sum + t.rounds, 0) / matchingTrajectories.length)\n        : trajectory.rounds;\n\n    const toolDetails = trajectory.toolSequence.map((tool, i) => {\n        const detail = trajectory.toolDetails[i];\n        const argsPreview = detail\n            ? JSON.stringify(detail.args).slice(0, 200)\n            : '{}';\n        const resultPreview = detail?.resultSnippet || '';\n        return `Step ${i + 1}: ${tool}(${argsPreview})${resultPreview ? ` → ${resultPreview.slice(0, 100)}` : ''}`;\n    }).join('\\n');\n\n    const prompt = `You are a skill documentation writer for the TITAN AI agent framework.\n\nA task has been completed successfully ${matchingTrajectories.length} times using this tool sequence.\nWrite a reusable SKILL.md that future agents can follow.\n\n## Task Details\n- **Task type**: ${trajectory.taskType}\n- **User request**: ${trajectory.task.slice(0, 300)}\n- **Tool sequence**: ${trajectory.toolSequence.join(' → ')}\n- **Rounds**: ${avgRounds} average\n- **Duration**: ${Math.round(trajectory.durationMs / 1000)}s\n\n## Tool Call Details\n${toolDetails}\n\n## Required Output Format\nWrite a SKILL.md with YAML frontmatter. Include these sections:\n1. **Trigger Patterns** — when should this skill be applied (2-4 bullet points)\n2. **Procedure** — step-by-step with the exact tool sequence and key arguments\n3. **Common Pitfalls** — what goes wrong and how to avoid it (2-3 items)\n4. **Verification** — how to confirm the task succeeded (1-2 checks)\n5. **Statistics** — success count, avg rounds, avg duration\n\nStart with:\n---\nname: ${skillDirName(trajectory.taskType, trajectory.toolSequence)}\ndescription: <one-line description>\nversion: 1.0.0\nauthor: TITAN AutoSkill\ncategory: auto-generated\ntaskType: ${trajectory.taskType}\ntoolSequence: ${frontmatterArray(trajectory.toolSequence)}\nsuccessCount: ${matchingTrajectories.length}\navgRounds: ${avgRounds}\ngeneratedAt: <ISO timestamp>\n---\n\nKeep it concise — under 60 lines total. No filler.`;\n\n    const response = await chat({\n        model,\n        messages: [{ role: 'user', content: prompt }],\n        temperature: 0.3,\n        maxTokens: 1500,\n    });\n\n    return response.content || '';\n}\n\n/**\n * Template-based skill generation (original behavior, used as fallback).\n */\nfunction generateSkillTemplate(trajectory: TaskTrajectory): string {\n    const matchingTrajectories = getRecentTrajectories(50, {\n        taskType: trajectory.taskType,\n        success: true,\n    }).filter(t => getSequenceSignature(t.toolSequence) === getSequenceSignature(trajectory.toolSequence));\n\n    const avgRounds = matchingTrajectories.length > 0\n        ? Math.round(matchingTrajectories.reduce((sum, t) => sum + t.rounds, 0) / matchingTrajectories.length)\n        : trajectory.rounds;\n\n    const avgDurationMs = matchingTrajectories.length > 0\n        ? Math.round(matchingTrajectories.reduce((sum, t) => sum + t.durationMs, 0) / matchingTrajectories.length)\n        : trajectory.durationMs;\n\n    const steps = trajectory.toolSequence.map((tool, i) => {\n        const detail = trajectory.toolDetails[i];\n        const argsPreview = detail\n            ? Object.keys(detail.args).slice(0, 3).join(', ')\n            : '';\n        return `${i + 1}. **${tool}**${argsPreview ? ` — args: ${argsPreview}` : ''}`;\n    }).join('\\n');\n\n    return `---\nname: ${skillDirName(trajectory.taskType, trajectory.toolSequence)}\ndescription: Auto-generated skill for ${trajectory.taskType} tasks using ${trajectory.toolSequence.join(' → ')}\nversion: 1.0.0\nauthor: TITAN AutoSkill\ncategory: auto-generated\ntaskType: ${trajectory.taskType}\ntoolSequence: ${frontmatterArray(trajectory.toolSequence)}\nsuccessCount: ${matchingTrajectories.length}\navgRounds: ${avgRounds}\ngeneratedAt: ${new Date().toISOString()}\n---\n\n# ${trajectory.taskType} Task Pattern\n\nProven tool sequence for this type of task:\n\n${steps}\n\n## Statistics\n- **Success rate**: ${matchingTrajectories.length} successful runs\n- **Average rounds**: ${avgRounds}\n- **Average duration**: ${Math.round(avgDurationMs / 1000)}s\n- **Generated**: ${new Date().toISOString()}\n\n## When to use\nApply this sequence when the user asks for a ${trajectory.taskType} task that involves ${trajectory.toolSequence.slice(0, 3).join(', ')}.\n`;\n}\n\n/**\n * Save a generated skill to disk.\n */\nexport async function saveGeneratedSkill(trajectory: TaskTrajectory): Promise<GeneratedSkill | null> {\n    try {\n        const dirPath = join(SKILLS_DIR, skillDirName(trajectory.taskType, trajectory.toolSequence));\n        const filePath = join(dirPath, 'SKILL.md');\n\n        if (!existsSync(dirPath)) {\n            mkdirSync(dirPath, { recursive: true });\n        }\n\n        const content = await generateSkillContent(trajectory);\n        writeFileSync(filePath, content, 'utf-8');\n\n        const skill: GeneratedSkill = {\n            name: skillDirName(trajectory.taskType, trajectory.toolSequence),\n            description: `Auto-generated skill for ${trajectory.taskType} tasks`,\n            taskType: trajectory.taskType,\n            toolSequence: trajectory.toolSequence,\n            triggerPatterns: [trajectory.taskType],\n            successCount: countMatchingTrajectories(trajectory.taskType, trajectory.toolSequence),\n            avgRounds: trajectory.rounds,\n            generatedAt: new Date().toISOString(),\n        };\n\n        logger.info(COMPONENT, `Generated auto-skill: ${skill.name} (${skill.toolSequence.join(' → ')})`);\n        return skill;\n    } catch (err) {\n        logger.warn(COMPONENT, `Failed to save auto-skill: ${(err as Error).message}`);\n        return null;\n    }\n}\n\n/**\n * Find auto-generated skills matching a message and task type.\n */\nexport function findMatchingSkills(message: string, taskType: string): GeneratedSkill[] {\n    if (!existsSync(SKILLS_DIR)) return [];\n\n    const results: GeneratedSkill[] = [];\n    try {\n        const dirs = readdirSync(SKILLS_DIR).filter(d => d.startsWith('auto-'));\n        for (const dir of dirs) {\n            const skillFile = join(SKILLS_DIR, dir, 'SKILL.md');\n            if (!existsSync(skillFile)) continue;\n\n            try {\n                const content = readFileSync(skillFile, 'utf-8');\n                // Parse frontmatter\n                const fmMatch = content.match(/^---\\n([\\s\\S]*?)\\n---/);\n                if (!fmMatch) continue;\n\n                const fm = fmMatch[1];\n                const description = parseFrontmatterScalar(fm, 'description');\n                const skillTaskType = parseFrontmatterScalar(fm, 'taskType') || taskType;\n\n                // Check if this skill matches the task type\n                if (\n                    skillTaskType !== taskType\n                    && !dir.includes(taskType)\n                    && !description.toLowerCase().includes(taskType)\n                ) continue;\n\n                // Prefer structured frontmatter. Fall back to legacy template parsing\n                // for skills generated before toolSequence was persisted.\n                const toolMatches = content.match(/\\*\\*(\\w+)\\*\\*/g);\n                const legacyToolSequence = toolMatches\n                    ? toolMatches.map(m => m.replace(/\\*\\*/g, '')).filter(t => !['Success', 'Average', 'Generated', 'When'].includes(t))\n                    : [];\n                const toolSequence = parseFrontmatterArray(parseFrontmatterScalar(fm, 'toolSequence'));\n\n                const successMatch = content.match(/(\\d+) successful runs/);\n                const roundsMatch = content.match(/Average rounds.*?(\\d+)/);\n\n                results.push({\n                    name: dir,\n                    description,\n                    taskType: skillTaskType,\n                    toolSequence: toolSequence.length > 0 ? toolSequence : legacyToolSequence,\n                    triggerPatterns: [taskType],\n                    successCount: parseFrontmatterNumber(fm, 'successCount') || (successMatch ? parseInt(successMatch[1]) : 0),\n                    avgRounds: parseFrontmatterNumber(fm, 'avgRounds') || (roundsMatch ? parseInt(roundsMatch[1]) : 0),\n                    generatedAt: parseFrontmatterScalar(fm, 'generatedAt'),\n                });\n            } catch { /* skip malformed skill files */ }\n        }\n    } catch { /* skills dir read error */ }\n\n    return results;\n}\n\n/**\n * Get skill guidance string for injection into the system prompt.\n * Returns null if no matching skills found.\n */\nexport function getSkillGuidance(message: string): string | null {\n    const taskType = classifyTaskType(message);\n    const skills = findMatchingSkills(message, taskType);\n    const learningPatternGuidance = renderLearningPatternGuidance(taskType);\n\n    if (skills.length === 0) return learningPatternGuidance;\n\n    const best = skills.sort((a, b) => b.successCount - a.successCount)[0];\n    const skillGuidance = `For similar ${best.taskType} tasks, a proven approach: ${best.toolSequence.join(' → ')} (${best.successCount} successful runs, ~${best.avgRounds} rounds). Auto-generated from past trajectories.`;\n    return learningPatternGuidance ? `${skillGuidance}\\n\\n${learningPatternGuidance}` : skillGuidance;\n}\n\n/**\n * Process a trajectory: log it, check if a skill should be generated, generate if so.\n * This is the main entry point called from agent.ts after each task.\n * Runs async (LLM call for rich skill generation) but fire-and-forget — never blocks the agent response.\n */\nexport function processTrajectoryForSkills(trajectory: TaskTrajectory): void {\n    processTrajectoryForLearningReview(trajectory);\n\n    if (shouldGenerateSkill(trajectory)) {\n        // Fire-and-forget: don't block the agent response on skill generation\n        saveGeneratedSkill(trajectory).catch(err => {\n            logger.warn(COMPONENT, `Auto-skill generation failed: ${(err as Error).message}`);\n        });\n    }\n}\n"],"mappings":"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","names":[]}

package/dist/agent/learningCurator.js

@@ -0,0 +1,383 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import logger from "../utils/logger.js";
+import { TITAN_HOME } from "../utils/constants.js";
+import { getRecentTrajectories, getSequenceSignature } from "./trajectoryLogger.js";
+import { recordLesson } from "./agentLessons.js";
+import { loadConfig } from "../config/config.js";
+function loadCuratorConfig() {
+  try {
+    const cfg = loadConfig();
+    const lc = cfg.learningCurator ?? {};
+    return {
+      enabled: lc.enabled ?? true,
+      intervalHours: lc.intervalHours ?? DEFAULT_INTERVAL_HOURS,
+      minTrajectories: lc.minTrajectories ?? DEFAULT_MIN_TRAJECTORIES,
+      staleAfterDays: lc.staleAfterDays ?? DEFAULT_STALE_AFTER_DAYS,
+      archiveAfterDays: lc.archiveAfterDays ?? DEFAULT_ARCHIVE_AFTER_DAYS
+    };
+  } catch {
+    return {
+      enabled: true,
+      intervalHours: DEFAULT_INTERVAL_HOURS,
+      minTrajectories: DEFAULT_MIN_TRAJECTORIES,
+      staleAfterDays: DEFAULT_STALE_AFTER_DAYS,
+      archiveAfterDays: DEFAULT_ARCHIVE_AFTER_DAYS
+    };
+  }
+}
+const COMPONENT = "LearningCurator";
+const STATE_PATH = join(TITAN_HOME, "learning-curator-state.json");
+const REPORTS_DIR = join(TITAN_HOME, "logs", "learning-curator");
+const DEFAULT_INTERVAL_HOURS = 24;
+const DEFAULT_MIN_TRAJECTORIES = 3;
+const DEFAULT_STALE_AFTER_DAYS = 30;
+const DEFAULT_ARCHIVE_AFTER_DAYS = 90;
+function defaultState() {
+  return {
+    lastRunAt: null,
+    lastRunDurationMs: null,
+    lastRunSummary: null,
+    lastReportPath: null,
+    runCount: 0,
+    paused: false,
+    patterns: {}
+  };
+}
+function loadLearningCuratorState() {
+  if (!existsSync(STATE_PATH)) return defaultState();
+  try {
+    const parsed = JSON.parse(readFileSync(STATE_PATH, "utf-8"));
+    return { ...defaultState(), ...parsed };
+  } catch {
+    return defaultState();
+  }
+}
+function saveLearningCuratorState(state) {
+  try {
+    mkdirSync(dirname(STATE_PATH), { recursive: true });
+    atomicWriteText(STATE_PATH, JSON.stringify(state, null, 2));
+  } catch (err) {
+    logger.warn(COMPONENT, `Failed to save curator state: ${err.message}`);
+  }
+}
+function atomicWriteText(path, content) {
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  writeFileSync(tmp, content, "utf-8");
+  try {
+    renameSync(tmp, path);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+function shouldRunLearningReview(now = /* @__PURE__ */ new Date(), intervalHours = DEFAULT_INTERVAL_HOURS) {
+  const state = loadLearningCuratorState();
+  if (state.paused) return false;
+  if (!state.lastRunAt) {
+    saveLearningCuratorState({
+      ...state,
+      lastRunAt: now.toISOString(),
+      lastRunDurationMs: 0,
+      lastRunSummary: "Seeded learning curator; first review deferred until interval elapses."
+    });
+    return false;
+  }
+  const lastRun = Date.parse(state.lastRunAt);
+  if (!Number.isFinite(lastRun)) return true;
+  return now.getTime() - lastRun >= intervalHours * 60 * 60 * 1e3;
+}
+function runLearningReview(trigger, now = /* @__PURE__ */ new Date(), minTrajectories = DEFAULT_MIN_TRAJECTORIES) {
+  const started = Date.now();
+  const emptyTransitions = {
+    checked: 0,
+    markedStale: 0,
+    archived: 0,
+    reactivated: 0
+  };
+  if (!shouldRunLearningReview(now)) {
+    return {
+      shouldRun: false,
+      lessonsRecorded: 0,
+      summary: "Learning review deferred by interval gate.",
+      reportPath: null,
+      transitions: emptyTransitions
+    };
+  }
+  const recent = getRecentTrajectories(200, { taskType: trigger.taskType });
+  if (recent.length < minTrajectories) {
+    const summary2 = `Skipped ${trigger.taskType}: only ${recent.length}/${minTrajectories} trajectories.`;
+    const reportPath2 = writeLearningReviewReport(now, {
+      taskType: trigger.taskType,
+      summary: summary2,
+      lessons: [],
+      transitions: emptyTransitions,
+      recentCount: recent.length,
+      durationMs: Date.now() - started
+    });
+    persistReview(now, summary2, reportPath2, Date.now() - started);
+    return {
+      shouldRun: true,
+      lessonsRecorded: 0,
+      summary: "Not enough trajectory history to curate.",
+      reportPath: reportPath2,
+      transitions: emptyTransitions
+    };
+  }
+  const transitions = applyLearningPatternTransitions(now);
+  const lessons = deriveLessons(trigger, recent);
+  for (const lesson of lessons) {
+    recordLesson("default", {
+      kind: lesson.kind,
+      topic: lesson.topic,
+      sessionId: trigger.sessionId,
+      text: lesson.text
+    });
+  }
+  const summary = lessons.length > 0 ? `Recorded ${lessons.length} ${trigger.taskType} learning lesson(s).` : `Reviewed ${recent.length} ${trigger.taskType} trajectories; nothing durable to save.`;
+  const durationMs = Date.now() - started;
+  const reportPath = writeLearningReviewReport(now, {
+    taskType: trigger.taskType,
+    summary,
+    lessons,
+    transitions,
+    recentCount: recent.length,
+    durationMs
+  });
+  persistReview(now, summary, reportPath, durationMs);
+  return { shouldRun: true, lessonsRecorded: lessons.length, summary, reportPath, transitions };
+}
+function persistReview(now, summary, reportPath, durationMs) {
+  const state = loadLearningCuratorState();
+  saveLearningCuratorState({
+    ...state,
+    lastRunAt: now.toISOString(),
+    lastRunDurationMs: durationMs,
+    lastRunSummary: summary,
+    lastReportPath: reportPath,
+    runCount: state.runCount + 1
+  });
+}
+function writeLearningReviewReport(now, report) {
+  try {
+    const stamp = now.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
+    const dir = join(REPORTS_DIR, stamp);
+    mkdirSync(dir, { recursive: true });
+    const jsonPath = join(dir, "run.json");
+    const mdPath = join(dir, "REPORT.md");
+    atomicWriteText(jsonPath, JSON.stringify({
+      generatedAt: now.toISOString(),
+      taskType: report.taskType,
+      summary: report.summary,
+      recentCount: report.recentCount,
+      lessons: report.lessons,
+      transitions: report.transitions,
+      durationMs: report.durationMs
+    }, null, 2));
+    atomicWriteText(mdPath, renderLearningReviewReport(now, report));
+    return mdPath;
+  } catch (err) {
+    logger.warn(COMPONENT, `Failed to write curator report: ${err.message}`);
+    return null;
+  }
+}
+function renderLearningReviewReport(now, report) {
+  const lessons = report.lessons.length > 0 ? report.lessons.map((lesson) => `- ${lesson.kind.toUpperCase()} / ${lesson.topic}: ${lesson.text}`).join("\n") : "- No durable lessons recorded.";
+  return `# TITAN Learning Curator Report
+
+- Generated: ${now.toISOString()}
+- Task type: ${report.taskType}
+- Recent trajectories checked: ${report.recentCount}
+- Duration: ${report.durationMs}ms
+- Summary: ${report.summary}
+
+## Pattern Transitions
+- Checked: ${report.transitions.checked}
+- Marked stale: ${report.transitions.markedStale}
+- Archived: ${report.transitions.archived}
+- Reactivated: ${report.transitions.reactivated}
+
+## Lessons
+${lessons}
+`;
+}
+function deriveLessons(trigger, recent) {
+  const lessons = [];
+  const signature = getSequenceSignature(trigger.toolSequence);
+  const sameSequence = recent.filter((t) => getSequenceSignature(t.toolSequence) === signature);
+  const successes = sameSequence.filter((t) => t.success);
+  const failures = sameSequence.filter((t) => !t.success && isDurableLearningFailure(t));
+  if (successes.length >= DEFAULT_MIN_TRAJECTORIES) {
+    lessons.push({
+      kind: "win",
+      topic: trigger.taskType,
+      text: `For ${trigger.taskType} tasks, the tool sequence ${signature} is proven across ${successes.length} successful trajectories; prefer it before inventing a new flow, then verify the final artifact before reporting done.`
+    });
+  }
+  if (failures.length >= 2) {
+    const failedTool = mostCommonFailureTool(failures);
+    lessons.push({
+      kind: "fail",
+      topic: trigger.taskType,
+      text: `For ${trigger.taskType} tasks, repeated failures happened in the ${signature} flow${failedTool ? ` around ${failedTool}` : ""}; inspect the last tool result and change approach instead of retrying the same sequence blindly.`
+    });
+  }
+  const recentFailure = recent.find((t) => !t.success && t.timestamp < trigger.timestamp);
+  if (trigger.success && recentFailure && signature !== getSequenceSignature(recentFailure.toolSequence)) {
+    lessons.push({
+      kind: "win",
+      topic: trigger.taskType,
+      text: `When a ${trigger.taskType} attempt stalls or fails, switching to ${signature} has produced a successful recovery path; use this as the first fallback candidate for similar work.`
+    });
+  }
+  return lessons;
+}
+function ingestTrajectoryLearningSignal(trajectory) {
+  const state = loadLearningCuratorState();
+  const now = trajectory.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+  const signature = getSequenceSignature(trajectory.toolSequence);
+  const key = patternKey(trajectory.taskType, signature);
+  const existing = state.patterns[key];
+  const transientFailure = !trajectory.success && !isDurableLearningFailure(trajectory);
+  const failureTool = !trajectory.success && !transientFailure ? mostCommonFailureTool([trajectory]) : "";
+  const pattern = {
+    taskType: trajectory.taskType,
+    signature,
+    toolSequence: trajectory.toolSequence,
+    successes: existing?.successes ?? 0,
+    failures: existing?.failures ?? 0,
+    transientFailures: existing?.transientFailures ?? 0,
+    state: existing?.state ?? "active",
+    firstSeenAt: existing?.firstSeenAt ?? now,
+    lastSeenAt: now,
+    lastSuccessAt: existing?.lastSuccessAt ?? null,
+    lastFailureAt: existing?.lastFailureAt ?? null,
+    commonFailureTool: existing?.commonFailureTool ?? null
+  };
+  if (trajectory.success) {
+    pattern.successes += 1;
+    pattern.lastSuccessAt = now;
+    pattern.state = "active";
+  } else if (transientFailure) {
+    pattern.transientFailures += 1;
+  } else {
+    pattern.failures += 1;
+    pattern.lastFailureAt = now;
+    pattern.commonFailureTool = failureTool || pattern.commonFailureTool;
+    if (pattern.failures >= 2) pattern.state = "watch";
+  }
+  state.patterns[key] = pattern;
+  saveLearningCuratorState(state);
+  return pattern;
+}
+function applyLearningPatternTransitions(now = /* @__PURE__ */ new Date(), staleAfterDays = DEFAULT_STALE_AFTER_DAYS, archiveAfterDays = DEFAULT_ARCHIVE_AFTER_DAYS) {
+  const state = loadLearningCuratorState();
+  const counts = {
+    checked: 0,
+    markedStale: 0,
+    archived: 0,
+    reactivated: 0
+  };
+  const staleCutoff = now.getTime() - staleAfterDays * 24 * 60 * 60 * 1e3;
+  const archiveCutoff = now.getTime() - archiveAfterDays * 24 * 60 * 60 * 1e3;
+  for (const pattern of Object.values(state.patterns)) {
+    counts.checked += 1;
+    const lastSeen = Date.parse(pattern.lastSeenAt);
+    if (!Number.isFinite(lastSeen)) continue;
+    if (lastSeen <= archiveCutoff && pattern.state !== "archived") {
+      pattern.state = "archived";
+      counts.archived += 1;
+    } else if (lastSeen <= staleCutoff && pattern.state === "active") {
+      pattern.state = "stale";
+      counts.markedStale += 1;
+    } else if (lastSeen > staleCutoff && pattern.state === "stale") {
+      pattern.state = "active";
+      counts.reactivated += 1;
+    }
+  }
+  if (counts.markedStale > 0 || counts.archived > 0 || counts.reactivated > 0) {
+    saveLearningCuratorState(state);
+  }
+  return counts;
+}
+function renderLearningPatternGuidance(taskType, limit = 3) {
+  const state = loadLearningCuratorState();
+  const patterns = Object.values(state.patterns).filter((pattern) => pattern.taskType === taskType && pattern.state !== "archived").sort((a, b) => patternSortScore(b) - patternSortScore(a)).slice(0, limit);
+  if (patterns.length === 0) return null;
+  const lines = ["Continuous learning patterns from recent TITAN trajectories:"];
+  for (const pattern of patterns) {
+    if (pattern.state === "watch") {
+      const failureDetail = pattern.commonFailureTool ? ` around ${pattern.commonFailureTool}` : "";
+      lines.push(`- Watch ${pattern.signature}: ${pattern.failures} durable failure(s)${failureDetail}; inspect the failed tool result before repeating this flow.`);
+    } else {
+      lines.push(`- Prefer ${pattern.signature}: ${pattern.successes} win(s), ${pattern.failures} durable failure(s); verify the final artifact before reporting done.`);
+    }
+  }
+  return lines.join("\n");
+}
+function patternSortScore(pattern) {
+  const stateBoost = pattern.state === "watch" ? 1e3 : pattern.state === "active" ? 500 : 0;
+  return stateBoost + pattern.successes * 10 - pattern.failures;
+}
+function patternKey(taskType, signature) {
+  return `${taskType}:${signature}`;
+}
+function isDurableLearningFailure(trajectory) {
+  if (trajectory.success) return false;
+  const text = trajectory.toolDetails.map((detail) => `${detail.name}
+${detail.resultSnippet ?? ""}`).join("\n").toLowerCase();
+  return ![
+    "command not found",
+    "module not found",
+    "cannot find module",
+    "no such file or directory",
+    "not configured",
+    "missing api key",
+    "missing token",
+    "invalid api key",
+    "credentials are not configured",
+    "authentication required",
+    "unauthorized",
+    "rate limit",
+    "temporarily unavailable",
+    "network error",
+    "econnreset",
+    "etimedout"
+  ].some((marker) => text.includes(marker));
+}
+function mostCommonFailureTool(failures) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const trajectory of failures) {
+    for (const detail of trajectory.toolDetails) {
+      if (!detail.success) counts.set(detail.name, (counts.get(detail.name) ?? 0) + 1);
+    }
+  }
+  return [...counts.entries()].sort((a, b) => b[1] - a[1])[0]?.[0] ?? "";
+}
+function processTrajectoryForLearningReview(trajectory) {
+  try {
+    const cfg = loadCuratorConfig();
+    if (!cfg.enabled) return;
+    ingestTrajectoryLearningSignal(trajectory);
+    const result = runLearningReview(trajectory, /* @__PURE__ */ new Date(), cfg.minTrajectories);
+    if (result.shouldRun) logger.info(COMPONENT, result.summary);
+  } catch (err) {
+    logger.warn(COMPONENT, `Learning review failed: ${err.message}`);
+  }
+}
+export {
+  applyLearningPatternTransitions,
+  ingestTrajectoryLearningSignal,
+  loadLearningCuratorState,
+  processTrajectoryForLearningReview,
+  renderLearningPatternGuidance,
+  runLearningReview,
+  saveLearningCuratorState,
+  shouldRunLearningReview,
+  writeLearningReviewReport
+};
+//# sourceMappingURL=learningCurator.js.map