@aiwg/cli 2026.10.4 → 2026.10.6

package/dist/src/artifacts/query-engine.js

@@ -18,7 +18,7 @@ import * as path from 'node:path';
 import { OPERATIONAL_DISCOVERY_TYPES, OPERATIONAL_SHOW_TYPES, isOperationalShowType, loadGlobalGraphConfigs, getGraphIndexDir, } from './types.js';
 import { loadMetadataIndex, loadGraphIndexFile } from './index-reader.js';
 import { bm25Rank } from './fulltext.js';
-import { parseFrontmatter } from './index-builder.js';
+import { parseFrontmatter, parseFlowDoc, extractMarkdownLinks } from './index-builder.js';
 import { applyFacetFusion, diagnoseFacetActivations, } from './discover-facets.js';
 import { recordTypeForEntry, stableRecordId, } from './browser-export.js';
 import { loadProviderModelMetadata } from '../models/provider-models.js';
@@ -27,6 +27,13 @@ import { operationalStateQueryProjection, } from './operational-state.js';
 function normalizeIndexedPath(entryPath) {
     return entryPath.replace(/\\/g, '/');
 }
+/** Historical records stay in the index for explicit show/history lookup. */
+export function isOrdinaryMemoryEntry(entry, _cwd) {
+    // Maintenance owners publish dispositions into the index before returning.
+    // Retrieval must not read sources: ordinary legacy entries need no memory
+    // stamp, and temporary source I/O failures cannot hide active metadata.
+    return !entry.memoryRecord || (entry.memoryRecord.lifecycle === 'active' && entry.memoryRecord.placement !== 'archived');
+}
 /**
  * Resolve an index entry's source file path and read its body (frontmatter
  * stripped). Entry paths are normally relative to the project; framework-graph
@@ -657,6 +664,8 @@ export async function queryIndex(cwd, params, options = {}) {
         }
         candidates = allEntries;
     }
+    // Retained tombstones are history, never ordinary retrieval results.
+    candidates = candidates.filter(entry => isOrdinaryMemoryEntry(entry, cwd));
     // Apply filters
     if (params.type) {
         candidates = candidates.filter(e => e.type === params.type);
@@ -704,8 +713,10 @@ export async function queryIndex(cwd, params, options = {}) {
             }
             process.exit(1);
         }
-        results = queried.results.map(result => {
+        const candidateByPath = new Map(candidates.map(entry => [entry.path, entry]));
+        results = queried.results.filter(result => candidateByPath.has(result.path)).map(result => {
             const entry = {
+                ...(candidateByPath.get(result.path)?.memoryRecord ? { memoryRecord: candidateByPath.get(result.path).memoryRecord } : {}),
                 path: result.path,
                 type: result.type,
                 phase: result.phase,
@@ -758,7 +769,7 @@ export async function queryIndex(cwd, params, options = {}) {
     }
     // Apply limit
     const limit = params.limit ?? 20;
-    results = results.slice(0, limit);
+    results = results.filter(result => isOrdinaryMemoryEntry(result.entry, cwd)).slice(0, limit);
     const queryTimeMs = Date.now() - startTime;
     // Output
     if (options.json) {
@@ -1071,6 +1082,7 @@ export async function discoverCapability(cwd, params) {
         process.exit(1);
     }
     // Filter by type
+    entries = entries.filter(entry => isOrdinaryMemoryEntry(entry, cwd));
     const candidates = entries.filter(e => types.includes(e.type));
     // Score (strict overlap gate). Keep the full sorted list so the facet
     // fusion below can inject/lift curated capabilities into the top-K before
@@ -1377,13 +1389,21 @@ async function loadShowEntries(cwd, params, compact = false) {
     if (compact && resourceSource !== 'web' && (!params.graph || params.graph === 'framework')) {
         relations = await ensureRelations(cwd) ?? undefined;
         if (relations?.index.artifacts) {
-            const frameworkEntries = Object.values(relations.index.artifacts).map(entry => withIndexProvenance({
-                phase: '', tags: [], created: '', updated: '', checksum: '', summary: '', dependencies: [], dependents: [], ...entry,
-            }, 'framework'));
+            const reader = relations;
+            const matched = findShowMatches(Object.values(reader.index.artifacts), params.typeFilter ?? [...OPERATIONAL_SHOW_TYPES], params.name.trim());
+            const frameworkEntries = matched.map(entry => {
+                const id = discoveryIdForEntry(entry);
+                const rule = reader.index.rules[id];
+                return withIndexProvenance({ ...entry, phase: '', tags: [], created: '', updated: '', checksum: '', summary: '', dependencies: [], dependents: [],
+                    ...(rule ? { activation: reader.pinnedRuleIds.has(id) ? 'kernel' : rule.activation ?? undefined,
+                        ruleSummary: rule.summary, ruleEnforcement: rule.enforcement ?? undefined, bound_to: rule.bound_to } : {}),
+                }, 'framework');
+            });
             const localEntries = params.graph ? [] : defaultCapabilityGraphs(cwd).filter(graph => graph !== 'framework')
-                .flatMap(graph => loadLocalCapabilityEntries(cwd, graph));
+                .flatMap(graph => loadLocalCapabilityEntries(cwd, graph, undefined, true));
             const compactEntries = [...localEntries, ...frameworkEntries];
-            if (findShowMatches(compactEntries, params.typeFilter ?? [...OPERATIONAL_SHOW_TYPES], params.name.trim()).length) {
+            if ((params.typeFilter?.every(type => ['skill', 'agent', 'flow', 'command', 'rule', 'behavior'].includes(type)))
+                || findShowMatches(compactEntries, params.typeFilter ?? [...OPERATIONAL_SHOW_TYPES], params.name.trim()).length) {
                 return { entries: compactEntries, aiwgRoot, resourceSource: 'local', relations };
             }
         }
@@ -1482,12 +1502,12 @@ async function loadShowEntries(cwd, params, compact = false) {
         }
     }
     else {
-        entries = loadLocalCapabilityEntries(cwd, params.graph);
+        entries = loadLocalCapabilityEntries(cwd, params.graph, undefined, true);
     }
     return { entries, aiwgRoot, resourceSource: 'local', relations };
 }
 /** Local index inputs shared by show and exact rule-binding validation (#2938). */
-export function loadLocalCapabilityEntries(cwd, graph, snapshot) {
+export function loadLocalCapabilityEntries(cwd, graph, snapshot, includeHistory = false) {
     const entries = [];
     for (const selectedGraph of graph ? [graph] : defaultCapabilityGraphs(cwd)) {
         const key = snapshot && `${selectedGraph}:${getGraphIndexDir(cwd, selectedGraph)}`;
@@ -1505,7 +1525,7 @@ export function loadLocalCapabilityEntries(cwd, graph, snapshot) {
         if (legacy)
             entries.push(...Object.values(legacy.entries));
     }
-    return entries;
+    return includeHistory ? entries : entries.filter(entry => isOrdinaryMemoryEntry(entry, cwd));
 }
 /** Project/user inputs only; package artifacts come from a validated compact table. */
 export function loadLocalOverrideCapabilityEntries(cwd) {
@@ -1539,7 +1559,7 @@ function findShowMatches(entries, types, needle) {
     const needleLower = needle.toLowerCase();
     const normalizedNeedle = normalizeIndexedPath(needle);
     const candidates = entries.filter(e => types.includes(e.type));
-    let matches = candidates.filter(e => discoveryIdForEntry(e) === needle);
+    let matches = needle.startsWith('aiwg:') ? candidates.filter(e => discoveryIdForEntry(e) === needle) : [];
     if (matches.length === 0) {
         matches = candidates.filter(e => e.path === needle || normalizeIndexedPath(e.path) === normalizedNeedle);
     }
@@ -1933,7 +1953,7 @@ export function compoundGoverningRules(entries, target, relations, phrase = '',
     const found = new Map();
     const add = (rule, why) => {
         const activation = rule.activation ?? (rule.type === 'behavior' ? 'kernel' : inferRuleActivation(rule.ruleEnforcement));
-        if (excludeKernel && (activation === 'kernel' || rule.kernel || relations?.pinnedRuleIds.has(discoveryIdForEntry(rule))))
+        if (excludeKernel && (activation === 'kernel' || activation === 'core' || rule.kernel || relations?.pinnedRuleIds.has(discoveryIdForEntry(rule))))
             return;
         const key = `${rule.type}:${rule.path}`, item = found.get(key) ?? { rule, applicability: [] };
         if (!item.applicability.includes(why))
@@ -1979,8 +1999,8 @@ export function compoundGoverningRules(entries, target, relations, phrase = '',
     return [...found.values()].sort((a, b) => (a.rule.name ?? a.rule.path).localeCompare(b.rule.name ?? b.rule.path) || a.rule.path.localeCompare(b.rule.path));
 }
 function boundRuleDescriptor(rule) {
-    return { name: rule.name ?? path.basename(rule.path, '.md'), activation: rule.activation ?? null,
-        summary: rule.ruleSummary ?? '', show_command: `aiwg show ${rule.type} ${rule.name ?? path.basename(rule.path, '.md')}` };
+    return { name: rule.name ?? path.basename(rule.path, '.md'), activation: rule.activation ?? null, enforcement: rule.ruleEnforcement ?? null,
+        summary: (rule.ruleSummary ?? '').replace(/\s+/g, ' ').trim(), show_command: `aiwg show ${rule.type} ${rule.name ?? path.basename(rule.path, '.md')} --body` };
 }
 /** Counts unique attached contracts; every emitted check is required irrespective of severity. */
 export function governingRuleStats(governing) {
@@ -1998,7 +2018,7 @@ export function governingRuleFields(governing) {
         return {};
     return { bound_rules: governing.map(({ rule }) => boundRuleDescriptor(rule)), rule_stats: governingRuleStats(governing),
         required_rule_checks: governing.map(({ rule, applicability }) => ({ rule_id: discoveryIdForEntry(rule),
-            applicability, fetch_command: `aiwg show ${rule.type} ${discoveryIdForEntry(rule)}` })), rule_check_obligation: RULE_CHECK_OBLIGATION };
+            applicability, fetch_command: `aiwg show ${rule.type} ${discoveryIdForEntry(rule)} --body` })), rule_check_obligation: RULE_CHECK_OBLIGATION };
 }
 function statsText(stats) {
     return `rules: ${Object.entries(stats.by_enforcement).map(([level, count]) => `${count} ${level}`).join(', ') || '0'} · activation: ${Object.entries(stats.by_activation).map(([mode, count]) => `${count} ${mode}`).join(', ') || 'none'} · ${stats.required_checks} required checks`;
@@ -2021,10 +2041,13 @@ export function relationshipRuleStats(entries, target, relations) {
 }
 async function showBindings(entries, target, content, params, read, relations) {
     const governing = compoundGoverningRules(entries, target, relations, '', false, false);
+    for (const { rule } of governing)
+        if (relations?.pinnedRuleIds.has(discoveryIdForEntry(rule)))
+            rule.activation = 'kernel';
     const rules = governing.map(item => item.rule);
     const boundRules = await Promise.all(rules.map(async (rule) => ({
         ...boundRuleDescriptor(rule),
-        ...(params.boundRuleBodies ? { content: await read(rule) } : {}),
+        ...((params.boundRuleBodies || params.withRuleBodies) ? { content: await read(rule) } : {}),
     })));
     // Parse the selected rule for reverse lookup, including corpus-only rules.
     const targets = target.type === 'rule' || target.type === 'behavior'
@@ -2035,24 +2058,227 @@ async function showBindings(entries, target, content, params, read, relations) {
             const names = Array.isArray(values) ? [...new Set(values.filter((value) => typeof value === 'string' && !!value.trim()))] : [];
             return names.length ? [[key, names]] : [];
         })) : {};
+    const boundTargets = new Map();
+    if (target.type === 'rule' || target.type === 'behavior') {
+        for (const edge of relations?.targetsForRule(discoveryIdForEntry(target)) ?? []) {
+            boundTargets.set(`${edge.type}:${edge.id}`, { ...edge, name: relations?.index.artifacts?.[edge.id]?.name
+                    ?? relations?.index.targets[`${edge.type}:${edge.id}`]?.name });
+        }
+        const selectedRule = { ...target, bound_to: boundTo };
+        for (const candidate of entries)
+            if (rulesBoundTo([selectedRule], candidate).length) {
+                const id = discoveryIdForEntry(candidate);
+                boundTargets.set(`${candidate.type}:${id}`, { type: candidate.type, id, name: candidate.name });
+            }
+    }
     let text = '';
     if (boundRules.length) {
-        text += `\n## Bound rules\n\n${RULE_CHECK_OBLIGATION}\n\n${statsText(governingRuleStats(governing))}\n\n` + boundRules.map(rule => `- **${rule.name}**: ${rule.summary} (\`${rule.show_command}\`)`
+        // Cards already print these stats in the header; body/section output has no header.
+        const stats = params.body || params.sections?.length ? `${statsText(governingRuleStats(governing))}\n\n` : '';
+        text += `\n## Bound rules\n\n${RULE_CHECK_OBLIGATION}\n\n${stats}` + boundRules.map(rule => `- **${rule.name}** [${rule.activation ?? 'unknown'} / ${rule.enforcement ?? 'unknown'}]: ${rule.summary} (\`${rule.show_command}\`)`
             + ('content' in rule ? `\n\n${rule.content}` : '')).join('\n') + '\n';
     }
     if (Object.keys(boundTo).length) {
         text += '\n## Bound targets\n\n' + Object.entries(boundTo)
             .map(([key, names]) => `- ${key}: ${names.map(name => `\`${name}\``).join(', ')}`).join('\n') + '\n';
     }
+    if (boundTargets.size)
+        text += '\nResolved targets: ' + [...boundTargets.values()].map(target => `${target.type} ${target.name ?? target.id}`).join(', ') + '\n';
     return { fields: {
             ...governingRuleFields(governing),
+            ...(['rule', 'behavior'].includes(target.type) ? { bound_to: boundTo, bound_targets: [...boundTargets.values()] } : {}),
             ...(boundRules.length ? { bound_rules: boundRules } : {}),
             ...(Object.keys(boundTo).length ? { bound_to: boundTo } : {}),
         }, text };
 }
+/** Sections include their nested headings, stopping at the next peer/ancestor. */
+function showSections(content) {
+    const body = parseFrontmatter(content).body;
+    const headings = [];
+    let offset = 0;
+    let fence = '';
+    const lines = body.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const marker = line.match(/^ {0,3}(`{3,}|~{3,})/);
+        if (marker) {
+            if (!fence)
+                fence = marker[1];
+            else if (marker[1][0] === fence[0] && marker[1].length >= fence.length)
+                fence = '';
+        }
+        else if (!fence) {
+            const atx = line.match(/^ {0,3}(#{1,6})\s+(.+?)(?:\s+#+)?\s*$/);
+            const setext = i + 1 < lines.length && lines[i + 1].match(/^ {0,3}(=+|-+)\s*$/);
+            if (atx)
+                headings.push({ heading: atx[2], level: atx[1].length, start: offset });
+            else if (line.trim() && setext)
+                headings.push({ heading: line.trim(), level: setext[1][0] === '=' ? 1 : 2, start: offset });
+        }
+        offset += line.length;
+    }
+    return headings.map((heading, i) => {
+        const end = headings.slice(i + 1).find(next => next.level <= heading.level)?.start ?? body.length;
+        const text = body.slice(heading.start, end);
+        return { heading: heading.heading, level: heading.level, bytes: Buffer.byteLength(text),
+            lines: text.split('\n').length - (text.endsWith('\n') ? 1 : 0), text };
+    });
+}
+/** List companion directories and explicitly linked resources within the owning bundle.
+ * Resolve paths against that boundary and exclude symlink components. */
+function showResources(filePath, source, release) {
+    if (release) {
+        const base = path.posix.dirname(filePath);
+        const linked = new Set(extractMarkdownLinks(source).map(link => path.posix.normalize(path.posix.join(base, link))));
+        const boundary = filePath.match(/^(raw\/agentic\/code\/(?:frameworks|addons|extensions)\/[^/]+)\//)?.[1];
+        return [...release.descriptors.values()].filter(descriptor => {
+            const relative = path.posix.relative(base, descriptor.path);
+            const category = /(?:^|\/)(?:templates|scripts|references|resources|assets)\//.test(relative);
+            const inside = relative !== '..' && !relative.startsWith('../');
+            return (inside && category || linked.has(descriptor.path) && (inside || category))
+                && (!boundary || descriptor.path.startsWith(`${boundary}/`));
+        }).map(descriptor => ({ path: path.posix.relative(base, descriptor.path), bytes: descriptor.size }))
+            .sort((a, b) => a.path.localeCompare(b.path));
+    }
+    const base = path.dirname(filePath);
+    const normalizedBase = normalizeIndexedPath(base);
+    const boundary = normalizedBase.match(/^(.*\/(?:frameworks|addons|extensions)\/[^/]+)(?:\/|$)/)?.[1]
+        ?? normalizedBase.match(/^(.*\/\.aiwg)(?:\/|$)/)?.[1] ?? base;
+    const resources = new Map();
+    const walk = (relative) => {
+        const absolute = path.resolve(base, relative);
+        const contained = path.relative(boundary, absolute);
+        if (contained === '..' || contained.startsWith(`..${path.sep}`) || path.isAbsolute(contained))
+            return;
+        let cursor = boundary;
+        let stat;
+        try {
+            for (const component of contained.split(path.sep)) {
+                cursor = path.join(cursor, component);
+                stat = fs.lstatSync(cursor);
+                if (stat.isSymbolicLink())
+                    return;
+            }
+        }
+        catch {
+            return;
+        }
+        if (stat?.isDirectory()) {
+            for (const name of fs.readdirSync(absolute).sort())
+                walk(path.join(relative, name));
+        }
+        else if (stat?.isFile() && absolute !== filePath) {
+            const key = normalizeIndexedPath(path.relative(base, absolute));
+            resources.set(key, { path: key, bytes: stat.size });
+        }
+    };
+    for (const directory of ['templates', 'scripts', 'references', 'resources', 'assets'])
+        walk(directory);
+    const { data } = parseFrontmatter(source);
+    const declared = Array.isArray(data.resources) ? data.resources.filter((value) => typeof value === 'string') : [];
+    for (const link of [...extractMarkdownLinks(source), ...declared]) {
+        if (path.isAbsolute(link) || /^[a-z]+:/i.test(link))
+            continue;
+        const relative = path.relative(base, path.resolve(base, link));
+        // Outside the artifact directory, only declared companion categories qualify.
+        if ((relative === '..' || relative.startsWith(`..${path.sep}`)) && !/(?:^|\/)(?:templates|scripts|references|resources|assets)\//.test(normalizeIndexedPath(relative)))
+            continue;
+        walk(relative);
+    }
+    return [...resources.values()].sort((a, b) => a.path.localeCompare(b.path));
+}
+async function emitShowCard(cwd, aiwgRoot, entry, filePath, source, params, bindings, extra, local, release) {
+    const { data } = parseFrontmatter(source);
+    const flow = entry.type === 'flow' || entry.type === 'runbook' ? parseFlowDoc(source, entry.path) : null;
+    const sections = showSections(source);
+    const selected = (params.sections ?? []).map(heading => {
+        const exact = sections.filter(section => section.heading === heading);
+        const matches = exact.length ? exact : sections.filter(section => section.heading.toLowerCase() === heading.toLowerCase());
+        if (matches.length !== 1)
+            throw new Error(`${matches.length ? 'Ambiguous' : 'Unknown'} heading "${heading}". Headings: ${sections.map(section => section.heading).join(', ') || '(none)'}`);
+        return matches[0].text;
+    });
+    const owner = normalizeIndexedPath(entry.path).match(/(?:^|\/)(?:agentic\/code|\.aiwg)\/(frameworks|addons|extensions)\/([^/]+)\//);
+    const kind = owner ? { frameworks: 'framework', addons: 'addon', extensions: 'extension' }[owner[1]] : null;
+    const installed = local && (owner && aiwgRoot
+        ? await isCorpusBundleInstalled(cwd, aiwgRoot, kind, owner[2]) : true);
+    const resources = local || release ? showResources(filePath, source, release) : [];
+    const resource = params.resource ? resources.find(resource => resource.path === params.resource) : undefined;
+    if (params.resource && !resource)
+        throw new Error(`Unknown resource "${params.resource}". Resources: ${resources.map(resource => resource.path).join(', ') || '(none)'}`);
+    const quote = (value) => '"' + value.replace(/["\\$`]/g, '\\$&') + '"';
+    const command = `aiwg show ${entry.type} ${extra.hint ? params.name : discoveryIdForEntry(entry)}`
+        + (params.graph ? ` --graph ${quote(params.graph)}` : '')
+        + (params.backend ? ` --backend ${params.backend}` : '')
+        + (params.resourceSource ? ` --resource-source ${params.resourceSource}` : '')
+        + (params.aiwgVersion ? ` --aiwg-version ${quote(params.aiwgVersion)}` : '')
+        + (params.offline ? ' --offline' : '');
+    let resourceBody;
+    if (resource) {
+        if (local)
+            resourceBody = fs.readFileSync(path.join(path.dirname(filePath), resource.path), 'utf8');
+        else if (release) {
+            const { fetchVerifiedRawResource } = await import('../resources/web-release.js');
+            resourceBody = (await fetchVerifiedRawResource(release, path.posix.normalize(path.posix.join(path.posix.dirname(filePath), resource.path)), { ...params.webReleaseOptions, offline: params.offline })).toString('utf8');
+        }
+    }
+    const localPin = extra.local_pin;
+    const pinNote = localPin ? `Pinned locally: kernel (canonical ${localPin.canonical_activation}; ${localPin.matches.map(match => match.source).join(', ')}).` : '';
+    const contentNotice = 'This is a metadata card. The component body has not been fetched. Before deciding or applying its workflow, read the needed sections or --body using the drill-in commands below. Read full governing rules before governed work; --rules alone lists checks.';
+    const card = {
+        id: discoveryIdForEntry(entry), type: entry.type, name: entry.name ?? String(data.name ?? entry.title),
+        title: entry.title, path: filePath, description: String(data.description ?? data.summary ?? flow?.description ?? entry.capability ?? entry.ruleSummary ?? entry.summary ?? ''),
+        capability: owner ? { kind, name: owner[2] } : null, installed, kernel: entry.kernel ?? false,
+        ...(['rule', 'behavior'].includes(entry.type) ? {
+            activation: localPin ? 'kernel' : entry.activation ?? data.activation ?? null, enforcement: data.enforcement ?? entry.ruleEnforcement ?? null,
+            bound_to: data.bound_to ?? entry.bound_to ?? {},
+        } : {}),
+        bound_rules: [], rule_stats: emptyRuleStats(), required_rule_checks: [], rule_check_obligation: RULE_CHECK_OBLIGATION,
+        ...bindings.fields,
+        outline: sections.map(({ text: _text, ...metadata }) => metadata), resources,
+        ...(!params.body && !selected.length ? { content_notice: contentNotice } : {}),
+        drill_in: {
+            sections: sections.map(section => `${command} --section ${quote(section.heading)}`),
+            rules: `${command} --rules`, rule_bodies: `${command} --rules --with-rule-bodies`,
+            resources: `${command} --resources`, resource: resources.map(resource => `${command} --resource ${quote(resource.path)}`),
+            body: `${command} --body`,
+        },
+        ...extra,
+        ...(params.body || selected.length ? { content: params.body ? source : selected.join('\n') } : {}),
+        ...(resource ? { resource: { ...resource, body: resourceBody } } : {}),
+    };
+    if (params.json) {
+        console.log(JSON.stringify(card, null, 2));
+        return;
+    }
+    if ('content' in card) {
+        if (extra.hint)
+            process.stdout.write(`<!-- AIWG: ${card.installed ? 'installed bundle artifact — not in the selected index.' : 'corpus-only artifact — not in the indexed workspace.'}\n     ${extra.hint}\n     Origin: ${filePath}\n-->\n\n`);
+        if (entry.script)
+            process.stdout.write(`<!-- AIWG: executable skill — run via: ${buildRunHint(entry)} -->\n`);
+        if (pinNote)
+            process.stdout.write(`${pinNote}\n`);
+        process.stdout.write(card.content);
+        if (!card.content.endsWith('\n'))
+            process.stdout.write('\n');
+        if (bindings.text)
+            process.stdout.write(bindings.text);
+        return;
+    }
+    const lines = [`# ${card.type}: ${card.name}`, `ID: ${card.id}`, card.description,
+        `Owner: ${card.capability ? `${card.capability.kind}:${card.capability.name}` : 'project/unowned'} | installed: ${card.installed}`, statsText(card.rule_stats)];
+    if (pinNote)
+        lines.push(pinNote);
+    if ('activation' in card)
+        lines.push(`Activation: ${card.activation} | enforcement: ${card.enforcement}`, `Bound targets: ${JSON.stringify(card.bound_to)}`);
+    lines.push(contentNotice, bindings.text || RULE_CHECK_OBLIGATION, '\n## Outline', ...card.outline.map(section => `- ${section.heading} (${section.bytes} bytes, ${section.lines} lines)`), '\n## Resources', ...resources.map(resource => `- ${resource.path} (${resource.bytes} bytes)`), '\n## Drill in', ...Object.values(card.drill_in).flat().map(command => `- ${command}`));
+    if (card.resource)
+        lines.push(`\n## Resource: ${card.resource.path}`, card.resource.body);
+    console.log(lines.join('\n'));
+}
 /**
- * Read and emit the full text of a specific artifact (typically a
- * SKILL.md). Consumers don't need to know where AIWG stores skills —
+ * Emit a metadata card, with opt-in body/section drill-ins for a
+ * SKILL.md. Consumers don't need to know where AIWG stores skills —
  * they pass the skill name and the CLI reads the file from the indexed
  * location.
  *
@@ -2074,7 +2300,7 @@ export async function showArtifact(cwd, params) {
         ? params.typeFilter
         : [...OPERATIONAL_SHOW_TYPES];
     const { entries, aiwgRoot, resourceSource, webRelease, relations, } = await loadShowEntries(cwd, params, true);
-    if (entries.length === 0 && params.backend !== 'fortemi-core') {
+    if (entries.length === 0 && !relations && params.backend !== 'fortemi-core') {
         console.error('Error: No artifact index found.');
         console.error('Run `aiwg index build --graph framework` (or `aiwg use <framework>`) first.');
         process.exit(1);
@@ -2106,42 +2332,10 @@ export async function showArtifact(cwd, params) {
                     : corpusMatch.bundleKind && corpusMatch.bundleId
                         ? `Run \`aiwg use ${corpusMatch.bundleId}\` to install this ${corpusMatch.bundleKind} into the workspace.`
                         : 'Run `aiwg index build --graph framework` to refresh the artifact index.';
-                const bindings = await showBindings(entries, {
-                    path: corpusMatch.path, type: corpusMatch.type, name: needle, title: needle,
-                }, content, params, rule => fs.readFile(resolveMetadataPath(cwd, aiwgRoot, rule), 'utf8'), relations);
-                if (params.json) {
-                    console.log(JSON.stringify({
-                        ...bindings.fields,
-                        path: corpusMatch.path,
-                        type: corpusMatch.type,
-                        title: needle,
-                        kernel: false,
-                        uninstalled: !installed,
-                        ...(localPin ? { local_pin: localPin } : {}),
-                        hint: installHint,
-                        content,
-                    }, null, 2));
-                    return;
-                }
-                // Plain text mode: distinguish a missing index entry from an
-                // uninstalled bundle, then stream the body.
-                const banner = [
-                    installed
-                        ? '<!-- AIWG: installed bundle artifact — not in the selected index.'
-                        : '<!-- AIWG: corpus-only artifact — not in the indexed workspace.',
-                    `     ${installHint}`,
-                    '     Origin: ' + corpusMatch.path,
-                    '-->',
-                    '',
-                ].join('\n');
-                process.stdout.write(banner);
-                if (localPin)
-                    process.stdout.write(`Pinned locally: kernel (canonical ${localPin.canonical_activation}; ${localPin.matches.map(match => match.source).join(', ')}).\n`);
-                process.stdout.write(content);
-                if (!content.endsWith('\n'))
-                    process.stdout.write('\n');
-                if (bindings.text)
-                    process.stdout.write(bindings.text);
+                const fallbackEntry = { path: path.relative(aiwgRoot, corpusMatch.path), type: corpusMatch.type, name: needle, title: needle };
+                const bindings = await showBindings(entries, fallbackEntry, content, params, rule => fs.readFile(resolveMetadataPath(cwd, aiwgRoot, rule), 'utf8'), relations);
+                await emitShowCard(cwd, aiwgRoot, fallbackEntry, corpusMatch.path, content, params, bindings, { uninstalled: !installed, installed, hint: installHint,
+                    ...(localPin ? { local_pin: localPin } : {}) }, true);
                 return;
             }
         }
@@ -2242,57 +2436,18 @@ export async function showArtifact(cwd, params) {
         });
         return resolved.bytes.toString('utf8');
     }, relations);
-    if (params.json) {
-        const providerModels = resourceSource === 'local'
-            ? await loadProviderModelMetadata(cwd, aiwgRoot)
-            : null;
-        console.log(JSON.stringify({
-            id: discoveryIdForEntry(entry),
-            path: filePath,
-            type: entry.type,
-            name: entry.name,
-            title: entry.title,
-            kernel: entry.kernel ?? false,
-            provenance: {
-                graph: entry.indexGraph ?? null,
-                scope: entry.indexScope ?? null,
-                ...(webRelease
-                    ? {
-                        resource_source: 'web',
-                        aiwg_selector: webRelease.selector,
-                        aiwg_version: webRelease.version,
-                        manifest_sha256: webRelease.manifestDigest,
-                        manifest_url: webRelease.manifestUrl,
-                    }
-                    : {}),
-            },
-            // #1227 — surface script-bearing skills so callers can route to
-            // `aiwg run skill <name>` instead of treating SKILL.md as
-            // instructions for the agent to execute itself.
-            ...(entry.script
-                ? { executable: true, run_hint: buildRunHint(entry) }
-                : {}),
-            ...(providerModels ? { providerModels } : {}),
-            ...bindings.fields,
-            ...(localPin ? { local_pin: localPin } : {}),
-            content,
-        }, null, 2));
-        return;
-    }
-    // Stream the authored content first; append binding guidance only when present.
-    // #1227 — for script-bearing skills, prepend a one-line banner so
-    // agents reading the body immediately see the skill is executable.
-    if (entry.script) {
-        const hint = buildRunHint(entry);
-        process.stdout.write(`<!-- AIWG: executable skill — run via: ${hint} -->\n`);
-    }
-    if (localPin)
-        process.stdout.write(`Pinned locally: kernel (canonical ${localPin.canonical_activation}; ${localPin.matches.map(match => match.source).join(', ')}).\n`);
-    process.stdout.write(content);
-    if (!content.endsWith('\n'))
-        process.stdout.write('\n');
-    if (bindings.text)
-        process.stdout.write(bindings.text);
+    const providerModels = resourceSource === 'local' ? await loadProviderModelMetadata(cwd, aiwgRoot) : null;
+    await emitShowCard(cwd, aiwgRoot, entry, filePath, content, params, bindings, {
+        provenance: {
+            graph: entry.indexGraph ?? null,
+            scope: entry.indexScope ?? null,
+            ...(webRelease ? { resource_source: 'web', aiwg_selector: webRelease.selector, aiwg_version: webRelease.version,
+                manifest_sha256: webRelease.manifestDigest, manifest_url: webRelease.manifestUrl } : {}),
+        },
+        ...(entry.script ? { executable: true, run_hint: buildRunHint(entry) } : {}),
+        ...(providerModels ? { providerModels } : {}),
+        ...(localPin ? { local_pin: localPin } : {}),
+    }, resourceSource === 'local', webRelease);
 }
 export async function showMetadata(cwd, params) {
     loadGlobalGraphConfigs();

package/dist/src/artifacts/relations-builder.js

@@ -152,11 +152,11 @@ export function buildRelations(entries) {
     }
     return index;
 }
-export async function writeRelations(entries, cwd, indexDir, force = false) {
+export async function writeRelations(entries, cwd, indexDir, force = false, existingDir = indexDir) {
     const values = Object.values(entries);
     const fingerprint = relationsFingerprint(values);
     try {
-        const existing = JSON.parse(fs.readFileSync(path.join(indexDir, 'relations.json'), 'utf8'));
+        const existing = JSON.parse(fs.readFileSync(path.join(existingDir, 'relations.json'), 'utf8'));
         if (!force && existing.version === RELATIONS_VERSION && existing.$schema === RELATIONS_SCHEMA
             && existing.fingerprint.version === fingerprint.version && existing.fingerprint.sources === fingerprint.sources
             && existing.artifacts && existing.rules && existing.targets && existing.capabilities && existing.aliases?.targets && existing.aliases.rules)

package/dist/src/artifacts/source-graph.js

@@ -80,7 +80,7 @@ function shouldSkipDir(dirName, fullPath) {
         return true;
     return fullPath.split(path.sep).includes('.aiwg') && fullPath.split(path.sep).includes('.index');
 }
-function collectSourceFiles(cwd) {
+export function collectSourceFiles(cwd, includeAssets = false) {
     const results = [];
     const visit = (dir) => {
         if (!fs.existsSync(dir))
@@ -91,7 +91,7 @@ function collectSourceFiles(cwd) {
                 if (!shouldSkipDir(entry.name, fullPath))
                     visit(fullPath);
             }
-            else if (entry.isFile() && CODE_EXTENSIONS.has(path.extname(entry.name))) {
+            else if (entry.isFile() && (CODE_EXTENSIONS.has(path.extname(entry.name)) || (includeAssets && ASSET_EXTENSIONS.has(path.extname(entry.name))))) {
                 results.push(fullPath);
             }
         }

package/dist/src/artifacts/types.js

@@ -110,7 +110,7 @@ export const INDEX_VERSION = '1.0.0';
  * making the serialized index schema incompatible; a mismatch simply forces a
  * one-time content re-extraction during the next incremental build.
  */
-export const INDEX_EXTRACTOR_VERSION = '2026.10.19.1';
+export const INDEX_EXTRACTOR_VERSION = '2026.10.24.1';
 /**
  * Built-in graph definitions
  */
@@ -672,6 +672,14 @@ export function loadGlobalGraphConfigs(diagnostics) {
 }
 /** Module-scoped guard so the config.yaml deprecation note prints at most once per process. */
 let yamlIndexDeprecationWarned = false;
+/** Reload one workspace's registrations, including removals between daemon runs. */
+export function loadWorkspaceGraphs(workspace, diagnostics) {
+    for (const name of Object.keys(GRAPH_CONFIGS))
+        delete GRAPH_CONFIGS[name];
+    Object.assign(GRAPH_CONFIGS, structuredClone(BUILTIN_GRAPH_CONFIGS));
+    loadUserGraphConfigs(workspace, diagnostics);
+    loadGlobalGraphConfigs(diagnostics);
+}
 /**
  * Get the index output directory for a given graph type
  *

package/dist/src/cli/handlers/decision.js

@@ -1,10 +1,11 @@
+import { decisionPricing } from '../../decision/pricing.js';
 import { ATTRIBUTION_FIELD_PATTERN, DecisionAskUsageError, decisionCapabilities, DecisionLedgerSinceError, decisionLedgerHistory, decisionLedgerStats, evaluateRequestPath, listPatterns, livePlan, MAX_ATTRIBUTION_FIELD_LENGTH, materializeSyntheticClassificationSetup, parseDecisionLedgerSince, readDecisionContextFile, runDecisionOffloadCheckpoint, runOfflinePattern, setupJev, showPattern, syntheticClassificationSetup, validateDecisionInput, } from '../../decision/driver.js';
 function jsonResult(value, exitCode = 0) {
     return { exitCode, message: JSON.stringify(value, null, 2), rawOutput: true };
 }
 function usage() {
     return [
-        'Usage: aiwg decision <capabilities|status|patterns|validate|evaluate|setup|history|stats> [options]',
+        'Usage: aiwg decision <capabilities|status|patterns|validate|evaluate|setup|history|stats|pricing> [options]',
         '       aiwg decision ask --question "<q>" (--yes-no | --choices a,b,c | --scale 1-5) [--context <text> | --context-file <path> | --context-stdin] [--threshold 0.8] [--timeout-ms 15000] [--passes N] [--escalation-passes N] [--provider <id>] [--session <id>] [--caller <tag>] [--record-text] [--json]',
         '',
         'Commands:',
@@ -19,6 +20,7 @@ function usage() {
         '  setup jev [--token-stdin] [--region <r>] [--endpoint <url>] [--verify] [--remove]',
         '  ask --question "<q>" (--yes-no | --choices a,b,c | --scale 1-5) [--provider <id>] [--session <id>] [--caller <tag>] [--record-text]',
         '  history [--since <date>] [--provider <id>] [--session <id>] [--kind yes-no|choices|scale] [--status answered|fallback] [--caller <tag>|<prefix>* | --no-caller] [--json]',
+        '  pricing [--refresh --model jev-X.Y.Z] [--dry-run] [--offline | --allow-snapshot] [--json]',
         '  stats [--since <date>] [--provider <id>] [--session <id>] [--kind yes-no|choices|scale] [--status answered|fallback] [--caller <tag>|<prefix>* | --no-caller] [--group-by provider|session|kind|caller|passes|escalation] [--json]',
         '',
         'Notes:',
@@ -314,6 +316,7 @@ async function decisionStats(ctx) {
         `  jev usage: input=${group.jevUsage.inputTokens} output=${group.jevUsage.outputTokens}`,
         `  tokens per answered decision=${group.tokensPerAnsweredDecision?.toFixed(2) ?? '-'}`,
         `  llm_tokens_avoided=${group.llm_tokens_avoided} jev_tokens=${group.jev_tokens} cost_weighted_net_usd=${group.cost_weighted_net_usd.toFixed(6)}`,
+        ...group.ratesUsed.map(rate => `  rates used (${rate.calls} calls): ${JSON.stringify(rate.method)} source=${rate.method.source ?? 'manual'} checked_at=${rate.method.checked_at ?? 'unknown'}`),
         `  v1 comparison only: estimated LLM tokens avoided=${group.estimatedLlmTokensAvoidedTotal} net savings=${group.netSavingsTokens}`,
         ...(group.legacyReestimatedCalls ? [`  v1 records re-estimated=${group.legacyReestimatedCalls} weights=${JSON.stringify(result.legacyEstimationWeights)}`] : []),
     ]);
@@ -331,6 +334,21 @@ async function executeDecision(ctx) {
             return await decisionAsk(ctx);
         if (command === 'history')
             return await decisionHistory(ctx);
+        if (command === 'pricing') {
+            const args = ctx.args.slice(1);
+            assertLedgerArgs(args, ['--model'], ['--refresh', '--dry-run', '--offline', '--allow-snapshot', '--json']);
+            const result = await decisionPricing({ cwd: ctx.cwd, refresh: args.includes('--refresh'), dryRun: args.includes('--dry-run'),
+                offline: args.includes('--offline'), allowSnapshot: args.includes('--allow-snapshot'), model: args.includes('--model') ? takeRequiredOption(args, '--model') : undefined });
+            if (args.includes('--json'))
+                return jsonResult(result);
+            return { exitCode: 0, rawOutput: true, message: [
+                    `decision.ask.cost: ${JSON.stringify(result.current)}`,
+                    `Source URL: ${result.sourceUrl}`,
+                    ...('snapshotDate' in result && result.snapshotDate ? [`Bundled snapshot dated ${result.snapshotDate}`] : []),
+                    ...('warning' in result && result.warning ? [`Warning: ${result.warning}`] : []),
+                    ...('diff' in result ? [`${result.written ? 'Written' : 'Dry run; config unchanged'}: ${JSON.stringify(result.diff)}`] : []),
+                ].join('\n') };
+        }
         if (command === 'stats')
             return await decisionStats(ctx);
         if (command === 'patterns') {