agentic-workflow-manager 2.0.0

package/dist/src/core/context/project-constitution-inject.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.injectProjectConstitution = injectProjectConstitution;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const providers_1 = require("../../providers");
+/**
+ * Entrega el `CONSTITUTION.md` del proyecto a agentes cuyo mecanismo de contexto es
+ * `config-instructions` (hoy OpenCode), agregando una entrada relativa
+ * `CONSTITUTION.md` al `instructions[]` de un `opencode.json` en la raíz del
+ * proyecto (commiteable, viaja con el repo). Claude lo recibe vía el hook
+ * SessionStart, así que para Claude es no-op. Agnóstico por construcción:
+ * cualquier agente futuro con inyección `config-instructions` hereda el trato.
+ */
+function injectProjectConstitution(projectRoot, agent) {
+    const inj = providers_1.PROVIDERS[agent].injection;
+    if (!inj || inj.type !== 'config-instructions')
+        return 'not-applicable';
+    if (!fs_1.default.existsSync(path_1.default.join(projectRoot, 'CONSTITUTION.md')))
+        return 'no-constitution';
+    const configPath = path_1.default.join(projectRoot, path_1.default.basename(inj.configPath)); // p.ej. 'opencode.json'
+    const field = inj.field; // 'instructions'
+    const REF = 'CONSTITUTION.md';
+    let cfg = { $schema: 'https://opencode.ai/config.json' };
+    if (fs_1.default.existsSync(configPath)) {
+        try {
+            cfg = JSON.parse(fs_1.default.readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            throw new Error(`${configPath} is not valid JSON. Fix it manually, then re-run.`);
+        }
+    }
+    const current = cfg[field];
+    if (current !== undefined && !Array.isArray(current)) {
+        throw new Error(`${configPath}: '${field}' field must be an array. Fix it manually, then re-run.`);
+    }
+    const list = Array.isArray(current) ? current : [];
+    if (list.includes(REF))
+        return 'already';
+    list.push(REF);
+    cfg[field] = list;
+    fs_1.default.writeFileSync(configPath, JSON.stringify(cfg, null, 2) + '\n', 'utf-8');
+    return 'injected';
+}

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

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = sha256;
+exports.buildContext = buildContext;
+// cli/src/core/context/provider.ts
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function sha256(input) {
+    return crypto_1.default.createHash('sha256').update(input, 'utf-8').digest('hex');
+}
+function parseVersion(skill) {
+    const m = skill.match(/^version:\s*["']?([^"'\n]+)["']?\s*$/m);
+    return m ? m[1].trim() : '0.0.0';
+}
+function buildContext(input) {
+    const skillPath = path_1.default.join(input.registryRoot, 'skills/using-awm/SKILL.md');
+    if (!fs_1.default.existsSync(skillPath)) {
+        throw new Error(`using-awm skill not found at ${skillPath}. Run 'awm update' first.`);
+    }
+    const skill = fs_1.default.readFileSync(skillPath, 'utf-8');
+    const exts = input.profileExtensions.length ? input.profileExtensions.join(', ') : 'ninguna';
+    const header = `<!-- AWM context (generated) -->\n# AWM\n\nExtensiones activas: ${exts}\n\n`;
+    const markdown = header + skill;
+    return { markdown, sourceVersion: parseVersion(skill), contentHash: sha256(markdown) };
+}

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

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.regenerateGlobalContext = regenerateGlobalContext;
+// W3 — Regeneración del contexto global tras `awm update`.
+// Para cada agente con inyección config-instructions cuya config exista:
+//   - 'stale'    (sentinel presente, archivo materializado ausente/viejo) → re-materializa.
+//   - 'injected' (ya fresco)                                              → no toca nada.
+//   - 'absent'   (sentinel ausente)                                       → no inyecta (eso es `awm init`).
+// Solo scope global. Defensivo: nunca rompe `awm update` por una falla de un agente.
+const fs_1 = __importDefault(require("fs"));
+const providers_1 = require("../../providers");
+const registries_1 = require("../registries");
+const orchestrator_1 = require("./orchestrator");
+function regenerateGlobalContext(orch = new orchestrator_1.InjectionOrchestrator()) {
+    const skillsRoot = (0, registries_1.capabilityRoot)('skills');
+    if (!skillsRoot)
+        return [];
+    const out = [];
+    for (const agent of Object.keys(providers_1.PROVIDERS)) {
+        const inj = providers_1.PROVIDERS[agent].injection;
+        if (!inj || inj.type !== 'config-instructions')
+            continue;
+        if (!fs_1.default.existsSync(inj.configPath))
+            continue;
+        const op = {
+            agent,
+            scope: 'global',
+            registryRoot: skillsRoot,
+            installMethod: 'symlink', // config-instructions strategy ignores this; consistent with stepContextInjection/gatherContextInjection
+            profileExtensions: [],
+        };
+        let state;
+        try {
+            state = orch.contextStatus(op);
+        }
+        catch {
+            out.push({ agent, action: 'skipped' });
+            continue;
+        }
+        if (state === 'injected') {
+            out.push({ agent, action: 'fresh' });
+            continue;
+        }
+        if (state === 'absent') {
+            out.push({ agent, action: 'skipped' });
+            continue;
+        }
+        // state === 'stale'
+        try {
+            orch.installContext(op);
+            out.push({ agent, action: 'refreshed' });
+        }
+        catch {
+            out.push({ agent, action: 'skipped' });
+        }
+    }
+    return out;
+}

package/dist/src/core/context/strategies/config-instructions.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.ConfigInstructionsStrategy = void 0;
+// cli/src/core/context/strategies/config-instructions.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const provider_1 = require("../provider");
+class ConfigInstructionsStrategy {
+    cfgOf(provider) {
+        const inj = provider.injection;
+        if (!inj || inj.type !== 'config-instructions') {
+            throw new Error('ConfigInstructionsStrategy requires a config-instructions provider');
+        }
+        return { configPath: inj.configPath, field: inj.field };
+    }
+    read(configPath) {
+        if (!fs_1.default.existsSync(configPath))
+            return { $schema: 'https://opencode.ai/config.json', instructions: [] };
+        const raw = fs_1.default.readFileSync(configPath, 'utf-8');
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            throw new Error(`${configPath} is not valid JSON. Fix it manually, then re-run.`);
+        }
+    }
+    write(configPath, cfg) {
+        fs_1.default.mkdirSync(path_1.default.dirname(configPath), { recursive: true });
+        fs_1.default.writeFileSync(configPath, JSON.stringify(cfg, null, 2) + '\n', 'utf-8');
+    }
+    inject(input, provider) {
+        const { configPath, field } = this.cfgOf(provider);
+        const cfg = this.read(configPath);
+        const current = cfg[field];
+        if (current !== undefined && !Array.isArray(current)) {
+            throw new Error(`${configPath}: '${field}' field must be an array. Fix it manually, then re-run.`);
+        }
+        const list = Array.isArray(current) ? current : [];
+        if (!list.includes(input.ref.absPath))
+            list.push(input.ref.absPath);
+        cfg[field] = list;
+        this.write(configPath, cfg);
+    }
+    remove(input, provider) {
+        const { configPath, field } = this.cfgOf(provider);
+        if (!fs_1.default.existsSync(configPath))
+            return;
+        const cfg = this.read(configPath);
+        const current = cfg[field];
+        if (current !== undefined && !Array.isArray(current)) {
+            throw new Error(`${configPath}: '${field}' field must be an array. Fix it manually, then re-run.`);
+        }
+        cfg[field] = (Array.isArray(current) ? current : []).filter((e) => e !== input.ref.absPath);
+        this.write(configPath, cfg);
+    }
+    status(input, provider) {
+        const { configPath, field } = this.cfgOf(provider);
+        if (!fs_1.default.existsSync(configPath))
+            return 'absent';
+        const cfg = this.read(configPath);
+        const list = cfg[field];
+        if (!Array.isArray(list) || !list.includes(input.ref.absPath))
+            return 'absent';
+        if (!fs_1.default.existsSync(input.ref.absPath))
+            return 'stale';
+        const onDisk = (0, provider_1.sha256)(fs_1.default.readFileSync(input.ref.absPath, 'utf-8'));
+        return onDisk === input.ref.contentHash ? 'injected' : 'stale';
+    }
+}
+exports.ConfigInstructionsStrategy = ConfigInstructionsStrategy;

package/dist/src/core/context/strategies/hook-merge.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookMergeStrategy = void 0;
+const install_1 = require("../../../commands/hooks/install");
+const uninstall_1 = require("../../../commands/hooks/uninstall");
+const status_1 = require("../../../commands/hooks/status");
+const STATE_BY_OVERALL = {
+    HEALTHY: 'injected',
+    DEGRADED: 'stale',
+    NOT_INSTALLED: 'absent',
+};
+class HookMergeStrategy {
+    inject(input, _provider) {
+        (0, install_1.installHook)({ agent: input.agent, registryRoot: input.registryRoot, installMethod: input.installMethod });
+    }
+    remove(input, _provider) {
+        (0, uninstall_1.uninstallHook)({ agent: input.agent });
+    }
+    status(input, _provider) {
+        return STATE_BY_OVERALL[(0, status_1.computeHookStatus)(input.agent).overall] ?? 'absent';
+    }
+}
+exports.HookMergeStrategy = HookMergeStrategy;

package/dist/src/core/context/strategies/strategy.js

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

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

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

package/dist/src/core/diagnostics/checks.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runChecks = runChecks;
+// src/core/diagnostics/checks.ts
+const path_1 = __importDefault(require("path"));
+const cmd = (value) => ({ kind: 'command', value });
+const skillRemedy = (value) => ({ kind: 'skill', value });
+const none = { kind: 'none' };
+function machineChecks(m) {
+    const out = [];
+    // machine.cli
+    if (!m.registryCache.present) {
+        out.push({ id: 'machine.cli', level: 'machine', label: 'CLI', status: 'missing',
+            detail: 'registry cache missing — run awm init', remedy: cmd('awm init') });
+    }
+    else if (m.registryCache.gitState === 'clean') {
+        out.push({ id: 'machine.cli', level: 'machine', label: 'CLI', status: 'ok', remedy: none });
+    }
+    else if (m.registryCache.gitState === 'behind') {
+        out.push({ id: 'machine.cli', level: 'machine', label: 'CLI', status: 'warn',
+            detail: 'cache desactualizado', remedy: cmd('awm update') });
+    }
+    else {
+        // dirty | unknown | undefined → advisory, sin acción
+        out.push({ id: 'machine.cli', level: 'machine', label: 'CLI', status: 'warn',
+            detail: `git ${m.registryCache.gitState ?? 'unknown'}`, remedy: none });
+    }
+    // machine.hook
+    if (m.hook.present && !m.hook.degraded) {
+        out.push({ id: 'machine.hook', level: 'machine', label: 'hook SessionStart', status: 'ok', remedy: none });
+    }
+    else if (m.hook.present) {
+        out.push({ id: 'machine.hook', level: 'machine', label: 'hook SessionStart', status: 'warn',
+            detail: 'scripts incompletos', remedy: cmd('awm init') });
+    }
+    else {
+        out.push({ id: 'machine.hook', level: 'machine', label: 'hook SessionStart', status: 'missing',
+            remedy: cmd('awm init') });
+    }
+    // machine.devCore
+    if (m.devCore.present && m.devCore.brokenLinks.length === 0) {
+        out.push({ id: 'machine.devCore', level: 'machine', label: 'dev-core (baseline)', status: 'ok', remedy: none });
+    }
+    else if (m.devCore.present) {
+        out.push({ id: 'machine.devCore', level: 'machine', label: 'dev-core (baseline)', status: 'warn',
+            detail: `${m.devCore.brokenLinks.length} symlinks rotos`, remedy: cmd('awm init') });
+    }
+    else {
+        out.push({ id: 'machine.devCore', level: 'machine', label: 'dev-core (baseline)', status: 'missing',
+            remedy: cmd('awm init') });
+    }
+    // machine.globalSkills — integridad de symlinks en ~/.claude/skills (fuera del baseline)
+    const brokenGlobal = m.globalSkills.repairable.length + m.globalSkills.dead.length;
+    if (brokenGlobal === 0) {
+        out.push({ id: 'machine.globalSkills', level: 'machine', label: 'skills globales', status: 'ok', remedy: none });
+    }
+    else {
+        out.push({ id: 'machine.globalSkills', level: 'machine', label: 'skills globales', status: 'warn',
+            detail: `${brokenGlobal} enlaces rotos`, remedy: cmd('awm init') });
+    }
+    // machine.ambient.<b> — una fila por bundle deseado
+    for (const b of m.ambient.wanted) {
+        const installed = m.ambient.installed.includes(b);
+        out.push({ id: `machine.ambient.${b}`, level: 'machine', label: `${b} (ambient)`,
+            status: installed ? 'ok' : 'missing', remedy: installed ? none : cmd(`awm add ${b}`) });
+    }
+    // machine.context.<agent> — una fila por agente con contexto AWM gestionado
+    for (const c of m.contextInjection) {
+        if (c.state === 'injected') {
+            out.push({ id: `machine.context.${c.agent}`, level: 'machine', label: `contexto AWM (${c.agent})`,
+                status: 'ok', remedy: none });
+        }
+        else if (c.state === 'stale') {
+            out.push({ id: `machine.context.${c.agent}`, level: 'machine', label: `contexto AWM (${c.agent})`,
+                status: 'warn', detail: 'contexto desactualizado', remedy: cmd('awm init') });
+        }
+        else {
+            out.push({ id: `machine.context.${c.agent}`, level: 'machine', label: `contexto AWM (${c.agent})`,
+                status: 'missing', remedy: cmd('awm init') });
+        }
+    }
+    return out;
+}
+function projectChecks(p) {
+    const out = [];
+    // project.profile
+    if (p.profile.present) {
+        const exts = p.profile.extensions.length ? p.profile.extensions.join(', ') : 'sin extensiones';
+        out.push({ id: 'project.profile', level: 'project', label: `.awm/profile.json (${exts})`,
+            status: 'ok', remedy: none });
+    }
+    else {
+        out.push({ id: 'project.profile', level: 'project', label: '.awm/profile.json', status: 'missing',
+            remedy: cmd('awm init') });
+    }
+    // project.activation
+    const missingLinks = p.activeBundles.expected.filter((s) => !p.activeBundles.linked.includes(s));
+    if (p.activeBundles.broken.length === 0 && missingLinks.length === 0) {
+        out.push({ id: 'project.activation', level: 'project', label: 'bundles activos', status: 'ok', remedy: none });
+    }
+    else {
+        out.push({ id: 'project.activation', level: 'project', label: 'bundles activos', status: 'missing',
+            detail: `${missingLinks.length} faltan, ${p.activeBundles.broken.length} rotos`, remedy: cmd('awm sync') });
+    }
+    // project.sensors
+    out.push(p.sensors.present
+        ? { id: 'project.sensors', level: 'project', label: 'sensores', status: 'ok', remedy: none }
+        : { id: 'project.sensors', level: 'project', label: 'sensores no inicializados', status: 'missing',
+            remedy: cmd('awm sensors init') });
+    // project.constitution (missing degrada; remedio agente)
+    out.push(p.constitution.present
+        ? { id: 'project.constitution', level: 'project', label: 'CONSTITUTION.md', status: 'ok', remedy: none }
+        : { id: 'project.constitution', level: 'project', label: 'CONSTITUTION.md ausente', status: 'missing',
+            remedy: skillRemedy('project-constitution') });
+    // project.context (advisory; no degrada)
+    if (p.context.present) {
+        out.push({ id: 'project.context', level: 'project', label: p.context.file ?? 'CLAUDE.md',
+            status: 'ok', remedy: none });
+    }
+    else {
+        out.push({ id: 'project.context', level: 'project', label: 'contexto del agente (CLAUDE.md/AGENTS.md) ausente', status: 'warn',
+            remedy: skillRemedy('project-context-init') });
+    }
+    return out;
+}
+function runChecks(ctx) {
+    const results = [
+        ...machineChecks(ctx.machine),
+        ...(ctx.project ? projectChecks(ctx.project) : []),
+    ];
+    const overall = results.some((r) => r.status === 'missing') ? 'degraded' : 'healthy';
+    return {
+        results,
+        overall,
+        hasProject: ctx.project !== null,
+        projectName: ctx.project ? path_1.default.basename(ctx.project.root) : undefined,
+    };
+}

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

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatherContext = gatherContext;
+// src/core/diagnostics/context.ts
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const providers_1 = require("../../providers");
+const registries_1 = require("../registries");
+const orchestrator_1 = require("../context/orchestrator");
+const status_1 = require("../../commands/hooks/status");
+const profile_1 = require("../profile");
+const bundles_1 = require("../bundles");
+const skill_integrity_1 = require("../skill-integrity");
+function home() { return process.env.HOME || os_1.default.homedir(); }
+function awmHome() { return process.env.AWM_HOME || path_1.default.join(home(), '.awm'); }
+// Estado de un artefacto en <dir>/<skill>: link vivo / symlink colgante / ausente.
+function linkState(dir, skill) {
+    const p = path_1.default.join(dir, skill);
+    let lst;
+    try {
+        lst = fs_1.default.lstatSync(p);
+    }
+    catch {
+        return 'absent';
+    }
+    if (lst.isSymbolicLink())
+        return fs_1.default.existsSync(p) ? 'present' : 'broken';
+    return 'present'; // un dir/archivo real también cuenta como presente
+}
+function classifyLinks(skillNames, dir) {
+    const linked = [];
+    const broken = [];
+    for (const s of skillNames) {
+        const st = linkState(dir, s);
+        if (st === 'present')
+            linked.push(s);
+        else if (st === 'broken')
+            broken.push(s);
+    }
+    return { linked, broken };
+}
+function detectGitState(repoDir) {
+    try {
+        const porcelain = (0, child_process_1.execSync)('git status --porcelain', { cwd: repoDir, stdio: ['ignore', 'pipe', 'ignore'] })
+            .toString().trim();
+        if (porcelain.length > 0)
+            return 'dirty';
+        try {
+            const behind = (0, child_process_1.execSync)('git rev-list --count HEAD..@{u}', { cwd: repoDir, stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 })
+                .toString().trim();
+            if (behind !== '' && behind !== '0')
+                return 'behind';
+        }
+        catch { /* sin upstream configurado */ }
+        return 'clean';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+// Estado del contexto AWM para agentes cuyo mecanismo de inyección es config-instructions
+// (hoy: opencode). claude-code usa el hook → ya se reporta como machine.hook, no se duplica.
+// Sólo se reporta un agente si su archivo de config existe (señal de que el agente está en uso).
+function gatherContextInjection() {
+    const out = [];
+    const orch = new orchestrator_1.InjectionOrchestrator();
+    for (const agent of Object.keys(providers_1.PROVIDERS)) {
+        const inj = providers_1.PROVIDERS[agent].injection;
+        if (!inj || inj.type !== 'config-instructions')
+            continue;
+        if (!fs_1.default.existsSync(inj.configPath))
+            continue;
+        let state = 'absent';
+        try {
+            state = orch.contextStatus({
+                agent,
+                scope: 'global',
+                registryRoot: (0, registries_1.capabilityRoot)('skills') ?? '',
+                installMethod: 'symlink',
+                profileExtensions: [],
+            });
+        }
+        catch {
+            // registry ausente u otra falla → tratar como ausente (no romper el doctor)
+        }
+        out.push({ agent, state });
+    }
+    return out;
+}
+function gatherMachine(bundles, agent = 'claude-code') {
+    // registryCache: estado del primer registry configurado (baseline en una máquina sembrada)
+    const regs = (0, registries_1.listRegistries)();
+    const first = regs[0];
+    const cachePresent = !!first && fs_1.default.existsSync(path_1.default.join(first.contentRoot, '.git'));
+    const gitState = cachePresent ? detectGitState(first.contentRoot) : undefined;
+    // hook (reutiliza computeHookStatus)
+    let hookPresent = false;
+    let hookDegraded = false;
+    try {
+        const hs = (0, status_1.computeHookStatus)('claude-code');
+        hookPresent = hs.checks.settingsEntry.ok;
+        hookDegraded = hs.overall === 'DEGRADED';
+    }
+    catch { /* sin soporte de hooks → ausente */ }
+    // devCore (bundle baseline)
+    const skillsDir = providers_1.PROVIDERS[agent].skill.global;
+    const baseline = bundles.find((b) => b.scope === 'baseline');
+    let devCorePresent = false;
+    let brokenLinks = [];
+    if (baseline) {
+        const skillNames = (0, bundles_1.resolveBundleSkills)(baseline.name, bundles);
+        const { linked, broken } = classifyLinks(skillNames, skillsDir);
+        const absent = skillNames.filter((s) => !linked.includes(s) && !broken.includes(s));
+        devCorePresent = skillNames.length > 0 && (linked.length + broken.length) > 0;
+        brokenLinks = [...broken, ...absent];
+    }
+    // ambient (deseados desde ~/.awm/config.json)
+    let wanted = [];
+    try {
+        const cfg = JSON.parse(fs_1.default.readFileSync(path_1.default.join(awmHome(), 'config.json'), 'utf-8'));
+        if (Array.isArray(cfg.ambient)) {
+            wanted = cfg.ambient.filter((x) => typeof x === 'string');
+        }
+    }
+    catch { /* sin config → ningún ambient deseado */ }
+    const installed = wanted.filter((name) => {
+        const skillNames = (0, bundles_1.resolveBundleSkills)(name, bundles);
+        if (skillNames.length === 0)
+            return false;
+        const { linked } = classifyLinks(skillNames, skillsDir);
+        return linked.length === skillNames.length;
+    });
+    return {
+        registryCache: { present: cachePresent, gitState },
+        hook: { present: hookPresent, degraded: hookDegraded },
+        devCore: { present: devCorePresent, brokenLinks },
+        ambient: { wanted, installed },
+        contextInjection: gatherContextInjection(),
+        globalSkills: (0, skill_integrity_1.classifyGlobalSkills)(skillsDir, (0, registries_1.contentRoots)()),
+    };
+}
+function gatherProject(root, bundles, agent = 'claude-code') {
+    const profile = (0, profile_1.readProfile)(root);
+    const profilePresent = fs_1.default.existsSync(path_1.default.join(root, '.awm', 'profile.json'));
+    const localSkillsDir = path_1.default.join(root, providers_1.PROVIDERS[agent].skill.local);
+    const expected = [];
+    for (const ext of profile.extensions) {
+        for (const s of (0, bundles_1.resolveBundleSkills)(ext, bundles))
+            if (!expected.includes(s))
+                expected.push(s);
+    }
+    const { linked, broken } = classifyLinks(expected, localSkillsDir);
+    let context = { present: false };
+    if (fs_1.default.existsSync(path_1.default.join(root, 'CLAUDE.md')))
+        context = { present: true, file: 'CLAUDE.md' };
+    else if (fs_1.default.existsSync(path_1.default.join(root, 'AGENTS.md')))
+        context = { present: true, file: 'AGENTS.md' };
+    return {
+        root,
+        profile: { present: profilePresent, extensions: profile.extensions },
+        activeBundles: { expected, linked, broken },
+        sensors: { present: fs_1.default.existsSync(path_1.default.join(root, '.awm', 'sensors.json')) },
+        constitution: { present: fs_1.default.existsSync(path_1.default.join(root, 'CONSTITUTION.md')) },
+        context,
+    };
+}
+function gatherContext(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const bundles = opts.bundles ?? (0, bundles_1.discoverAllBundles)();
+    const agent = opts.agent ?? 'claude-code';
+    const root = (0, profile_1.findProjectRoot)(cwd);
+    return {
+        machine: gatherMachine(bundles, agent),
+        project: root ? gatherProject(root, bundles, agent) : null,
+    };
+}

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

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