aiden-runtime 4.1.0 → 4.1.2

package/dist/core/v4/promptBuilder.js

@@ -38,11 +38,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromptBuilder = void 0;
 exports.shouldInjectLlama33ToolHint = shouldInjectLlama33ToolHint;
+exports.shouldInjectExecutionDiscipline = shouldInjectExecutionDiscipline;
 const node_fs_1 = require("node:fs");
 const node_os_1 = __importDefault(require("node:os"));
 // When SOUL.md is missing or whitespace-only the bundled default takes
 // over so a fresh install still has a working identity.
 const defaultSoul_1 = require("../../cli/v4/defaultSoul");
+// Phase v4.1.2-followup: runtime-injected version + capabilities slot.
+const capabilities_1 = require("./capabilities");
 // ── Section header / sentinel string contract ─────────────────────────
 //
 // Every literal here is part of the API contract pinned by tests. Header
@@ -59,6 +62,74 @@ const NOTE_USER_LIVE = '[System note: Treat as live identity, not past conversat
 const NOTE_MEMORY_LIVE = '[System note: Treat as live working memory, not past conversation.]';
 const SKILLS_LOAD_NOTE = 'You MUST load it first via the `skill_view` tool before invoking ' +
     'the underlying capability. Skills carry the procedure the tools alone don\'t.';
+/**
+ * Phase v4.1.2 alive-core: when the user has authored a real SOUL.md
+ * (not the bundled default), prepend a one-line embodiment directive
+ * to its content. The directive tells the model to *be* the identity,
+ * not narrate about it — closes the most common "stiff generic reply"
+ * failure mode where the model paraphrases SOUL.md back at the user.
+ *
+ * Intentionally suppressed when the identity slot falls back to
+ * DEFAULT_SOUL_MD: that text is generic by design and the directive
+ * would coach the model to perform a flat persona.
+ */
+const EMBODIMENT_DIRECTIVE = 'Embody this identity and tone. Speak as Aiden, not about Aiden. ' +
+    'Avoid generic, stiff replies.';
+/**
+ * Phase v4.1.2 alive-core: tool-conditional guidance blocks. Each one
+ * is injected only when the corresponding toolset tag is in
+ * `opts.toolsetsLoaded`. Replaces the "fixed slot order regardless of
+ * capability" assumption — persona shape-shifts per available
+ * capability (prior-art pattern surfaced during v4.2 recon).
+ *
+ * Key match strings:
+ *   - 'memory'         → MEMORY_GUIDANCE
+ *   - 'session-search' → SESSION_SEARCH_GUIDANCE
+ *   - 'skills'         → SKILLS_GUIDANCE
+ *
+ * Match the strings in `ToolHandler.toolset` on the registered tools
+ * (tools/v4/memory/*.ts ships `toolset: 'memory'`,
+ * tools/v4/sessions/sessionSearch.ts ships `toolset: 'session-search'`,
+ * skill tools ship `toolset: 'skills'`).
+ */
+const MEMORY_GUIDANCE = [
+    '## Persistent memory',
+    '',
+    'You have persistent memory across sessions. Save durable facts using `memory_add`:',
+    'user preferences, environment details, stable conventions. Memory is injected into',
+    'every turn; keep it compact and focused on facts that will still matter later.',
+    'Prioritize what reduces future user steering.',
+].join('\n');
+const SESSION_SEARCH_GUIDANCE = [
+    '## Session recall',
+    '',
+    'When the user references something from a past conversation or you suspect',
+    'relevant cross-session context exists, use `session_search` to recall it before',
+    'asking them to repeat themselves.',
+].join('\n');
+const SKILLS_GUIDANCE = [
+    '## Skill upkeep',
+    '',
+    'After completing a complex task (5+ tool calls), fixing a tricky error, or',
+    'discovering a non-trivial workflow, save it as a skill so you can reuse it next',
+    'time. When using an existing skill and finding it outdated, patch it immediately',
+    '— don\'t wait to be asked.',
+].join('\n');
+/**
+ * Phase v4.1.2 alive-core: execution-discipline prose. Counters the
+ * "I'll run the tests" → no tool call → end-of-turn failure mode by
+ * making the contract explicit. Injected when
+ * `shouldInjectExecutionDiscipline(modelId)` is true (currently always).
+ */
+const EXECUTION_DISCIPLINE_PROSE = [
+    '## Tool use enforcement',
+    '',
+    'When you say you will perform an action ("I\'ll run the tests", "let me check the',
+    'file"), you MUST immediately make the corresponding tool call in the same response.',
+    'Never end your turn with a promise of future action — execute it now. Every',
+    'response should either contain tool calls that make progress, or deliver a final',
+    'result. Responses that only describe intentions without acting are not acceptable.',
+].join('\n');
 /**
  * Llama-3.3-specific tool-call format guard. Adapter-side recovery picks
  * up failures, but we'd rather avoid the 400 round-trip.
@@ -73,6 +144,16 @@ function shouldInjectLlama33ToolHint(modelId) {
         return false;
     return /llama-?3\.3/i.test(modelId);
 }
+/**
+ * Phase v4.1.2: predicate for the execution-discipline prose slot.
+ * Currently always-on — the "act, don't narrate" directive helps every
+ * tool-using model we route through. Narrow this if a specific model
+ * proves counter-productive; better to over-apply a useful prompt than
+ * guess incorrectly which models need it.
+ */
+function shouldInjectExecutionDiscipline(_modelId) {
+    return true;
+}
 // ── Internal helpers ──────────────────────────────────────────────────
 function detectPlatform() {
     const p = node_os_1.default.platform();
@@ -171,9 +252,16 @@ class PromptBuilder {
         if (!opts.skipFilesystem) {
             identity = await readNonEmpty(opts.paths.soulMd);
         }
+        // Phase v4.1.2: track whether the identity came from a real
+        // user-authored SOUL.md so the embodiment directive only fires
+        // when there's a meaningful persona to embody.
+        const identityFromDisk = identity !== null;
         if (!identity)
             identity = defaultSoul_1.DEFAULT_SOUL_MD;
-        slots.push({ name: 'identity', content: identity.trim(), optional: false });
+        const identityContent = identityFromDisk
+            ? `${EMBODIMENT_DIRECTIVE}\n\n${identity.trim()}`
+            : identity.trim();
+        slots.push({ name: 'identity', content: identityContent, optional: false });
         // ── 2. Personality overlay ────────────────────────────────────────
         const overlay = opts.personalityOverlay?.trim();
         if (overlay) {
@@ -197,6 +285,51 @@ class PromptBuilder {
                 optional: true,
             });
         }
+        // ── 4.25. Runtime manifest (self-awareness) ───────────────────────
+        // High-signal facts about what Aiden actually has loaded right now:
+        // version, tool count, skill count, channel/surface list, current
+        // provider/model. Always present so "what version are you" /
+        // "what tools do you have" answers come from facts in context,
+        // not from whatever stale text used to live in SOUL.md.
+        const runtimeManifest = (0, capabilities_1.buildRuntimeManifest)({
+            toolCount: opts.toolCount ?? 0,
+            skillCount: opts.skillsList?.length ?? 0,
+            providerId: opts.providerId,
+            modelId: opts.modelId,
+        });
+        slots.push({
+            name: 'runtime',
+            content: (0, capabilities_1.renderRuntimeSlot)(runtimeManifest),
+            optional: false,
+        });
+        // ── 4.5. Tool-conditional guidance ────────────────────────────────
+        // Each block fires only when its corresponding toolset is loaded.
+        // Order is deterministic so the prefix cache stays stable across
+        // turns with the same toolset set.
+        const toolsets = opts.toolsetsLoaded;
+        if (toolsets && toolsets.size > 0) {
+            if (toolsets.has('memory')) {
+                slots.push({
+                    name: 'guidance.memory',
+                    content: MEMORY_GUIDANCE,
+                    optional: true,
+                });
+            }
+            if (toolsets.has('session-search')) {
+                slots.push({
+                    name: 'guidance.sessionSearch',
+                    content: SESSION_SEARCH_GUIDANCE,
+                    optional: true,
+                });
+            }
+            if (toolsets.has('skills')) {
+                slots.push({
+                    name: 'guidance.skills',
+                    content: SKILLS_GUIDANCE,
+                    optional: true,
+                });
+            }
+        }
         // ── 5. Skills ─────────────────────────────────────────────────────
         if (opts.skillsList && opts.skillsList.length > 0) {
             slots.push({
@@ -213,6 +346,17 @@ class PromptBuilder {
                 optional: true,
             });
         }
+        // ── 6.5. Execution discipline ─────────────────────────────────────
+        // Phase v4.1.2: closes the "promise without acting" failure mode.
+        // Model-conditional via shouldInjectExecutionDiscipline so we can
+        // narrow later if a specific model proves counter-productive.
+        if (shouldInjectExecutionDiscipline(opts.modelId)) {
+            slots.push({
+                name: 'executionDiscipline',
+                content: EXECUTION_DISCIPLINE_PROSE,
+                optional: true,
+            });
+        }
         // ── 7. Iteration budget ───────────────────────────────────────────
         if (opts.initialBudget) {
             const { used, max } = opts.initialBudget;

package/dist/core/v4/sessionDistiller.js

@@ -0,0 +1,405 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/sessionDistiller.ts — Phase v4.1.2-memory-AB.
+ *
+ * Replaces the lossy 5-bullet auxiliary summary with a structured
+ * SessionDistillation:
+ *
+ *   - bullets[]       (5 bullets, back-compat with MEMORY.md `## Recent sessions`)
+ *   - decisions[]     (higher-fidelity than bullets)
+ *   - open_items[]    (unfinished work, useful for next session)
+ *   - keywords[]      (for future retrieval ranking — Phase C)
+ *   - files_touched[] (DETERMINISTIC — derived from tool-call result payloads)
+ *   - tools_used[]    (DETERMINISTIC — counted from tool-call trace names)
+ *   - schema_version  (always 1; reserved for future migrations)
+ *   - exit_path       (which exit caused the distillation: quit/sigint/etc.)
+ *   - partial         (set true when LLM JSON parse falls back to bullets-only)
+ *
+ * Source-of-truth split:
+ *   - Programmatic fields (files_touched, tools_used) → trace inspection.
+ *   - Semantic fields (bullets, decisions, open_items, keywords) → single
+ *     auxiliary-LLM call with strict-then-lenient JSON parsing.
+ *
+ * Phase A's CLI ChatSession owns the per-session HonestyTraceEntry[]
+ * accumulator and passes it here. The auxiliary call sees the full
+ * message history (not the trace — the trace is purely for programmatic
+ * field derivation).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_RESULT_TRUNCATION = exports.SESSION_DISTILLATION_SCHEMA_VERSION = void 0;
+exports.deriveProgrammaticFields = deriveProgrammaticFields;
+exports.parseLLMDistillation = parseLLMDistillation;
+exports.filterMessagesForDistillation = filterMessagesForDistillation;
+exports.distillSession = distillSession;
+// ── Public surface ───────────────────────────────────────────────────────
+exports.SESSION_DISTILLATION_SCHEMA_VERSION = 1;
+// ── Programmatic field derivation ─────────────────────────────────────────
+/**
+ * Tools whose result payload SHOULD contain a `path` field naming the
+ * file they touched. Used to populate `files_touched`.
+ *
+ * Curated rather than "any tool with a path in its result" because
+ * read-only tools (`file_read`, `file_list`) shouldn't count as
+ * "touched" — only mutating ops do.
+ */
+const FILE_TOUCH_TOOLS = new Set([
+    'file_write',
+    'file_patch',
+    'file_create',
+    'file_delete',
+    'memory_add', // writes MEMORY.md / USER.md
+    'memory_remove',
+    'memory_replace',
+    'session_summary', // writes MEMORY.md
+]);
+/**
+ * Extract programmatic fields from the accumulated tool trace. Pure
+ * function — no I/O.
+ */
+function deriveProgrammaticFields(trace) {
+    // tools_used: count by name, sorted by count desc, name asc.
+    const counts = new Map();
+    for (const e of trace) {
+        counts.set(e.name, (counts.get(e.name) ?? 0) + 1);
+    }
+    const tools_used = Array.from(counts.entries())
+        .map(([name, count]) => ({ name, count }))
+        .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name));
+    // files_touched: unique paths from mutating tool results.
+    // Each entry's `result` may be { success, path, ... } or { path: ... }
+    // depending on the tool. We accept either shape.
+    const paths = new Set();
+    for (const e of trace) {
+        if (e.error)
+            continue; // failed tool — don't credit
+        if (!FILE_TOUCH_TOOLS.has(e.name))
+            continue;
+        const candidate = extractPath(e.result);
+        if (candidate)
+            paths.add(candidate);
+    }
+    const files_touched = Array.from(paths).sort();
+    return { files_touched, tools_used };
+}
+function extractPath(result) {
+    if (!result || typeof result !== 'object')
+        return null;
+    // Top-level path field — most write tools.
+    const top = result.path;
+    if (typeof top === 'string' && top.length > 0)
+        return top;
+    // Nested under .result (some adapters wrap output).
+    const inner = result.result;
+    if (inner && typeof inner === 'object') {
+        const innerPath = inner.path;
+        if (typeof innerPath === 'string' && innerPath.length > 0)
+            return innerPath;
+    }
+    return null;
+}
+// ── LLM extraction ────────────────────────────────────────────────────────
+/**
+ * Strict-then-lenient parser for the auxiliary LLM's distillation JSON.
+ *
+ * Strict path: parse as JSON, validate shape, return all four semantic
+ * fields. Lenient path (only when strict fails): try to extract a
+ * bullets array from a malformed body (codepath shared with slice2's
+ * parseSessionBulletsResponse fallback), set the other three fields to
+ * empty arrays, and signal `partial: true` to the caller.
+ *
+ * Pure function — no I/O. Caller decides what to do with `partial`.
+ */
+function parseLLMDistillation(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        return { bullets: [], decisions: [], open_items: [], keywords: [], partial: true };
+    }
+    // Strict path.
+    const strict = tryStrictParse(trimmed);
+    if (strict)
+        return { ...strict, partial: false };
+    // Lenient: scan for a JSON object embedded in prose (some models
+    // prefix "Here is the JSON:\n{...}"). Trim to the first '{' through
+    // the last '}' and retry.
+    const first = trimmed.indexOf('{');
+    const last = trimmed.lastIndexOf('}');
+    if (first >= 0 && last > first) {
+        const inner = trimmed.slice(first, last + 1);
+        const second = tryStrictParse(inner);
+        if (second)
+            return { ...second, partial: false };
+    }
+    // Bullets-only fallback — recover what we can. Tries a bare bullet
+    // list ("- ...", "* ...", numbered lines) or a JSON-array fragment.
+    const fallbackBullets = recoverBullets(trimmed);
+    return {
+        bullets: fallbackBullets,
+        decisions: [],
+        open_items: [],
+        keywords: [],
+        partial: true,
+    };
+}
+function tryStrictParse(s) {
+    try {
+        const obj = JSON.parse(s);
+        if (!obj || typeof obj !== 'object' || Array.isArray(obj))
+            return null;
+        const o = obj;
+        const bullets = toStringArray(o.bullets);
+        const decisions = toStringArray(o.decisions);
+        const open_items = toStringArray(o.open_items ?? o.openItems);
+        const keywords = toStringArray(o.keywords);
+        if (bullets.length === 0 && decisions.length === 0 && open_items.length === 0) {
+            return null; // nothing useful — let the lenient path try
+        }
+        return { bullets, decisions, open_items, keywords };
+    }
+    catch {
+        return null;
+    }
+}
+function toStringArray(v) {
+    if (!Array.isArray(v))
+        return [];
+    return v
+        .filter((x) => typeof x === 'string')
+        .map((x) => x.trim())
+        .filter((x) => x.length > 0);
+}
+function recoverBullets(raw) {
+    // Strategy 1: bullet-prefixed lines.
+    const lines = raw.split(/\r?\n/);
+    const bulleted = lines
+        .map((l) => l.replace(/^\s*(?:[-*•]|\d+\.)\s+/, '').trim())
+        .filter((l, i, arr) => l.length > 0 && /^\s*(?:[-*•]|\d+\.)\s+/.test(lines[i] ?? ''));
+    if (bulleted.length > 0)
+        return bulleted.slice(0, 5);
+    // Strategy 2: a JSON array of strings, with or without the object wrapper.
+    const arrMatch = raw.match(/\[\s*"[\s\S]*?"\s*\]/);
+    if (arrMatch) {
+        try {
+            const arr = JSON.parse(arrMatch[0]);
+            return toStringArray(arr).slice(0, 5);
+        }
+        catch { /* fall through */ }
+    }
+    return [];
+}
+const DEFAULT_TIMEOUT_MS = 4000;
+/**
+ * Phase v4.1.2-bug-Y: max chars of tool-result content surfaced to the
+ * auxiliary LLM. Covers typical error messages + JSON-payload heads
+ * without bloating the prompt with full tool-output dumps. User and
+ * assistant TEXT are never truncated — user intent must survive in
+ * full. Widen this only after eval shows truncation eating signal.
+ */
+exports.TOOL_RESULT_TRUNCATION = 200;
+/**
+ * Pure: filter + format the conversation history into the transcript
+ * the auxiliary LLM sees. Phase v4.1.2-bug-Y root-cause fix:
+ *
+ *   The previous distiller dumped chatSession.history verbatim,
+ *   including the giant `role: 'system'` block PromptBuilder
+ *   constructs (SOUL.md identity, MEMORY.md, USER.md, Runtime slot,
+ *   Capabilities boilerplate, tool-catalog descriptions, personality
+ *   overlay, execution-discipline notes). Weak summarizer models
+ *   latched onto this longest-coherent-block in context as the
+ *   session topic, returning bullets like "I'm Aiden, a local-first
+ *   AI agent built by Taracod" regardless of what the user and
+ *   assistant actually discussed.
+ *
+ *   This filter drops ALL `role: 'system'` messages and emits the
+ *   remaining traffic as role-tagged lines:
+ *
+ *     [USER] full user message verbatim
+ *     [ASSISTANT] assistant text (if non-empty)
+ *     [TOOL:name] {args}
+ *     [TOOL:name] → result-payload, truncated to TOOL_RESULT_TRUNCATION
+ *
+ *   Tool results carry their tool name (resolved via toolCallId →
+ *   call-name map walked through preceding assistant turns) so the
+ *   model can correlate tool intent with output. Empty messages are
+ *   dropped entirely. Multi-line content within a message is
+ *   preserved.
+ */
+function filterMessagesForDistillation(messages) {
+    /** Per-toolCallId → toolName, populated as we walk assistant turns. */
+    const callNames = new Map();
+    const lines = [];
+    for (const m of messages) {
+        if (m.role === 'system')
+            continue; // entire boilerplate source — dropped
+        if (m.role === 'user') {
+            const text = m.content.trim();
+            if (text.length === 0)
+                continue;
+            lines.push(`[USER] ${text}`);
+            continue;
+        }
+        if (m.role === 'assistant') {
+            // Emit assistant text only if non-empty — avoid empty `[ASSISTANT]`
+            // placeholder for tool-only turns.
+            const text = (m.content ?? '').trim();
+            if (text.length > 0)
+                lines.push(`[ASSISTANT] ${text}`);
+            // Tool calls: cache the id → name pair so the matching tool
+            // result downstream can render with its tool name. Emit the
+            // call line in original order.
+            if (m.toolCalls && m.toolCalls.length > 0) {
+                for (const tc of m.toolCalls) {
+                    callNames.set(tc.id, tc.name);
+                    const argsStr = compactArgs(tc.arguments);
+                    lines.push(`[TOOL:${tc.name}] ${argsStr}`);
+                }
+            }
+            continue;
+        }
+        if (m.role === 'tool') {
+            const name = callNames.get(m.toolCallId) ?? 'unknown';
+            const truncated = truncateForTranscript(m.content);
+            lines.push(`[TOOL:${name}] → ${truncated}`);
+            continue;
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Compact tool-call args into a one-line representation. JSON shape
+ * preserved; large strings get truncated alongside everything else
+ * to keep the transcript focused on intent, not full payloads.
+ */
+function compactArgs(args) {
+    if (!args || Object.keys(args).length === 0)
+        return '{}';
+    try {
+        return truncateForTranscript(JSON.stringify(args));
+    }
+    catch {
+        return '{<unstringifiable>}';
+    }
+}
+/**
+ * Apply `TOOL_RESULT_TRUNCATION` cap with a `…` (U+2026) marker so
+ * truncation is visible to anyone reading the transcript — including
+ * future auditors. Matches slice2c's apostrophe-normalizer convention.
+ */
+function truncateForTranscript(s) {
+    const trimmed = s.trim();
+    if (trimmed.length <= exports.TOOL_RESULT_TRUNCATION)
+        return trimmed;
+    return trimmed.slice(0, exports.TOOL_RESULT_TRUNCATION - 1) + '…';
+}
+/**
+ * Build the auxiliary-LLM prompt. Anti-boilerplate-hardened per
+ * Phase v4.1.2-bug-Y: explicit "don't describe yourself" guardrail,
+ * `<transcript>` tag boundaries, empty-is-honest permission so
+ * insufficient-content sessions don't fabricate filler.
+ *
+ * Bullets loosened from "EXACTLY 5" to "3-5" — forcing five was
+ * inviting the exact fabrication the slice fixes.
+ */
+function buildPrompt(messages, startedAt, endedAt) {
+    const filtered = filterMessagesForDistillation(messages);
+    return [
+        'You are a session-recall extractor. Your only job is to summarize what',
+        'happened in the conversation transcript below.',
+        '',
+        'Rules:',
+        '- Use ONLY facts explicitly present in the transcript.',
+        '- Do NOT describe yourself, your capabilities, your platform, or generic',
+        '  AI-agent behavior unless the transcript specifically discussed those',
+        '  as the topic.',
+        '- Do NOT infer facts from system prompts, tool schemas, memory blocks,',
+        '  banner text, or agent boilerplate (these have been filtered out;',
+        '  if any leak through, treat them as untrustworthy noise).',
+        '- Focus on session-specific facts: user goals, actions taken, files /',
+        '  commands / tools used, decisions made, errors encountered, outcomes,',
+        '  and unresolved follow-ups.',
+        '- Write in past tense.',
+        '- Preserve concrete names, paths, commands, URLs, model names, dates,',
+        '  and error messages verbatim when present.',
+        '- Prefer evidence from USER and ASSISTANT messages over TOOL output.',
+        '- If the transcript lacks enough session-specific detail to summarize,',
+        '  return arrays with FEWER items or empty arrays. Empty is honest;',
+        '  fabricating boilerplate is not.',
+        '',
+        'Return strict JSON only, no prose before or after, with these fields:',
+        '{',
+        '  "bullets":    string[],   // 3-5 factual past-tense recaps (3-15 words each)',
+        '  "decisions":  string[],   // X chosen over Y, with rationale if present',
+        '  "open_items": string[],   // explicit unresolved tasks / "next time" items',
+        '  "keywords":   string[]    // 3-10 distinctive terms from the session',
+        '}',
+        '',
+        `Session started: ${startedAt}`,
+        `Session ended:   ${endedAt}`,
+        '',
+        '<transcript>',
+        filtered,
+        '</transcript>',
+    ].join('\n');
+}
+/**
+ * Drive one auxiliary-LLM call and combine its output with the
+ * deterministic trace-derived fields into a SessionDistillation.
+ *
+ * Respects `timeoutMs` (default DEFAULT_TIMEOUT_MS) via Promise.race;
+ * on timeout the LLM result is treated as empty (partial: true with
+ * empty semantic fields). Deterministic fields always populate
+ * regardless of LLM outcome — the distillation is never empty.
+ */
+async function distillSession(opts) {
+    const endedAt = opts.endedAt ?? new Date().toISOString();
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const programmatic = deriveProgrammaticFields(opts.toolTrace);
+    // Run the auxiliary call under a hard timeout. The race resolves
+    // with `{timedOut: true}` if the LLM doesn't return in time — we
+    // record that as a partial distillation.
+    const prompt = buildPrompt(opts.messages, opts.startedAt, endedAt);
+    const llmRaw = await Promise.race([
+        opts.auxiliaryClient
+            .call({ purpose: 'session_summary', prompt, maxTokens: 800 })
+            .then((r) => ({ ok: true, content: r.content ?? '' }))
+            .catch((e) => ({ ok: false, error: e })),
+        new Promise((resolve) => {
+            setTimeout(() => resolve({ ok: false, error: new Error(`auxiliary call timed out after ${timeoutMs}ms`), timedOut: true }), timeoutMs);
+        }),
+    ]);
+    let semantic;
+    if (llmRaw.ok) {
+        semantic = parseLLMDistillation(llmRaw.content);
+    }
+    else {
+        semantic = {
+            bullets: [],
+            decisions: [],
+            open_items: [],
+            keywords: [],
+            partial: true,
+        };
+    }
+    const dist = {
+        schema_version: exports.SESSION_DISTILLATION_SCHEMA_VERSION,
+        session_id: opts.sessionId,
+        started_at: opts.startedAt,
+        ended_at: endedAt,
+        exit_path: opts.exitPath,
+        user_turns: opts.userTurns,
+        bullets: semantic.bullets,
+        decisions: semantic.decisions,
+        open_items: semantic.open_items,
+        keywords: semantic.keywords,
+        files_touched: programmatic.files_touched,
+        tools_used: programmatic.tools_used,
+    };
+    if (semantic.partial)
+        dist.partial = true;
+    return dist;
+}

package/dist/core/v4/skillMining/extractorPrompt.js

@@ -16,10 +16,10 @@
  *      metadata.aiden.* must round-trip unchanged. We re-parse the
  *      refined output and discard it if any required field drifts.
  *
- *   2. Never write attribution tokens (hermes / nous / "portions
- *      adapted from" / "original copyright"). The permanent
- *      attribution sweep validates this; if a refined output
- *      contains any forbidden token, we fall back to the skeleton.
+ *   2. Never write attribution tokens or "portions adapted from..." /
+ *      "original copyright" strings. The permanent attribution
+ *      sweep validates this; if a refined output contains any
+ *      forbidden token, we fall back to the skeleton.
  *
  * If the auxiliary client is unavailable, the call times out, or
  * the refined output fails validation, the function returns the
@@ -29,23 +29,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.refine = refine;
 const skillSpec_1 = require("../skillSpec");
-const FORBIDDEN_TOKENS_RE = /\b(hermes|nous|portions adapted from|original copyright)\b/i;
-const REFINER_SYSTEM_PROMPT = `
-You polish auto-generated skill markdown for a local-first AI agent.
-
-Your job is to improve the WORDING ONLY of an already-valid SKILL.md
-file. The frontmatter (everything between the leading "---" markers)
-must round-trip BYTE-FOR-BYTE unchanged. The "# <name>" heading must
-stay first in the body. The numbered "## Steps" list must remain
-numbered and in the same order; you may rephrase step descriptions
-but must NOT add or remove steps.
-
-Hard rules:
-- Output the COMPLETE SKILL.md, not a diff.
-- Do not add boilerplate, citations, or attribution to any other
-  agent or codebase. The skill is 100% the user's own.
-- Do not introduce mock/fake values into commands.
-- Keep total length under 6000 characters.
+const BANNED_TOKENS = [
+    'portions adapted from',
+    'original copyright',
+    'derived from',
+    'based on the',
+    'adapted from',
+];
+const FORBIDDEN_TOKENS_RE = new RegExp(`\\b(${BANNED_TOKENS.join('|')})\\b`, 'i');
+const REFINER_SYSTEM_PROMPT = `
+You polish auto-generated skill markdown for a local-first AI agent.
+
+Your job is to improve the WORDING ONLY of an already-valid SKILL.md
+file. The frontmatter (everything between the leading "---" markers)
+must round-trip BYTE-FOR-BYTE unchanged. The "# <name>" heading must
+stay first in the body. The numbered "## Steps" list must remain
+numbered and in the same order; you may rephrase step descriptions
+but must NOT add or remove steps.
+
+Hard rules:
+- Output the COMPLETE SKILL.md, not a diff.
+- Do not add boilerplate, citations, or attribution to any other
+  agent or codebase. The skill is 100% the user's own.
+- Do not introduce mock/fake values into commands.
+- Keep total length under 6000 characters.
 `.trim();
 /**
  * Refine `skeleton` via the auxiliary client. Always returns a

package/dist/core/v4/skillMining/proposalBuilder.js

@@ -18,8 +18,9 @@
  *   - emits required fields `name`, `description`, `version`
  *   - emits `metadata.aiden` with the mining provenance fields
  *   - body is numbered tool-call steps in markdown
- *   - never writes hermes/nous/copyright attribution strings — the
- *     permanent attribution sweep validates this
+ *   - never writes attribution strings — the banned-token regex
+ *     strips them at extraction time and the permanent attribution
+ *     sweep validates the result
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deriveName = deriveName;