agentic-workflow-manager 9.17.0 → 9.19.0

package/dist/src/commands/env/index.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeFactDefinitions = mergeFactDefinitions;
+exports.registerEnvCommand = registerEnvCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const readline_1 = __importDefault(require("readline"));
+const catalog_1 = require("../../core/facts/catalog");
+const registries_1 = require("../../core/registries");
+const store_1 = require("../../core/environments/store");
+const resolve_1 = require("../../core/environments/resolve");
+/**
+ * Merge facts catalogs from installed registry roots.
+ * Later roots may refine a fact, but must not weaken durability: volatile wins
+ * over durable so an expired secret cannot be revived by a durable override.
+ */
+function mergeFactDefinitions(into, from) {
+    for (const [id, next] of Object.entries(from)) {
+        const prev = Object.hasOwn(into, id) ? into[id] : undefined;
+        if (!prev) {
+            into[id] = next;
+            continue;
+        }
+        if (prev.durability === 'volatile' && next.durability === 'durable') {
+            const kept = { ...next, durability: 'volatile' };
+            if (prev.ttl !== undefined)
+                kept.ttl = prev.ttl;
+            into[id] = kept;
+            continue;
+        }
+        into[id] = next;
+    }
+}
+function loadCatalogFromInstalledRoots() {
+    const merged = { schemaVersion: 1, facts: {} };
+    for (const root of (0, registries_1.contentRoots)()) {
+        const factsPath = path_1.default.join(root, 'facts.json');
+        if (!fs_1.default.existsSync(factsPath))
+            continue;
+        const catalog = (0, catalog_1.parseFactsCatalog)(factsPath);
+        mergeFactDefinitions(merged.facts, catalog.facts);
+    }
+    return merged;
+}
+function defaultConsultedRoots() {
+    return (0, registries_1.contentRoots)();
+}
+function requireValue(value, flagHint) {
+    if (value === undefined) {
+        throw new store_1.EnvironmentStoreError(`${flagHint} requires --value <text> in non-interactive mode (prompt / editable store / --value only; RF-3.3)`);
+    }
+    return value;
+}
+async function defaultPromptValue(question) {
+    const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return await new Promise((resolve) => {
+            rl.question(question, (answer) => resolve(answer));
+        });
+    }
+    finally {
+        rl.close();
+    }
+}
+async function resolveValue(optsValue, flagHint, factId, deps) {
+    if (optsValue !== undefined)
+        return optsValue;
+    if (!deps.stdinIsTTY()) {
+        return requireValue(undefined, flagHint);
+    }
+    return Promise.resolve(deps.promptValue(`Value for ${factId}: `));
+}
+function setFact(factId, rawValue, deps) {
+    const catalog = deps.loadCatalog();
+    const name = (0, store_1.getActiveEnvironmentName)();
+    (0, store_1.writeFact)(name, factId, {
+        value: rawValue,
+        status: 'fresh',
+        updatedAt: new Date().toISOString(),
+    }, {
+        catalog,
+        consultedRoots: deps.consultedRoots(),
+    });
+}
+function registerEnvCommand(program, deps = {}) {
+    const loadCatalog = deps.loadCatalog ?? loadCatalogFromInstalledRoots;
+    const consultedRoots = deps.consultedRoots ?? defaultConsultedRoots;
+    const now = deps.now ?? (() => new Date());
+    const stdinIsTTY = deps.stdinIsTTY ?? (() => Boolean(process.stdin.isTTY));
+    const promptValue = deps.promptValue ?? defaultPromptValue;
+    const env = program.command('env').description('manage machine-local operator environments (facts store)');
+    env.command('status')
+        .description('show active environment and fact statuses vs catalog')
+        .action(() => {
+        const name = (0, store_1.getActiveEnvironmentName)();
+        const catalog = loadCatalog();
+        const store = (0, store_1.readValues)(name);
+        const statuses = (0, resolve_1.statusFor)(catalog, store, now());
+        const lines = [
+            `Active environment: ${name}`,
+            `Store: ${(0, store_1.valuesPath)(name)}`,
+            '',
+            'Facts:',
+        ];
+        const ids = Object.keys(catalog.facts).sort();
+        if (ids.length === 0) {
+            lines.push('  (no facts in consulted catalogs)');
+        }
+        else {
+            for (const id of ids) {
+                lines.push(`  ${id}: ${statuses[id]}`);
+            }
+        }
+        process.stdout.write(lines.join('\n') + '\n');
+    });
+    env.command('set <factId>')
+        .description('set a fact value in the active environment (--value for non-interactive)')
+        .option('--value <text>', 'fact value (required non-interactive; never runs registry commands)')
+        .action(async (factId, opts) => {
+        const value = await resolveValue(opts.value, 'awm env set', factId, {
+            stdinIsTTY,
+            promptValue,
+        });
+        setFact(factId, value, { loadCatalog, consultedRoots });
+        process.stdout.write(`Set ${factId} in environment ${(0, store_1.getActiveEnvironmentName)()}\n`);
+    });
+    env.command('edit')
+        .description('print the absolute path of the active environment values.json')
+        .action(() => {
+        const name = (0, store_1.getActiveEnvironmentName)();
+        const file = (0, store_1.valuesPath)(name);
+        process.stdout.write(`${file}\n`);
+    });
+    env.command('refresh [factId]')
+        .description('re-set a fact value (prompt / --value only; no registry commands)')
+        .option('--value <text>', 'new value (required non-interactive)')
+        .option('--all', 'refresh every fact present in the store (interactive prompts, or pass factId)')
+        .action(async (factId, opts) => {
+        if (opts.all && !factId) {
+            if (!stdinIsTTY()) {
+                throw new store_1.EnvironmentStoreError('awm env refresh --all requires a TTY (or pass <factId> with --value in non-interactive mode)');
+            }
+            const name = (0, store_1.getActiveEnvironmentName)();
+            const ids = Object.keys((0, store_1.readValues)(name));
+            if (ids.length === 0) {
+                throw new store_1.EnvironmentStoreError('awm env refresh --all: active store has no facts');
+            }
+            for (const id of ids) {
+                const value = await Promise.resolve(promptValue(`Value for ${id}: `));
+                setFact(id, value, { loadCatalog, consultedRoots });
+                process.stdout.write(`Refreshed ${id} in environment ${(0, store_1.getActiveEnvironmentName)()}\n`);
+            }
+            return;
+        }
+        if (!factId) {
+            throw new store_1.EnvironmentStoreError('awm env refresh requires <factId> (or interactive --all)');
+        }
+        const value = await resolveValue(opts.value, 'awm env refresh', factId, {
+            stdinIsTTY,
+            promptValue,
+        });
+        setFact(factId, value, { loadCatalog, consultedRoots });
+        process.stdout.write(`Refreshed ${factId} in environment ${(0, store_1.getActiveEnvironmentName)()}\n`);
+    });
+    env.command('use <name>')
+        .description('switch the active environment (one active per machine)')
+        .action((name) => {
+        (0, store_1.setActiveEnvironmentName)(name);
+        process.stdout.write(`Active environment: ${name}\n`);
+    });
+    env.command('inject')
+        .description('print JSON injection payload for the active environment (default mode: reference)')
+        .option('--mode <mode>', 'injection mode: reference|context', 'reference')
+        .action((opts) => {
+        const rawMode = opts.mode ?? 'reference';
+        const mode = rawMode === 'reference' || rawMode === 'context' ? rawMode : 'reference';
+        const name = (0, store_1.getActiveEnvironmentName)();
+        const catalog = loadCatalog();
+        const store = (0, store_1.readValues)(name);
+        const result = (0, resolve_1.buildInjection)({
+            catalog,
+            store,
+            storePath: (0, store_1.valuesPath)(name),
+            inject: mode,
+            now: now(),
+        });
+        process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    });
+}

package/dist/src/commands/plan/index.js

@@ -283,7 +283,7 @@ function registerPlanCommand(program, deps = { validatePlanFile: validate_1.vali
         .requiredOption('--cwd <path>', 'repository root for plan containment and source resolution')
         .option('--execution-mode <mode>', 'explicit override: interactivo or desatendido')
         .option('--require-current', 'require authoritative consumed-contract currentness')
-        .option('--verify-sensors', 'require an empirical sensor pass')
+        .option('--verify-sensors', 'require an empirical sensor pass; read-only observation skips git-ignored build output (see .awm/admission.json)')
         .option('--runtime-kind <kind>', 'routing runtime kind for compact v2')
         .option('--runtime-version <version>', 'routing runtime version for compact v2')
         .option('--account-scope-digest <sha>', 'routing account scope digest for compact v2')

package/dist/src/commands/registry/doctor.js

@@ -0,0 +1,428 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorExitCode = doctorExitCode;
+exports.doctorRegistry = doctorRegistry;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const catalog_1 = require("../../core/facts/catalog");
+const needs_1 = require("../../core/facts/needs");
+const types_1 = require("../../core/facts/types");
+const bundles_1 = require("../../core/bundles");
+const registries_1 = require("../../core/registries");
+const versioning_1 = require("../../core/versioning");
+/** Exit code for CLI: structural failures → 1; advisories alone → 0. */
+function doctorExitCode(report) {
+    return report.structural.length ? 1 : 0;
+}
+/** Capability ids the doctor understands in v1; others are advisory (forward-compatible). */
+const KNOWN_CAPABILITY_IDS = new Set(['facts']);
+const CAPABILITIES_HEADER_RE = /^\|\s*id\s*\|\s*status\s*\|\s*notes\s*\|$/i;
+const HOME_PATH_RE = /(^|[^\w])~(\/|\\)/;
+const USERS_PATH_RE = /\/Users\/[^/\s]+/;
+const ADVISORY_CAP = 50;
+const STORE_BASENAMES = new Set(['values.json', 'meta.json']);
+function isMissing(error) {
+    return error?.code === 'ENOENT';
+}
+function walkRegularFiles(root, visit) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name === '.git' || entry.name === 'node_modules')
+                continue;
+            const abs = path_1.default.join(dir, entry.name);
+            let stat;
+            try {
+                stat = fs_1.default.lstatSync(abs);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isSymbolicLink())
+                continue;
+            if (stat.isDirectory()) {
+                stack.push(abs);
+                continue;
+            }
+            if (stat.isFile()) {
+                visit(abs, path_1.default.relative(root, abs));
+            }
+        }
+    }
+}
+function parseCapabilitiesIndex(markdown) {
+    const lines = markdown.split(/\r?\n/);
+    const headingIdx = lines.findIndex((l) => /^##\s+Capabilities\s*$/i.test(l.trim()));
+    if (headingIdx === -1) {
+        return { rows: [], errors: ['REGISTRY.md missing ## Capabilities section'] };
+    }
+    let headerIdx = -1;
+    for (let i = headingIdx + 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (/^##\s+/.test(line))
+            break;
+        if (CAPABILITIES_HEADER_RE.test(line)) {
+            headerIdx = i;
+            break;
+        }
+    }
+    if (headerIdx === -1) {
+        return {
+            rows: [],
+            errors: ['REGISTRY.md Capabilities index missing | id | status | notes | header'],
+        };
+    }
+    const rows = [];
+    const errors = [];
+    const seen = new Set();
+    for (let i = headerIdx + 1; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line === '')
+            continue;
+        if (/^##\s+/.test(line))
+            break;
+        if (!line.startsWith('|'))
+            continue;
+        if (/^\|\s*-+/.test(line))
+            continue; // separator row
+        const cells = line
+            .replace(/^\|/, '')
+            .replace(/\|$/, '')
+            .split('|')
+            .map((c) => c.trim());
+        if (cells.length < 3) {
+            errors.push(`Capabilities row malformed: ${line}`);
+            continue;
+        }
+        const id = cells[0];
+        if (id === '') {
+            errors.push('Capabilities table has empty id');
+            continue;
+        }
+        if (seen.has(id)) {
+            errors.push(`Capabilities table duplicate id "${id}"`);
+            continue;
+        }
+        seen.add(id);
+        rows.push({ id, status: cells[1] ?? '', notes: cells[2] ?? '' });
+    }
+    return { rows, errors };
+}
+/** Collect readable regular SKILL.md paths; symlink / non-regular / unreadable → structural. */
+function collectSkillMdPaths(root, structural) {
+    const skillsRoot = path_1.default.join(root, 'skills');
+    const out = [];
+    if (!fs_1.default.existsSync(skillsRoot))
+        return out;
+    let entries;
+    try {
+        entries = fs_1.default.readdirSync(skillsRoot, { withFileTypes: true });
+    }
+    catch (e) {
+        structural.push(`Cannot read skills/: ${e instanceof Error ? e.message : String(e)}`);
+        return out;
+    }
+    for (const entry of entries) {
+        const skillDir = path_1.default.join(skillsRoot, entry.name);
+        const relDir = path_1.default.relative(root, skillDir);
+        let dirStat;
+        try {
+            dirStat = fs_1.default.lstatSync(skillDir);
+        }
+        catch (e) {
+            structural.push(`Cannot inspect skill path ${relDir}: ${e instanceof Error ? e.message : String(e)}`);
+            continue;
+        }
+        if (dirStat.isSymbolicLink()) {
+            structural.push(`Skill path ${relDir} must not be a symbolic link (fail closed)`);
+            continue;
+        }
+        if (!dirStat.isDirectory()) {
+            // Scaffold tracks empty skills/ with .gitkeep so git clone keeps the
+            // content dir (RF-4.1). Other loose files remain structural.
+            if (entry.name === '.gitkeep' && dirStat.isFile())
+                continue;
+            structural.push(`Skill path ${relDir} must be a regular directory (fail closed)`);
+            continue;
+        }
+        const skillMd = path_1.default.join(skillDir, 'SKILL.md');
+        const relMd = path_1.default.relative(root, skillMd);
+        let mdStat;
+        try {
+            mdStat = fs_1.default.lstatSync(skillMd);
+        }
+        catch (error) {
+            if (isMissing(error))
+                continue;
+            structural.push(`Cannot inspect ${relMd}: ${error instanceof Error ? error.message : String(error)}`);
+            continue;
+        }
+        if (mdStat.isSymbolicLink()) {
+            structural.push(`${relMd} must not be a symbolic link (fail closed)`);
+            continue;
+        }
+        if (!mdStat.isFile()) {
+            structural.push(`${relMd} must be a regular file (fail closed)`);
+            continue;
+        }
+        try {
+            fs_1.default.accessSync(skillMd, fs_1.default.constants.R_OK);
+        }
+        catch (e) {
+            structural.push(`Unreadable ${relMd}: ${e instanceof Error ? e.message : String(e)} (fail closed)`);
+            continue;
+        }
+        out.push(skillMd);
+    }
+    return out;
+}
+/**
+ * RF-4.5: store files under the registry tree are structural.
+ * Symlink entries named `environments`, or basename `values.json`/`meta.json`, are structural
+ * even when the walk does not follow the link.
+ */
+function scanEnvStoreInTree(root, structural) {
+    const stack = [root];
+    while (stack.length > 0) {
+        const dir = stack.pop();
+        let entries;
+        try {
+            entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.name === '.git' || entry.name === 'node_modules')
+                continue;
+            const abs = path_1.default.join(dir, entry.name);
+            const rel = path_1.default.relative(root, abs);
+            let stat;
+            try {
+                stat = fs_1.default.lstatSync(abs);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isSymbolicLink()) {
+                if (entry.name === 'environments' || STORE_BASENAMES.has(entry.name)) {
+                    structural.push(`Environment store symlink must not live in the registry tree: ${rel} (RF-4.5)`);
+                }
+                continue;
+            }
+            if (stat.isDirectory()) {
+                stack.push(abs);
+                continue;
+            }
+            if (stat.isFile()) {
+                const parts = rel.split(/[/\\]/);
+                if (parts.includes('environments') && STORE_BASENAMES.has(entry.name)) {
+                    structural.push(`Environment store file must not live in the registry tree: ${rel} (RF-4.5)`);
+                }
+            }
+        }
+    }
+}
+function scanProsePathHints(root, advisories) {
+    const skillsRoot = path_1.default.join(root, 'skills');
+    if (!fs_1.default.existsSync(skillsRoot))
+        return;
+    walkRegularFiles(skillsRoot, (abs, rel) => {
+        if (!abs.endsWith('.md'))
+            return;
+        if (advisories.length >= ADVISORY_CAP)
+            return;
+        let text;
+        try {
+            text = fs_1.default.readFileSync(abs, 'utf-8');
+        }
+        catch {
+            return;
+        }
+        for (const line of text.split(/\r?\n/)) {
+            if (advisories.length >= ADVISORY_CAP)
+                return;
+            if (HOME_PATH_RE.test(line) || USERS_PATH_RE.test(line)) {
+                advisories.push(`Possible machine path in ${rel}: prefer a fact (e.g. ~/Developments or /Users/…)`);
+                break;
+            }
+        }
+    });
+}
+function checkVersionCoherence(root, structural) {
+    let entries;
+    try {
+        entries = (0, bundles_1.readCatalog)(root);
+    }
+    catch (e) {
+        structural.push(`catalog.json unreadable: ${e instanceof Error ? e.message : String(e)}`);
+        return;
+    }
+    for (const entry of entries) {
+        if (typeof entry.version !== 'string')
+            continue;
+        const bundlePath = path_1.default.join(root, entry.source, 'bundle.json');
+        let stat;
+        try {
+            stat = fs_1.default.lstatSync(bundlePath);
+        }
+        catch (error) {
+            if (isMissing(error))
+                continue;
+            structural.push(`Cannot inspect ${path_1.default.relative(root, bundlePath)}`);
+            continue;
+        }
+        if (!stat.isFile() || stat.isSymbolicLink())
+            continue;
+        let raw;
+        try {
+            raw = JSON.parse(fs_1.default.readFileSync(bundlePath, 'utf-8'));
+        }
+        catch (e) {
+            structural.push(`bundle.json invalid at ${path_1.default.relative(root, bundlePath)}: ${e instanceof Error ? e.message : String(e)}`);
+            continue;
+        }
+        const bundleVersion = raw !== null && typeof raw === 'object' && typeof raw.version === 'string'
+            ? raw.version
+            : undefined;
+        if (bundleVersion !== undefined && bundleVersion !== entry.version) {
+            structural.push(`Bundle "${entry.name}" version skew: catalog=${entry.version} bundle.json=${bundleVersion} (RF-4.7)`);
+        }
+    }
+}
+/**
+ * Structural + advisory audit of a registry tree. Path-only API (RF-5.1) — schema/doctor are the gates.
+ */
+function doctorRegistry(root) {
+    const structural = [];
+    const advisories = [];
+    if (typeof root !== 'string' || root.trim() === '') {
+        return {
+            structural: ['Registry root must be a non-empty string'],
+            advisories,
+        };
+    }
+    const resolvedRoot = path_1.default.resolve(root);
+    if (!fs_1.default.existsSync(resolvedRoot) || !fs_1.default.statSync(resolvedRoot).isDirectory()) {
+        return { structural: [`Registry root does not exist or is not a directory: ${resolvedRoot}`], advisories };
+    }
+    let manifestMin;
+    try {
+        const manifest = (0, registries_1.readRegistryManifest)(resolvedRoot);
+        manifestMin = manifest.minCliVersion;
+    }
+    catch (e) {
+        structural.push(`awm-registry.json invalid: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    const handbookPath = path_1.default.join(resolvedRoot, 'REGISTRY.md');
+    if (!fs_1.default.existsSync(handbookPath)) {
+        structural.push('missing REGISTRY.md');
+    }
+    else {
+        let handbook;
+        try {
+            handbook = fs_1.default.readFileSync(handbookPath, 'utf-8');
+        }
+        catch (e) {
+            structural.push(`Cannot read REGISTRY.md: ${e instanceof Error ? e.message : String(e)}`);
+            handbook = '';
+        }
+        if (handbook) {
+            const caps = parseCapabilitiesIndex(handbook);
+            structural.push(...caps.errors);
+            for (const row of caps.rows) {
+                if (!KNOWN_CAPABILITY_IDS.has(row.id)) {
+                    if (advisories.length < ADVISORY_CAP) {
+                        advisories.push(`Unknown capability id "${row.id}" in REGISTRY.md (advisory; RF-4.6)`);
+                    }
+                }
+            }
+        }
+    }
+    checkVersionCoherence(resolvedRoot, structural);
+    scanEnvStoreInTree(resolvedRoot, structural);
+    const factsPath = path_1.default.join(resolvedRoot, 'facts.json');
+    let catalog = null;
+    let factsPresent = false;
+    try {
+        const factsStat = fs_1.default.lstatSync(factsPath);
+        factsPresent = true;
+        if (factsStat.isSymbolicLink()) {
+            structural.push('facts.json must not be a symbolic link (regular-file guard)');
+        }
+        else if (!factsStat.isFile()) {
+            structural.push('facts.json must be a regular file');
+        }
+        else {
+            try {
+                catalog = (0, catalog_1.parseFactsCatalog)(factsPath);
+            }
+            catch (e) {
+                structural.push(`facts.json invalid: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+    }
+    catch (error) {
+        if (!isMissing(error)) {
+            structural.push(`Cannot inspect facts.json: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const skillPaths = collectSkillMdPaths(resolvedRoot, structural);
+    let anyNeeds = false;
+    for (const skillMd of skillPaths) {
+        let needs;
+        try {
+            needs = (0, needs_1.readSkillNeeds)(skillMd);
+        }
+        catch (e) {
+            if (e instanceof types_1.SkillNeedsError) {
+                structural.push(e.message);
+                continue;
+            }
+            structural.push(`Cannot read needs from ${path_1.default.relative(resolvedRoot, skillMd)}`);
+            continue;
+        }
+        if (needs.length === 0)
+            continue;
+        anyNeeds = true;
+        if (!catalog) {
+            const reason = factsPresent
+                ? 'facts.json is invalid/unreadable'
+                : 'facts.json is missing';
+            structural.push(`Skill ${path_1.default.relative(resolvedRoot, skillMd)} declares needs but ${reason} (fail closed)`);
+            continue;
+        }
+        const orphans = (0, needs_1.findOrphanNeeds)(needs, catalog);
+        for (const id of orphans) {
+            structural.push(`Orphan need "${id}" in ${path_1.default.relative(resolvedRoot, skillMd)} — not in facts.json (RF-1.3)`);
+        }
+    }
+    if (factsPresent || anyNeeds) {
+        if (!manifestMin) {
+            structural.push(`minCliVersion required when facts/needs are present (must be >= ${types_1.FACTS_MIN_CLI_VERSION}) (RF-4.8)`);
+        }
+        else {
+            try {
+                if ((0, versioning_1.compareSemver)(manifestMin, types_1.FACTS_MIN_CLI_VERSION) < 0) {
+                    structural.push(`minCliVersion ${manifestMin} is below FACTS_MIN_CLI_VERSION ${types_1.FACTS_MIN_CLI_VERSION} (RF-4.8)`);
+                }
+            }
+            catch (e) {
+                structural.push(`minCliVersion unreadable for facts gate: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+    }
+    scanProsePathHints(resolvedRoot, advisories);
+    return { structural, advisories };
+}