loopengine 0.1.15 → 0.1.22

package/dist/core/toollane.d.ts

@@ -0,0 +1,46 @@
+/** A tool call is just a callable with identity — this module doesn't
+ * know or care what a "tool" is beyond that. */
+export interface ToolCall {
+    id: string;
+    name: string;
+    execute: () => Promise<unknown>;
+}
+/** Host-provided: does this specific call belong in a parallel lane?
+ * Mirrors Claude Code's own isReadOnly()/isConcurrencySafe() per-tool
+ * declarations. */
+export type SafetyClassifier = (call: ToolCall) => boolean;
+export interface Lane {
+    mode: 'parallel' | 'solo';
+    calls: ToolCall[];
+}
+export interface LaneResult {
+    id: string;
+    name: string;
+    status: 'fulfilled' | 'rejected';
+    value?: unknown;
+    error?: unknown;
+}
+/** Groups a batch of tool calls into lanes: consecutive safety-declared
+ * calls merge into one parallel lane; anything else gets its own solo
+ * lane. Batch order is preserved across lanes — this never reorders
+ * calls, only decides what runs together. */
+export declare function buildLanes(calls: ToolCall[], isSafe: SafetyClassifier): Lane[];
+/** Runs lanes in order; calls within a parallel lane run concurrently.
+ * Every call resolves to a LaneResult regardless of success or failure —
+ * one call throwing never rejects the batch, it just carries the error
+ * in its own slot. */
+export declare function runLanes(lanes: Lane[]): AsyncGenerator<LaneResult>;
+export interface ToolLaneOptions {
+    isSafe: SafetyClassifier;
+}
+/** Ties classification, scheduling, and execution together: given a
+ * batch of approved tool calls, decide a safe execution plan and run
+ * it, streaming each call's result as it completes. */
+export declare class ToolLane {
+    private readonly isSafe;
+    constructor(options: ToolLaneOptions);
+    /** Read-only — returns the lane plan without executing anything. */
+    plan(calls: ToolCall[]): Lane[];
+    /** Builds the plan and executes it. */
+    run(calls: ToolCall[]): AsyncGenerator<LaneResult>;
+}

package/dist/core/toollane.js

@@ -0,0 +1,69 @@
+// Formerly the standalone `toollane` package — folded in here for the
+// same reason mcpplug.ts was: no consumer besides loopengine itself ever
+// actually materialized, so the separate-package/portable-to-any-host
+// framing was aspirational rather than realized. A concurrency-safety-
+// aware scheduler for a batch of already-approved tool calls: consecutive
+// safety-declared calls run together in a parallel lane, anything else
+// gets its own solo lane, order preserved, one failure isolated to its
+// own slot rather than rejecting the whole batch.
+/** Groups a batch of tool calls into lanes: consecutive safety-declared
+ * calls merge into one parallel lane; anything else gets its own solo
+ * lane. Batch order is preserved across lanes — this never reorders
+ * calls, only decides what runs together. */
+export function buildLanes(calls, isSafe) {
+    const lanes = [];
+    for (const call of calls) {
+        const safe = isSafe(call);
+        const lastLane = lanes.at(-1);
+        if (safe && lastLane?.mode === 'parallel') {
+            lastLane.calls.push(call);
+            continue;
+        }
+        lanes.push({ mode: safe ? 'parallel' : 'solo', calls: [call] });
+    }
+    return lanes;
+}
+async function runCall(call) {
+    try {
+        const value = await call.execute();
+        return { id: call.id, name: call.name, status: 'fulfilled', value };
+    }
+    catch (error) {
+        return { id: call.id, name: call.name, status: 'rejected', error };
+    }
+}
+/** Runs lanes in order; calls within a parallel lane run concurrently.
+ * Every call resolves to a LaneResult regardless of success or failure —
+ * one call throwing never rejects the batch, it just carries the error
+ * in its own slot. */
+export async function* runLanes(lanes) {
+    for (const lane of lanes) {
+        if (lane.mode === 'solo') {
+            const call = lane.calls[0];
+            if (call)
+                yield await runCall(call);
+            continue;
+        }
+        const results = await Promise.all(lane.calls.map(runCall));
+        for (const result of results) {
+            yield result;
+        }
+    }
+}
+/** Ties classification, scheduling, and execution together: given a
+ * batch of approved tool calls, decide a safe execution plan and run
+ * it, streaming each call's result as it completes. */
+export class ToolLane {
+    isSafe;
+    constructor(options) {
+        this.isSafe = options.isSafe;
+    }
+    /** Read-only — returns the lane plan without executing anything. */
+    plan(calls) {
+        return buildLanes(calls, this.isSafe);
+    }
+    /** Builds the plan and executes it. */
+    async *run(calls) {
+        yield* runLanes(this.plan(calls));
+    }
+}

package/dist/index.d.ts

@@ -6,6 +6,10 @@ export { streamMessage, streamMessageWithCallbacks, sendMessage, approveCall, de
 export type { RequestOptions, SendMessageResult, PendingApprovalResult, PendingQuestionResult, PendingResult, MessageResult, StreamMessageCallbacks, } from './core/client.js';
 export { FileSessionStore, RedisSessionStore, createSessionStore } from './core/session-store.js';
 export type { SessionStore, SessionResult, RedisSessionStoreOptions } from './core/session-store.js';
+export { SessionKnit, FileStorage, MemoryStorage, reconstructChain } from './core/sessionknit.js';
+export type { Storage, SessionEntry, ResumeResult, SessionKnitOptions, ReconstructResult } from './core/sessionknit.js';
+export { SkillGarden, parseSkillFile, discoverSkillFiles, estimateTokens as estimateSkillIndexTokens, buildBudgetedIndex, substituteArguments, matchesActivationPaths, } from './core/skillgarden/index.js';
+export type { SkillGardenOptions, SkillFrontmatter, SkillIndexEntry, LoadedSkill, DiscoveredSkillFile, BuildIndexOptions, BudgetedIndex, } from './core/skillgarden/index.js';
 export { VectorIndex, embed, cosineSimilarity } from './core/vector-index.js';
 export type { Document, ScoredDocument } from './core/vector-index.js';
 export { createAnthropicModelCall } from './core/model-calls/anthropic-model-call.js';
@@ -32,6 +36,10 @@ export { createCheckpointStore } from './core/durable-approvals.js';
 export type { TurnCheckpoint, CheckpointStore, OutstandingItem } from './core/durable-approvals.js';
 export { addGatewayTool, agentDir, disconnectComposioAccount, describeGatewayTools, listComposioConnections, listComposioTools, loadGatewayToolsFromDir, removeGatewayTool, removeGatewayToolSlug, GatewayToolExistsError, GatewayToolNotFoundError, } from './core/gateway-tools.js';
 export type { GatewayToolEntry, GatewayToolDecision } from './core/gateway-tools.js';
+export { connectComposioSource } from './core/mcpplug.js';
+export type { ToolSource, ComposioSourceOptions } from './core/mcpplug.js';
+export { ToolLane, buildLanes, runLanes } from './core/toollane.js';
+export type { ToolLaneOptions, SafetyClassifier, ToolCall, Lane, LaneResult } from './core/toollane.js';
 export { WebhookNotifier } from './core/http-notify-triggers/webhook.js';
 export { listQuestions, answerQuestion as resolvePendingQuestion, findQuestion, createAskUserTool } from './core/system-tools/index.js';
 export type { PendingQuestion } from './core/system-tools/index.js';
@@ -45,8 +53,6 @@ export { globalConfigPageHtml } from './web/global-config-page.js';
 export { playgroundHtml } from './web/playground.js';
 export { readSkill, writeSkill, deleteSkill, SkillInvalidIdError, SkillNotFoundError } from './web/skills-admin.js';
 export type { SkillContent } from './web/skills-admin.js';
-export { listSkillgardenCatalog, readSkillgardenCatalogEntry, addSkillgardenSkillToAgent, SkillgardenUnavailableError } from './web/skillgarden-admin.js';
-export type { SkillgardenCatalogEntry, SkillgardenCatalogDetail } from './web/skillgarden-admin.js';
 export { listDeclaredEnvVars, setEnvVar, EnvVarNameError } from './web/env-admin.js';
 export type { DeclaredEnvVar } from './web/env-admin.js';
 export { readActauthConfig, addActauthRule, updateActauthRule, removeActauthRule, setDefaultDecision, ActauthRuleExistsError, ActauthRuleNotFoundError, } from './web/actauth-admin.js';

package/dist/index.js

@@ -12,6 +12,8 @@ export { runAgent } from '#core/run-agent.js';
 // exception.
 export { streamMessage, streamMessageWithCallbacks, sendMessage, approveCall, denyCall, answerQuestion, getSessionHistory, } from './core/client.js';
 export { FileSessionStore, RedisSessionStore, createSessionStore } from './core/session-store.js';
+export { SessionKnit, FileStorage, MemoryStorage, reconstructChain } from './core/sessionknit.js';
+export { SkillGarden, parseSkillFile, discoverSkillFiles, estimateTokens as estimateSkillIndexTokens, buildBudgetedIndex, substituteArguments, matchesActivationPaths, } from './core/skillgarden/index.js';
 export { VectorIndex, embed, cosineSimilarity } from './core/vector-index.js';
 export { createAnthropicModelCall } from './core/model-calls/anthropic-model-call.js';
 export { createOpenAIModelCall } from './core/model-calls/openai-model-call.js';
@@ -33,6 +35,8 @@ export { Compactor, TruncatingSummarizer } from './core/compaction.js';
 export { LLMSummarizer } from './core/llm-summarizer.js';
 export { createCheckpointStore } from './core/durable-approvals.js';
 export { addGatewayTool, agentDir, disconnectComposioAccount, describeGatewayTools, listComposioConnections, listComposioTools, loadGatewayToolsFromDir, removeGatewayTool, removeGatewayToolSlug, GatewayToolExistsError, GatewayToolNotFoundError, } from './core/gateway-tools.js';
+export { connectComposioSource } from './core/mcpplug.js';
+export { ToolLane, buildLanes, runLanes } from './core/toollane.js';
 export { WebhookNotifier } from './core/http-notify-triggers/webhook.js';
 // answerQuestion above (core/client.ts) is the HTTP client-side helper —
 // this is the server-side function that actually resolves a pending
@@ -45,7 +49,6 @@ export { agentsListPageHtml } from './web/agents-list-page.js';
 export { globalConfigPageHtml } from './web/global-config-page.js';
 export { playgroundHtml } from './web/playground.js';
 export { readSkill, writeSkill, deleteSkill, SkillInvalidIdError, SkillNotFoundError } from './web/skills-admin.js';
-export { listSkillgardenCatalog, readSkillgardenCatalogEntry, addSkillgardenSkillToAgent, SkillgardenUnavailableError } from './web/skillgarden-admin.js';
 export { listDeclaredEnvVars, setEnvVar, EnvVarNameError } from './web/env-admin.js';
 export { readActauthConfig, addActauthRule, updateActauthRule, removeActauthRule, setDefaultDecision, ActauthRuleExistsError, ActauthRuleNotFoundError, } from './web/actauth-admin.js';
 export { describeModelProviders, describeGateways } from './web/global-config.js';

package/dist/web/agents-config-page.js

@@ -367,26 +367,6 @@ export const agentsConfigPageHtml = `<!doctype html>
   #httpToolAddFieldBtn, #httpToolAddHeaderBtn {
     padding: 6px 12px;
   }
-  .skillgarden-category-badge {
-    display: inline-block;
-    font-family: ui-sans-serif, system-ui, sans-serif;
-    font-size: 10px;
-    font-weight: 600;
-    text-transform: uppercase;
-    letter-spacing: 0.03em;
-    padding: 1px 7px;
-    border-radius: 999px;
-    background: light-dark(#eef1ec, #1e2519);
-    color: light-dark(#3f6b4a, #7fbf8f);
-    margin-right: 6px;
-  }
-  #skillgardenFilterInput { margin-bottom: 8px; }
-  .skillgarden-catalog-body {
-    margin-top: 8px;
-    padding-top: 8px;
-    border-top: 1px solid light-dark(#eee, #2a2a2e);
-    font-size: 13px;
-  }
 </style>
 </head>
 <body>
@@ -1270,194 +1250,18 @@ export const agentsConfigPageHtml = `<!doctype html>
           '<button type="submit" id="skillSubmitBtn">Add</button>' +
           '<button type="button" id="skillCancelBtn" style="display:none">Cancel</button>' +
           '<div id="skillFormError" class="error"></div>' +
-        '</form></section>' +
-      '<section><h3>Browse skillgarden catalog</h3>' +
-        '<input type="text" id="skillgardenFilterInput" placeholder="Filter by name or category&hellip;">' +
-        '<div id="skillgardenCatalogList"><p class="hint">Loading&hellip;</p></div>' +
-      '</section>';
+        '</form></section>';
   }
 
   function skillsPanelEl() {
     return detail.querySelector('[data-tab-panel="skills"]');
   }
 
-  // ---- Skills tab's "Browse skillgarden catalog" section: a
-  // read-only, agent-independent list of everything GET /skillgarden-
-  // catalog reports (see web/skillgarden-admin.ts) — cached in this one
-  // module-level variable, not per-agent like gatewayLoadedFor, since
-  // the catalog itself never varies by agent. renderSkillsTabHtml
-  // regenerates the whole Skills panel (including this section's own
-  // markup) on every agent switch/refresh, so loadSkillgardenCatalogSection
-  // re-renders from this cache instead of re-fetching every time — only
-  // the very first time this tab is opened in the page's lifetime hits
-  // the network at all. ----
-  var skillgardenCatalog = null;
-
-  function skillgardenCatalogListEl() {
-    var panel = skillsPanelEl();
-    return panel ? panel.querySelector('#skillgardenCatalogList') : null;
-  }
-
-  function renderSkillgardenCatalogEntry(entry) {
-    return '<div class="source" data-category="' + escapeHtml(entry.category) + '" data-id="' + escapeHtml(entry.id) + '">' +
-      '<div class="source-head">' +
-        '<h4><span class="skillgarden-category-badge">' + escapeHtml(entry.category) + '</span>' + escapeHtml(entry.id) + '</h4>' +
-        '<span>' +
-          '<button type="button" class="skillgarden-view-btn" data-category="' + escapeHtml(entry.category) + '" data-id="' + escapeHtml(entry.id) + '">View</button> ' +
-          '<button type="button" class="skillgarden-add-btn" data-category="' + escapeHtml(entry.category) + '" data-id="' + escapeHtml(entry.id) + '">Add to this agent</button>' +
-        '</span>' +
-      '</div>' +
-      '<p class="hint">' + escapeHtml(entry.description) + '</p>' +
-      '<div class="skillgarden-catalog-body" style="display:none"></div>' +
-      '</div>';
-  }
-
-  function renderSkillgardenCatalogList(entries) {
-    return entries.length ? entries.map(renderSkillgardenCatalogEntry).join('') : '<p class="hint">No skills match.</p>';
-  }
-
-  function applySkillgardenCatalog(name, entries) {
-    var listEl = skillgardenCatalogListEl();
-    if (!listEl) return;
-    listEl.innerHTML = renderSkillgardenCatalogList(entries);
-    wireSkillgardenCatalogHandlers(name);
-  }
-
-  function filteredSkillgardenCatalog(filterText) {
-    if (!filterText) return skillgardenCatalog;
-    var needle = filterText.toLowerCase();
-    return skillgardenCatalog.filter(function (entry) {
-      return entry.category.toLowerCase().indexOf(needle) !== -1 || entry.id.toLowerCase().indexOf(needle) !== -1;
-    });
-  }
-
-  function loadSkillgardenCatalogSection(name) {
-    var listEl = skillgardenCatalogListEl();
-    if (!listEl) return;
-    if (skillgardenCatalog) {
-      var panel = skillsPanelEl();
-      var filterInput = panel ? panel.querySelector('#skillgardenFilterInput') : null;
-      applySkillgardenCatalog(name, filteredSkillgardenCatalog(filterInput ? filterInput.value.trim() : ''));
-      return;
-    }
-    listEl.innerHTML = '<p class="hint">Loading&hellip;</p>';
-    fetch('/skillgarden-catalog')
-      .then(function (r) { return r.json().then(function (j) { return { ok: r.ok, body: j }; }); })
-      .then(function (result) {
-        if (!result.ok) throw new Error(result.body.error || 'request failed');
-        skillgardenCatalog = result.body;
-        if (currentName !== name) return;
-        applySkillgardenCatalog(name, skillgardenCatalog);
-      })
-      .catch(function (err) {
-        if (currentName !== name) return;
-        listEl.innerHTML = '<p class="error">Could not load skillgarden catalog: ' + escapeHtml(err.message) + '</p>';
-      });
-  }
-
-  // force=true retries as an explicit overwrite after the operator
-  // confirms — same "ask once a plain add collides, don't ask up front"
-  // flow the rest of this page never has to think about since nothing
-  // else lets an operator add something whose id they don't already
-  // control the uniqueness of themselves.
-  function performSkillgardenAdd(name, category, id, btn, originalText, force) {
-    fetch('/agents/' + encodeURIComponent(name) + '/skillgarden-catalog/' + encodeURIComponent(category) + '/' + encodeURIComponent(id), {
-      method: 'POST',
-      headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ force: !!force }),
-    })
-      .then(function (r) { return r.json().then(function (j) { return { ok: r.ok, body: j }; }); })
-      .then(function (result) {
-        if (result.ok) {
-          refreshSkillsDependentPanels(name);
-          return;
-        }
-        if (!force && /already exists/.test(result.body.error || '')) {
-          if (confirm('A skill named "' + id + '" already exists for this agent. Overwrite it?')) {
-            performSkillgardenAdd(name, category, id, btn, originalText, true);
-            return;
-          }
-          btn.disabled = false;
-          btn.textContent = originalText;
-          return;
-        }
-        throw new Error(result.body.error || 'request failed');
-      })
-      .catch(function (err) {
-        alert('Could not add "' + id + '": ' + err.message);
-        btn.disabled = false;
-        btn.textContent = originalText;
-      });
-  }
-
-  function wireSkillgardenCatalogHandlers(name) {
-    var listEl = skillgardenCatalogListEl();
-    if (!listEl) return;
-
-    var viewButtons = listEl.querySelectorAll('.skillgarden-view-btn');
-    for (var i = 0; i < viewButtons.length; i++) {
-      viewButtons[i].addEventListener('click', function (ev) {
-        var btn = ev.currentTarget;
-        var category = btn.getAttribute('data-category');
-        var id = btn.getAttribute('data-id');
-        var card = btn.closest('.source');
-        var bodyEl = card.querySelector('.skillgarden-catalog-body');
-        if (bodyEl.style.display !== 'none') {
-          bodyEl.style.display = 'none';
-          btn.textContent = 'View';
-          return;
-        }
-        if (bodyEl.getAttribute('data-loaded') === '1') {
-          bodyEl.style.display = 'block';
-          btn.textContent = 'Hide';
-          return;
-        }
-        btn.disabled = true;
-        fetch('/skillgarden-catalog/' + encodeURIComponent(category) + '/' + encodeURIComponent(id))
-          .then(function (r) { return r.json().then(function (j) { return { ok: r.ok, body: j }; }); })
-          .then(function (result) {
-            if (!result.ok) throw new Error(result.body.error || 'request failed');
-            bodyEl.innerHTML = renderMarkdownPreview(result.body.body);
-            bodyEl.setAttribute('data-loaded', '1');
-            bodyEl.style.display = 'block';
-            btn.textContent = 'Hide';
-          })
-          .catch(function (err) {
-            bodyEl.innerHTML = '<p class="error">' + escapeHtml(err.message) + '</p>';
-            bodyEl.style.display = 'block';
-          })
-          .then(function () { btn.disabled = false; });
-      });
-    }
-
-    var addButtons = listEl.querySelectorAll('.skillgarden-add-btn');
-    for (var j = 0; j < addButtons.length; j++) {
-      addButtons[j].addEventListener('click', function (ev) {
-        var btn = ev.currentTarget;
-        var category = btn.getAttribute('data-category');
-        var id = btn.getAttribute('data-id');
-        var originalText = btn.textContent;
-        btn.disabled = true;
-        btn.textContent = 'Adding…';
-        performSkillgardenAdd(name, category, id, btn, originalText, false);
-      });
-    }
-  }
-
   function wireSkillsHandlers(name) {
     var panel = skillsPanelEl();
     if (!panel) return;
     var editingSkillId = null;
 
-    loadSkillgardenCatalogSection(name);
-    var skillgardenFilterInput = panel.querySelector('#skillgardenFilterInput');
-    if (skillgardenFilterInput) {
-      skillgardenFilterInput.addEventListener('input', function () {
-        if (!skillgardenCatalog) return;
-        applySkillgardenCatalog(name, filteredSkillgardenCatalog(skillgardenFilterInput.value.trim()));
-      });
-    }
-
     // Write/Preview toggle for the Body field — same idea as GitHub's own
     // issue/PR editor: the textarea and the rendered preview show/hide
     // each other, the textarea's value is the only source of truth (the

package/dist/web/skills-admin.js

@@ -11,7 +11,7 @@
 // only adding/editing/removing one through this UI is out of scope.
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { parseSkillFile } from 'skillgarden';
+import { parseSkillFile } from '../core/skillgarden/index.js';
 import { agentDir } from '../core/gateway-tools.js';
 export class SkillInvalidIdError extends Error {
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loopengine",
-  "version": "0.1.15",
+  "version": "0.1.22",
   "type": "module",
   "description": "Runtime for tool-using AI agents with a transparent ReAct loop.",
   "license": "MIT",
@@ -55,6 +55,12 @@
     "dist/core/agent-as-tool.d.ts",
     "dist/core/gateway-tools.js",
     "dist/core/gateway-tools.d.ts",
+    "dist/core/mcpplug.js",
+    "dist/core/mcpplug.d.ts",
+    "dist/core/toollane.js",
+    "dist/core/toollane.d.ts",
+    "dist/core/sessionknit.js",
+    "dist/core/sessionknit.d.ts",
     "dist/core/budget.js",
     "dist/core/budget.d.ts",
     "dist/core/compaction.js",
@@ -68,6 +74,7 @@
     "dist/core/http-notify-triggers",
     "dist/core/system-tools",
     "dist/core/system-skills",
+    "dist/core/skillgarden",
     "dist/core/durable-approvals.js",
     "dist/core/durable-approvals.d.ts",
     "dist/web",
@@ -85,12 +92,8 @@
     "@anthropic-ai/sdk": "^0.116.0",
     "actauth": "^0.0.12",
     "ioredis": "^6.0.0",
-    "mcpplug": "^0.0.1",
     "openai": "^7.4.0",
     "semver": "^7.8.5",
-    "sessionknit": "^0.0.2",
-    "skillgarden": "^0.0.9",
-    "toollane": "^0.0.1",
     "typescript": "^5.7.0",
     "yaml": "^2.6.0"
   },

package/dist/web/skillgarden-admin.d.ts

@@ -1,24 +0,0 @@
-export declare class SkillgardenUnavailableError extends Error {
-}
-export interface SkillgardenCatalogEntry {
-    category: string;
-    id: string;
-    description: string;
-}
-export interface SkillgardenCatalogDetail extends SkillgardenCatalogEntry {
-    body: string;
-}
-export declare function listSkillgardenCatalog(): SkillgardenCatalogEntry[];
-export declare function readSkillgardenCatalogEntry(category: string, id: string): SkillgardenCatalogDetail;
-/** Copies `registry/<category>/<id>/` into `agents/<agentName>/skills/<id>/`
- * — delegates entirely to skillgarden's own `addSkill`, which already
- * knows this exact `agents/<agent>/skills` destination convention (see
- * its own doc comment) and already refuses (or, with `force`,
- * overwrites) an existing destination. Returns the bare skill id actually
- * installed — never category-qualified, matching `addSkill`'s own
- * "category is a registry-organization concept, not forced onto what a
- * caller now owns" convention. */
-export declare function addSkillgardenSkillToAgent(agentName: string, category: string, id: string, force?: boolean): {
-    id: string;
-    path: string;
-};

package/dist/web/skillgarden-admin.js

@@ -1,76 +0,0 @@
-// Lets an operator browse skillgarden's own bundled skill registry from
-// the Skills tab in /agents/config, and add one straight into an agent's
-// agents/<name>/skills/ folder — a shortcut for the same thing
-// `npx skillgarden add <skill> --agent <name>` already does from a
-// terminal, surfaced in the UI instead. This module only ever *reads*
-// the registry and delegates the actual copy to skillgarden's own
-// exported `addSkill` (see below) — it never re-implements that logic.
-import { createRequire } from 'node:module';
-import { dirname, join } from 'node:path';
-import { SkillGarden, addSkill as skillgardenAddSkill } from 'skillgarden';
-export class SkillgardenUnavailableError extends Error {
-}
-// skillgarden's own CLI resolves its bundled registry/ relative to its
-// own compiled dist/cli.js location (see its cli.ts's own
-// DEFAULT_REGISTRY_DIR), but doesn't export that path — `addSkill`
-// itself defaults to it internally, which is enough for *installing* a
-// skill, but browsing/previewing the catalog needs the directory path
-// itself. Re-derived here the same way Node's own module resolution
-// would: from package.json's real installed location, not assumed
-// relative to this file (skillgarden is a real npm dependency, not a
-// vendored copy).
-function registryDir() {
-    const require = createRequire(import.meta.url);
-    let pkgJsonPath;
-    try {
-        pkgJsonPath = require.resolve('skillgarden/package.json');
-    }
-    catch {
-        throw new SkillgardenUnavailableError('skillgarden is not installed — run `npm install skillgarden` to enable the skill catalog.');
-    }
-    return join(dirname(pkgJsonPath), 'registry');
-}
-// A large, fixed budget, not run-agent.ts's own live skillIndexBudgetTokens
-// default — this indexes a small, fixed, bundled catalog for browsing,
-// not an agent's own live context, so nothing here should ever silently
-// truncate the list an operator sees.
-const CATALOG_INDEX_BUDGET_TOKENS = 1_000_000;
-// discoverSkillFiles namespaces registry/<category>/<skill>/SKILL.md as
-// "<category>:<skill>" (colon-joined, one level of nesting) — split on
-// just the first colon, not skillId itself, in case a future entry ever
-// nests deeper than one category level.
-function splitNamespacedName(namespacedName) {
-    const colon = namespacedName.indexOf(':');
-    return { category: namespacedName.slice(0, colon), id: namespacedName.slice(colon + 1) };
-}
-function catalogGarden() {
-    return new SkillGarden({ dirs: [registryDir()], indexBudgetTokens: CATALOG_INDEX_BUDGET_TOKENS });
-}
-export function listSkillgardenCatalog() {
-    const { included } = catalogGarden().buildIndex();
-    return included
-        .map((entry) => ({ ...splitNamespacedName(entry.name), description: entry.description }))
-        .sort((a, b) => (a.category === b.category ? a.id.localeCompare(b.id) : a.category.localeCompare(b.category)));
-}
-export function readSkillgardenCatalogEntry(category, id) {
-    const garden = catalogGarden();
-    garden.buildIndex();
-    // load() throws a plain Error for an unindexed name — same "not found"
-    // shape a bad category/id combination should surface as; the caller
-    // (adapters/http.ts) maps any throw here to 404, so there's nothing
-    // more specific to catch and re-throw.
-    const loaded = garden.load(`${category}:${id}`);
-    return { category, id, description: loaded.description, body: loaded.body };
-}
-/** Copies `registry/<category>/<id>/` into `agents/<agentName>/skills/<id>/`
- * — delegates entirely to skillgarden's own `addSkill`, which already
- * knows this exact `agents/<agent>/skills` destination convention (see
- * its own doc comment) and already refuses (or, with `force`,
- * overwrites) an existing destination. Returns the bare skill id actually
- * installed — never category-qualified, matching `addSkill`'s own
- * "category is a registry-organization concept, not forced onto what a
- * caller now owns" convention. */
-export function addSkillgardenSkillToAgent(agentName, category, id, force = false) {
-    const result = skillgardenAddSkill({ skill: `${category}/${id}`, agent: agentName, registryDir: registryDir(), force });
-    return { id, path: join(result.destination, 'SKILL.md') };
-}