infernoflow 0.10.28 → 0.11.0

package/dist/bin/infernoflow.mjs

@@ -5,6 +5,9 @@ import { fileURLToPath } from "node:url";
 import { bold, gray, cyan, red } from "../lib/ui/output.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+// When installed globally: __dirname = .../infernoflow/dist/bin
+// Root package.json lives two levels up at .../infernoflow/package.json
+// npm always includes the root package.json, so this path is always reliable.
 const pkg = JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf8"));
 const VERSION = pkg.version || "0.0.0";
 const COMMAND_DESCRIPTIONS = {
@@ -26,6 +29,8 @@ const COMMAND_DESCRIPTIONS = {
   implement: "Generate code-agent implementation prompt(s)",
   context: "Generate AI-ready context for new sessions",
   "generate-skills": "Generate personalised Cursor rules + skill files from your developer profile",
+  synthesize: "Auto-detect workflow patterns and synthesize reusable skills + agents",
+  agent: "Manage and run auto-synthesized agents (list | run | show | delete)",
 };
 
 const COMMAND_HANDLERS = {
@@ -48,6 +53,8 @@ const COMMAND_HANDLERS = {
   context: async (args) => (await import("../lib/commands/context.mjs")).contextCommand(args),
   "doc-gate": async (args) => (await import("../lib/commands/docGate.mjs")).docGateCommand(args),
   "generate-skills": async (args) => (await import("../lib/commands/generateSkills.mjs")).generateSkillsCommand(args),
+  synthesize: async (args) => (await import("../lib/commands/synthesize.mjs")).synthesizeCommand(args),
+  agent: async (args) => (await import("../lib/commands/agent.mjs")).agentCommand(args),
 };
 
 function formatCommandsHelp() {

package/dist/lib/commands/agent.mjs

@@ -0,0 +1,191 @@
+/**
+ * infernoflow agent
+ *
+ * Manage and run auto-synthesized agents.
+ *
+ * Sub-commands:
+ *   infernoflow agent list              — list all saved agents
+ *   infernoflow agent run <name>        — execute an agent's command sequence
+ *   infernoflow agent show <name>       — print agent definition
+ *   infernoflow agent delete <name>     — remove an agent
+ */
+
+import * as fs      from "node:fs";
+import * as path    from "node:path";
+import { execSync } from "node:child_process";
+import { header, ok, warn, info, done, bold, cyan, green, gray, red } from "../ui/output.mjs";
+import { observeCommandStart } from "../learning/observe.mjs";
+
+function findInfernoDir(cwd) {
+  const d = path.join(cwd, "inferno");
+  return fs.existsSync(d) ? d : null;
+}
+
+function agentsDir(infernoDir) {
+  return path.join(infernoDir, "agents");
+}
+
+function loadAgents(infernoDir) {
+  const dir = agentsDir(infernoDir);
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter(f => f.endsWith(".json"))
+    .map(f => {
+      try { return JSON.parse(fs.readFileSync(path.join(dir, f), "utf8")); }
+      catch { return null; }
+    })
+    .filter(Boolean);
+}
+
+function findAgent(infernoDir, name) {
+  const agents = loadAgents(infernoDir);
+  return agents.find(a => a.name === name || a.id === name);
+}
+
+function runStep(cmd, args, cwd) {
+  const fullCmd = `npx infernoflow ${cmd} ${args.join(" ")}`.trim();
+  try {
+    const out = execSync(fullCmd, {
+      cwd,
+      encoding: "utf8",
+      timeout: 60_000,
+      stdio: ["inherit", "pipe", "inherit"],
+    });
+    return { ok: true, output: out };
+  } catch (err) {
+    return { ok: false, output: err.stdout || err.message };
+  }
+}
+
+// ── Sub-commands ──────────────────────────────────────────────────────────────
+
+function listAgents(infernoDir) {
+  const agents = loadAgents(infernoDir);
+  if (agents.length === 0) {
+    info("No agents saved yet.");
+    info(`Run ${cyan("infernoflow synthesize")} to auto-generate agents from your workflow patterns.`);
+    return;
+  }
+
+  header("infernoflow agents");
+  console.log(`\n  ${bold(String(agents.length))} saved agent${agents.length !== 1 ? "s" : ""}:\n`);
+  for (const agent of agents) {
+    const steps = (agent.steps || []).map(s => s.command).join(" → ");
+    const conf  = agent.confidence ? gray(`${Math.round(agent.confidence * 100)}% confidence`) : "";
+    console.log(`  ${green("▶")} ${bold(agent.name)}  ${conf}`);
+    console.log(`      ${gray(agent.description || steps)}`);
+    console.log(`      Steps: ${cyan(steps)}`);
+    console.log();
+  }
+  console.log(`  Run: ${cyan("infernoflow agent run <name>")}`);
+}
+
+async function runAgent(infernoDir, cwd, name) {
+  const agent = findAgent(infernoDir, name);
+  if (!agent) {
+    warn(`Agent "${name}" not found.`);
+    warn(`Run ${cyan("infernoflow agent list")} to see available agents.`);
+    process.exit(1);
+  }
+
+  header(`infernoflow agent run: ${agent.name}`);
+  info(agent.description || agent.name);
+  console.log();
+
+  const steps = agent.steps || [];
+  let allOk = true;
+
+  for (let i = 0; i < steps.length; i++) {
+    const step = steps[i];
+    const cmd  = typeof step === "string" ? step : step.command;
+    const args = typeof step === "string" ? [] : (step.args || []);
+
+    console.log(`  ${bold(`[${i + 1}/${steps.length}]`)} ${cyan(`infernoflow ${cmd} ${args.join(" ")}`.trim())}`);
+
+    const result = runStep(cmd, args, cwd);
+    if (result.output) {
+      const lines = result.output.trim().split("\n");
+      for (const line of lines) console.log(`    ${gray(line)}`);
+    }
+
+    if (!result.ok) {
+      warn(`Step "${cmd}" exited with an error — stopping agent.`);
+      allOk = false;
+      break;
+    }
+
+    ok(`Step ${i + 1} complete`);
+    console.log();
+  }
+
+  if (allOk) {
+    done(`Agent "${agent.name}" completed all ${steps.length} steps`);
+  } else {
+    console.log(`\n  ${red("✘")} Agent stopped early. Fix the error above and re-run.`);
+    process.exit(1);
+  }
+}
+
+function showAgent(infernoDir, name) {
+  const agent = findAgent(infernoDir, name);
+  if (!agent) {
+    warn(`Agent "${name}" not found.`);
+    process.exit(1);
+  }
+  console.log(JSON.stringify(agent, null, 2));
+}
+
+function deleteAgent(infernoDir, name) {
+  const agent = findAgent(infernoDir, name);
+  if (!agent) {
+    warn(`Agent "${name}" not found.`);
+    process.exit(1);
+  }
+  const filePath = path.join(agentsDir(infernoDir), `${agent.name}.json`);
+  fs.unlinkSync(filePath);
+  ok(`Deleted agent: ${agent.name}`);
+}
+
+// ── Main ──────────────────────────────────────────────────────────────────────
+
+export async function agentCommand(args) {
+  const cwd = process.cwd();
+  const infernoDir = findInfernoDir(cwd);
+
+  if (!infernoDir) {
+    warn("inferno/ not found — run infernoflow init first");
+    process.exit(1);
+  }
+
+  observeCommandStart(infernoDir, "agent");
+
+  const sub  = args[0];
+  const name = args[1];
+
+  switch (sub) {
+    case "list":
+    case undefined:
+      listAgents(infernoDir);
+      break;
+
+    case "run":
+      if (!name) { warn("Usage: infernoflow agent run <name>"); process.exit(1); }
+      await runAgent(infernoDir, cwd, name);
+      break;
+
+    case "show":
+      if (!name) { warn("Usage: infernoflow agent show <name>"); process.exit(1); }
+      showAgent(infernoDir, name);
+      break;
+
+    case "delete":
+    case "remove":
+      if (!name) { warn("Usage: infernoflow agent delete <name>"); process.exit(1); }
+      deleteAgent(infernoDir, name);
+      break;
+
+    default:
+      // Treat unknown arg as agent name to run (convenience shortcut)
+      await runAgent(infernoDir, cwd, sub);
+  }
+}

package/dist/lib/commands/synthesize.mjs

@@ -0,0 +1,228 @@
+/**
+ * infernoflow synthesize
+ *
+ * Analyzes your observed development sessions and auto-proposes reusable
+ * skills and agents based on repeated patterns.
+ *
+ * Usage:
+ *   infernoflow synthesize               — interactive review of candidates
+ *   infernoflow synthesize --auto        — auto-approve high-confidence (≥0.8)
+ *   infernoflow synthesize --json        — print candidates as JSON, exit
+ *   infernoflow synthesize --threshold 2 — surface patterns seen 2+ times
+ *   infernoflow synthesize --watch       — re-run every 60s, surface new candidates
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+import * as readline from "node:readline";
+import { header, ok, warn, info, done, bold, cyan, yellow, green, gray } from "../ui/output.mjs";
+import { readProfile, writeProfile } from "../learning/profile.mjs";
+import { detectPatterns, mergeCandidates, pendingCandidates } from "../learning/patternDetector.mjs";
+import { synthesizeCandidate } from "../learning/skillSynthesizer.mjs";
+import { observeCommandStart } from "../learning/observe.mjs";
+
+function findInfernoDir(cwd) {
+  const infernoDir = path.join(cwd, "inferno");
+  if (!fs.existsSync(infernoDir)) return null;
+  return infernoDir;
+}
+
+function ask(rl, question) {
+  return new Promise(resolve => rl.question(question, a => resolve(a.trim().toLowerCase())));
+}
+
+function renderCandidate(c, index) {
+  const type   = c.type === "agent" ? cyan("agent") : green("skill");
+  const conf   = Math.round(c.confidence * 100);
+  const confStr = conf >= 80 ? green(`${conf}%`) : conf >= 60 ? yellow(`${conf}%`) : gray(`${conf}%`);
+  const freq   = gray(`seen ${c.frequency}×`);
+
+  console.log(`\n  ${bold(`[${index + 1}]`)} ${type}  ${bold(c.name)}  ${confStr} confidence  ${freq}`);
+  console.log(`      Pattern:  ${cyan(c.trigger)}`);
+  if (c.steps) console.log(`      Steps:    ${c.steps.join(" → ")}`);
+  if (c.examples?.length) {
+    console.log(`      Examples: ${c.examples.slice(0, 2).map(e => `"${e}"`).join(", ")}`);
+  }
+}
+
+async function reviewInteractive(cwd, infernoDir, profile, candidates) {
+  if (candidates.length === 0) {
+    info("No new candidates to review.");
+    return { approved: 0, rejected: 0 };
+  }
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let approved = 0, rejected = 0;
+
+  console.log(`\n  ${bold("Candidates found:")} ${candidates.length}\n`);
+  console.log(gray("  For each: [y] approve  [n] reject  [s] skip  [q] quit\n"));
+
+  for (let i = 0; i < candidates.length; i++) {
+    const c = candidates[i];
+    renderCandidate(c, i);
+
+    const ans = await ask(rl, `\n      Approve? [y/n/s/q]: `);
+
+    if (ans === "q") break;
+    if (ans === "s") continue;
+
+    const all = [...(profile.agentCandidates || []), ...(profile.skillCandidates || [])];
+    const entry = all.find(x => x.id === c.id);
+    if (!entry) continue;
+
+    if (ans === "y") {
+      entry.status = "approved";
+      try {
+        const { filePaths } = synthesizeCandidate(cwd, infernoDir, c);
+        const approvedList = c.type === "agent" ? "approvedAgents" : "approvedSkills";
+        if (!profile[approvedList]) profile[approvedList] = [];
+        profile[approvedList].push({
+          id: c.id,
+          name: c.name,
+          filePaths,
+          approvedAt: new Date().toISOString(),
+        });
+        ok(`  ${c.type === "agent" ? "Agent" : "Skill"} created:`);
+        for (const fp of filePaths) console.log(`    ${green("→")} ${fp}`);
+        approved++;
+      } catch (err) {
+        warn(`  Could not write files: ${err.message}`);
+      }
+    } else {
+      entry.status = "rejected";
+      rejected++;
+    }
+  }
+
+  rl.close();
+  return { approved, rejected };
+}
+
+function autoApprove(cwd, infernoDir, profile, candidates, threshold = 0.8) {
+  let approved = 0;
+  for (const c of candidates) {
+    if (c.confidence < threshold) continue;
+
+    const all = [...(profile.agentCandidates || []), ...(profile.skillCandidates || [])];
+    const entry = all.find(x => x.id === c.id);
+    if (!entry) continue;
+
+    entry.status = "approved";
+    try {
+      const { filePaths } = synthesizeCandidate(cwd, infernoDir, c);
+      const approvedList = c.type === "agent" ? "approvedAgents" : "approvedSkills";
+      if (!profile[approvedList]) profile[approvedList] = [];
+      profile[approvedList].push({
+        id: c.id,
+        name: c.name,
+        filePaths,
+        approvedAt: new Date().toISOString(),
+      });
+      ok(`Auto-approved ${c.type}: ${bold(c.name)} (${Math.round(c.confidence * 100)}% confidence)`);
+      for (const fp of filePaths) console.log(`  ${green("→")} ${fp}`);
+      approved++;
+    } catch (err) {
+      warn(`Could not write ${c.name}: ${err.message}`);
+    }
+  }
+  return approved;
+}
+
+export async function synthesizeCommand(args) {
+  const cwd       = process.cwd();
+  const isAuto    = args.includes("--auto");
+  const isJson    = args.includes("--json");
+  const isWatch   = args.includes("--watch");
+  const threshold = (() => {
+    const idx = args.indexOf("--threshold");
+    return idx !== -1 ? Number(args[idx + 1]) || 3 : 3;
+  })();
+
+  const infernoDir = findInfernoDir(cwd);
+  if (!infernoDir) {
+    if (isJson) {
+      process.stdout.write(JSON.stringify({ ok: false, error: "inferno/ not found" }) + "\n");
+    } else {
+      warn("inferno/ not found — run infernoflow init first");
+    }
+    process.exit(1);
+  }
+
+  observeCommandStart(infernoDir, "synthesize");
+
+  async function runOnce() {
+    const profile = readProfile(infernoDir);
+
+    // ── Detect patterns ──────────────────────────────────────────────────────
+    const { agentCandidates, skillCandidates } = detectPatterns(profile, { minFreq: threshold });
+    mergeCandidates(profile, { agentCandidates, skillCandidates });
+
+    const pending = pendingCandidates(profile);
+
+    // ── JSON mode ────────────────────────────────────────────────────────────
+    if (isJson) {
+      writeProfile(infernoDir, profile);
+      process.stdout.write(JSON.stringify({
+        ok: true,
+        pendingCount: pending.length,
+        candidates: pending,
+        sessions: profile.recentSessions?.length || 0,
+      }, null, 2) + "\n");
+      return;
+    }
+
+    header("infernoflow synthesize");
+    info(`Sessions analyzed: ${bold(String(profile.recentSessions?.length || 0))}`);
+    info(`Minimum frequency: ${bold(String(threshold))}×`);
+
+    if (pending.length === 0) {
+      console.log();
+      if ((profile.recentSessions?.length || 0) < threshold) {
+        warn(`Not enough session data yet — need at least ${threshold} sessions with similar commands.`);
+        warn(`Keep using infernoflow and run synthesize again soon.`);
+      } else {
+        ok("No new patterns detected — your workflow is already well captured.");
+      }
+      writeProfile(infernoDir, profile);
+      return;
+    }
+
+    info(`New patterns detected: ${bold(String(pending.length))}`);
+
+    // ── Auto mode ────────────────────────────────────────────────────────────
+    let approved;
+    if (isAuto) {
+      info(`Auto-approving candidates with ≥80% confidence...`);
+      approved = autoApprove(cwd, infernoDir, profile, pending);
+    } else {
+      const result = await reviewInteractive(cwd, infernoDir, profile, pending);
+      approved = result.approved;
+      if (result.rejected > 0) info(`Rejected: ${result.rejected}`);
+    }
+
+    writeProfile(infernoDir, profile);
+
+    if (approved > 0) {
+      console.log();
+      done(`${approved} skill${approved !== 1 ? "s/agents" : "/agent"} synthesized`);
+      console.log(`\n  ${bold("What was created:")}`);
+      for (const item of [...(profile.approvedSkills || []), ...(profile.approvedAgents || [])].slice(-approved)) {
+        const type = profile.approvedAgents?.find(a => a.id === item.id) ? "agent" : "skill";
+        console.log(`    ${green("✔")} ${type}: ${bold(item.name)}`);
+        for (const fp of item.filePaths || []) console.log(`       ${gray(fp)}`);
+      }
+      console.log(`\n  ${bold("Next:")} Run ${cyan("infernoflow agent list")} to see your agents`);
+      console.log(`         or ${cyan("infernoflow agent run <name>")} to execute one`);
+    }
+  }
+
+  if (isWatch) {
+    info("Watching for new patterns — press Ctrl+C to stop");
+    const INTERVAL = 60_000;
+    await runOnce();
+    setInterval(runOnce, INTERVAL);
+    await new Promise(() => {}); // keep alive
+  } else {
+    await runOnce();
+  }
+}

package/dist/lib/learning/observe.mjs

@@ -15,6 +15,7 @@ import {
   readProfile,
   writeProfile,
   recordCommandUse,
+  recordSessionCommand,
   detectNamingStyle,
   detectPreferredVerbs,
   recordCapabilityCluster,
@@ -27,8 +28,9 @@ const SESSION_GAP_MS = 30 * 60 * 1000; // 30 minutes = new session
  *
  * @param {string} infernoDir  — path to the inferno/ directory
  * @param {string} command     — the CLI command name (e.g. "suggest", "run", "check")
+ * @param {object} [extras]    — optional: { task: string } for suggest/implement/run
  */
-export function observeCommandStart(infernoDir, command) {
+export function observeCommandStart(infernoDir, command, extras = {}) {
   try {
     const profile = readProfile(infernoDir);
 
@@ -43,6 +45,9 @@ export function observeCommandStart(infernoDir, command) {
     }
     profile._lastCommandTs = now;
 
+    // Sprint 5: record rich session event
+    recordSessionCommand(profile, command, extras);
+
     writeProfile(infernoDir, profile);
   } catch {
     // Silent — never break the real command

package/dist/lib/learning/patternDetector.mjs

@@ -0,0 +1,298 @@
+/**
+ * lib/learning/patternDetector.mjs
+ *
+ * Analyzes recentSessions from developer-profile.json and surfaces two kinds
+ * of candidates:
+ *
+ *  1. AGENT candidates — command sequences repeated 3+ times in the same order
+ *     e.g. ["suggest","implement","check","changelog"] → "release-feature" agent
+ *
+ *  2. SKILL candidates — task descriptions that share a template pattern
+ *     e.g. "add X filter", "add Y filter", "add Z filter"
+ *     → skill: "When adding filters, follow the FilterBy* naming convention"
+ *
+ * Returns: { agentCandidates: Candidate[], skillCandidates: Candidate[] }
+ */
+
+// ── Sequence analysis ─────────────────────────────────────────────────────────
+
+/**
+ * Extract all command sequences from sessions.
+ * Returns an array of string[] — one per session.
+ */
+function extractSequences(sessions) {
+  return (sessions || [])
+    .map(s => (s.commands || []).map(c => c.cmd))
+    .filter(seq => seq.length >= 2);
+}
+
+/**
+ * Find subsequences that repeat across sessions.
+ * A subsequence is a contiguous run of 2+ commands.
+ * Returns Map<sequenceKey, { seq, count, sessions[] }>
+ */
+function findRepeatedSubsequences(sequences, minLen = 2, minFreq = 2) {
+  const counts = new Map();
+
+  for (let si = 0; si < sequences.length; si++) {
+    const seq = sequences[si];
+    const seen = new Set(); // deduplicate within one session
+    for (let start = 0; start < seq.length; start++) {
+      for (let end = start + minLen; end <= seq.length; end++) {
+        const sub = seq.slice(start, end);
+        const key = sub.join("→");
+        if (seen.has(key)) continue;
+        seen.add(key);
+        if (!counts.has(key)) counts.set(key, { seq: sub, count: 0, sessionIndexes: [] });
+        const entry = counts.get(key);
+        entry.count++;
+        entry.sessionIndexes.push(si);
+      }
+    }
+  }
+
+  // Filter by minimum frequency and return sorted by count desc
+  return Array.from(counts.values())
+    .filter(e => e.count >= minFreq)
+    .sort((a, b) => b.count - a.count || b.seq.length - a.seq.length);
+}
+
+/**
+ * Remove subsequences that are strict subsets of a longer one with equal count.
+ * e.g. if "suggest→implement→check" appears 4x and "suggest→implement" appears 4x,
+ * drop the shorter one.
+ */
+function deduplicateSubsequences(entries) {
+  return entries.filter(e => {
+    const eKey = e.seq.join("→");
+    // Keep if no longer sequence contains this one with same or higher count
+    return !entries.some(other => {
+      if (other === e) return false;
+      const otherKey = other.seq.join("→");
+      return other.seq.length > e.seq.length &&
+             other.count >= e.count &&
+             otherKey.includes(eKey);
+    });
+  });
+}
+
+// ── Task template analysis ────────────────────────────────────────────────────
+
+/**
+ * Extract all task strings from sessions.
+ */
+function extractTasks(sessions) {
+  const tasks = [];
+  for (const session of sessions || []) {
+    for (const cmd of session.commands || []) {
+      if (cmd.task && typeof cmd.task === "string") {
+        tasks.push({ task: cmd.task, cmd: cmd.cmd, sessionId: session.id });
+      }
+    }
+  }
+  return tasks;
+}
+
+/**
+ * Tokenize a task string into [verb, ...rest].
+ * "add due date filter" → ["add", "due date filter"]
+ */
+function tokenize(task) {
+  const words = task.toLowerCase().trim().split(/\s+/);
+  return words;
+}
+
+/**
+ * Find the longest common prefix between two word arrays.
+ */
+function commonPrefixLen(a, b) {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) i++;
+  return i;
+}
+
+/**
+ * Group tasks by their verb (first word) and detect template patterns.
+ * Returns Map<verb, { verb, tasks, template, frequency }>
+ */
+function detectTaskTemplates(taskEntries, minFreq = 2) {
+  // Group by first word (verb)
+  const byVerb = new Map();
+  for (const { task, cmd } of taskEntries) {
+    const words = tokenize(task);
+    if (words.length < 2) continue;
+    const verb = words[0];
+    if (!byVerb.has(verb)) byVerb.set(verb, []);
+    byVerb.get(verb).push({ words, original: task, cmd });
+  }
+
+  const templates = [];
+  for (const [verb, entries] of byVerb) {
+    if (entries.length < minFreq) continue;
+
+    // Find common prefix across all tasks with this verb
+    let prefix = entries[0].words;
+    for (const e of entries.slice(1)) {
+      const len = commonPrefixLen(prefix, e.words);
+      prefix = prefix.slice(0, Math.max(1, len));
+    }
+
+    const prefixStr = prefix.join(" ");
+    const templateStr = prefixStr + (prefix.length < entries[0].words.length ? " {feature}" : "");
+    const commands = [...new Set(entries.map(e => e.cmd))];
+
+    templates.push({
+      verb,
+      template: templateStr,
+      examples: entries.slice(0, 3).map(e => e.original),
+      frequency: entries.length,
+      commands,
+    });
+  }
+
+  return templates.sort((a, b) => b.frequency - a.frequency);
+}
+
+// ── Candidate builders ────────────────────────────────────────────────────────
+
+function agentName(seq) {
+  // Generate a readable name from the sequence
+  const known = {
+    "suggest→implement→check": "feature-workflow",
+    "suggest→check": "quick-suggest",
+    "check→changelog→publish": "release-workflow",
+    "suggest→implement→check→changelog": "full-feature-cycle",
+    "diff→changelog": "changelog-from-diff",
+    "context→implement": "context-first-implement",
+    "check→diff": "health-check",
+  };
+  const key = seq.join("→");
+  if (known[key]) return known[key];
+  return seq.join("-");
+}
+
+function agentDescription(seq) {
+  const labels = {
+    suggest: "generate contract update",
+    implement: "generate implementation prompt",
+    check: "validate contract health",
+    changelog: "draft changelog entry",
+    diff: "show capability diff",
+    context: "refresh AI context",
+    run: "run full task flow",
+    publish: "publish new version",
+    setup: "set up project",
+    status: "show status",
+  };
+  return seq.map(cmd => labels[cmd] || cmd).join(" → ");
+}
+
+function skillName(template) {
+  return template.replace(/[^a-zA-Z0-9]+/g, "-").replace(/-+/g, "-").toLowerCase().slice(0, 40);
+}
+
+function confidence(frequency, totalSessions) {
+  // Sigmoid-like: saturates at 1.0 around 8+ occurrences
+  const raw = Math.min(frequency / Math.max(totalSessions * 0.4, 4), 1);
+  return Math.round(raw * 100) / 100;
+}
+
+// ── Main export ───────────────────────────────────────────────────────────────
+
+/**
+ * Analyze sessions and return skill + agent candidates.
+ *
+ * @param {object} profile — the full developer profile
+ * @param {object} options
+ * @param {number} [options.minFreq=3]   — minimum repetitions to surface
+ * @param {number} [options.minSeqLen=2] — minimum sequence length for agents
+ * @returns {{ agentCandidates: Candidate[], skillCandidates: Candidate[] }}
+ */
+export function detectPatterns(profile, { minFreq = 3, minSeqLen = 2 } = {}) {
+  const sessions = profile.recentSessions || [];
+  const totalSessions = Math.max(sessions.length, 1);
+
+  // ── Agent candidates (command sequences) ─────────────────────────────────
+  const sequences = extractSequences(sessions);
+  const repeated = findRepeatedSubsequences(sequences, minSeqLen, minFreq);
+  const deduped = deduplicateSubsequences(repeated);
+
+  const existingAgentIds = new Set([
+    ...(profile.agentCandidates || []).map(c => c.id),
+    ...(profile.approvedAgents || []).map(c => c.id),
+  ]);
+
+  const agentCandidates = deduped.map(entry => {
+    const id = `agent_${entry.seq.join("_")}`;
+    if (existingAgentIds.has(id)) return null;
+    return {
+      id,
+      type: "agent",
+      name: agentName(entry.seq),
+      description: agentDescription(entry.seq),
+      trigger: `infernoflow agent run ${agentName(entry.seq)}`,
+      steps: entry.seq,
+      frequency: entry.count,
+      confidence: confidence(entry.count, totalSessions),
+      status: "pending",
+      detectedAt: new Date().toISOString(),
+    };
+  }).filter(Boolean);
+
+  // ── Skill candidates (task templates) ────────────────────────────────────
+  const taskEntries = extractTasks(sessions);
+  const templates = detectTaskTemplates(taskEntries, minFreq);
+
+  const existingSkillIds = new Set([
+    ...(profile.skillCandidates || []).map(c => c.id),
+    ...(profile.approvedSkills || []).map(c => c.id),
+  ]);
+
+  const skillCandidates = templates.map(t => {
+    const id = `skill_${skillName(t.template)}`;
+    if (existingSkillIds.has(id)) return null;
+    return {
+      id,
+      type: "skill",
+      name: skillName(t.template),
+      description: `Auto-skill: "${t.template}" pattern`,
+      trigger: t.template,
+      steps: t.commands,
+      examples: t.examples,
+      frequency: t.frequency,
+      confidence: confidence(t.frequency, totalSessions),
+      status: "pending",
+      detectedAt: new Date().toISOString(),
+    };
+  }).filter(Boolean);
+
+  return { agentCandidates, skillCandidates };
+}
+
+/**
+ * Merge newly detected candidates into the profile without duplicating
+ * already-known (pending/approved/rejected) entries.
+ */
+export function mergeCandidates(profile, { agentCandidates, skillCandidates }) {
+  const existingAgentIds = new Set((profile.agentCandidates || []).map(c => c.id));
+  const existingSkillIds = new Set((profile.skillCandidates || []).map(c => c.id));
+
+  for (const c of agentCandidates) {
+    if (!existingAgentIds.has(c.id)) {
+      profile.agentCandidates = [...(profile.agentCandidates || []), c];
+    }
+  }
+  for (const c of skillCandidates) {
+    if (!existingSkillIds.has(c.id)) {
+      profile.skillCandidates = [...(profile.skillCandidates || []), c];
+    }
+  }
+  return profile;
+}
+
+/** Return all pending candidates (not yet approved or rejected). */
+export function pendingCandidates(profile) {
+  const agents = (profile.agentCandidates || []).filter(c => c.status === "pending");
+  const skills = (profile.skillCandidates || []).filter(c => c.status === "pending");
+  return [...agents, ...skills].sort((a, b) => b.confidence - a.confidence);
+}

package/dist/lib/learning/profile.mjs

@@ -9,7 +9,7 @@
  *
  * Schema:
  * {
- *   schemaVersion: 1,
+ *   schemaVersion: 2,
  *   createdAt: ISO string,
  *   updatedAt: ISO string,
  *   sessionCount: number,
@@ -35,13 +35,41 @@
  *     framework: string,
  *     projectType: string,
  *   },
+ *
+ *   // Sprint 5: Session sequence tracking for auto-skill synthesis
+ *   recentSessions: SessionRecord[],   // last 100 sessions
+ *   skillCandidates: Candidate[],      // pending skill proposals
+ *   agentCandidates: Candidate[],      // pending agent proposals
+ *   approvedSkills: ApprovedItem[],    // approved + written to disk
+ *   approvedAgents: ApprovedItem[],    // approved + written to disk
+ * }
+ *
+ * SessionRecord = {
+ *   id: string,
+ *   startedAt: ISO string,
+ *   commands: Array<{ cmd, task?, caps?, ts }>,
+ * }
+ *
+ * Candidate = {
+ *   id: string,
+ *   type: "skill" | "agent",
+ *   name: string,
+ *   trigger: string,          // e.g. "add {feature} filter"
+ *   steps: string[],          // e.g. ["suggest", "implement", "check"]
+ *   frequency: number,
+ *   confidence: number,       // 0–1
+ *   status: "pending" | "approved" | "rejected",
+ *   detectedAt: ISO string,
  * }
+ *
+ * ApprovedItem = { id, name, filePath, approvedAt }
  */
 
 import * as fs from "node:fs";
 import * as path from "node:path";
 
-export const PROFILE_SCHEMA_VERSION = 1;
+export const PROFILE_SCHEMA_VERSION = 2;
+export const MAX_RECENT_SESSIONS = 100;
 
 export function profilePath(infernoDir) {
   return path.join(infernoDir, "developer-profile.json");
@@ -67,7 +95,46 @@ export function blankProfile() {
       framework: "unknown",
       projectType: "unknown",
     },
+    // Sprint 5 fields
+    recentSessions: [],
+    skillCandidates: [],
+    agentCandidates: [],
+    approvedSkills: [],
+    approvedAgents: [],
+  };
+}
+
+// ── Session helpers ───────────────────────────────────────────────────────────
+
+/** Open or continue the current session in the profile. */
+export function openSession(profile) {
+  const SESSION_GAP_MS = 30 * 60 * 1000;
+  const now = Date.now();
+  const last = profile.recentSessions?.[profile.recentSessions.length - 1];
+
+  if (last && now - new Date(last.startedAt).getTime() < SESSION_GAP_MS) {
+    return last; // continue existing session
+  }
+
+  // Start new session
+  const session = {
+    id: `s${profile.sessionCount + 1}_${now}`,
+    startedAt: new Date(now).toISOString(),
+    commands: [],
   };
+  if (!profile.recentSessions) profile.recentSessions = [];
+  profile.recentSessions.push(session);
+  // Keep only last MAX_RECENT_SESSIONS
+  if (profile.recentSessions.length > MAX_RECENT_SESSIONS) {
+    profile.recentSessions = profile.recentSessions.slice(-MAX_RECENT_SESSIONS);
+  }
+  return session;
+}
+
+/** Append a command event to the current session. */
+export function recordSessionCommand(profile, cmd, extras = {}) {
+  const session = openSession(profile);
+  session.commands.push({ cmd, ts: Date.now(), ...extras });
 }
 
 /** Read the profile, returning a blank one if it doesn't exist yet. */

package/dist/lib/learning/skillSynthesizer.mjs

@@ -0,0 +1,173 @@
+/**
+ * lib/learning/skillSynthesizer.mjs
+ *
+ * Converts approved candidates into actual files on disk:
+ *
+ *  AGENTS  → inferno/agents/<name>.json
+ *            (runnable via `infernoflow agent run <name>`)
+ *
+ *  SKILLS  → inferno/skills/<name>.md
+ *            + appends to .cursor/rules/infernoflow-auto.mdc
+ *            + appends to CLAUDE.md (if it exists)
+ */
+
+import * as fs   from "node:fs";
+import * as path from "node:path";
+
+// ── Agent file writer ─────────────────────────────────────────────────────────
+
+/**
+ * Write an agent definition to inferno/agents/<name>.json.
+ * Returns the file path written.
+ */
+export function writeAgentFile(infernoDir, candidate) {
+  const agentsDir = path.join(infernoDir, "agents");
+  fs.mkdirSync(agentsDir, { recursive: true });
+
+  const agentDef = {
+    id: candidate.id,
+    name: candidate.name,
+    description: candidate.description,
+    steps: candidate.steps.map(cmd => ({ command: cmd, args: [] })),
+    createdAt: new Date().toISOString(),
+    source: "auto-synthesized",
+    frequency: candidate.frequency,
+    confidence: candidate.confidence,
+  };
+
+  const filePath = path.join(agentsDir, `${candidate.name}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(agentDef, null, 2) + "\n", "utf8");
+  return filePath;
+}
+
+// ── Skill file writers ────────────────────────────────────────────────────────
+
+/**
+ * Write a skill markdown file to inferno/skills/<name>.md.
+ */
+export function writeSkillFile(infernoDir, candidate) {
+  const skillsDir = path.join(infernoDir, "skills");
+  fs.mkdirSync(skillsDir, { recursive: true });
+
+  const examples = (candidate.examples || [])
+    .map(e => `  - "${e}"`)
+    .join("\n");
+
+  const steps = (candidate.steps || [])
+    .map((s, i) => `${i + 1}. Run \`infernoflow ${s}\``)
+    .join("\n");
+
+  const content = `# Skill: ${candidate.name}
+
+> Auto-synthesized from ${candidate.frequency} observed sessions (confidence: ${Math.round(candidate.confidence * 100)}%)
+
+## Trigger pattern
+
+\`${candidate.trigger}\`
+
+## Example tasks this applies to
+
+${examples || "  (none recorded)"}
+
+## Recommended workflow
+
+When working on a task matching the pattern above:
+
+${steps}
+
+## Notes
+
+- This skill was automatically generated by \`infernoflow synthesize\`
+- Review and edit as needed — it is yours to own
+- Re-run \`infernoflow synthesize\` to update as your patterns evolve
+`;
+
+  const filePath = path.join(skillsDir, `${candidate.name}.md`);
+  fs.writeFileSync(filePath, content, "utf8");
+  return filePath;
+}
+
+/**
+ * Append a skill rule to .cursor/rules/infernoflow-auto.mdc.
+ * Creates the file if it doesn't exist.
+ */
+export function appendToCursorRules(cwd, candidate) {
+  const rulesDir = path.join(cwd, ".cursor", "rules");
+  fs.mkdirSync(rulesDir, { recursive: true });
+
+  const filePath = path.join(rulesDir, "infernoflow-auto.mdc");
+
+  const header = fs.existsSync(filePath) ? "" :
+    `---
+description: Auto-generated infernoflow workflow rules
+globs: ["**/*"]
+alwaysApply: true
+---
+
+# infernoflow Auto-Generated Workflow Rules
+
+These rules are synthesized from your observed development patterns.
+Do not edit manually — re-run \`infernoflow synthesize\` to regenerate.
+
+`;
+
+  const rule = `
+## ${candidate.name}
+
+Pattern: \`${candidate.trigger}\`
+
+When working on tasks matching this pattern:
+${(candidate.steps || []).map((s, i) => `${i + 1}. Run \`infernoflow ${s}\``).join("\n")}
+
+`;
+
+  fs.appendFileSync(filePath, header + rule, "utf8");
+  return filePath;
+}
+
+/**
+ * Append a skill tip to CLAUDE.md if it exists.
+ */
+export function appendToClaudeMd(cwd, candidate) {
+  const claudeMdPath = path.join(cwd, "CLAUDE.md");
+  if (!fs.existsSync(claudeMdPath)) return null;
+
+  const existing = fs.readFileSync(claudeMdPath, "utf8");
+  const marker = "## infernoflow Auto-Skills";
+
+  const tip = `\n- **${candidate.name}**: For tasks like \`${candidate.trigger}\`, run: ${(candidate.steps || []).map(s => `\`infernoflow ${s}\``).join(" → ")}`;
+
+  if (!existing.includes(marker)) {
+    fs.appendFileSync(claudeMdPath, `\n\n${marker}\n${tip}\n`, "utf8");
+  } else {
+    // Append after the marker section
+    const updated = existing.replace(marker, marker + tip);
+    fs.writeFileSync(claudeMdPath, updated, "utf8");
+  }
+
+  return claudeMdPath;
+}
+
+// ── Main synthesize function ──────────────────────────────────────────────────
+
+/**
+ * Write all files for an approved candidate.
+ * Returns { filePaths: string[] } — list of files written.
+ */
+export function synthesizeCandidate(cwd, infernoDir, candidate) {
+  const filePaths = [];
+
+  if (candidate.type === "agent") {
+    filePaths.push(writeAgentFile(infernoDir, candidate));
+  } else {
+    // skill
+    filePaths.push(writeSkillFile(infernoDir, candidate));
+    try { filePaths.push(appendToCursorRules(cwd, candidate)); } catch {}
+    try {
+      const p = appendToClaudeMd(cwd, candidate);
+      if (p) filePaths.push(p);
+    } catch {}
+  }
+
+  return { filePaths };
+}

package/dist/templates/cursor/inferno-mcp-server.mjs

@@ -22,6 +22,9 @@ const TOOLS = [
   { name: "infernoflow_implement", description: "Generate a structured code implementation prompt for a task. Uses the contract and stack context to produce step-by-step coding instructions for the agent.", inputSchema: { type: "object", properties: { task: { type: "string", description: "What to implement" }, mode: { type: "string", enum: ["cursor", "generic", "both"], description: "Prompt style (default: both)" } }, required: ["task"] } },
   { name: "infernoflow_scan_ui", description: "Scan components and styles for UI changes vs the stored contract. Returns new/changed components, design token changes, and suggested contract updates.", inputSchema: { type: "object", properties: {} } },
   { name: "infernoflow_review", description: "Pre-merge capability drift check. Compares all changed files in the current branch against the capability contract and reports drift risk before you merge.", inputSchema: { type: "object", properties: { branch: { type: "string", description: "Branch to compare against (default: main)" } } } },
+  { name: "infernoflow_synthesize", description: "Detect repeated workflow patterns in this developer's sessions and surface skill/agent candidates. Call this proactively to help the developer automate their recurring workflows.", inputSchema: { type: "object", properties: { threshold: { type: "number", description: "Minimum times a pattern must repeat to surface it (default: 2)" }, autoApprove: { type: "boolean", description: "Auto-approve high-confidence (≥80%) candidates without asking" } } } },
+  { name: "infernoflow_agent_run", description: "Execute a saved infernoflow agent (a named sequence of commands). Use infernoflow_synthesize first to see available agents.", inputSchema: { type: "object", properties: { name: { type: "string", description: "Agent name to run" } }, required: ["name"] } },
+  { name: "infernoflow_agent_list", description: "List all saved infernoflow agents available in this project.", inputSchema: { type: "object", properties: {} } },
 ];
 
 // ── git drift detection (inline — no external imports in this template file) ─
@@ -226,6 +229,66 @@ function scanUi() {
   return lines.join("\n");
 }
 
+// ── infernoflow_synthesize / agent tools ──────────────────────────────────
+function synthesizePatterns(threshold, autoApprove) {
+  const args = `synthesize --json --threshold ${threshold}`;
+  const out = runCmd(args);
+  try {
+    const data = JSON.parse(out);
+    if (!data.ok) return `synthesize error: ${data.error}`;
+    const pending = data.candidates || [];
+    if (pending.length === 0) {
+      return `No new workflow patterns detected yet (${data.sessions} sessions analyzed).\nKeep using infernoflow and run this tool again after a few more sessions.`;
+    }
+    const lines = [
+      `📊 ${data.sessions} sessions analyzed — ${pending.length} new pattern${pending.length !== 1 ? "s" : ""} found:\n`
+    ];
+    for (const c of pending) {
+      const conf = Math.round(c.confidence * 100);
+      lines.push(`  [${c.type.toUpperCase()}] ${c.name} (${conf}% confidence, seen ${c.frequency}×)`);
+      lines.push(`    Pattern: "${c.trigger}"`);
+      if (c.steps) lines.push(`    Steps: ${c.steps.join(" → ")}`);
+      if (c.examples?.length) lines.push(`    Examples: ${c.examples.slice(0, 2).map(e => `"${e}"`).join(", ")}`);
+      lines.push("");
+    }
+    if (autoApprove) {
+      runCmd(`synthesize --auto --threshold ${threshold}`);
+      lines.push(`\n✅ High-confidence candidates auto-approved. Run infernoflow agent list to see new agents.`);
+    } else {
+      lines.push(`💡 To approve these, run: infernoflow synthesize`);
+      lines.push(`   Or auto-approve all: infernoflow synthesize --auto`);
+    }
+    return lines.join("\n");
+  } catch {
+    return out || "synthesize returned no output";
+  }
+}
+
+function listAgents() {
+  const cwd = process.cwd();
+  const agentsDir = path.join(cwd, "inferno", "agents");
+  if (!fs.existsSync(agentsDir)) return "No agents saved yet. Run infernoflow synthesize to auto-generate agents from your workflow patterns.";
+  const files = fs.readdirSync(agentsDir).filter(f => f.endsWith(".json"));
+  if (!files.length) return "No agents saved yet. Run infernoflow synthesize to auto-generate agents.";
+  const agents = files.map(f => {
+    try { return JSON.parse(fs.readFileSync(path.join(agentsDir, f), "utf8")); }
+    catch { return null; }
+  }).filter(Boolean);
+  const lines = [`${agents.length} saved agent${agents.length !== 1 ? "s" : ""}:\n`];
+  for (const a of agents) {
+    const steps = (a.steps || []).map(s => typeof s === "string" ? s : s.command).join(" → ");
+    lines.push(`  ▶ ${a.name}`);
+    lines.push(`    ${a.description || steps}`);
+    lines.push(`    Run: infernoflow agent run ${a.name}\n`);
+  }
+  return lines.join("\n");
+}
+
+function runAgent(name) {
+  if (!name) return "Usage: provide an agent name";
+  return runCmd(`agent run ${name}`) || `Agent "${name}" completed.`;
+}
+
 // ── infernoflow_review ─────────────────────────────────────────────────────
 function reviewDrift(baseBranch) {
   const cwd = process.cwd();
@@ -454,6 +517,12 @@ function handleTool(id, name, input) {
       text = scanUi();
     } else if (name === "infernoflow_review") {
       text = reviewDrift(input.branch || "main");
+    } else if (name === "infernoflow_synthesize") {
+      text = synthesizePatterns(input.threshold || 2, input.autoApprove || false);
+    } else if (name === "infernoflow_agent_list") {
+      text = listAgents();
+    } else if (name === "infernoflow_agent_run") {
+      text = runAgent(input.name);
     } else { return sendError(id, -32601, `Unknown tool: ${name}`); }
     sendResult(id, { content: [{ type: "text", text: text || "(no output)" }] });
   } catch (err) { sendError(id, -32000, err.message); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "infernoflow",
-  "version": "0.10.28",
+  "version": "0.11.0",
   "description": "The forge for liquid code — keep capabilities, contracts, and docs in sync.",
   "type": "module",
   "bin": {