aiden-runtime 4.0.2 → 4.1.1

package/dist/core/v4/logger/factory.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/logger/factory.ts — Phase v4.1-1.3a
+ *
+ * Build a root `Logger` for the running process based on which mode
+ * Aiden is in. Each mode has different invariants:
+ *
+ *   - cli-interactive  — REPL is sacred. Zero stdout sinks. Errors go
+ *                        to stderr (visible to the user without
+ *                        touching the chat prompt). Everything to file.
+ *   - cli-headless     — `aiden setup`, `aiden doctor`, scripts. No
+ *                        REPL to protect. Warnings/errors go to stderr.
+ *                        Everything to file. Stdout stays free for the
+ *                        command's own output (so users can pipe).
+ *   - serve            — daemon. Logs go to stdout as NDJSON for systemd
+ *                        / docker / log aggregators. File mirror keeps
+ *                        a local trace.
+ *   - test             — vitest etc. NullSink only. Pass `withMemory:
+ *                        true` to swap in a MemorySink for assertions.
+ *
+ * Modules NEVER pick their own sinks — they receive a Logger and call
+ * `.info()` etc. The factory is the only place mode-routing decisions
+ * live.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBootLogger = createBootLogger;
+exports.noopLogger = noopLogger;
+exports.markReplActive = markReplActive;
+exports.markReplInactive = markReplInactive;
+exports.isReplActive = isReplActive;
+const logger_1 = require("./logger");
+const fileSink_1 = require("./sinks/fileSink");
+const stdSink_1 = require("./sinks/stdSink");
+const nullSink_1 = require("./sinks/nullSink");
+function createBootLogger(opts) {
+    switch (opts.mode) {
+        case 'cli-interactive': {
+            // REPL invariant: zero stdout writes. Stderr is allowed for
+            // warn/error so a real failure isn't completely silent.
+            const sinks = [];
+            if (opts.logsDir)
+                sinks.push(new fileSink_1.FileSink({ dir: opts.logsDir, name: 'aiden' }));
+            sinks.push(new stdSink_1.StderrSink({ minLevel: 'warn' }));
+            return { logger: new logger_1.CoreLogger({ sinks }) };
+        }
+        case 'cli-headless': {
+            const sinks = [];
+            if (opts.logsDir)
+                sinks.push(new fileSink_1.FileSink({ dir: opts.logsDir, name: 'aiden' }));
+            sinks.push(new stdSink_1.StderrSink({ minLevel: 'warn' }));
+            return { logger: new logger_1.CoreLogger({ sinks }) };
+        }
+        case 'serve': {
+            // Daemon — stdout NDJSON for log aggregators, mirror to file for
+            // local-on-disk debugging.
+            const sinks = [new stdSink_1.StdoutJsonSink()];
+            if (opts.logsDir)
+                sinks.push(new fileSink_1.FileSink({ dir: opts.logsDir, name: 'aiden' }));
+            return { logger: new logger_1.CoreLogger({ sinks }) };
+        }
+        case 'test': {
+            if (opts.withMemory) {
+                const memory = new nullSink_1.MemorySink();
+                return { logger: new logger_1.CoreLogger({ sinks: [memory] }), memory };
+            }
+            return { logger: new logger_1.CoreLogger({ sinks: [new nullSink_1.NullSink()] }) };
+        }
+        case 'mcp-stdio': {
+            // Phase v4.1-mcp invariant: stdout carries the JSON-RPC protocol
+            // frames — any byte written to stdout outside the MCP transport
+            // corrupts the wire. So this mode wires ZERO stdout sinks. Errors
+            // and warnings go to stderr (visible to the spawning client's log
+            // stream); everything else lands in the file sink for postmortems.
+            const sinks = [];
+            if (opts.logsDir)
+                sinks.push(new fileSink_1.FileSink({ dir: opts.logsDir, name: 'aiden-mcp' }));
+            sinks.push(new stdSink_1.StderrSink({ minLevel: 'warn' }));
+            return { logger: new logger_1.CoreLogger({ sinks }) };
+        }
+    }
+}
+/**
+ * No-op singleton — what `attachLogger()` setters fall back to when no
+ * caller has wired in a real one yet. Avoids null-checks at every emit
+ * site. Lazy-built so tests that import this module don't allocate
+ * sinks they'll never touch.
+ */
+let _noop = null;
+function noopLogger() {
+    if (!_noop)
+        _noop = new logger_1.CoreLogger({ sinks: [new nullSink_1.NullSink()] });
+    return _noop;
+}
+/**
+ * Phase v4.1-1.3a — process-wide flag tripped once the chat prompt is
+ * up. The repl-sacred invariant in `cli-interactive` mode comes from
+ * the factory not wiring any stdout sink, but a defense-in-depth layer:
+ * if any future code path manages to grab stdout directly, this flag
+ * lets us assert in tests + audit.
+ */
+let _replActive = false;
+function markReplActive() { _replActive = true; }
+function markReplInactive() { _replActive = false; }
+function isReplActive() { return _replActive; }

package/dist/core/v4/logger/index.js

@@ -0,0 +1,22 @@
+"use strict";
+// core/v4/logger/index.ts — Phase v4.1-1.3a barrel export.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiSink = exports.MemorySink = exports.NullSink = exports.StdoutJsonSink = exports.StderrSink = exports.FileSink = exports.isReplActive = exports.markReplInactive = exports.markReplActive = exports.noopLogger = exports.createBootLogger = exports.CoreLogger = void 0;
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "CoreLogger", { enumerable: true, get: function () { return logger_1.CoreLogger; } });
+var factory_1 = require("./factory");
+Object.defineProperty(exports, "createBootLogger", { enumerable: true, get: function () { return factory_1.createBootLogger; } });
+Object.defineProperty(exports, "noopLogger", { enumerable: true, get: function () { return factory_1.noopLogger; } });
+Object.defineProperty(exports, "markReplActive", { enumerable: true, get: function () { return factory_1.markReplActive; } });
+Object.defineProperty(exports, "markReplInactive", { enumerable: true, get: function () { return factory_1.markReplInactive; } });
+Object.defineProperty(exports, "isReplActive", { enumerable: true, get: function () { return factory_1.isReplActive; } });
+var fileSink_1 = require("./sinks/fileSink");
+Object.defineProperty(exports, "FileSink", { enumerable: true, get: function () { return fileSink_1.FileSink; } });
+var stdSink_1 = require("./sinks/stdSink");
+Object.defineProperty(exports, "StderrSink", { enumerable: true, get: function () { return stdSink_1.StderrSink; } });
+Object.defineProperty(exports, "StdoutJsonSink", { enumerable: true, get: function () { return stdSink_1.StdoutJsonSink; } });
+var nullSink_1 = require("./sinks/nullSink");
+Object.defineProperty(exports, "NullSink", { enumerable: true, get: function () { return nullSink_1.NullSink; } });
+Object.defineProperty(exports, "MemorySink", { enumerable: true, get: function () { return nullSink_1.MemorySink; } });
+var multiSink_1 = require("./sinks/multiSink");
+Object.defineProperty(exports, "MultiSink", { enumerable: true, get: function () { return multiSink_1.MultiSink; } });

package/dist/core/v4/logger/logger.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/logger/logger.ts — Phase v4.1-1.3a
+ *
+ * The Logger contract. Every module that emits diagnostics goes through
+ * this — never `console.*` directly. The CLI's REPL is sacred: in
+ * `cli-interactive` mode the factory wires zero stdout sinks, so a
+ * misbehaving module CANNOT corrupt the chat prompt.
+ *
+ * Three pieces:
+ *   - `Logger`       — what consumers call (debug / info / warn / error
+ *                      + child(scope) for nested namespaces).
+ *   - `LoggerSink`   — where lines actually go (file, stderr, null, …).
+ *   - `Logger` impl  — fans every line out to all attached sinks.
+ *
+ * Sinks are the routing surface; the factory in `./factory.ts` picks
+ * the right combination per AidenMode. Adding a new module never
+ * touches sink logic — modules just call `logger.info('...')` and
+ * the factory decides where it goes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreLogger = exports.LOG_LEVEL_ORDER = void 0;
+/** Stable numeric ordering for level filtering. */
+exports.LOG_LEVEL_ORDER = {
+    debug: 10,
+    info: 20,
+    warn: 30,
+    error: 40,
+};
+/**
+ * Default `Logger` implementation. Holds a list of sinks and the
+ * current scope; child loggers share the same sink list (so updating
+ * the level / detaching at the root affects everything).
+ */
+class CoreLogger {
+    /**
+     * Construct a root logger. Use `child(segment)` for sub-loggers.
+     * `sinks` may be empty — useful for tests; writes silently drop.
+     */
+    constructor(opts) {
+        this.scope = opts.scope ?? '';
+        this.sinks = opts.sinks;
+        this.level = opts.level ?? 'debug';
+        this.sinksOwner = { sinks: this.sinks, level: this.level };
+    }
+    /** Internal — used by `child()` to share state with the root. */
+    static childOf(parent, segment) {
+        const c = Object.create(CoreLogger.prototype);
+        const nextScope = parent.scope ? `${parent.scope}.${segment}` : segment;
+        Object.assign(c, {
+            scope: nextScope,
+            sinks: parent.sinksOwner.sinks,
+            level: parent.sinksOwner.level,
+            sinksOwner: parent.sinksOwner,
+        });
+        return c;
+    }
+    child(segment) {
+        return CoreLogger.childOf(this, segment);
+    }
+    setLevel(level) {
+        this.sinksOwner.level = level;
+        this.level = level;
+    }
+    getLevel() {
+        return this.sinksOwner.level;
+    }
+    detachAll() {
+        this.sinksOwner.sinks.length = 0;
+    }
+    debug(msg, ctx) { this.write('debug', msg, ctx); }
+    info(msg, ctx) { this.write('info', msg, ctx); }
+    warn(msg, ctx) { this.write('warn', msg, ctx); }
+    error(msg, ctx) { this.write('error', msg, ctx); }
+    write(level, msg, ctx) {
+        if (exports.LOG_LEVEL_ORDER[level] < exports.LOG_LEVEL_ORDER[this.sinksOwner.level])
+            return;
+        const record = {
+            ts: new Date(),
+            level,
+            scope: this.scope,
+            msg,
+            ctx,
+        };
+        // Sinks must not throw — the helpers in ./sinks/* all wrap their
+        // I/O in try/catch. Be defensive anyway.
+        for (const s of this.sinksOwner.sinks) {
+            try {
+                s.write(record);
+            }
+            catch { /* logging must not break callers */ }
+        }
+    }
+}
+exports.CoreLogger = CoreLogger;

package/dist/core/v4/logger/sinks/fileSink.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/logger/sinks/fileSink.ts — Phase v4.1-1.3a
+ *
+ * Append log records to a file under `<aidenRoot>/logs/<name>.log`.
+ *
+ * One file per stream. Synchronous append (`appendFileSync`) so a line
+ * is durable even if the process exits mid-emission — same trade-off
+ * `core/v4/aidenLogger.ts` makes; small writes (< 100 / s during boot,
+ * occasional after) keep the cost negligible.
+ *
+ * Coarse rotation: when the file passes `MAX_BYTES`, rename to
+ * `<name>.log.1` (overwriting any previous rotation). One rotation is
+ * enough for diagnostics — older history isn't useful for debugging
+ * the current session and we'd rather not stash megabytes.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSink = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+/** Rotate at 5 MB — comfortable for a long debugging session, never huge. */
+const MAX_BYTES = 5 * 1024 * 1024;
+class FileSink {
+    constructor(opts) {
+        this.dirReady = false;
+        this.dir = opts.dir;
+        this.filePath = node_path_1.default.join(opts.dir, `${opts.name}.log`);
+    }
+    write(record) {
+        if (!this.ensureDir())
+            return;
+        this.maybeRotate();
+        const line = this.format(record);
+        try {
+            (0, node_fs_1.appendFileSync)(this.filePath, line, 'utf8');
+        }
+        catch { /* disk full / permission denied — drop */ }
+    }
+    /** Make `<dir>` once. Repeated calls are cheap (cache hit). */
+    ensureDir() {
+        if (this.dirReady)
+            return true;
+        try {
+            (0, node_fs_1.mkdirSync)(this.dir, { recursive: true });
+            this.dirReady = true;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * If the file is over MAX_BYTES, rename to `<name>.log.1` (overwriting
+     * the prior rotation if any). Best-effort — rotation failure isn't
+     * worth blocking the next write for.
+     */
+    maybeRotate() {
+        let size = 0;
+        try {
+            size = (0, node_fs_1.statSync)(this.filePath).size;
+        }
+        catch {
+            return;
+        }
+        if (size <= MAX_BYTES)
+            return;
+        try {
+            (0, node_fs_1.renameSync)(this.filePath, `${this.filePath}.1`);
+        }
+        catch { /* ignore */ }
+    }
+    /**
+     * Pretty single-line format — easy to grep, easy to tail. Structured
+     * fields are appended JSON-style after the message. Sinks that want
+     * NDJSON live elsewhere (e.g. `serve` mode would use a future
+     * JsonStdoutSink).
+     *
+     *   2026-05-08T01:32:44.681Z [info] [channels.telegram] Connected as @bot
+     *   2026-05-08T01:32:50.001Z [warn] [channels.telegram] Polling 409 {"streak":1}
+     */
+    format(r) {
+        const scope = r.scope ? ` [${r.scope}]` : '';
+        const ctx = r.ctx && Object.keys(r.ctx).length > 0
+            ? ' ' + safeJson(r.ctx)
+            : '';
+        return `${r.ts.toISOString()} [${r.level}]${scope} ${r.msg}${ctx}\n`;
+    }
+}
+exports.FileSink = FileSink;
+/**
+ * Defensive JSON.stringify — never throws; circular refs collapse to a
+ * placeholder so a misbehaving caller can't kill the log line.
+ */
+function safeJson(obj) {
+    try {
+        return JSON.stringify(obj);
+    }
+    catch {
+        return '"[unserializable ctx]"';
+    }
+}

package/dist/core/v4/logger/sinks/multiSink.js

@@ -0,0 +1,43 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/logger/sinks/multiSink.ts — Phase v4.1-1.3a
+ *
+ * `Logger` already fans out to every attached sink, so MultiSink is
+ * thin sugar for the cases where a sink itself wants to delegate to
+ * several others (e.g. wrap a stderr-warn-only filter and a file
+ * everything filter behind a single object the caller treats as one
+ * sink). In 3a it's used by tests; production logger compositions go
+ * through `factory.createBootLogger` which picks sinks per mode.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiSink = void 0;
+class MultiSink {
+    constructor(children) {
+        this.children = children;
+    }
+    write(r) {
+        for (const c of this.children) {
+            try {
+                c.write(r);
+            }
+            catch { /* one sink's failure must not poison the others */ }
+        }
+    }
+    async close() {
+        for (const c of this.children) {
+            if (typeof c.close === 'function') {
+                try {
+                    await c.close();
+                }
+                catch { /* ignore */ }
+            }
+        }
+    }
+}
+exports.MultiSink = MultiSink;

package/dist/core/v4/logger/sinks/nullSink.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/logger/sinks/nullSink.ts — Phase v4.1-1.3a
+ *
+ * Discard every record. The default for `'test'` mode so vitest output
+ * stays clean even when the code under test emits warnings — and the
+ * fallback when a module is constructed without a logger (the
+ * `noopLogger` factory in `../factory.ts` uses this).
+ *
+ * `MemorySink` is also here: it captures records into an in-process
+ * array so tests can assert on log output without any I/O. Two surfaces
+ * in one file because they share the "nothing leaves this process"
+ * property.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemorySink = exports.NullSink = void 0;
+/** Drops every record. */
+class NullSink {
+    write(_record) { }
+}
+exports.NullSink = NullSink;
+/**
+ * Captures every record into `records`. Tests use this:
+ *
+ *   const sink = new MemorySink();
+ *   const log = new CoreLogger({ sinks: [sink] });
+ *   log.info('hello');
+ *   expect(sink.records[0].msg).toBe('hello');
+ *
+ * `clear()` resets between assertions; `findScope()` is a small
+ * convenience for "did the channels.telegram scope log anything?".
+ */
+class MemorySink {
+    constructor() {
+        this.records = [];
+    }
+    write(r) {
+        this.records.push(r);
+    }
+    clear() {
+        this.records.length = 0;
+    }
+    findScope(scope) {
+        return this.records.filter((r) => r.scope === scope || r.scope.startsWith(`${scope}.`));
+    }
+}
+exports.MemorySink = MemorySink;

package/dist/core/v4/logger/sinks/stdSink.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/logger/sinks/stdSink.ts — Phase v4.1-1.3a
+ *
+ * Stdout / stderr sinks. Two flavours:
+ *
+ *   - StderrSink     — pretty single-line format; used in cli-headless
+ *                      mode for warnings + errors so the user sees them
+ *                      without polluting stdout (which scripts may pipe).
+ *   - StdoutJsonSink — NDJSON one-record-per-line; used in `serve` mode
+ *                      so log aggregators (systemd-journald, docker logs,
+ *                      Loki, etc.) get structured fields.
+ *
+ * No StdoutPrettySink in 3a — `cli-interactive` deliberately wires no
+ * stdout sink at all (REPL is sacred), and `cli-headless` uses the
+ * stderr flavour so stdout stays free for tool output piping. If a
+ * future mode needs colourful stdout (e.g. `aiden status` one-shot),
+ * add it then.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StdoutJsonSink = exports.StderrSink = void 0;
+const LEVEL_THRESHOLD = {
+    debug: 10, info: 20, warn: 30, error: 40,
+};
+class StderrSink {
+    constructor(opts = {}) {
+        this.minLevel = LEVEL_THRESHOLD[opts.minLevel ?? 'warn'];
+    }
+    write(r) {
+        if (LEVEL_THRESHOLD[r.level] < this.minLevel)
+            return;
+        const scope = r.scope ? ` [${r.scope}]` : '';
+        try {
+            process.stderr.write(`${r.ts.toISOString()} [${r.level}]${scope} ${r.msg}\n`);
+        }
+        catch { /* dropped */ }
+    }
+}
+exports.StderrSink = StderrSink;
+/**
+ * NDJSON stdout for `serve` mode. One record per line, structured
+ * fields preserved. Aggregators love this; humans don't. Headless
+ * scripts that want pretty output use the file sink instead and tail
+ * the log file.
+ */
+class StdoutJsonSink {
+    constructor(opts = {}) {
+        this.minLevel = LEVEL_THRESHOLD[opts.minLevel ?? 'debug'];
+    }
+    write(r) {
+        if (LEVEL_THRESHOLD[r.level] < this.minLevel)
+            return;
+        const payload = {
+            ts: r.ts.toISOString(),
+            level: r.level,
+            scope: r.scope || undefined,
+            msg: r.msg,
+        };
+        if (r.ctx)
+            Object.assign(payload, r.ctx);
+        try {
+            process.stdout.write(safeJson(payload) + '\n');
+        }
+        catch { /* dropped */ }
+    }
+}
+exports.StdoutJsonSink = StdoutJsonSink;
+function safeJson(obj) {
+    try {
+        return JSON.stringify(obj);
+    }
+    catch {
+        return '{"err":"unserializable"}';
+    }
+}

package/dist/core/v4/mcp/server/diagnostics.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/mcp/server/diagnostics.ts — Phase v4.1-mcp
+ *
+ * Build fingerprint + counts surfaced by the `aiden mcp status` CLI
+ * subcommand and the launch log line. The fingerprint follows the same
+ * convention the Telegram adapter set in v4.1-3.2 — a constant string
+ * the user can grep for to verify the build that's actually running
+ * matches the phase they expected.
+ *
+ * Bump on every shipped phase. Format: `v4.1-mcp[+suffix]`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AIDEN_MCP_BUILD = void 0;
+exports.collectMcpDiagnostics = collectMcpDiagnostics;
+const toolBridge_1 = require("./toolBridge");
+/** Build fingerprint — bump per phase. Surfaced in `aiden mcp status`
+ *  and the stderr launch line so it's grep-able from the spawning
+ *  client's log stream. */
+exports.AIDEN_MCP_BUILD = 'v4.1-mcp.2';
+async function collectMcpDiagnostics(registry, loader, env = (0, toolBridge_1.readToolBridgeEnv)()) {
+    const exposed = (0, toolBridge_1.exposedToolNames)(registry, env);
+    const skills = await loader.list();
+    return {
+        build: exports.AIDEN_MCP_BUILD,
+        toolsTotal: registry.list().length,
+        toolsExposed: exposed.length,
+        skillsTotal: skills.length,
+        env: {
+            allowDestructive: env.allowDestructive,
+            allowlist: env.allowlist ? [...env.allowlist].sort() : null,
+        },
+    };
+}

package/dist/core/v4/mcp/server/skillBridge.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * core/v4/mcp/server/skillBridge.ts — Phase v4.1-mcp
+ *
+ * Expose Aiden's loaded skills as MCP resources. Skills are inert
+ * markdown playbooks (`SKILL.md` + frontmatter), perfect candidates for
+ * MCP's read-only resource surface.
+ *
+ * URI scheme — `aiden-skill://<name>`. We deliberately namespaced this
+ * (rather than the bare `skill://`) so when a client connects to multiple
+ * agent MCP servers, resource URIs do not collide. The `name` segment is
+ * the SKILL.md frontmatter `name` field, which is already the lookup key
+ * used by the rest of the runtime (`SkillLoader.load(name)`).
+ *
+ * The bridge is intentionally read-only:
+ *   - `resources/list` enumerates every loaded skill
+ *   - `resources/read` returns the raw markdown (frontmatter + body)
+ *
+ * Mutations live behind the `skill_manage` tool; an MCP client that
+ * needs to install or modify a skill must go through that tool path so
+ * the same trust-level checks the REPL uses also apply remotely.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skillUri = skillUri;
+exports.parseSkillUri = parseSkillUri;
+exports.summaryToResource = summaryToResource;
+exports.buildResourcesList = buildResourcesList;
+exports.readSkillResource = readSkillResource;
+const node_fs_1 = require("node:fs");
+const URI_SCHEME = 'aiden-skill';
+const URI_PREFIX = `${URI_SCHEME}://`;
+function skillUri(name) {
+    return `${URI_PREFIX}${encodeURIComponent(name)}`;
+}
+/** Pull the `<name>` segment back out of an `aiden-skill://<name>` URI.
+ *  Returns null on malformed input — the read handler reports `isError`
+ *  in that case rather than crashing the protocol. */
+function parseSkillUri(uri) {
+    if (!uri.startsWith(URI_PREFIX))
+        return null;
+    const raw = uri.slice(URI_PREFIX.length);
+    if (!raw)
+        return null;
+    try {
+        return decodeURIComponent(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function summaryToResource(s) {
+    return {
+        uri: skillUri(s.name),
+        name: s.name,
+        description: s.description,
+        mimeType: 'text/markdown',
+    };
+}
+/**
+ * Build the resources array advertised on `resources/list`. Walks the
+ * SkillLoader cache (already warmed at boot in the runtime) so this is
+ * just an in-memory map.
+ */
+async function buildResourcesList(loader) {
+    const list = await loader.list();
+    return list.map(summaryToResource);
+}
+/**
+ * `resources/read` handler. Returns the raw SKILL.md content for the
+ * named skill. Throws when the URI is malformed or the skill is unknown
+ * — the stdio-server layer maps those to JSON-RPC errors.
+ */
+async function readSkillResource(loader, uri) {
+    const name = parseSkillUri(uri);
+    if (name === null) {
+        throw new Error(`Malformed resource URI (expected ${URI_PREFIX}<name>): ${uri}`);
+    }
+    const skill = await loader.load(name);
+    if (!skill) {
+        throw new Error(`Skill not found: ${name}`);
+    }
+    // SKILL.md content lives on disk. The loader exposes `filePath`; read
+    // the raw bytes so the client gets frontmatter + body verbatim. (We
+    // could reconstruct from `frontmatter` + `content`, but raw avoids
+    // round-trip drift if the loader ever rewrites YAML on parse.)
+    const text = await node_fs_1.promises.readFile(skill.filePath, 'utf-8');
+    return { uri, mimeType: 'text/markdown', text };
+}