agentic-workflow-manager 2.0.0

package/dist/src/core/discovery.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readArtifactDescription = readArtifactDescription;
+exports.discoverSkills = discoverSkills;
+exports.discoverWorkflows = discoverWorkflows;
+exports.discoverAgents = discoverAgents;
+// src/core/discovery.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const registries_1 = require("./registries");
+function readArtifactDescription(filePath) {
+    try {
+        const raw = fs_1.default.readFileSync(filePath, 'utf-8');
+        const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+        if (!fmMatch)
+            return '';
+        const line = fmMatch[1]
+            .split(/\r?\n/)
+            .find((l) => /^description\s*:/.test(l));
+        if (!line)
+            return '';
+        let val = line.replace(/^description\s*:/, '').trim();
+        if ((val.startsWith('"') && val.endsWith('"')) ||
+            (val.startsWith("'") && val.endsWith("'"))) {
+            val = val.slice(1, -1);
+        }
+        const BLOCK_INDICATORS = new Set(['>-', '>', '|-', '|', '>+', '|+']);
+        if (BLOCK_INDICATORS.has(val.trim()))
+            return '';
+        return val.trim();
+    }
+    catch {
+        return '';
+    }
+}
+function collisionError(kind, name, first, second) {
+    return new Error(`Artifact name collision: ${kind} "${name}" exists in both ${first} and ${second}. ` +
+        `Remove or rename one of them, or declare "${name}" in "overrides" of the later registry's awm-registry.json.`);
+}
+/** Inserta o resuelve colisión: override declarado en el root posterior → reemplaza
+ *  (Map.set sobre key existente conserva la posición de inserción); no declarado → error. */
+function mergeEntry(kind, byName, entry, rootOverrides) {
+    const prev = byName.get(entry.name);
+    if (!prev) {
+        byName.set(entry.name, entry);
+        return;
+    }
+    if (rootOverrides.has(entry.name)) {
+        byName.set(entry.name, { ...entry, overrode: prev.path });
+        return;
+    }
+    throw collisionError(kind, entry.name, prev.path, entry.path);
+}
+/**
+ * Scans skills directories across all provided content roots and returns all valid skills.
+ * A valid skill is a directory that contains a SKILL.md file.
+ * Throws on name collision across roots unless the later root declares the name in its awm-registry.json overrides.
+ */
+function discoverSkills(roots = (0, registries_1.contentRoots)()) {
+    const byName = new Map();
+    for (const root of roots) {
+        const dir = path_1.default.join(root, 'skills');
+        if (!fs_1.default.existsSync(dir))
+            continue;
+        const overrides = (0, registries_1.readRegistryManifest)(root).overrides;
+        for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const skillPath = path_1.default.join(dir, entry.name);
+            if (!fs_1.default.existsSync(path_1.default.join(skillPath, 'SKILL.md')))
+                continue;
+            mergeEntry('skill', byName, {
+                name: entry.name,
+                path: skillPath,
+                description: readArtifactDescription(path_1.default.join(skillPath, 'SKILL.md')),
+            }, overrides);
+        }
+    }
+    return Array.from(byName.values());
+}
+/**
+ * Scans workflows directories across all provided content roots and returns all valid workflows.
+ * A valid workflow is a .md file.
+ * Throws on name collision across roots unless the later root declares the name in its awm-registry.json overrides.
+ */
+function discoverWorkflows(roots = (0, registries_1.contentRoots)()) {
+    const byName = new Map();
+    for (const root of roots) {
+        const dir = path_1.default.join(root, 'workflows');
+        if (!fs_1.default.existsSync(dir))
+            continue;
+        const overrides = (0, registries_1.readRegistryManifest)(root).overrides;
+        for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.isDirectory() || !entry.name.endsWith('.md'))
+                continue;
+            const name = entry.name.replace('.md', '');
+            const filePath = path_1.default.join(dir, entry.name);
+            mergeEntry('workflow', byName, {
+                name,
+                path: filePath,
+                description: readArtifactDescription(filePath),
+            }, overrides);
+        }
+    }
+    return Array.from(byName.values());
+}
+/**
+ * Scans agents directories across all provided content roots and returns all valid agent profiles.
+ * A valid agent is a .md file.
+ * Throws on name collision across roots unless the later root declares the name in its awm-registry.json overrides.
+ */
+function discoverAgents(roots = (0, registries_1.contentRoots)()) {
+    const byName = new Map();
+    for (const root of roots) {
+        const dir = path_1.default.join(root, 'agents');
+        if (!fs_1.default.existsSync(dir))
+            continue;
+        const overrides = (0, registries_1.readRegistryManifest)(root).overrides;
+        for (const entry of fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.isDirectory() || !entry.name.endsWith('.md'))
+                continue;
+            const name = entry.name.replace('.md', '');
+            const filePath = path_1.default.join(dir, entry.name);
+            mergeEntry('agent', byName, {
+                name,
+                path: filePath,
+                description: readArtifactDescription(filePath),
+            }, overrides);
+        }
+    }
+    return Array.from(byName.values());
+}

package/dist/src/core/executor.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeArtifact = removeArtifact;
+exports.installArtifact = installArtifact;
+// src/core/executor.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function removeArtifact(targetPath) {
+    let exists = false;
+    try {
+        fs_1.default.lstatSync(targetPath);
+        exists = true;
+    }
+    catch {
+        exists = false;
+    }
+    if (!exists) {
+        throw new Error(`Artifact not found at: ${targetPath}`);
+    }
+    fs_1.default.rmSync(targetPath, { recursive: true, force: true });
+}
+function installArtifact(sourcePath, targetPath, method) {
+    if (!fs_1.default.existsSync(sourcePath)) {
+        throw new Error(`Source path does not exist: ${sourcePath}`);
+    }
+    const parentDir = path_1.default.dirname(targetPath);
+    if (!fs_1.default.existsSync(parentDir)) {
+        fs_1.default.mkdirSync(parentDir, { recursive: true });
+    }
+    // Clean up existing if it exists
+    fs_1.default.rmSync(targetPath, { recursive: true, force: true });
+    if (method === 'symlink') {
+        fs_1.default.symlinkSync(sourcePath, targetPath, 'dir');
+    }
+    else {
+        fs_1.default.cpSync(sourcePath, targetPath, { recursive: true });
+    }
+}

package/dist/src/core/init/detector.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectExtensions = detectExtensions;
+// src/core/init/detector.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const FRONTEND_DEPS = ['next', 'react', 'vue', 'astro', 'svelte'];
+const FRONTEND_DIRS = ['pages', 'app', 'landing'];
+const DOCS_CONFIGS = ['mkdocs.yml', 'docusaurus.config.js', 'docusaurus.config.ts'];
+const INFRA_MARKERS = ['Dockerfile', 'helm', 'terraform'];
+function readPackageDeps(root) {
+    const pkgPath = path_1.default.join(root, 'package.json');
+    if (!fs_1.default.existsSync(pkgPath))
+        return { deps: {}, found: false };
+    try {
+        const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+        return { deps: { ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) }, found: true };
+    }
+    catch {
+        return { deps: {}, found: true };
+    }
+}
+function docsHasContent(root) {
+    const docsDir = path_1.default.join(root, 'docs');
+    if (!fs_1.default.existsSync(docsDir) || !fs_1.default.statSync(docsDir).isDirectory())
+        return false;
+    const mdFiles = fs_1.default.readdirSync(docsDir).filter((f) => f.toLowerCase().endsWith('.md'));
+    // Un README suelto no cuenta; requiere config (manejada aparte) o ≥2 markdown.
+    return mdFiles.length >= 2;
+}
+function detectExtensions(root) {
+    const proposed = [];
+    const signals = [];
+    const deferred = [];
+    // frontend
+    const { deps } = readPackageDeps(root);
+    const frontDep = FRONTEND_DEPS.find((d) => d in deps);
+    const frontDir = FRONTEND_DIRS.find((d) => fs_1.default.existsSync(path_1.default.join(root, d)) && fs_1.default.statSync(path_1.default.join(root, d)).isDirectory());
+    if (frontDep || frontDir) {
+        proposed.push('frontend');
+        signals.push(frontDep ? `${frontDep} (package.json)` : `${frontDir}/`);
+    }
+    // docs
+    const docsConfig = DOCS_CONFIGS.find((c) => fs_1.default.existsSync(path_1.default.join(root, c)));
+    if (docsConfig) {
+        proposed.push('docs');
+        signals.push(`${docsConfig}`);
+    }
+    else if (docsHasContent(root)) {
+        proposed.push('docs');
+        signals.push('docs/ (≥2 .md)');
+    }
+    // infra (deferred — sin bundle aún)
+    let k8s = false;
+    try {
+        k8s = fs_1.default.readdirSync(root).some((f) => f.endsWith('.k8s.yaml'));
+    }
+    catch { /* directory vanished */ }
+    const infraMarker = INFRA_MARKERS.find((m) => fs_1.default.existsSync(path_1.default.join(root, m)));
+    if (k8s || infraMarker) {
+        deferred.push('infra (Fase futura)');
+    }
+    return { proposed, signals, deferred };
+}

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInitSteps = runInitSteps;
+const steps_1 = require("./steps");
+const checks_1 = require("../diagnostics/checks");
+const context_1 = require("../diagnostics/context");
+function wrapStep(id, level, fn) {
+    // id/level used only on error path; happy-path result carries its own id from the step function.
+    try {
+        const result = fn();
+        if (result instanceof Promise) {
+            return result.catch((e) => ({
+                id, level, action: 'failed',
+                error: e instanceof Error ? e.message : String(e),
+            }));
+        }
+        return Promise.resolve(result);
+    }
+    catch (e) {
+        return Promise.resolve({
+            id, level, action: 'failed',
+            error: e instanceof Error ? e.message : String(e),
+        });
+    }
+}
+async function runInitSteps(deps) {
+    const before = (0, checks_1.runChecks)(deps.ctx);
+    const steps = [];
+    // Nivel máquina (siempre)
+    steps.push(await wrapStep('machine.cache', 'machine', () => (0, steps_1.stepCache)(deps)));
+    steps.push(await wrapStep('machine.hook', 'machine', () => (0, steps_1.stepHook)(deps)));
+    steps.push(await wrapStep('machine.contextInjection', 'machine', () => (0, steps_1.stepContextInjection)(deps)));
+    steps.push(await wrapStep('machine.devCore', 'machine', () => (0, steps_1.stepDevCore)(deps)));
+    steps.push(await wrapStep('machine.globalSkills', 'machine', () => (0, steps_1.stepGlobalSkillsRepair)(deps)));
+    steps.push(await wrapStep('machine.ambient', 'machine', () => (0, steps_1.stepAmbient)(deps)));
+    // Nivel proyecto (solo en repo)
+    if (deps.ctx.project) {
+        steps.push(await wrapStep('project.profile', 'project', () => (0, steps_1.stepProfile)(deps)));
+        steps.push(await wrapStep('project.activation', 'project', () => (0, steps_1.stepActivation)(deps)));
+        steps.push(await wrapStep('project.sensors', 'project', () => (0, steps_1.stepSensors)(deps)));
+        steps.push(await wrapStep('project.constitution', 'project', () => (0, steps_1.stepConstitution)(deps)));
+        steps.push(await wrapStep('project.constitutionInjection', 'project', () => (0, steps_1.stepConstitutionInjection)(deps)));
+        steps.push(await wrapStep('project.context', 'project', () => (0, steps_1.stepContext)(deps)));
+    }
+    const after = (0, checks_1.runChecks)((0, context_1.gatherContext)({ cwd: deps.cwd, bundles: deps.bundles, agent: deps.agent }));
+    return {
+        steps,
+        applied: steps.filter((s) => s.action === 'applied').length,
+        pending: steps.filter((s) => s.action === 'pending').length,
+        failed: steps.filter((s) => s.action === 'failed').length,
+        before,
+        after,
+    };
+}

package/dist/src/core/init/steps.js

@@ -0,0 +1,279 @@
+"use strict";
+// src/core/init/steps.ts
+//
+// Pure, ordered, idempotent steps over the diagnostics HarnessContext.
+// Each step receives InitDeps (which carries the current snapshot + injected
+// actions) and returns a StepResult describing what happened.
+//
+// defaultActions wires the real I/O implementations; tests inject spies.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultActions = void 0;
+exports.stepCache = stepCache;
+exports.stepHook = stepHook;
+exports.stepDevCore = stepDevCore;
+exports.stepGlobalSkillsRepair = stepGlobalSkillsRepair;
+exports.stepAmbient = stepAmbient;
+exports.stepProfile = stepProfile;
+exports.stepActivation = stepActivation;
+exports.stepSensors = stepSensors;
+exports.stepConstitution = stepConstitution;
+exports.stepConstitutionInjection = stepConstitutionInjection;
+exports.stepContext = stepContext;
+exports.stepContextInjection = stepContextInjection;
+const registries_1 = require("../registries");
+const install_1 = require("../../commands/hooks/install");
+const bundle_install_1 = require("../bundle-install");
+const init_1 = require("../../commands/sensors/init");
+const profile_1 = require("../profile");
+const context_1 = require("../diagnostics/context");
+const detector_1 = require("./detector");
+const orchestrator_1 = require("../context/orchestrator");
+const providers_1 = require("../../providers");
+const skill_integrity_1 = require("../skill-integrity");
+const registries_2 = require("../registries");
+const project_constitution_inject_1 = require("../context/project-constitution-inject");
+// ---------------------------------------------------------------------------
+// defaultActions — bridges the real functions to the InitActions interface
+// ---------------------------------------------------------------------------
+const realInjectionOrchestrator = new orchestrator_1.InjectionOrchestrator();
+exports.defaultActions = {
+    syncCache: async () => { await (0, registries_1.syncRegistries)(); },
+    installHook: (o) => (0, install_1.installHook)({
+        agent: o.agent,
+        registryRoot: o.registryRoot,
+        installMethod: o.installMethod,
+    }),
+    installBundle: (o) => (0, bundle_install_1.installBundle)({
+        bundleName: o.bundleName,
+        bundles: o.bundles,
+        agents: o.agents,
+        method: o.method,
+        projectRoot: o.projectRoot,
+        contentDir: o.contentDir,
+    }),
+    syncProfile: (o) => (0, bundle_install_1.syncProfile)({
+        projectRoot: o.projectRoot,
+        bundles: o.bundles,
+        agents: o.agents,
+        method: o.method,
+        contentDir: o.contentDir,
+    }),
+    initSensors: (o) => {
+        const result = (0, init_1.initSensors)({ cwd: o.cwd, registryRoot: o.registryRoot, configure: o.configure });
+        return { detection: result.detection };
+    },
+    addExtension: (root, name) => { (0, profile_1.addExtension)(root, name); },
+    ensureProfile: (root) => { (0, profile_1.ensureProfile)(root); },
+    gatherProject: (cwd, bundles, agent) => (0, context_1.gatherContext)({ cwd, bundles, agent }).project,
+    contextStatus: (op) => realInjectionOrchestrator.contextStatus(op),
+    installContext: (op) => { realInjectionOrchestrator.installContext(op); },
+    repairGlobalSkills: (skillsDir, registryContentDirs) => (0, skill_integrity_1.repairGlobalSkills)(skillsDir, registryContentDirs),
+    injectProjectConstitution: (o) => (0, project_constitution_inject_1.injectProjectConstitution)(o.projectRoot, o.agent),
+};
+// ---------------------------------------------------------------------------
+// Step helpers
+// ---------------------------------------------------------------------------
+function ok(id, level, action, detail) {
+    return { id, level, action, detail };
+}
+function failed(id, level, error) {
+    return { id, level, action: 'failed', error };
+}
+// ---------------------------------------------------------------------------
+// Machine-level steps
+// ---------------------------------------------------------------------------
+/** Step 1 – Sync the registry cache (clone / pull). */
+async function stepCache(d) {
+    const { registryCache } = d.ctx.machine;
+    const needsSync = !registryCache.present || registryCache.gitState === 'behind';
+    if (!needsSync)
+        return ok('machine.cache', 'machine', 'skipped');
+    try {
+        await d.actions.syncCache();
+        return ok('machine.cache', 'machine', 'applied');
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return failed('machine.cache', 'machine', msg);
+    }
+}
+/** Step 2 – Install the session-start hook for the target agent. */
+function stepHook(d) {
+    const { hook } = d.ctx.machine;
+    if (hook.present && !hook.degraded)
+        return ok('machine.hook', 'machine', 'skipped');
+    d.actions.installHook({
+        agent: d.agent,
+        registryRoot: d.registryRoot,
+        installMethod: d.installMethod,
+    });
+    return ok('machine.hook', 'machine', 'applied');
+}
+/** Step 3 – Install / repair the baseline bundle (dev-core). */
+function stepDevCore(d) {
+    const { devCore } = d.ctx.machine;
+    if (devCore.present && devCore.brokenLinks.length === 0) {
+        return ok('machine.devCore', 'machine', 'skipped');
+    }
+    // Find the baseline bundle (there may be several; pick first baseline)
+    const baselineBundle = d.bundles.find((b) => b.scope === 'baseline');
+    const bundleName = baselineBundle?.name ?? 'dev';
+    d.actions.installBundle({
+        bundleName,
+        bundles: d.bundles,
+        agents: [d.agent],
+        method: d.installMethod,
+        projectRoot: d.cwd,
+        contentDir: d.contentDir,
+    });
+    return ok('machine.devCore', 'machine', 'applied');
+}
+/** Step 3.5 – Repair broken global skill symlinks (orphans outside the baseline). */
+function stepGlobalSkillsRepair(d) {
+    const { globalSkills } = d.ctx.machine;
+    const broken = globalSkills.repairable.length + globalSkills.dead.length;
+    if (broken === 0)
+        return ok('machine.globalSkills', 'machine', 'skipped');
+    const skillsDir = providers_1.PROVIDERS[d.agent].skill.global;
+    const r = d.actions.repairGlobalSkills(skillsDir, (0, registries_2.contentRoots)());
+    return ok('machine.globalSkills', 'machine', 'applied', `re-linked ${r.relinked.length}, pruned ${r.pruned.length}`);
+}
+/** Step 4 – Install missing ambient bundles. */
+function stepAmbient(d) {
+    const { wanted, installed } = d.ctx.machine.ambient;
+    if (wanted.length === 0)
+        return ok('machine.ambient', 'machine', 'skipped');
+    const missing = wanted.filter((w) => !installed.includes(w));
+    if (missing.length === 0)
+        return ok('machine.ambient', 'machine', 'skipped');
+    for (const bundleName of missing) {
+        d.actions.installBundle({
+            bundleName,
+            bundles: d.bundles,
+            agents: [d.agent],
+            method: d.installMethod,
+            projectRoot: d.cwd,
+            contentDir: d.contentDir,
+        });
+    }
+    return ok('machine.ambient', 'machine', 'applied', `installed: ${missing.join(', ')}`);
+}
+// ---------------------------------------------------------------------------
+// Project-level steps
+// ---------------------------------------------------------------------------
+/** Step 5 – Detect and confirm project extensions, then add them to the profile. */
+async function stepProfile(d) {
+    const proj = d.ctx.project;
+    if (!proj)
+        return ok('project.profile', 'project', 'skipped', 'no project');
+    const { proposed, signals } = (0, detector_1.detectExtensions)(proj.root);
+    const alreadyPresent = proj.profile.extensions;
+    const newProposed = proposed.filter((p) => !alreadyPresent.includes(p));
+    if (newProposed.length === 0)
+        return bootstrapOrSkip(d, proj, 'sin extensiones nuevas');
+    const confirmed = await d.confirmExtensions(newProposed, signals);
+    if (confirmed.length === 0)
+        return bootstrapOrSkip(d, proj, 'sin extensiones confirmadas');
+    for (const name of confirmed) {
+        d.actions.addExtension(proj.root, name);
+    }
+    return ok('project.profile', 'project', 'applied', `added: ${confirmed.join(', ')}`);
+}
+/**
+ * No new extensions to add. If the profile file doesn't exist yet, bootstrap an
+ * empty one so the project is marked initialized — otherwise `awm init` would
+ * leave `.awm/profile.json` missing and the diagnostic would self-referentially
+ * suggest re-running `awm init`. If it already exists, this is a true no-op.
+ */
+function bootstrapOrSkip(d, proj, skipDetail) {
+    if (!proj.profile.present) {
+        d.actions.ensureProfile(proj.root);
+        return ok('project.profile', 'project', 'applied', 'perfil inicializado (sin extensiones)');
+    }
+    return ok('project.profile', 'project', 'skipped', skipDetail);
+}
+/** Step 6 – Re-gather project facts and sync the profile symlinks if needed. */
+function stepActivation(d) {
+    const proj = d.ctx.project;
+    if (!proj)
+        return ok('project.activation', 'project', 'skipped', 'no project');
+    // Re-read project state so we pick up extensions added by stepProfile
+    const fresh = d.actions.gatherProject(proj.root, d.bundles, d.agent) ?? proj;
+    const { expected, linked, broken } = fresh.activeBundles;
+    const allLinked = expected.every((e) => linked.includes(e)) && broken.length === 0;
+    if (allLinked)
+        return ok('project.activation', 'project', 'skipped');
+    d.actions.syncProfile({
+        projectRoot: proj.root,
+        bundles: d.bundles,
+        agents: [d.agent],
+        method: d.installMethod,
+        contentDir: d.contentDir,
+    });
+    return ok('project.activation', 'project', 'applied');
+}
+/** Step 7 – Initialize the sensor manifest if absent. */
+function stepSensors(d) {
+    const proj = d.ctx.project;
+    if (!proj)
+        return ok('project.sensors', 'project', 'skipped', 'no project');
+    if (proj.sensors.present)
+        return ok('project.sensors', 'project', 'skipped');
+    d.actions.initSensors({ cwd: proj.root, registryRoot: d.sensorPacksRoot, configure: true });
+    return ok('project.sensors', 'project', 'applied');
+}
+/** Step 8 – Signal that the agent should run the project-constitution skill. */
+function stepConstitution(d) {
+    const proj = d.ctx.project;
+    if (!proj)
+        return ok('project.constitution', 'project', 'skipped', 'no project');
+    if (proj.constitution.present)
+        return ok('project.constitution', 'project', 'skipped');
+    return ok('project.constitution', 'project', 'pending', 'skill: project-constitution');
+}
+/** Step 8b – Entregar CONSTITUTION.md a agentes con inyección config-instructions
+ *  (opencode) vía un opencode.json local del proyecto. Claude lo recibe por el hook. */
+function stepConstitutionInjection(d) {
+    const proj = d.ctx.project;
+    if (!proj)
+        return ok('project.constitutionInjection', 'project', 'skipped', 'no project');
+    const inj = (0, providers_1.getInjection)(d.agent);
+    if (!inj || inj.type !== 'config-instructions') {
+        return ok('project.constitutionInjection', 'project', 'skipped', 'cubierto por hook');
+    }
+    if (!proj.constitution.present) {
+        return ok('project.constitutionInjection', 'project', 'skipped', 'sin CONSTITUTION.md');
+    }
+    const res = d.actions.injectProjectConstitution({ projectRoot: proj.root, agent: d.agent });
+    if (res === 'injected')
+        return ok('project.constitutionInjection', 'project', 'applied');
+    return ok('project.constitutionInjection', 'project', 'skipped', res);
+}
+/** Step 9 – Signal that the agent should run the project-context-init skill. */
+function stepContext(d) {
+    const proj = d.ctx.project;
+    if (!proj)
+        return ok('project.context', 'project', 'skipped', 'no project');
+    if (proj.context.present)
+        return ok('project.context', 'project', 'skipped');
+    return ok('project.context', 'project', 'pending', 'skill: project-context-init');
+}
+/** Step 2b – Inject AWM context for agents whose mechanism isn't the Claude hook. */
+function stepContextInjection(d) {
+    const inj = (0, providers_1.getInjection)(d.agent);
+    if (!inj)
+        return ok('machine.contextInjection', 'machine', 'skipped', 'sin mecanismo de inyección');
+    if (inj.type === 'cc-settings-merge')
+        return ok('machine.contextInjection', 'machine', 'skipped', 'cubierto por hook');
+    const op = {
+        agent: d.agent,
+        scope: 'global',
+        registryRoot: d.registryRoot,
+        installMethod: d.installMethod,
+        profileExtensions: [],
+    };
+    if (d.actions.contextStatus(op) === 'injected')
+        return ok('machine.contextInjection', 'machine', 'skipped');
+    d.actions.installContext(op);
+    return ok('machine.contextInjection', 'machine', 'applied');
+}

package/dist/src/core/init/types.js

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

package/dist/src/core/ledger/store.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectBranch = detectBranch;
+exports.ledgerPath = ledgerPath;
+exports.addEntry = addEntry;
+exports.listEntries = listEntries;
+exports.recurring = recurring;
+exports.archiveLedger = archiveLedger;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const LEDGER_DIR = path_1.default.join('.awm', 'ledger');
+function detectBranch(cwd) {
+    try {
+        const b = (0, child_process_1.execSync)('git rev-parse --abbrev-ref HEAD', {
+            cwd, encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000,
+        }).trim();
+        return b && b !== 'HEAD' ? b : '_no-branch';
+    }
+    catch {
+        return '_no-branch';
+    }
+}
+function ledgerPath(cwd, branch) {
+    const safe = branch.replace(/\//g, '__');
+    return path_1.default.join(cwd, LEDGER_DIR, `${safe}.jsonl`);
+}
+function addEntry(cwd, entry) {
+    const p = ledgerPath(cwd, entry.branch);
+    fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+    fs_1.default.appendFileSync(p, JSON.stringify(entry) + '\n', 'utf-8');
+}
+function listEntries(cwd, branch) {
+    const p = ledgerPath(cwd, branch);
+    if (!fs_1.default.existsSync(p))
+        return [];
+    const out = [];
+    for (const line of fs_1.default.readFileSync(p, 'utf-8').split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            out.push(JSON.parse(trimmed));
+        }
+        catch { /* skip malformed line */ }
+    }
+    return out;
+}
+function recurring(cwd, branch, min) {
+    const bySig = new Map();
+    for (const e of listEntries(cwd, branch)) {
+        const arr = bySig.get(e.signature) ?? [];
+        arr.push(e);
+        bySig.set(e.signature, arr);
+    }
+    return [...bySig.entries()]
+        .map(([signature, entries]) => ({ signature, count: entries.length, entries }))
+        .filter(c => c.count >= min)
+        .sort((a, b) => b.count - a.count);
+}
+function archiveLedger(cwd, branch, label) {
+    const src = ledgerPath(cwd, branch);
+    if (!fs_1.default.existsSync(src))
+        return false;
+    const safe = branch.replace(/\//g, '__');
+    const dst = path_1.default.join(cwd, LEDGER_DIR, 'archive', `${safe}-${label}.jsonl`);
+    fs_1.default.mkdirSync(path_1.default.dirname(dst), { recursive: true });
+    fs_1.default.renameSync(src, dst);
+    return true;
+}

package/dist/src/core/ledger/types.js

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