@husk-ai/sessions 0.1.1

package/dist/distill.js

@@ -0,0 +1,773 @@
+import { clampText, estimateTokens, mapLimit, parseSpec, slug, deepMerge, } from '@husk-ai/core';
+import { CandidateSchema, MergedSchema, extractSystemPrompt, extractUserPrompt, mergeSystemPrompt, mergeUserPrompt, renderWindow, } from './prompts.js';
+import { redactDistilled } from './redactor.js';
+import { containsHarnessArtifact, isScaffoldingOnly, looksLikeStatusReport, markupRatio, stripScaffolding, } from './scaffold.js';
+/**
+ * Two distillers, on purpose.
+ *
+ * `distillHeuristic` is the free path. It has to produce a bot somebody would
+ * actually use, because most people will never set an API key. `distillWithModel`
+ * is better when a model is reachable, and falls back to the free path rather
+ * than failing.
+ */
+// -- shared mining helpers ---------------------------------------------------
+/** Claude Code and friends inject synthetic user turns. They are not the user. */
+const SYNTHETIC_USER = [
+    /^<(command-name|command-message|command-args|local-command-stdout|local-command-stderr|user-prompt-submit-hook|system-reminder|task-notification|ci-monitor-event)>/i,
+    /^\[SYSTEM NOTIFICATION\b/i,
+    /^Caveat: The messages below were generated by the user while running/i,
+    /^\[Request interrupted/i,
+    /^\[Image: original \d+x\d+/i,
+    /^\[image: /i,
+    /^Base directory for this skill:/i,
+    /^This session is being continued from a previous conversation/i,
+    /^Please continue the conversation from where we left it off/i,
+];
+const CORRECTION = [
+    /^\s*(no+[,.! ]|nope\b|wrong\b|incorrect\b|stop\b|undo\b|revert\b|redo\b)/i,
+    /^\s*(that'?s (not|wrong|incorrect)|not what i|try again|fix (that|it|this)|you (didn'?t|did not|missed|broke|forgot))/i,
+    /\b(you were supposed to|i (already )?said|i asked you to|that'?s not what i|still (broken|failing|wrong)|doesn'?t work)\b/i,
+];
+export const DIRECTIVES = [
+    // Deliberately anchored. A bare "you're" in the middle of a sentence is not a
+    // role definition, and treating it as one produces a nonsense persona opener.
+    {
+        re: /^(?:you are|you're)\s+(?:a|an|the|my|our)\b|^(?:act|behave|work) as\b|\byour role is\b|^you (?:are|act) (?:now )?(?:a|an|the)\b/i,
+        weight: 4,
+        kind: 'identity',
+    },
+    // People rarely write "you are a senior engineer". They write "think like a
+    // CTO", "approach this as a reviewer", "wear your PM hat". Missing these was
+    // the difference between a persona and a topic sentence on real transcripts.
+    {
+        re: /^(?:think|reason|respond|behave|approach\s+\w+)\s+(?:like|as)\s+(?:a|an|the)?\b|^(?:you|please)?\s*(?:think|act)\s+like\s+/i,
+        weight: 4,
+        kind: 'identity',
+    },
+    {
+        re: /\b(?:wear(?:ing)?|put on)\s+(?:your|the|a|an)\s+[\w\s-]{0,24}\bhat\b|\bas (?:if you were|though you were)\b/i,
+        weight: 3,
+        kind: 'identity',
+    },
+    {
+        re: /^(?:be|become)\s+(?:a|an|the|my|our)\s+\w+|^pretend (?:to be|you)\b|^imagine (?:you are|you're)\b|^assume the role\b/i,
+        weight: 3,
+        kind: 'identity',
+    },
+    { re: /\b(from now on|going forward|every time|whenever|each time)\b/i, weight: 3, kind: 'rule' },
+    { re: /\balways\b/i, weight: 3, kind: 'rule' },
+    { re: /\bnever\b/i, weight: 3, kind: 'rule' },
+    { re: /\b(do not|don'?t|avoid|refuse to|under no circumstances)\b/i, weight: 2, kind: 'rule' },
+    { re: /\b(make sure|ensure|be sure to|you must|you should|remember to)\b/i, weight: 2, kind: 'rule' },
+    { re: /\b(use|prefer|stick to|default to|rely on)\b/i, weight: 1, kind: 'preference' },
+    { re: /\b(keep it|be)\s+(brief|concise|short|terse|detailed|thorough|specific|blunt|honest)\b/i, weight: 2, kind: 'style' },
+    { re: /\b(respond|reply|answer|write|output|format)\b.{0,30}\b(in|as|with|using)\b/i, weight: 1, kind: 'style' },
+];
+const TOOL_BUNDLES = [
+    { bundle: 'computer', re: /^(bash|powershell|shell|sh|zsh|terminal|cmd|exec|execute|run|command|bashoutput|killshell|killbash|computer|container)/i },
+    { bundle: 'files', re: /^(read|write|edit|multiedit|str_replace|create_file|notebook(read|edit)?|glob|grep|ls|listdir|list_files|search_files|file)/i },
+    { bundle: 'web', re: /^(webfetch|websearch|web_search|browse|browser|fetch|navigate|http|curl|url|search)/i },
+];
+/** Orchestration plumbing. Real in the transcript, meaningless in a husk.yaml. */
+const IGNORED_TOOLS = /^(task|todowrite|todoread|exitplanmode|enterplanmode|sendmessage|taskoutput|taskstop|toolsearch|skill|monitor|askuserquestion|thinking)$/i;
+function isSynthetic(text) {
+    const head = text.trimStart();
+    if (SYNTHETIC_USER.some((re) => re.test(head)))
+        return true;
+    // A turn that is nothing but a harness block is plumbing whatever role it
+    // was filed under. The importer normally removes these; a transcript
+    // imported before that fix, or by another importer, still gets screened.
+    return isScaffoldingOnly(head);
+}
+function isCorrection(text) {
+    const head = text.trimStart().slice(0, 400);
+    return CORRECTION.some((re) => re.test(head));
+}
+/**
+ * Real user turns: what a person typed, with the plumbing removed.
+ *
+ * When the importer recorded `promptSource` -- Claude Code does -- that field is
+ * authoritative and the text heuristics are skipped. It is the difference
+ * between a prompt the user wrote and a skill document the harness pasted in
+ * wearing the user's role.
+ */
+export function humanTurns(messages) {
+    const candidates = messages
+        .filter((m) => m.role === 'user' && !m.toolName && m.content.trim().length > 0)
+        // Attribution decides *which* turns to consider; it never licenses a turn
+        // that is plainly machine output. An importer that mis-attributes one
+        // harness block should cost us that block, not the whole screen.
+        .filter((m) => !isSynthetic(m.content));
+    const attributed = candidates.filter((m) => typeof m.meta?.promptSource === 'string');
+    return attributed.length ? attributed : candidates;
+}
+function assistantSpeech(messages) {
+    return messages.filter((m) => m.role === 'assistant' && !m.toolName && m.content.trim().length > 0);
+}
+/** Sentence-ish units, with markdown chrome removed and fragments discarded. */
+function sentences(text) {
+    const withoutCode = text.replace(/```[\s\S]*?```/g, ' ');
+    return withoutCode
+        .split(/\n{2,}|(?<=[.!?])\s+(?=[A-Z"'`\-*\d])|\n(?=[-*•]\s)|\n/g)
+        .map((s) => s
+        .replace(/^[-*•]\s+/, '')
+        .replace(/^\d+[.)]\s+/, '')
+        .replace(/^#+\s*/, '')
+        .replace(/\*\*|__|`/g, '')
+        .replace(/\s+/g, ' ')
+        .trim())
+        .filter((s) => s.length >= 12 && s.length <= 300)
+        // A unit that starts lower-case and does not open with a directive verb is
+        // the tail of a wrapped line, not an instruction.
+        .filter((s) => !/^[a-z]/.test(s) || /^(always|never|don'?t|do not|avoid|use|prefer|make sure|ensure|keep|you|only|stick)\b/i.test(s));
+}
+function normaliseKey(s) {
+    return s
+        .toLowerCase()
+        .replace(/[^a-z ]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .slice(0, 120);
+}
+/**
+ * Standing instructions, ranked.
+ *
+ * Recurrence is the signal that matters: a sentence the user typed once might be
+ * about today's task, and one they typed four times is how they want to be
+ * worked with.
+ */
+export function mineRules(messages, limit = 12) {
+    const seen = new Map();
+    for (const m of humanTurns(messages)) {
+        if (isCorrection(m.content))
+            continue;
+        for (const raw of sentences(m.content)) {
+            if (/^https?:\/\//i.test(raw) || /^[`{[]/.test(raw))
+                continue;
+            // A sentence carrying a tool-use id or a temp path is describing one run.
+            if (containsHarnessArtifact(raw))
+                continue;
+            let weight = 0;
+            let kind = 'rule';
+            for (const d of DIRECTIVES) {
+                if (!d.re.test(raw))
+                    continue;
+                if (d.weight > weight) {
+                    weight = d.weight;
+                    kind = d.kind;
+                }
+            }
+            if (weight < 2)
+                continue;
+            const key = normaliseKey(raw);
+            if (!key)
+                continue;
+            const existing = seen.get(key);
+            if (existing) {
+                existing.occurrences++;
+                if (raw.length < existing.text.length)
+                    existing.text = raw;
+            }
+            else {
+                seen.set(key, { text: raw.replace(/\s+/g, ' ').trim(), kind, occurrences: 1, score: weight });
+            }
+        }
+    }
+    return [...seen.values()]
+        .map((r) => ({ ...r, score: r.score * (1 + Math.log2(r.occurrences)) }))
+        .sort((a, b) => b.score - a.score || a.text.length - b.text.length)
+        .slice(0, limit);
+}
+/** Clip on a word boundary. A title cut mid-word reads like a bug. */
+function trimTitle(s, max) {
+    const t = s.trim();
+    if (t.length <= max)
+        return t;
+    const cut = t.slice(0, max);
+    const space = cut.lastIndexOf(' ');
+    return (space > max * 0.5 ? cut.slice(0, space) : cut).trimEnd() + '...';
+}
+const FACT_SIGNALS = [
+    /```/,
+    /https?:\/\//,
+    /(^|\s)[A-Za-z]:[\\/]|(^|\s)\/[a-z]+\//,
+    /^\s*[-*]\s+\S+/m,
+    /^\s*\w[\w .-]{0,40}:\s+\S+/m,
+];
+/**
+ * Longest raw candidate that can still be a fact.
+ *
+ * Above this it is a dump, and clamping it only produces a head, a tail and
+ * "[N bytes elided]" in the middle -- a shape that teaches a model nothing and
+ * costs a fortune in every request. Several short reusable facts beat one 5 KB
+ * blob, so the blob is refused rather than mutilated.
+ */
+const KNOWLEDGE_HARD_MAX = 3000;
+/** What survives the floor is still clamped, so one item cannot dominate. */
+const KNOWLEDGE_CLAMP = 1200;
+/** Above this share of angle-bracket markup outside code fences, it is a dump. */
+const KNOWLEDGE_MAX_MARKUP = 0.15;
+/**
+ * The quality floor for a knowledge item.
+ *
+ * Everything here is a way of asking one question: would this still be true,
+ * and still be useful, in a conversation that happens next week? A tool-use id
+ * would not. A temp path would not. "Agent X finished" would not.
+ */
+export function isUsableKnowledge(title, content) {
+    if (content.length > KNOWLEDGE_HARD_MAX)
+        return false;
+    if (containsHarnessArtifact(title) || containsHarnessArtifact(content))
+        return false;
+    // Anything the scaffolding stripper still wants to cut is not a fact.
+    if (stripScaffolding(content).length !== content.length)
+        return false;
+    const cleanTitle = title.trim();
+    if (cleanTitle.length < 8)
+        return false;
+    // A title that is only a tag ("<task-notification>") names nothing.
+    if (/^<[^>]*>$/.test(cleanTitle))
+        return false;
+    if (markupRatio(content) > KNOWLEDGE_MAX_MARKUP)
+        return false;
+    if (looksLikeStatusReport(content))
+        return false;
+    return true;
+}
+export function mineKnowledge(messages, limit = 6) {
+    const out = [];
+    const seen = new Set();
+    for (const m of humanTurns(messages)) {
+        const text = m.content.trim();
+        if (text.length < 180)
+            continue;
+        if (isCorrection(text))
+            continue;
+        if (text.endsWith('?') && text.length < 400)
+            continue;
+        const signals = FACT_SIGNALS.filter((re) => re.test(text)).length;
+        if (signals === 0)
+            continue;
+        const firstLine = (text.split('\n').find((l) => l.trim().length > 3) ?? text).trim();
+        const title = trimTitle(firstLine.replace(/^#+\s*/, '').replace(/[.:]$/, ''), 72);
+        if (!isUsableKnowledge(title, text))
+            continue;
+        const key = normaliseKey(title);
+        if (!key || seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({ title, content: clampText(text, KNOWLEDGE_CLAMP).text, weight: signals * Math.log2(text.length) });
+    }
+    return out
+        .sort((a, b) => b.weight - a.weight)
+        .slice(0, limit)
+        .map(({ title, content }) => ({ title, content }));
+}
+/**
+ * Exchanges worth imitating.
+ *
+ * A turn the user immediately corrected is a counter-example, so it is excluded
+ * rather than held up as how the bot should behave.
+ */
+export function mineExamples(messages, limit = 5) {
+    const humans = humanTurns(messages);
+    const indexOfHuman = new Map();
+    humans.forEach((m, i) => indexOfHuman.set(m, i));
+    const candidates = [];
+    for (let i = 0; i < messages.length; i++) {
+        const u = messages[i];
+        if (!u || !indexOfHuman.has(u))
+            continue;
+        const humanIdx = indexOfHuman.get(u);
+        // The next thing the user typed. If it is a correction, this pair is a bad example.
+        const next = humans[humanIdx + 1];
+        if (next && isCorrection(next.content))
+            continue;
+        let reply;
+        for (let j = i + 1; j < messages.length; j++) {
+            const m = messages[j];
+            if (!m)
+                continue;
+            if (indexOfHuman.has(m))
+                break;
+            if (m.role === 'assistant' && !m.toolName && m.content.trim().length >= 40) {
+                reply = m;
+                break;
+            }
+        }
+        if (!reply)
+            continue;
+        const userText = u.content.trim();
+        const replyText = reply.content.trim();
+        if (userText.length < 15 || userText.length > 1200)
+            continue;
+        if (replyText.length > 2000)
+            continue;
+        // A few-shot exemplar is a model of how to talk to this bot. A system
+        // notification standing in for the user teaches exactly the wrong thing,
+        // and an answer full of tool-use ids teaches the wrong voice back.
+        if (isSynthetic(userText) || containsHarnessArtifact(userText))
+            continue;
+        if (containsHarnessArtifact(replyText) || looksLikeStatusReport(replyText))
+            continue;
+        candidates.push({
+            user: userText,
+            assistant: replyText,
+            weight: Math.min(replyText.length, 800) + (next ? 0 : 120),
+            at: i,
+        });
+    }
+    // Two exemplars with the same prompt teach one lesson and cost two. People
+    // repeat themselves most when a session stalls ("continue where you left
+    // off"), so the duplicates cluster on the least interesting turns.
+    const bestByPrompt = new Map();
+    for (const c of candidates) {
+        // Whole-text key, not `normaliseKey`: that one truncates at 120 chars and
+        // would collide two long prompts that merely share an opening.
+        const key = c.user.replace(/\s+/g, ' ').trim().toLowerCase();
+        const held = bestByPrompt.get(key);
+        if (!held || c.weight > held.weight)
+            bestByPrompt.set(key, c);
+    }
+    const unique = [...bestByPrompt.values()];
+    // Spread the picks across the conversation rather than taking the first five.
+    const sorted = unique.sort((a, b) => b.weight - a.weight).slice(0, limit * 4);
+    sorted.sort((a, b) => a.at - b.at);
+    if (sorted.length <= limit)
+        return sorted.map(({ user, assistant }) => ({ user, assistant }));
+    const step = sorted.length / limit;
+    const picked = [];
+    for (let i = 0; i < limit; i++) {
+        const item = sorted[Math.floor(i * step)];
+        if (item)
+            picked.push({ user: item.user, assistant: item.assistant });
+    }
+    return picked;
+}
+export function observedTools(transcript) {
+    const raw = new Set();
+    for (const m of transcript.messages)
+        if (m.toolName)
+            raw.add(m.toolName);
+    const meta = transcript.meta ?? {};
+    for (const key of ['tools', 'sidechainTools']) {
+        const v = meta[key];
+        if (Array.isArray(v))
+            for (const n of v)
+                if (typeof n === 'string')
+                    raw.add(n);
+    }
+    const bundles = new Set();
+    const passthrough = new Set();
+    for (const name of raw) {
+        if (IGNORED_TOOLS.test(name))
+            continue;
+        const hit = TOOL_BUNDLES.find((b) => b.re.test(name));
+        if (hit)
+            bundles.add(hit.bundle);
+        else
+            passthrough.add(name);
+    }
+    const order = ['computer', 'files', 'web'];
+    const suggested = [
+        ...order.filter((b) => bundles.has(b)),
+        ...[...passthrough].sort().slice(0, 10),
+    ];
+    return {
+        raw: [...raw].sort(),
+        bundles: [...bundles],
+        suggested,
+        needsComputer: bundles.has('computer'),
+    };
+}
+// -- the free path -----------------------------------------------------------
+/**
+ * Reject mined fragments that are not instructions.
+ *
+ * Markdown headings ("Humanizer rules:") and dangling references ("Same as
+ * always:") survive the mining pass because they are shaped like directives.
+ * In a persona they read as noise and teach the model nothing, so a rule has to
+ * be a whole sentence that stands on its own.
+ */
+function isUsableRule(text) {
+    if (text.length < 12)
+        return false;
+    if (text.endsWith(':'))
+        return false;
+    if (text.split(/\s+/).length < 4)
+        return false;
+    // Nothing that names a tool-use id, a temp path or a finished run belongs in
+    // a system prompt. This is the last gate before the persona.
+    if (containsHarnessArtifact(text))
+        return false;
+    if (looksLikeStatusReport(text))
+        return false;
+    if (/^<[a-z][a-z0-9-]*>/i.test(text))
+        return false;
+    // A fragment that only points elsewhere carries no instruction with it.
+    if (/^(same as (always|above|before)|see (above|below)|as (above|discussed))/i.test(text))
+        return false;
+    if (/^(part \d|step \d|#{2,}\s)/i.test(text))
+        return false;
+    return true;
+}
+function buildPersona(identity, rules, tools) {
+    const lines = [identity];
+    const ruleLines = rules
+        .filter((r) => r.kind !== 'identity')
+        .map((r) => r.text.trim())
+        .filter(isUsableRule)
+        .map((text) => `- ${text}`);
+    if (ruleLines.length)
+        lines.push('', 'How you work:', ...ruleLines);
+    if (tools.needsComputer) {
+        lines.push('', 'You have a Linux computer. Run commands to check things rather than guessing,', 'and show the command you ran when the result matters.');
+    }
+    return lines.join('\n').trim();
+}
+/**
+ * No model, no network, no key. Mines the transcript for standing instructions,
+ * durable facts, uncorrected exchanges and observed tools.
+ */
+export function distillHeuristic(transcript, opts = {}) {
+    const messages = transcript.messages;
+    const rules = mineRules(messages, opts.maxRules ?? 10);
+    const knowledge = mineKnowledge(messages, opts.maxKnowledge ?? 6);
+    const examples = mineExamples(messages, opts.maxExamples ?? 5);
+    const tools = observedTools(transcript);
+    const humans = humanTurns(messages);
+    const speech = assistantSpeech(messages);
+    const identityRule = rules.find((r) => r.kind === 'identity');
+    const subject = transcript.title?.replace(/[.\s]+$/, '') ??
+        humans[0]?.content.split('\n')[0]?.slice(0, 60) ??
+        'this conversation';
+    const identity = identityRule
+        ? `${identityRule.text.replace(/^\s*(so|ok|okay)[,\s]+/i, '').trim()}`
+        : `You are an assistant distilled from a real working session about ${subject}.`;
+    const name = slug(transcript.title ?? `${transcript.source}-bot`, 48) || 'husk-bot';
+    const description = clampText(transcript.title ?? `Distilled from a ${transcript.source} transcript with ${messages.length} messages.`, 240).text;
+    const notes = [];
+    if (!identityRule)
+        notes.push('No role instruction found -- nothing matching "you are a...", "act as", or "think like a..." -- so the persona opens with the topic instead.');
+    if (!rules.length)
+        notes.push('No recurring standing instructions found. The persona is topic-only.');
+    if (!knowledge.length)
+        notes.push('No durable user-supplied facts found worth carrying as knowledge.');
+    if (!examples.length)
+        notes.push('No uncorrected user/assistant exchange was clean enough to use as an example.');
+    if (!tools.suggested.length)
+        notes.push('No tool use observed; the bot is configured without tools.');
+    if (tools.raw.some((t) => IGNORED_TOOLS.test(t)))
+        notes.push('Orchestration tools (Task, TodoWrite, ...) were observed but are not portable to a husk.');
+    notes.push('Heuristic distillation: no model was used. Review the persona before shipping.');
+    // Capped below 1 on purpose. Pattern-matching sentences is a decent first
+    // pass, not a reading of the conversation, and the number should say so.
+    const HEURISTIC_CEILING = 0.75;
+    const confidence = Math.round(100 *
+        HEURISTIC_CEILING *
+        Math.min(1, (Math.min(rules.length, 6) / 6) * 0.35 +
+            (Math.min(examples.length, 4) / 4) * 0.3 +
+            (Math.min(knowledge.length, 3) / 3) * 0.15 +
+            (tools.suggested.length ? 0.1 : 0) +
+            (Math.min(speech.length, 20) / 20) * 0.1)) / 100;
+    const agent = {
+        name,
+        description,
+        persona: buildPersona(identity, rules, tools),
+        knowledge,
+        examples,
+        suggestedTools: tools.suggested,
+        needsComputer: tools.needsComputer,
+        confidence,
+        notes,
+    };
+    const observedModel = typeof transcript.meta?.model === 'string' ? transcript.meta.model : undefined;
+    const alias = observedModel ? modelAlias(observedModel) : undefined;
+    if (alias)
+        agent.suggestedModel = alias;
+    return opts.redact === false ? agent : redactDistilled(agent).agent;
+}
+/** Map an observed provider model id onto a Husk alias. Unknown ids stay unset. */
+export function modelAlias(model) {
+    const m = model.toLowerCase();
+    if (m.includes('opus'))
+        return 'opus';
+    if (m.includes('sonnet'))
+        return 'sonnet';
+    if (m.includes('haiku'))
+        return 'haiku';
+    if (m.includes('gpt-4') || m.includes('gpt-5') || m.startsWith('o1') || m.startsWith('o3'))
+        return 'gpt';
+    if (m.includes('flash'))
+        return 'flash';
+    if (m.includes('gemini'))
+        return 'gemini';
+    return undefined;
+}
+/**
+ * Split the whole transcript into windows.
+ *
+ * Every message lands in exactly one window plus an overlap. Nothing is dropped:
+ * truncating a 500-message transcript to its first 50 throws away the part where
+ * the user finally explained what they wanted.
+ */
+export function windowMessages(messages, windowTokens, overlap) {
+    const windows = [];
+    let current = [];
+    let tokens = 0;
+    for (const m of messages) {
+        const cost = estimateTokens(m.content) + 8;
+        if (current.length && tokens + cost > windowTokens) {
+            windows.push(current);
+            current = overlap > 0 ? current.slice(-overlap) : [];
+            tokens = current.reduce((n, x) => n + estimateTokens(x.content) + 8, 0);
+        }
+        current.push(m);
+        tokens += cost;
+    }
+    if (current.length)
+        windows.push(current);
+    return windows.length ? windows : [[]];
+}
+function stripFence(s) {
+    const t = s.trim();
+    const fenced = /^```(?:json)?\s*\n([\s\S]*?)\n?```$/.exec(t);
+    const body = (fenced?.[1] ?? t).trim();
+    // Some models prepend a sentence. Take the outermost JSON object.
+    const first = body.indexOf('{');
+    const last = body.lastIndexOf('}');
+    return first >= 0 && last > first ? body.slice(first, last + 1) : body;
+}
+function unionRules(candidates) {
+    const seen = new Map();
+    for (const c of candidates) {
+        for (const raw of c.personaRules) {
+            const text = raw.trim();
+            if (text.length < 8)
+                continue;
+            const key = normaliseKey(text);
+            const hit = seen.get(key);
+            if (hit)
+                hit.occurrences++;
+            else
+                seen.set(key, { text, kind: 'rule', occurrences: 1, score: 1 });
+        }
+    }
+    return [...seen.values()].sort((a, b) => b.occurrences - a.occurrences).slice(0, 12);
+}
+/** The same floor the heuristic path applies, for exemplars a model proposed. */
+function isCleanExample(e) {
+    if (isSynthetic(e.user) || containsHarnessArtifact(e.user))
+        return false;
+    return !containsHarnessArtifact(e.assistant) && !looksLikeStatusReport(e.assistant);
+}
+/** Deterministic merge, used when the reduce call fails or returns junk. */
+function mergeLocally(candidates, fallback, tools) {
+    const rules = unionRules(candidates);
+    if (!rules.length)
+        return fallback;
+    const knowledge = [];
+    const seenK = new Set();
+    for (const c of candidates)
+        for (const k of c.knowledge) {
+            const key = normaliseKey(k.title);
+            if (!key || seenK.has(key))
+                continue;
+            if (!isUsableKnowledge(k.title, k.content))
+                continue;
+            seenK.add(key);
+            knowledge.push({ title: k.title, content: k.content });
+            if (knowledge.length >= 8)
+                break;
+        }
+    const examples = [];
+    for (const c of candidates)
+        for (const e of c.examples)
+            if (examples.length < 6 && isCleanExample(e))
+                examples.push(e);
+    const named = candidates.find((c) => c.name.trim().length > 0);
+    return {
+        ...fallback,
+        ...(named ? { name: slug(named.name, 48) } : {}),
+        persona: buildPersona(fallback.persona.split('\n')[0] ?? '', rules, tools),
+        knowledge: knowledge.length ? knowledge : fallback.knowledge,
+        examples: examples.length ? examples : fallback.examples,
+        confidence: Math.min(0.7, fallback.confidence + 0.1),
+        notes: [...fallback.notes, 'Model reduce pass failed; candidates were merged deterministically.'],
+    };
+}
+/**
+ * Map over every window to extract candidates, then one reduce pass to merge.
+ * Any failure degrades to `distillHeuristic` rather than throwing.
+ */
+export async function distillWithModel(transcript, router, opts = {}) {
+    const heuristic = distillHeuristic(transcript, { ...opts, redact: false });
+    const tools = observedTools(transcript);
+    const model = opts.model ?? 'auto';
+    const notes = [];
+    const windows = windowMessages(transcript.messages, opts.windowTokens ?? 12_000, opts.overlap ?? 2);
+    const meta = { source: transcript.source, ...(transcript.title ? { title: transcript.title } : {}) };
+    const results = await mapLimit(windows, opts.concurrency ?? 3, async (win, index) => {
+        if (!win.length)
+            return undefined;
+        try {
+            const res = await router.chat({
+                model,
+                system: extractSystemPrompt(),
+                messages: [{ role: 'user', content: extractUserPrompt(renderWindow(win), { ...meta, index, total: windows.length }) }],
+                temperature: 0,
+                responseFormat: { type: 'json' },
+                ...(opts.signal ? { signal: opts.signal } : {}),
+            });
+            const parsed = CandidateSchema.safeParse(JSON.parse(stripFence(res.text)));
+            if (!parsed.success) {
+                notes.push(`Slice ${index + 1}/${windows.length}: model JSON did not validate.`);
+                return undefined;
+            }
+            return parsed.data;
+        }
+        catch {
+            notes.push(`Slice ${index + 1}/${windows.length}: extraction failed.`);
+            return undefined;
+        }
+    });
+    const candidates = results.filter((c) => c !== undefined);
+    if (!candidates.length) {
+        return finish({
+            ...heuristic,
+            notes: [...heuristic.notes, 'Model distillation produced nothing usable; fell back to heuristics.', ...notes],
+        }, opts);
+    }
+    let merged;
+    try {
+        const res = await router.chat({
+            model,
+            system: mergeSystemPrompt(),
+            messages: [{ role: 'user', content: mergeUserPrompt(candidates, meta) }],
+            temperature: 0,
+            responseFormat: { type: 'json' },
+            ...(opts.signal ? { signal: opts.signal } : {}),
+        });
+        const parsed = MergedSchema.safeParse(JSON.parse(stripFence(res.text)));
+        if (!parsed.success)
+            throw new Error('merge did not validate');
+        const m = parsed.data;
+        merged = {
+            name: slug(m.name || heuristic.name, 48),
+            description: clampText(m.description || heuristic.description, 240).text,
+            persona: m.persona.trim() || buildPersona(heuristic.persona.split('\n')[0] ?? '', unionRules(candidates), tools),
+            knowledge: m.knowledge.filter((k) => isUsableKnowledge(k.title, k.content)).slice(0, 8),
+            examples: m.examples.filter(isCleanExample).slice(0, 6),
+            // The transcript is ground truth about tools; the model only adds to it.
+            suggestedTools: [...new Set([...tools.suggested, ...m.tools.filter((t) => !IGNORED_TOOLS.test(t))])],
+            needsComputer: tools.needsComputer || m.needsComputer,
+            confidence: Math.min(1, Math.max(0, m.confidence)),
+            notes: [...m.notes, ...notes, `Distilled with a model over ${windows.length} window(s).`],
+        };
+        if (heuristic.suggestedModel)
+            merged.suggestedModel = heuristic.suggestedModel;
+    }
+    catch {
+        merged = mergeLocally(candidates, heuristic, tools);
+        merged.notes = [...merged.notes, ...notes];
+    }
+    return finish(merged, opts);
+}
+function finish(agent, opts) {
+    return opts.redact === false ? agent : redactDistilled(agent).agent;
+}
+/** Model path when a router is given, free path otherwise. */
+export async function distill(transcript, opts = {}) {
+    return opts.router ? distillWithModel(transcript, opts.router, opts) : distillHeuristic(transcript, opts);
+}
+/** The bundles `@husk-ai/agent` can actually resolve. Anything else is a typo. */
+const KNOWN_BUNDLES = new Set(['computer', 'files', 'web', 'http']);
+const FALLBACK_PERSONA = 'You are a careful, concise assistant.';
+/**
+ * `suggestedTools` is advisory; `spec.tools` is executable.
+ *
+ * The transcript contributes whatever the host tool happened to call things --
+ * `Bash`, `WebFetch`, `mcp__foo__bar` -- and the model path lets the model add
+ * more. Writing those through verbatim produces a husk.yaml that validates and
+ * then resolves to nothing at run time, which is the worst of both. Names are
+ * mapped onto bundles, unrecognised ones are dropped, and a husk always ends up
+ * with at least one tool.
+ */
+export function normaliseTools(suggested, needsComputer) {
+    const out = new Set();
+    for (const raw of suggested ?? []) {
+        const name = String(raw).trim();
+        if (!name)
+            continue;
+        const lower = name.toLowerCase();
+        if (KNOWN_BUNDLES.has(lower)) {
+            out.add(lower);
+            continue;
+        }
+        const hit = TOOL_BUNDLES.find((b) => b.re.test(name));
+        if (hit)
+            out.add(hit.bundle);
+    }
+    if (needsComputer)
+        out.add('computer');
+    if (!out.size)
+        out.add('files');
+    return [...out];
+}
+/**
+ * Turn a distilled agent into a spec that `parseSpec` accepts, every time.
+ * Names are slugged, strings are clamped to the schema's limits, and `origin`
+ * records where the husk came from.
+ *
+ * This is the **only** `DistilledAgent -> HuskSpec` mapper. The CLI's
+ * `specFromDistilled` and the server's `/v1/sessions/distill` both call it, so a
+ * husk distilled at the terminal and the same husk distilled over HTTP are the
+ * same file. They were not: the two call sites wrote `metadata.distilledConfidence`
+ * and `metadata.distillConfidence` respectively, and disagreed about what
+ * `origin.source` meant.
+ */
+export function toSpec(agent, overrides = {}) {
+    const { transcript, ...rest } = overrides;
+    const name = normaliseName(agent.name);
+    const base = {
+        apiVersion: 'husk/v1',
+        name,
+        displayName: humaniseName(agent.name || name),
+        description: clampText(agent.description, 280).text.slice(0, 280),
+        model: agent.suggestedModel ?? 'auto',
+        persona: agent.persona || FALLBACK_PERSONA,
+        knowledge: agent.knowledge.map((k) => ({
+            title: k.title,
+            content: k.content,
+            ...(k.source ? { source: k.source } : {}),
+        })),
+        examples: agent.examples,
+        tools: normaliseTools(agent.suggestedTools, agent.needsComputer),
+        computer: { enabled: agent.needsComputer },
+        metadata: {
+            distilledConfidence: agent.confidence,
+            distillerNotes: agent.notes,
+        },
+        ...(transcript
+            ? {
+                origin: {
+                    source: transcript.origin ?? transcript.source,
+                    transcriptId: transcript.id,
+                    importedAt: new Date().toISOString(),
+                    messageCount: transcript.messages.length,
+                },
+            }
+            : {}),
+    };
+    return parseSpec(deepMerge(base, rest));
+}
+function humaniseName(input) {
+    const words = input.replace(/[-_]+/g, ' ').replace(/\s+/g, ' ').trim();
+    const cased = words.charAt(0).toUpperCase() + words.slice(1);
+    return cased.slice(0, 96);
+}
+function normaliseName(input) {
+    const s = slug(input || 'husk-bot', 64).replace(/^[^a-z0-9]+/, '');
+    return /^[a-z0-9][a-z0-9-]*$/.test(s) ? s.slice(0, 64) : 'husk-bot';
+}
+//# sourceMappingURL=distill.js.map