agentic-workflow-manager 2.0.0

package/dist/src/commands/sensors/run.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reconcilePack = reconcilePack;
+exports.findManifestDir = findManifestDir;
+exports.runSensors = runSensors;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const tsc_1 = require("./formatters/tsc");
+const eslint_1 = require("./formatters/eslint");
+const semgrep_1 = require("./formatters/semgrep");
+const generic_1 = require("./formatters/generic");
+const test_1 = require("./formatters/test");
+const baseline_1 = require("./baseline");
+const init_1 = require("./init");
+const registries_1 = require("../../core/registries");
+const MANIFEST_FILE = '.awm/sensors.json';
+const DEFAULT_FAST_TIMEOUT = 10_000;
+const DEFAULT_SLOW_TIMEOUT = 120_000;
+// Sensor JSON output can be several MB on large repos (e.g. `eslint --format json`
+// with thousands of findings). execSync defaults to a 1MB buffer and kills the
+// child with SIGTERM when exceeded — which previously surfaced as a false "timeout".
+const MAX_BUFFER = 64 * 1024 * 1024;
+/**
+ * Apply the baseline to a sensor result: keep only findings not already accepted.
+ * `status` becomes 'pass' when every finding was baseline-suppressed. Skipped
+ * sensors are returned untouched.
+ */
+function applyBaseline(result, accepted) {
+    if (result.status === 'skipped')
+        return result;
+    const { newErrors, suppressed } = (0, baseline_1.partition)(result.name, result.errors, accepted);
+    if (suppressed === 0)
+        return result;
+    return {
+        ...result,
+        errors: newErrors,
+        status: newErrors.length > 0 ? 'fail' : 'pass',
+        newCount: newErrors.length,
+        baselineCount: suppressed,
+    };
+}
+function readManifest(cwd) {
+    const p = path_1.default.join(cwd, MANIFEST_FILE);
+    if (!fs_1.default.existsSync(p))
+        return null;
+    try {
+        return JSON.parse(fs_1.default.readFileSync(p, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Upgrade-only, idempotent pack reconciliation. If the manifest sits on the
+ * `generic` fallback but the tree now has real stack indicators (package.json,
+ * pyproject.toml…), re-detect and rebuild via initSensors — which merges existing
+ * custom sensors and copies the pack's config files. Never downgrades, never
+ * touches a real pack. FS/registry failures degrade to a no-op (the honest floor
+ * in runSensors covers the gap).
+ */
+function reconcilePack(manifestDir, manifest, registryRoot) {
+    if (manifest.pack !== 'generic') {
+        const detection = (0, init_1.detectStack)(manifestDir);
+        return { manifest, detection };
+    }
+    const detection = (0, init_1.detectStack)(manifestDir);
+    if (detection.pack === 'generic')
+        return { manifest, detection }; // truly generic — stay honest
+    const root = registryRoot ?? (0, registries_1.capabilityRoot)('sensor-packs');
+    if (!root || !fs_1.default.existsSync(root))
+        return { manifest, detection }; // can't rebuild without registry
+    try {
+        const { manifest: rebuilt } = (0, init_1.initSensors)({ cwd: manifestDir, registryRoot: root, configure: true });
+        return { manifest: rebuilt, upgradedFrom: 'generic', detection };
+    }
+    catch {
+        return { manifest, detection }; // never abort the run on a reconcile failure
+    }
+}
+/**
+ * Walk up from `startCwd` looking for the nearest ancestor that contains
+ * `.awm/sensors.json` (git/.git pattern). Returns that directory, or null
+ * if none is found before the filesystem root.
+ */
+function findManifestDir(startCwd) {
+    let dir = path_1.default.resolve(startCwd);
+    while (true) {
+        if (fs_1.default.existsSync(path_1.default.join(dir, MANIFEST_FILE)))
+            return dir;
+        const parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            return null; // reached filesystem root
+        dir = parent;
+    }
+}
+function shouldRun(isFast, opts) {
+    if (opts.all)
+        return true;
+    if (opts.fast && isFast)
+        return true;
+    if (opts.slow && !isFast)
+        return true;
+    if (!opts.fast && !opts.slow && !opts.all)
+        return true;
+    return false;
+}
+function getFormatter(name) {
+    if (name === 'typecheck')
+        return tsc_1.parseTscOutput;
+    if (name === 'lint')
+        return eslint_1.parseEslintOutput;
+    if (name === 'security')
+        return semgrep_1.parseSemgrepOutput;
+    if (name === 'test')
+        return test_1.parseTestOutput;
+    return generic_1.parseGenericOutput;
+}
+function isExitCodeSensor(name) {
+    return name === 'test';
+}
+function runSensor(name, cmd, timeout, cwd) {
+    try {
+        const raw = (0, child_process_1.execSync)(cmd, { encoding: 'utf-8', timeout, cwd, maxBuffer: MAX_BUFFER, stdio: ['pipe', 'pipe', 'pipe'] });
+        const errors = getFormatter(name)(raw);
+        return { name, status: errors.length > 0 ? 'fail' : 'pass', errors };
+    }
+    catch (err) {
+        // Output exceeded maxBuffer — child is killed before output can be read.
+        // Check this BEFORE the SIGTERM branch (ENOBUFS kills with SIGTERM too).
+        if (err.code === 'ENOBUFS') {
+            return { name, status: 'skipped', errors: [], skipReason: `output exceeded ${MAX_BUFFER} bytes` };
+        }
+        // Genuine timeout: execSync kills with SIGTERM after `timeout` ms.
+        if (err.code === 'ETIMEDOUT' || (err.killed && err.signal === 'SIGTERM')) {
+            return { name, status: 'skipped', errors: [], skipReason: `timeout after ${timeout}ms` };
+        }
+        // Non-zero exit — the normal path for linters/typecheckers that found
+        // findings. Parse the output; if it yields findings, that's a fail.
+        const raw = String((err.stdout ?? '') + (err.stderr ?? ''));
+        const errors = getFormatter(name)(raw);
+        if (errors.length > 0)
+            return { name, status: 'fail', errors };
+        // A missing tool (binary not installed) must NOT pass silently — the gate
+        // cannot certify what it could not run. Treat it as a fail with a clear message.
+        const lower = raw.toLowerCase();
+        const toolMissing = err.code === 'ENOENT' || // execSync spawn failure (no shell)
+            lower.includes('command not found') ||
+            lower.includes('enoent') ||
+            lower.includes('could not determine executable');
+        if (toolMissing) {
+            return {
+                name,
+                status: 'fail',
+                errors: [{ message: `sensor tool not available: ${raw.slice(0, 200)}` }],
+            };
+        }
+        // Exit-code sensors (tests): any genuine non-zero exit is a real failure,
+        // even when no per-line findings can be parsed from the output.
+        if (isExitCodeSensor(name)) {
+            return { name, status: 'fail', errors: [{ message: `SENSOR[${name}] failed (exit ${err.status})` }] };
+        }
+        return { name, status: 'skipped', errors: [], skipReason: `exit ${err.status}: ${raw.slice(0, 200)}` };
+    }
+}
+function runSensors(opts = {}) {
+    const startCwd = opts.cwd ?? process.cwd();
+    const manifestDir = findManifestDir(startCwd);
+    if (!manifestDir)
+        return { sensors: [], overall: 'not_certified' };
+    const manifest = readManifest(manifestDir);
+    if (!manifest)
+        return { sensors: [], overall: 'not_certified' };
+    const reconciled = reconcilePack(manifestDir, manifest);
+    const activeManifest = reconciled.manifest;
+    const cwd = manifestDir; // ejecutar sensores y baseline desde donde vive el manifest
+    const results = [];
+    // Baseline suppresses already-accepted findings so sensors fail only on NEW
+    // ones (essential on repos with a large pre-existing baseline). Absent file or
+    // --ignore-baseline → every finding counts (backward-compatible).
+    const baseline = opts.ignoreBaseline ? null : (0, baseline_1.readBaseline)(cwd);
+    for (const [name, config] of Object.entries(activeManifest.sensors)) {
+        const isFast = config.fast ?? false;
+        if (!shouldRun(isFast, opts))
+            continue;
+        if (config.enabled === false) {
+            results.push({ name, status: 'skipped', errors: [], skipReason: 'disabled' });
+            continue;
+        }
+        if (!config.cmd) {
+            results.push({ name, status: 'skipped', errors: [], skipReason: 'no cmd configured' });
+            continue;
+        }
+        const timeout = config.timeout ?? (isFast ? DEFAULT_FAST_TIMEOUT : DEFAULT_SLOW_TIMEOUT);
+        let result = runSensor(name, config.cmd, timeout, cwd);
+        if (baseline)
+            result = applyBaseline(result, baseline[name]);
+        results.push(result);
+    }
+    let overall = results.some(r => r.status === 'fail') ? 'fail'
+        : results.length > 0 && results.every(r => r.status === 'skipped') ? 'skipped'
+            : results.length === 0 ? 'skipped'
+                : 'pass';
+    // Honest floor: a benign-green 'skipped' over a tree that clearly HAS a stack
+    // (indicators present) is a false green — the gate ran nothing real. Never green.
+    if (overall === 'skipped' && reconciled.detection.pack !== 'generic') {
+        overall = 'not_certified';
+    }
+    return {
+        sensors: results,
+        overall,
+        ...(reconciled.upgradedFrom ? { packUpgraded: `${reconciled.upgradedFrom}→${activeManifest.pack}` } : {}),
+    };
+}

package/dist/src/commands/sensors/status.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeSensorStatus = computeSensorStatus;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/** First non-flag token after `npx` — the tool the command actually runs. */
+function npxTool(parts) {
+    for (let i = 1; i < parts.length; i++) {
+        if (!parts[i].startsWith('-'))
+            return parts[i];
+    }
+    return undefined;
+}
+/** If the command references `--config <file>`, that file must exist in the repo. */
+function configCheck(parts, cwd) {
+    const i = parts.indexOf('--config');
+    const cfg = i !== -1 ? parts[i + 1] : undefined;
+    if (cfg && !fs_1.default.existsSync(path_1.default.join(cwd, cfg))) {
+        return { ok: false, detail: `config faltante: ${cfg}` };
+    }
+    return null;
+}
+/**
+ * Verify a sensor command can actually run — not just that `npx` exists.
+ * - `npx <tool>`: the tool MUST be installed locally (node_modules/.bin). Otherwise
+ *   `npx` would fetch a remote package at run time (dependency-confusion risk) and
+ *   the sensor would fail. A green status here would be a lie.
+ * - other binaries: must resolve on PATH (`which`).
+ * - any `--config <file>` referenced must exist.
+ */
+function checkCmd(cmd, cwd) {
+    const parts = cmd.split(/\s+/).filter(Boolean);
+    const bin = parts[0];
+    if (bin === 'npx') {
+        const tool = npxTool(parts);
+        if (!tool)
+            return { ok: false, detail: 'npx sin tool especificada' };
+        const localBin = path_1.default.join(cwd, 'node_modules', '.bin', tool);
+        if (!fs_1.default.existsSync(localBin)) {
+            return {
+                ok: false,
+                detail: `${tool} no instalada localmente (npx bajaría un paquete remoto) — agregala a devDependencies`,
+            };
+        }
+        return configCheck(parts, cwd) ?? { ok: true, detail: `${tool} (node_modules/.bin)` };
+    }
+    try {
+        (0, child_process_1.execSync)(`which ${bin}`, { stdio: 'pipe' });
+    }
+    catch {
+        return { ok: false, detail: `${bin} not found in PATH` };
+    }
+    return configCheck(parts, cwd) ?? { ok: true, detail: bin };
+}
+function computeSensorStatus(cwd = process.cwd()) {
+    const manifestPath = path_1.default.join(cwd, '.awm', 'sensors.json');
+    if (!fs_1.default.existsSync(manifestPath)) {
+        return { overall: 'NOT_CONFIGURED', pack: null, checks: {} };
+    }
+    let manifest;
+    try {
+        manifest = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
+    }
+    catch {
+        return { overall: 'NOT_CONFIGURED', pack: null, checks: {} };
+    }
+    const checks = {};
+    for (const [name, config] of Object.entries(manifest.sensors)) {
+        if (config.enabled === false) {
+            checks[name] = { ok: true, detail: 'disabled' };
+            continue;
+        }
+        if (!config.cmd) {
+            checks[name] = { ok: false, detail: 'no cmd configured' };
+            continue;
+        }
+        checks[name] = checkCmd(config.cmd, cwd);
+    }
+    const allOk = Object.values(checks).every(c => c.ok);
+    return { overall: allOk ? 'HEALTHY' : 'DEGRADED', pack: manifest.pack, checks };
+}

package/dist/src/commands/sensors/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/core/bundle-install.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installBundle = installBundle;
+exports.addBundle = addBundle;
+exports.syncProfile = syncProfile;
+// src/core/bundle-install.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const bundles_1 = require("./bundles");
+const executor_1 = require("./executor");
+const providers_1 = require("../providers");
+const profile_1 = require("./profile");
+const registries_1 = require("./registries");
+function bundleArtifacts(b, contentDir) {
+    const refs = [];
+    for (const s of b.skills) {
+        refs.push({ name: s.name, type: 'skill', installName: s.name, sourcePath: path_1.default.join(contentDir, 'skills', s.name) });
+    }
+    for (const w of b.workflows) {
+        refs.push({ name: w, type: 'workflow', installName: `${w}.md`, sourcePath: path_1.default.join(contentDir, 'workflows', `${w}.md`) });
+    }
+    for (const a of b.agents) {
+        refs.push({ name: a, type: 'agent', installName: `${a}.md`, sourcePath: path_1.default.join(contentDir, 'agents', `${a}.md`) });
+    }
+    return refs;
+}
+/**
+ * Materializes a bundle and its dependency closure into the target agents.
+ * The named bundle uses `scopeOverride` if given; dependencies always use
+ * their own default scope (baseline→global, project→local, ambient→global).
+ * Local installs resolve under `projectRoot`; global installs use the
+ * provider's absolute global path. Unsupported artifact types per agent and
+ * missing sources are skipped (never thrown).
+ */
+function installBundle(opts) {
+    const fallbackContentDir = opts.contentDir ?? (0, registries_1.contentRoots)()[0] ?? '';
+    const closure = (0, bundles_1.resolveBundleClosure)(opts.bundleName, opts.bundles);
+    const installed = [];
+    const skipped = [];
+    for (const b of closure) {
+        const contentDir = b.contentRoot ?? fallbackContentDir;
+        const scope = b.name === opts.bundleName
+            ? opts.scopeOverride ?? (0, bundles_1.defaultScopeForBundle)(b.scope)
+            : (0, bundles_1.defaultScopeForBundle)(b.scope);
+        for (const art of bundleArtifacts(b, contentDir)) {
+            if (!fs_1.default.existsSync(art.sourcePath)) {
+                skipped.push(`${art.name} (source missing: ${art.sourcePath})`);
+                continue;
+            }
+            for (const agent of opts.agents) {
+                if (providers_1.PROVIDERS[agent][art.type] === null) {
+                    skipped.push(`${art.name} (${agent}: ${art.type} unsupported)`);
+                    continue;
+                }
+                const rel = (0, providers_1.getTargetPath)(art.type, agent, scope);
+                const baseDir = scope === 'local' ? path_1.default.join(opts.projectRoot, rel) : rel;
+                const dest = path_1.default.join(baseDir, art.installName);
+                (0, executor_1.installArtifact)(art.sourcePath, dest, opts.method);
+                installed.push(`${art.name} → ${agent} (${scope}) [${b.name}]`);
+            }
+        }
+    }
+    return { installed, skipped };
+}
+/**
+ * Installs a bundle (closure) and, when it is a project-scope bundle installed
+ * locally, records it as an extension in `.awm/profile.json` and ensures the
+ * local symlinks are gitignored. Dependencies are never recorded.
+ */
+function addBundle(opts) {
+    const summary = installBundle(opts);
+    const target = opts.bundles.find((b) => b.name === opts.bundleName);
+    let recordedExtension = null;
+    // Check the named bundle's own artifacts (not just closure deps) were installed.
+    const ownInstalled = summary.installed.filter((line) => line.endsWith(`[${opts.bundleName}]`));
+    if (target && ownInstalled.length > 0) {
+        const effective = opts.scopeOverride ?? (0, bundles_1.defaultScopeForBundle)(target.scope);
+        if ((0, profile_1.shouldRecordExtension)(target.scope, effective)) {
+            (0, profile_1.addExtension)(opts.projectRoot, opts.bundleName);
+            (0, profile_1.ensureSkillsGitignored)(opts.projectRoot, opts.agents);
+            recordedExtension = opts.bundleName;
+        }
+    }
+    return { ...summary, recordedExtension };
+}
+/**
+ * Rebuilds local symlinks from `.awm/profile.json` — each listed extension is
+ * installed locally (with its dependency closure). Does not modify the profile.
+ */
+function syncProfile(opts) {
+    const profile = (0, profile_1.readProfile)(opts.projectRoot);
+    const installed = [];
+    const skipped = [];
+    for (const ext of profile.extensions) {
+        if (!opts.bundles.some((b) => b.name === ext)) {
+            skipped.push(`${ext} (bundle not found in registry — remove with \`awm remove ${ext}\`)`);
+            continue;
+        }
+        const summary = installBundle({
+            bundleName: ext,
+            bundles: opts.bundles,
+            agents: opts.agents,
+            method: opts.method,
+            projectRoot: opts.projectRoot,
+            contentDir: opts.contentDir,
+        });
+        installed.push(...summary.installed);
+        skipped.push(...summary.skipped);
+    }
+    if (profile.extensions.length > 0)
+        (0, profile_1.ensureSkillsGitignored)(opts.projectRoot, opts.agents);
+    return { installed, skipped, extensions: profile.extensions };
+}

package/dist/src/core/bundles.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCatalog = readCatalog;
+exports.discoverBundles = discoverBundles;
+exports.resolveBundleSkills = resolveBundleSkills;
+exports.defaultScopeForBundle = defaultScopeForBundle;
+exports.discoverAllBundles = discoverAllBundles;
+exports.resolveBundleClosure = resolveBundleClosure;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const registries_1 = require("./registries");
+function catalogPath(contentDir) {
+    return path_1.default.join(contentDir, 'catalog.json');
+}
+function readCatalog(contentDir) {
+    const file = catalogPath(contentDir);
+    if (!fs_1.default.existsSync(file))
+        return [];
+    const parsed = JSON.parse(fs_1.default.readFileSync(file, 'utf-8'));
+    return parsed.bundles ?? [];
+}
+function normalizeSkillRefs(raw) {
+    return (raw ?? []).map((s) => typeof s === 'string' ? { name: s, onSignal: false } : { name: s.name, onSignal: s.onSignal === true });
+}
+function discoverBundles(contentDir) {
+    const entries = readCatalog(contentDir);
+    const bundles = [];
+    for (const entry of entries) {
+        const manifestPath = path_1.default.join(contentDir, entry.source, 'bundle.json');
+        if (!fs_1.default.existsSync(manifestPath))
+            continue;
+        const raw = JSON.parse(fs_1.default.readFileSync(manifestPath, 'utf-8'));
+        bundles.push({
+            name: raw.name,
+            description: raw.description ?? '',
+            version: raw.version ?? '0.0.0',
+            scope: raw.scope ?? 'project',
+            visibility: raw.visibility ?? 'public',
+            dependsOn: raw.dependsOn ?? [],
+            skills: normalizeSkillRefs(raw.skills),
+            workflows: raw.workflows ?? [],
+            agents: raw.agents ?? [],
+            contentRoot: contentDir,
+        });
+    }
+    return bundles;
+}
+function resolveBundleSkills(bundleName, bundles) {
+    const byName = new Map(bundles.map((b) => [b.name, b]));
+    const seen = new Set();
+    const skills = new Set();
+    const visit = (name) => {
+        if (seen.has(name))
+            return;
+        seen.add(name);
+        const b = byName.get(name);
+        if (!b)
+            return;
+        for (const dep of b.dependsOn)
+            visit(dep);
+        for (const s of b.skills)
+            skills.add(s.name);
+    };
+    visit(bundleName);
+    return Array.from(skills);
+}
+/**
+ * Default install scope for a bundle, derived from its scope class.
+ * baseline/ambient install globally; project bundles install locally.
+ */
+function defaultScopeForBundle(scope) {
+    return scope === 'project' ? 'local' : 'global';
+}
+/** Descubre bundles de TODOS los roots (base + registries adicionales).
+ *  Colisión de nombre entre roots: override declarado en awm-registry.json
+ *  del root posterior → reemplaza; no declarado → error nombrando ambas fuentes. */
+function discoverAllBundles(roots = (0, registries_1.contentRoots)()) {
+    const byName = new Map();
+    for (const root of roots) {
+        const overrides = (0, registries_1.readRegistryManifest)(root).overrides;
+        for (const b of discoverBundles(root)) {
+            const prev = byName.get(b.name);
+            if (!prev) {
+                byName.set(b.name, b);
+                continue;
+            }
+            if (overrides.has(b.name)) {
+                byName.set(b.name, { ...b, overrode: prev.contentRoot });
+                continue;
+            }
+            throw new Error(`Artifact name collision: bundle "${b.name}" exists in both ${prev.contentRoot} and ${root}. ` +
+                `Remove or rename one of them, or declare "${b.name}" in "overrides" of the later registry's awm-registry.json.`);
+        }
+    }
+    return Array.from(byName.values());
+}
+/**
+ * Resolves the dependency closure of a bundle in deps-first order, deduped.
+ * Each bundle appears once, after all bundles it depends on. Unknown names
+ * (missing from `bundles`) are skipped.
+ */
+function resolveBundleClosure(bundleName, bundles) {
+    const byName = new Map(bundles.map((b) => [b.name, b]));
+    const ordered = [];
+    const seen = new Set();
+    const visit = (name) => {
+        if (seen.has(name))
+            return;
+        seen.add(name);
+        const b = byName.get(name);
+        if (!b)
+            return;
+        for (const dep of b.dependsOn)
+            visit(dep);
+        ordered.push(b);
+    };
+    visit(bundleName);
+    return ordered;
+}

package/dist/src/core/cli-version.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_PACKAGE_NAME = void 0;
+exports.cliVersion = cliVersion;
+// src/core/cli-version.ts
+//
+// Versión del propio CLI. Funciona compilado (dist/src/core) y en ts-node
+// (src/core): sube directorios hasta encontrar el package.json del paquete.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.CLI_PACKAGE_NAME = 'agentic-workflow-manager';
+function cliVersion() {
+    let dir = __dirname;
+    for (let i = 0; i < 6; i++) {
+        const p = path_1.default.join(dir, 'package.json');
+        if (fs_1.default.existsSync(p)) {
+            try {
+                const pkg = JSON.parse(fs_1.default.readFileSync(p, 'utf-8'));
+                if (pkg.name === exports.CLI_PACKAGE_NAME && typeof pkg.version === 'string')
+                    return pkg.version;
+            }
+            catch { /* package.json ajeno o ilegible — seguir subiendo */ }
+        }
+        dir = path_1.default.dirname(dir);
+    }
+    return '0.0.0';
+}

package/dist/src/core/context/materializer.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalContextPath = globalContextPath;
+exports.materialize = materialize;
+// cli/src/core/context/materializer.ts
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const provider_1 = require("./provider");
+function awmHome() {
+    return process.env.AWM_HOME || path_1.default.join(process.env.HOME || os_1.default.homedir(), '.awm');
+}
+function globalContextPath() {
+    return path_1.default.join(awmHome(), 'context', 'awm-context.md');
+}
+function materialize(ctx, absPath, scope) {
+    let onDisk = null;
+    try {
+        onDisk = (0, provider_1.sha256)(fs_1.default.readFileSync(absPath, 'utf-8'));
+    }
+    catch { /* file absent or removed */ }
+    if (onDisk !== ctx.contentHash) {
+        fs_1.default.mkdirSync(path_1.default.dirname(absPath), { recursive: true });
+        fs_1.default.writeFileSync(absPath, ctx.markdown, 'utf-8');
+    }
+    return { absPath, scope, contentHash: ctx.contentHash };
+}

package/dist/src/core/context/orchestrator.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectionOrchestrator = void 0;
+// cli/src/core/context/orchestrator.ts
+const providers_1 = require("../../providers");
+const hook_merge_1 = require("./strategies/hook-merge");
+const config_instructions_1 = require("./strategies/config-instructions");
+const provider_1 = require("./provider");
+const materializer_1 = require("./materializer");
+class InjectionOrchestrator {
+    overrides;
+    constructor(overrides = {}) {
+        this.overrides = overrides;
+    }
+    provider(agent) {
+        return this.overrides.providerOverride ?? providers_1.PROVIDERS[agent];
+    }
+    strategy(agent) {
+        const inj = this.overrides.providerOverride !== undefined
+            ? this.overrides.providerOverride.injection
+            : (0, providers_1.getInjection)(agent);
+        if (!inj)
+            throw new Error(`agent '${agent}' has no injection mechanism configured`);
+        switch (inj.type) {
+            case 'cc-settings-merge': return new hook_merge_1.HookMergeStrategy();
+            case 'config-instructions': return new config_instructions_1.ConfigInstructionsStrategy();
+        }
+    }
+    /** Full input: builds context from registry and materializes to disk. Used by installContext only. */
+    inputFor(op) {
+        const ctx = (0, provider_1.buildContext)({ registryRoot: op.registryRoot, profileExtensions: op.profileExtensions });
+        const absPath = this.overrides.contextPathOverride ?? (0, materializer_1.globalContextPath)();
+        const ref = (0, materializer_1.materialize)(ctx, absPath, op.scope);
+        return { ref, registryRoot: op.registryRoot, installMethod: op.installMethod, agent: op.agent, scope: op.scope };
+    }
+    /** Path-only input: no buildContext, no materialize. Safe for remove() which never reads contentHash. */
+    pathInputFor(op) {
+        const absPath = this.overrides.contextPathOverride ?? (0, materializer_1.globalContextPath)();
+        const ref = { absPath, scope: op.scope, contentHash: '' };
+        return { ref, registryRoot: op.registryRoot, installMethod: op.installMethod, agent: op.agent, scope: op.scope };
+    }
+    /**
+     * Status input: builds context from registry (to get expected hash) but does NOT materialize.
+     * Avoids silently correcting a stale file before the strategy can observe it.
+     */
+    statusInputFor(op) {
+        const absPath = this.overrides.contextPathOverride ?? (0, materializer_1.globalContextPath)();
+        let contentHash = '';
+        try {
+            const ctx = (0, provider_1.buildContext)({ registryRoot: op.registryRoot, profileExtensions: op.profileExtensions });
+            contentHash = ctx.contentHash;
+        }
+        catch (err) {
+            // Only suppress "registry not yet initialised" — all other errors propagate.
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!msg.includes('using-awm skill not found'))
+                throw err;
+        }
+        const ref = { absPath, scope: op.scope, contentHash };
+        return { ref, registryRoot: op.registryRoot, installMethod: op.installMethod, agent: op.agent, scope: op.scope };
+    }
+    installContext(op) {
+        const provider = this.provider(op.agent);
+        this.strategy(op.agent).inject(this.inputFor(op), provider);
+    }
+    uninstallContext(op) {
+        const provider = this.provider(op.agent);
+        this.strategy(op.agent).remove(this.pathInputFor(op), provider);
+    }
+    contextStatus(op) {
+        const provider = this.provider(op.agent);
+        return this.strategy(op.agent).status(this.statusInputFor(op), provider);
+    }
+}
+exports.InjectionOrchestrator = InjectionOrchestrator;