@aiwg/cli 2026.8.7 → 2026.8.10

package/dist/src/evidence/bundle.js

@@ -0,0 +1,256 @@
+/** Portable, self-verifying local evidence bundles. @issue #2039 */
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+const SCHEMA_VERSION = 'aiwg.evidence.bundle/v1';
+const RESTRICTED_KEY = /(?:^|_)(?:content|terminal|prompt|environment|env|credential|secret|password|authorization|bearer|token|private_key|certificate|restricted_(?:url|uri|link))(?:$|_)/i;
+const ALLOWED_POLICY_KEYS = new Set(['restricted_content_grants']);
+const EVIDENCE_ROLES = new Set(['activity-export', 'report', 'source', 'eval-config', 'provenance']);
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function containsRestricted(value) {
+    if (Array.isArray(value))
+        return value.some(containsRestricted);
+    if (!value || typeof value !== 'object')
+        return false;
+    return Object.entries(value).some(([key, child]) => (!ALLOWED_POLICY_KEYS.has(key.toLowerCase()) && RESTRICTED_KEY.test(key)) || containsRestricted(child));
+}
+function numeric(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : null;
+}
+function stringArray(value) {
+    return Array.isArray(value) && value.every(item => typeof item === 'string') ? [...value].sort() : null;
+}
+function activitySummary(value) {
+    const reasons = [];
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('activity export is not an object; refusing to copy unassessed activity evidence');
+    }
+    if (containsRestricted(value))
+        throw new Error('activity export contains prohibited credential or restricted-content fields');
+    const envelope = value;
+    const manifest = envelope.manifest ?? {};
+    const completeness = envelope.completeness ?? manifest.completeness ?? {};
+    const coverage = envelope.coverage ?? manifest.coverage ?? [];
+    const collectors = envelope.collectors ?? manifest.collectors ?? {};
+    const redaction = envelope.redaction ?? manifest.redaction ?? {};
+    const grants = envelope.restricted_content_grants ?? manifest.restricted_content_grants;
+    const summary = {
+        coverage_label: typeof envelope.coverage_label === 'string' ? envelope.coverage_label
+            : typeof manifest.coverage_label === 'string' ? manifest.coverage_label
+                : Array.isArray(coverage) && coverage.length ? coverage.map(String).sort().join(',') : null,
+        sequence_gaps: numeric(completeness.sequence_gaps ?? manifest.sequence_gaps),
+        durable_loss: typeof completeness.durable_loss === 'boolean' ? completeness.durable_loss
+            : typeof manifest.durable_loss === 'boolean' ? manifest.durable_loss : null,
+        dropped_events: numeric(completeness.dropped_events ?? manifest.dropped_events),
+        stale_collectors: stringArray(collectors.stale ?? manifest.stale_collectors),
+        clock_uncertainty: typeof manifest.clock_uncertainty === 'string' || typeof manifest.clock_uncertainty === 'number'
+            ? manifest.clock_uncertainty : null,
+        redaction_status: typeof redaction.status === 'string' ? redaction.status
+            : typeof manifest.redaction_status === 'string' ? manifest.redaction_status : null,
+        restricted_content_grants: stringArray(grants),
+        signature_key_id: typeof manifest.key_id === 'string' ? manifest.key_id : null,
+        signed_merkle_root: typeof manifest.merkle_root === 'string' ? manifest.merkle_root : null,
+    };
+    for (const [key, value] of Object.entries(summary)) {
+        if (value === null)
+            reasons.push(`activity evidence is missing ${key}`);
+    }
+    if ((summary.sequence_gaps ?? 0) > 0)
+        reasons.push(`activity evidence reports ${summary.sequence_gaps} sequence gap(s)`);
+    if (summary.durable_loss === true)
+        reasons.push('activity evidence reports durable loss');
+    if ((summary.dropped_events ?? 0) > 0)
+        reasons.push(`activity evidence reports ${summary.dropped_events} dropped event(s)`);
+    if (summary.stale_collectors?.length)
+        reasons.push(`activity evidence reports stale collectors: ${summary.stale_collectors.join(', ')}`);
+    if (summary.redaction_status && summary.redaction_status !== 'complete')
+        reasons.push(`activity evidence redaction status is ${summary.redaction_status}`);
+    return { summary, reasons };
+}
+function emptyActivity() {
+    return {
+        coverage_label: null,
+        sequence_gaps: null,
+        durable_loss: null,
+        dropped_events: null,
+        stale_collectors: null,
+        clock_uncertainty: null,
+        redaction_status: null,
+        restricted_content_grants: null,
+        signature_key_id: null,
+        signed_merkle_root: null,
+    };
+}
+function checkpoint(members) {
+    let chain = sha256(`${SCHEMA_VERSION}\n`);
+    for (const member of [...members].sort((a, b) => a.path.localeCompare(b.path))) {
+        chain = sha256(`${chain}\n${member.role}\n${member.path}\n${member.sha256}\n`);
+    }
+    return chain;
+}
+function safeName(file, used) {
+    const parsed = path.parse(file);
+    const base = parsed.name.replace(/[^A-Za-z0-9._-]/g, '-') || 'member';
+    const extension = parsed.ext.replace(/[^A-Za-z0-9.]/g, '');
+    let candidate = `${base}${extension}`;
+    let suffix = 2;
+    while (used.has(candidate))
+        candidate = `${base}-${suffix++}${extension}`;
+    used.add(candidate);
+    return candidate;
+}
+export async function createEvidenceBundle(options) {
+    const output = path.resolve(options.output);
+    const membersDirectory = path.join(output, 'members');
+    const members = [];
+    const used = new Set();
+    const incompleteReasons = [];
+    let activity = emptyActivity();
+    const prepared = [];
+    for (const input of options.inputs) {
+        const source = path.resolve(input.file);
+        let content;
+        try {
+            content = await fs.readFile(source);
+        }
+        catch (error) {
+            incompleteReasons.push(`${input.role} member unavailable: ${path.basename(source)} (${error.code ?? 'read-error'})`);
+            continue;
+        }
+        if (input.role === 'activity-export') {
+            let parsed;
+            try {
+                parsed = JSON.parse(content.toString('utf8'));
+            }
+            catch {
+                throw new Error('activity export is not valid JSON; refusing to copy unassessed activity evidence');
+            }
+            const assessed = activitySummary(parsed);
+            activity = assessed.summary;
+            incompleteReasons.push(...assessed.reasons);
+        }
+        prepared.push({ input, source, content });
+    }
+    await fs.mkdir(path.dirname(output), { recursive: true });
+    await fs.mkdir(output);
+    await fs.mkdir(membersDirectory);
+    for (const { input, source, content } of prepared) {
+        const name = safeName(source, used);
+        const relative = path.posix.join('members', name);
+        await fs.writeFile(path.join(output, relative), content, { flag: 'wx' });
+        members.push({ path: relative, role: input.role, source_name: path.basename(source), sha256: sha256(content), bytes: content.length });
+    }
+    const roles = new Set(members.map(member => member.role));
+    for (const role of ['activity-export', 'report', 'source', 'eval-config', 'provenance']) {
+        if (!roles.has(role))
+            incompleteReasons.push(`bundle has no ${role} member`);
+    }
+    if (!Object.keys(options.modelVersions ?? {}).length)
+        incompleteReasons.push('model versions are missing');
+    if (!Object.keys(options.toolVersions ?? {}).length)
+        incompleteReasons.push('tool versions are missing');
+    const notRunReason = options.notRunReason?.trim() || null;
+    const status = (options.checkOnly && notRunReason)
+        ? 'not-run' : incompleteReasons.length ? 'incomplete' : 'complete';
+    const manifest = {
+        schema_version: SCHEMA_VERSION,
+        status,
+        incomplete_reasons: [...new Set(incompleteReasons)].sort(),
+        not_run_reason: status === 'not-run' ? notRunReason : null,
+        created_at: (options.now ?? new Date()).toISOString(),
+        model_versions: Object.fromEntries(Object.entries(options.modelVersions ?? {}).sort()),
+        tool_versions: Object.fromEntries(Object.entries(options.toolVersions ?? {}).sort()),
+        activity,
+        members: members.sort((a, b) => a.path.localeCompare(b.path)),
+        verifier: {
+            algorithm: 'sha256',
+            checkpoint: 'sorted-member-hash-chain',
+            root: checkpoint(members),
+            command: 'aiwg evidence verify <bundle>',
+        },
+    };
+    await fs.writeFile(path.join(output, 'evidence-manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`, { flag: 'wx' });
+    return manifest;
+}
+export async function verifyEvidenceBundle(bundle, expectedRoot) {
+    const root = path.resolve(bundle);
+    const errors = [];
+    const warnings = [];
+    let manifest;
+    try {
+        manifest = JSON.parse(await fs.readFile(path.join(root, 'evidence-manifest.json'), 'utf8'));
+    }
+    catch {
+        return { valid: false, status: 'invalid', errors: ['manifest is missing or invalid JSON'], warnings, root: null };
+    }
+    if (manifest.schema_version !== SCHEMA_VERSION)
+        errors.push(`unsupported schema_version ${String(manifest.schema_version)}`);
+    if (!['complete', 'incomplete', 'not-run'].includes(manifest.status))
+        errors.push(`unsupported status ${String(manifest.status)}`);
+    if (!Array.isArray(manifest.members)) {
+        errors.push('manifest members must be an array');
+        manifest.members = [];
+    }
+    const declaredPaths = new Set();
+    for (const member of manifest.members) {
+        if (!member
+            || typeof member.path !== 'string'
+            || !/^members\/[A-Za-z0-9._-]+$/.test(member.path)
+            || !EVIDENCE_ROLES.has(member.role)
+            || !/^[0-9a-f]{64}$/.test(member.sha256)
+            || !Number.isInteger(member.bytes)
+            || member.bytes < 0) {
+            errors.push('manifest contains a malformed member');
+            continue;
+        }
+        if (declaredPaths.has(member.path))
+            errors.push(`member is declared more than once: ${member.path}`);
+        declaredPaths.add(member.path);
+        const target = path.resolve(root, member.path);
+        if (!target.startsWith(`${root}${path.sep}`)) {
+            errors.push(`member escapes bundle root: ${member.path}`);
+            continue;
+        }
+        try {
+            const metadata = await fs.lstat(target);
+            if (!metadata.isFile() || metadata.isSymbolicLink()) {
+                errors.push(`member is not a regular file: ${member.path}`);
+                continue;
+            }
+            const content = await fs.readFile(target);
+            if (content.length !== member.bytes)
+                errors.push(`member size changed: ${member.path}`);
+            if (sha256(content) !== member.sha256)
+                errors.push(`member hash changed: ${member.path}`);
+        }
+        catch {
+            errors.push(`member is missing: ${member.path}`);
+        }
+    }
+    try {
+        const actualNames = await fs.readdir(path.join(root, 'members'));
+        for (const name of actualNames) {
+            const relative = path.posix.join('members', name);
+            if (!declaredPaths.has(relative))
+                errors.push(`bundle contains an undeclared member: ${relative}`);
+        }
+    }
+    catch {
+        if (manifest.members.length)
+            errors.push('bundle members directory is missing');
+    }
+    const checkpointMembers = manifest.members.filter(member => member && typeof member.path === 'string' && typeof member.role === 'string' && typeof member.sha256 === 'string');
+    const computed = checkpoint(checkpointMembers);
+    if (computed !== manifest.verifier?.root)
+        errors.push('bundle checkpoint does not match manifest members');
+    if (expectedRoot && computed !== expectedRoot)
+        errors.push('bundle checkpoint does not match expected root');
+    if (manifest.status === 'incomplete')
+        warnings.push(...(manifest.incomplete_reasons ?? []));
+    if (manifest.status === 'not-run')
+        warnings.push(`NOT RUN: ${manifest.not_run_reason ?? 'reason unavailable'}`);
+    return { valid: errors.length === 0, status: errors.length ? 'invalid' : manifest.status, errors, warnings, root: computed };
+}
+//# sourceMappingURL=bundle.js.map

package/dist/src/extensions/commands/definitions.js

@@ -104,6 +104,27 @@ export const doctorCommand = {
     metadata: {
         type: 'skill',
         triggerPhrases: ['doctor', 'check health', 'diagnose', 'troubleshoot installation'],
+        commandHint: {
+            template: 'utility',
+            argumentHint: '[--deployment] [--provider <p>] [--bundle <id>] [--scope project|user] [--json]',
+            allowedTools: ['Read', 'Bash'],
+        },
+    },
+};
+export const contextFirewallCommand = {
+    id: 'context-firewall',
+    type: 'skill',
+    name: 'Context Firewall',
+    description: 'Audit provider context and manage its reviewed digest baseline',
+    version: '1.0.0',
+    capabilities: ['cli', 'diagnostics', 'security', 'context-budget', 'memory-review'],
+    keywords: ['context', 'memory', 'firewall', 'baseline', 'poisoning', 'budget', 'trust'],
+    category: 'maintenance',
+    platforms: { claude: 'full', generic: 'full' },
+    deployment: { pathTemplate: '.{platform}/commands/{id}.md', core: true },
+    metadata: {
+        type: 'skill',
+        triggerPhrases: ['audit context', 'context firewall', 'review memory baseline', 'context budget'],
         commandHint: {
             template: 'utility',
             allowedTools: ['Read', 'Bash'],
@@ -274,14 +295,15 @@ export const useCommand = {
         triggerPhrases: ['use framework', 'deploy framework', 'install framework', 'use sdlc', 'use addon'],
         commandHint: {
             template: 'orchestration',
-            argumentHint: '<framework|addon> [--provider <p>] [--prefix <dir>] [--profile <name>] [--harness-agents <list>]',
+            argumentHint: '<framework|addon> [--provider <p>] [--scope project|user] [--dry-run] [--json]',
             allowedTools: ['Read', 'Write', 'Bash', 'Glob'],
             executionSteps: [
                 'Validate framework name',
                 'Check dependencies',
                 'Deploy framework files',
-                'Register in framework registry',
-                'Deploy platform-specific adaptations',
+                'Register installed state and deploy platform-specific adaptations',
+                'Refresh the applicable capability index and canonical context',
+                'Verify required invariants and report readiness or repair findings',
             ],
         },
     },
@@ -729,10 +751,10 @@ export const issueCommand = {
     id: 'issue',
     type: 'skill',
     name: 'Issue',
-    description: 'Manage local project issues under .aiwg/issues/',
+    description: 'Policy-plan and manage local project issues under .aiwg/issues/',
     version: '1.0.0',
     capabilities: ['cli', 'project', 'issues', 'local-provider'],
-    keywords: ['issue', 'issues', 'local', 'tracker', 'tickets'],
+    keywords: ['issue', 'issues', 'local', 'tracker', 'tickets', 'policy', 'segmentation'],
     category: 'project',
     platforms: {
         claude: 'full',
@@ -744,10 +766,10 @@ export const issueCommand = {
     },
     metadata: {
         type: 'skill',
-        triggerPhrases: ['local issues', 'issue init', 'issue list', 'issue create'],
+        triggerPhrases: ['local issues', 'issue init', 'issue list', 'issue create', 'plan issue draft'],
         commandHint: {
             template: 'utility',
-            argumentHint: '<init|new|list|show|comment|close|index> [--provider local]',
+            argumentHint: '<init|plan|new|list|show|comment|close|index> [--provider local]',
             allowedTools: ['Read', 'Write', 'Bash'],
         },
     },
@@ -1325,8 +1347,8 @@ export const artifactsCommand = {
     name: 'Project Artifacts',
     description: 'Move or inspect the configured project AIWG artifact root',
     version: '1.0.0',
-    capabilities: ['cli', 'artifacts', 'relocation', 'configuration', 'index'],
-    keywords: ['artifacts', 'aiwg artifacts', 'move .aiwg', 'relocate .aiwg', 'rename .aiwg', 'artifact root', 'AIWG_ARTIFACTS_PATH'],
+    capabilities: ['cli', 'artifacts', 'relocation', 'repair', 'configuration', 'index'],
+    keywords: ['artifacts', 'aiwg artifacts', 'move .aiwg', 'relocate .aiwg', 'rename .aiwg', 'repair artifact root', 'external corpus', 'split root', 'artifact root', 'AIWG_ARTIFACTS_PATH'],
     category: 'index',
     platforms: {
         claude: 'full',
@@ -1338,10 +1360,10 @@ export const artifactsCommand = {
     },
     metadata: {
         type: 'skill',
-        triggerPhrases: ['move .aiwg', 'relocate .aiwg', 'rename .aiwg', 'move aiwg artifacts', 'artifact root'],
+        triggerPhrases: ['move .aiwg', 'relocate .aiwg', 'rename .aiwg', 'move aiwg artifacts', 'repair external corpus', 'externalize corpus', 'artifact root'],
         commandHint: {
             template: 'utility',
-            argumentHint: 'move --to <path> [--from <path>] [--dry-run]',
+            argumentHint: 'move|attach|repair [--to <path>] [--dry-run|--apply]',
             allowedTools: ['Read', 'Write', 'Bash'],
         },
     },
@@ -1351,10 +1373,10 @@ export const corpusCommand = {
     id: 'corpus',
     type: 'skill',
     name: 'Research Corpus Tools',
-    description: 'Research-corpus tools (radar-init, radar-status, radar-report)',
-    version: '1.0.0',
-    capabilities: ['cli', 'research', 'corpus', 'radar', 'freshness', 'profiles', 'discovery'],
-    keywords: ['corpus', 'radar', 'freshness', 'staleness', 'radar-init', 'radar-status', 'radar-report', 'profile-status', 'profile-generate', 'profile-metrics', 'profile-temporal', 'profile-communities', 'h-index', 'PageRank', 'CD-index', 'centrality', 'community detection', 'hot streak', 'funder-network', 'funder analytics', 'co-funding', 'novelty bias', 'curator-status', 'curator-init', 'discovery-log', 'PROF-S', 'source tracking', 'discovery provenance', 'stale profiles', 'hub authors', 'refresh cadence', 'GRADE trajectory'],
+    description: 'Research-corpus tools for freshness, profiles, provenance, and retrieval benchmarks',
+    version: '1.1.0',
+    capabilities: ['cli', 'research', 'corpus', 'radar', 'freshness', 'profiles', 'discovery', 'retrieval-benchmark'],
+    keywords: ['corpus', 'radar', 'freshness', 'staleness', 'radar-init', 'radar-status', 'radar-report', 'profile-status', 'profile-generate', 'profile-metrics', 'profile-temporal', 'profile-communities', 'h-index', 'PageRank', 'CD-index', 'centrality', 'community detection', 'hot streak', 'funder-network', 'funder analytics', 'co-funding', 'novelty bias', 'curator-status', 'curator-init', 'discovery-log', 'PROF-S', 'source tracking', 'discovery provenance', 'stale profiles', 'hub authors', 'refresh cadence', 'GRADE trajectory', 'retrieval-lab', 'BM25', 'vector retrieval', 'concept graph', 'PPR', 'RRF', 'source selection'],
     category: 'index',
     platforms: {
         claude: 'full',
@@ -1366,10 +1388,10 @@ export const corpusCommand = {
     },
     metadata: {
         type: 'skill',
-        triggerPhrases: ['radar', 'radar status', 'radar report', 'scaffold radar', 'stale radars', 'corpus freshness', 'stale profiles', 'profile status', 'curator yield', 'discovery source', 'log discovery'],
+        triggerPhrases: ['radar', 'radar status', 'radar report', 'scaffold radar', 'stale radars', 'corpus freshness', 'stale profiles', 'profile status', 'curator yield', 'discovery source', 'log discovery', 'benchmark corpus retrieval', 'hybrid retrieval lab'],
         commandHint: {
             template: 'utility',
-            argumentHint: '<radar-*|profile-*|curator-*|discovery-log|funder-network> [options]',
+            argumentHint: '<radar-*|profile-*|curator-*|discovery-log|funder-network|retrieval-lab> [options]',
             allowedTools: ['Read', 'Glob', 'Grep', 'Write'],
         },
     },
@@ -1522,7 +1544,7 @@ export const featuresCommand = {
     description: 'List, inspect, and (eventually) install AIWG\'s optional runtime features',
     version: '1.0.0',
     capabilities: ['cli', 'maintenance', 'install', 'optional-deps'],
-    keywords: ['features', 'optional', 'install', 'embeddings', 'sqlite', 'pty', 'webserver'],
+    keywords: ['features', 'optional', 'install', 'embeddings', 'sqlite', 'pty', 'webserver', 'graph', 'terminal'],
     category: 'maintenance',
     platforms: {
         claude: 'full',
@@ -2428,14 +2450,42 @@ export const teamCommand = {
     },
 };
 // Cost & Metrics Commands
+export const evidenceCommand = {
+    id: 'evidence',
+    type: 'skill',
+    name: 'Evidence',
+    description: 'Export and verify portable evaluation evidence bundles',
+    version: '1.0.0',
+    capabilities: ['cli', 'evidence', 'provenance', 'verification', 'evaluation'],
+    keywords: ['evidence', 'bundle', 'provenance', 'verify', 'evaluation', 'activity-export'],
+    category: 'metrics',
+    platforms: {
+        claude: 'full',
+        generic: 'full',
+    },
+    deployment: {
+        pathTemplate: '.{platform}/commands/{id}.md',
+        core: false,
+    },
+    metadata: {
+        type: 'skill',
+        triggerPhrases: ['evidence bundle', 'export evidence', 'verify evidence', 'evaluation provenance'],
+        commandHint: {
+            template: 'utility',
+            allowedTools: ['Read', 'Bash'],
+            argumentHint: '<export|verify> [options]',
+            cliDisabled: false,
+        },
+    },
+};
 export const costReportCommand = {
     id: 'cost-report',
     type: 'skill',
     name: 'Cost Report',
-    description: 'Generate token cost and spending report for workflows',
-    version: '1.0.0',
-    capabilities: ['cli', 'metrics', 'cost-tracking', 'reporting'],
-    keywords: ['cost', 'report', 'tokens', 'spending', 'budget', 'metrics'],
+    description: 'Generate session or OpenRouter fleet cost and spending reports',
+    version: '1.1.0',
+    capabilities: ['cli', 'metrics', 'cost-tracking', 'reporting', 'fleet', 'openrouter'],
+    keywords: ['cost', 'report', 'tokens', 'spending', 'budget', 'metrics', 'fleet', 'openrouter'],
     category: 'metrics',
     platforms: {
         claude: 'full',
@@ -2447,11 +2497,11 @@ export const costReportCommand = {
     },
     metadata: {
         type: 'skill',
-        triggerPhrases: ['cost report', 'show costs', 'token spending', 'cost summary', 'budget report'],
+        triggerPhrases: ['cost report', 'show costs', 'token spending', 'cost summary', 'budget report', 'fleet spend'],
         commandHint: {
             template: 'utility',
             allowedTools: ['Read', 'Bash'],
-            cliDisabled: true,
+            cliDisabled: false,
         },
     },
 };
@@ -3481,6 +3531,7 @@ export const commandDefinitions = [
     versionCommand,
     authCommand,
     doctorCommand,
+    contextFirewallCommand,
     updateCommand,
     refreshCommand,
     regenerateCommand,
@@ -3561,7 +3612,8 @@ export const commandDefinitions = [
     stewardCommand,
     // Agent Teams (1)
     teamCommand,
-    // Metrics (3)
+    // Metrics (4)
+    evidenceCommand,
     costReportCommand,
     costHistoryCommand,
     metricsTokensCommand,

package/dist/src/extensions/deployment-registration.js

@@ -425,14 +425,15 @@ export async function scanDeployedBehaviors(behaviorsPath, provider, cwd = proce
  * ```
  */
 export async function registerDeployedExtensions(registry, options) {
-    const { agentsPath, skillsPath, behaviorsPath, provider, cwd } = options;
+    const { agentsPath, skillsPath, behaviorsPath, provider, cwd, quiet = false } = options;
     // Scan and register agents
     if (agentsPath) {
         const agents = await scanDeployedAgents(agentsPath, provider, cwd);
         for (const agent of agents) {
             registry.register(agent);
         }
-        console.log(`Registered ${agents.length} agents from ${agentsPath}`);
+        if (!quiet)
+            console.log(`Registered ${agents.length} agents from ${agentsPath}`);
     }
     // Scan and register skills
     if (skillsPath) {
@@ -446,7 +447,8 @@ export async function registerDeployedExtensions(registry, options) {
             total += skills.length;
             perPath.push(`${skills.length} from ${pathToScan}`);
         }
-        console.log(`Registered ${total} skills (${perPath.join(', ')})`);
+        if (!quiet)
+            console.log(`Registered ${total} skills (${perPath.join(', ')})`);
     }
     // Scan and register behaviors (#609)
     if (behaviorsPath) {
@@ -454,7 +456,7 @@ export async function registerDeployedExtensions(registry, options) {
         for (const behavior of behaviors) {
             registry.register(behavior);
         }
-        if (behaviors.length > 0) {
+        if (!quiet && behaviors.length > 0) {
             console.log(`Registered ${behaviors.length} behaviors from ${behaviorsPath}`);
         }
     }

package/dist/src/extensions/project-local-doctor.js

@@ -54,12 +54,15 @@ export async function buildProjectLocalDoctorSection(opts) {
     const quickrefAudit = await auditProjectQuickref(projectDir, config?.providers ?? []);
     const quickrefErrors = [...quickrefAudit.errors];
     if (quickrefAudit.exists) {
-        const quickrefRelPath = projectRelativePathIfInside(projectDir, projectAiwgPath(projectDir, 'quickref.json'));
-        const ignored = quickrefRelPath
-            ? await checkBundleManifestIgnored(projectDir, quickrefRelPath)
-            : null;
-        if (ignored === true && quickrefRelPath) {
-            quickrefErrors.push(`${quickrefRelPath} is ignored by git; canonical project quickref source must be committed`);
+        for (const name of ['quickref.json', 'quickref.config.json']) {
+            const sourcePath = projectAiwgPath(projectDir, name);
+            const quickrefRelPath = projectRelativePathIfInside(projectDir, sourcePath);
+            const ignored = quickrefRelPath
+                ? await checkBundleManifestIgnored(projectDir, quickrefRelPath)
+                : null;
+            if (ignored === true && quickrefRelPath) {
+                quickrefErrors.push(`${quickrefRelPath} is ignored by git; operator project quickref input must be committed`);
+            }
         }
     }
     // No project-local content → no section at all
@@ -236,6 +239,7 @@ export async function buildProjectLocalDoctorSection(opts) {
             }
             lines.push('    Project-local bundle source should be tracked. Add to .gitignore:');
             lines.push('      !.aiwg/quickref.json');
+            lines.push('      !.aiwg/quickref.config.json');
             lines.push('      !.aiwg/addons/');
             lines.push('      !.aiwg/extensions/');
             lines.push('      !.aiwg/frameworks/');

package/dist/src/extensions/project-local-gitignore.js

@@ -39,6 +39,7 @@ export const AIWG_GITIGNORE_BLOCK = [
     AIWG_GITIGNORE_SENTINEL,
     '!.aiwg/aiwg.config',
     '!.aiwg/quickref.json',
+    '!.aiwg/quickref.config.json',
     '!.aiwg/addons/',
     '!.aiwg/extensions/',
     '!.aiwg/frameworks/',
@@ -120,11 +121,14 @@ export async function appendAiwgSourceTrackBlock(projectDir) {
     // runs.
     if (report.hasManagedBlock) {
         const path = join(projectDir, '.gitignore');
-        const existing = await readFile(path, 'utf8');
-        if (!existing.split(/\r?\n/).some(line => line.trim() === '!.aiwg/quickref.json')) {
+        let existing = await readFile(path, 'utf8');
+        const required = ['!.aiwg/quickref.json', '!.aiwg/quickref.config.json'];
+        const missing = required.filter(negation => !existing.split(/\r?\n/).some(line => line.trim() === negation));
+        if (missing.length > 0) {
             const sep = existing.endsWith('\n') ? '' : '\n';
-            await writeFile(path, `${existing}${sep}!.aiwg/quickref.json\n`, 'utf8');
-            return { added: true, reason: 'updated managed block to track .aiwg/quickref.json' };
+            existing = `${existing}${sep}${missing.join('\n')}\n`;
+            await writeFile(path, existing, 'utf8');
+            return { added: true, reason: `updated managed block to track ${missing.join(', ')}` };
         }
         return { added: false, reason: 'block already present — no change' };
     }