@nebutra/agent-runtime 0.2.0

package/dist/chunk-NN7DATXA.js

@@ -0,0 +1,46 @@
+// src/tools.ts
+var ToolRegistry = class {
+  #tools = /* @__PURE__ */ new Map();
+  #hooks;
+  constructor(hooks = {}) {
+    this.#hooks = hooks;
+  }
+  register(definition, handler, origin = { kind: "native" }) {
+    if (this.#tools.has(definition.name)) {
+      throw new Error(`Tool already registered: ${definition.name}`);
+    }
+    this.#tools.set(definition.name, {
+      reg: { definition, origin },
+      handler
+    });
+  }
+  list() {
+    return [...this.#tools.values()].map((e) => e.reg);
+  }
+  async dispatch(name, rawInput, ctx) {
+    const entry = this.#tools.get(name);
+    if (!entry) throw new Error(`Unknown tool: ${name}`);
+    const input = entry.reg.definition.inputSchema.parse(rawInput);
+    await this.#hooks.preToolUse?.(name, input, ctx);
+    const output = await entry.handler(input, ctx);
+    const validated = entry.reg.definition.outputSchema ? entry.reg.definition.outputSchema.parse(output) : output;
+    await this.#hooks.postToolUse?.(name, validated, ctx);
+    return validated;
+  }
+};
+function adaptMcpTool(server, definition, client) {
+  return {
+    definition,
+    origin: { kind: "mcp", server },
+    handler: async (input, ctx) => client.executeTool(definition.name, input, {
+      requestId: globalThis.crypto?.randomUUID?.() ?? `${Date.now()}`,
+      tenantId: ctx.tenantId
+    })
+  };
+}
+
+export {
+  ToolRegistry,
+  adaptMcpTool
+};
+//# sourceMappingURL=chunk-NN7DATXA.js.map

package/dist/chunk-NN7DATXA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tools.ts"],"sourcesContent":["/**\n * Tool / MCP abstraction (WRAP — capability #9).\n *\n * Faithful re-expression of the upstream uniform tool model: one\n * `ToolDefinition` interface, JSON-schema in/out, a deferred-load flag, and\n * MCP-as-adapter behind the same interface (MCP tools and native tools are\n * indistinguishable at dispatch). Activates `@nebutra/mcp` primitives rather\n * than re-porting them.\n */\n\nimport type { z } from \"zod\";\n\n/** A tool definition — pure data; transport-agnostic. */\nexport interface ToolDefinition<I = unknown, O = unknown> {\n  readonly name: string;\n  readonly description: string;\n  readonly inputSchema: z.ZodType<I>;\n  readonly outputSchema?: z.ZodType<O>;\n  /**\n   * When true, the full schema is withheld until a `tool_search` discovery\n   * step lazily loads it (parity with the upstream deferred-tool pattern).\n   */\n  readonly deferLoading?: boolean;\n}\n\n/** Source provenance — native vs. adapted from an MCP server. */\nexport type ToolOrigin =\n  | { readonly kind: \"native\" }\n  | { readonly kind: \"mcp\"; readonly server: string };\n\nexport interface RegisteredTool {\n  readonly definition: ToolDefinition;\n  readonly origin: ToolOrigin;\n}\n\n/** A tool invocation routed through the registry. */\nexport interface ToolDispatchContext {\n  /** Mandatory tenant scope — every dispatch is tenant-bound. */\n  readonly tenantId: string;\n  readonly threadId: string;\n}\n\nexport type ToolHandler<I = unknown, O = unknown> = (\n  input: I,\n  ctx: ToolDispatchContext,\n) => Promise<O>;\n\n/** Pre/post dispatch hooks (parity with upstream orchestrator hooks). */\nexport interface ToolHooks {\n  readonly preToolUse?: (name: string, input: unknown, ctx: ToolDispatchContext) => Promise<void>;\n  readonly postToolUse?: (name: string, output: unknown, ctx: ToolDispatchContext) => Promise<void>;\n}\n\n/**\n * registry -> router -> orchestrator pipeline. MCP tools register via\n * {@link adaptMcpTool} and are dispatched identically to native tools.\n */\nexport class ToolRegistry {\n  readonly #tools = new Map<string, { reg: RegisteredTool; handler: ToolHandler }>();\n  readonly #hooks: ToolHooks;\n\n  constructor(hooks: ToolHooks = {}) {\n    this.#hooks = hooks;\n  }\n\n  register<I, O>(\n    definition: ToolDefinition<I, O>,\n    handler: ToolHandler<I, O>,\n    origin: ToolOrigin = { kind: \"native\" },\n  ): void {\n    if (this.#tools.has(definition.name)) {\n      throw new Error(`Tool already registered: ${definition.name}`);\n    }\n    this.#tools.set(definition.name, {\n      reg: { definition: definition as ToolDefinition, origin },\n      handler: handler as ToolHandler,\n    });\n  }\n\n  list(): readonly RegisteredTool[] {\n    return [...this.#tools.values()].map((e) => e.reg);\n  }\n\n  async dispatch(name: string, rawInput: unknown, ctx: ToolDispatchContext): Promise<unknown> {\n    const entry = this.#tools.get(name);\n    if (!entry) throw new Error(`Unknown tool: ${name}`);\n    const input = entry.reg.definition.inputSchema.parse(rawInput);\n    await this.#hooks.preToolUse?.(name, input, ctx);\n    const output = await entry.handler(input, ctx);\n    const validated = entry.reg.definition.outputSchema\n      ? entry.reg.definition.outputSchema.parse(output)\n      : output;\n    await this.#hooks.postToolUse?.(name, validated, ctx);\n    return validated;\n  }\n}\n\n/** Minimal shape of an MCP client (satisfied by `@nebutra/mcp`'s `mcpClient`). */\nexport interface McpClientLike {\n  executeTool(\n    name: string,\n    args: unknown,\n    ctx: { requestId: string; tenantId: string },\n  ): Promise<unknown>;\n}\n\n/**\n * Adapt an external MCP tool into the uniform tool model. The resulting\n * handler delegates to the MCP client; callers cannot tell it apart from a\n * native tool.\n */\nexport function adaptMcpTool(\n  server: string,\n  definition: ToolDefinition,\n  client: McpClientLike,\n): { definition: ToolDefinition; handler: ToolHandler; origin: ToolOrigin } {\n  return {\n    definition,\n    origin: { kind: \"mcp\", server },\n    handler: async (input, ctx) =>\n      client.executeTool(definition.name, input, {\n        requestId: globalThis.crypto?.randomUUID?.() ?? `${Date.now()}`,\n        tenantId: ctx.tenantId,\n      }),\n  };\n}\n"],"mappings":";AAyDO,IAAM,eAAN,MAAmB;AAAA,EACf,SAAS,oBAAI,IAA2D;AAAA,EACxE;AAAA,EAET,YAAY,QAAmB,CAAC,GAAG;AACjC,SAAK,SAAS;AAAA,EAChB;AAAA,EAEA,SACE,YACA,SACA,SAAqB,EAAE,MAAM,SAAS,GAChC;AACN,QAAI,KAAK,OAAO,IAAI,WAAW,IAAI,GAAG;AACpC,YAAM,IAAI,MAAM,4BAA4B,WAAW,IAAI,EAAE;AAAA,IAC/D;AACA,SAAK,OAAO,IAAI,WAAW,MAAM;AAAA,MAC/B,KAAK,EAAE,YAA0C,OAAO;AAAA,MACxD;AAAA,IACF,CAAC;AAAA,EACH;AAAA,EAEA,OAAkC;AAChC,WAAO,CAAC,GAAG,KAAK,OAAO,OAAO,CAAC,EAAE,IAAI,CAAC,MAAM,EAAE,GAAG;AAAA,EACnD;AAAA,EAEA,MAAM,SAAS,MAAc,UAAmB,KAA4C;AAC1F,UAAM,QAAQ,KAAK,OAAO,IAAI,IAAI;AAClC,QAAI,CAAC,MAAO,OAAM,IAAI,MAAM,iBAAiB,IAAI,EAAE;AACnD,UAAM,QAAQ,MAAM,IAAI,WAAW,YAAY,MAAM,QAAQ;AAC7D,UAAM,KAAK,OAAO,aAAa,MAAM,OAAO,GAAG;AAC/C,UAAM,SAAS,MAAM,MAAM,QAAQ,OAAO,GAAG;AAC7C,UAAM,YAAY,MAAM,IAAI,WAAW,eACnC,MAAM,IAAI,WAAW,aAAa,MAAM,MAAM,IAC9C;AACJ,UAAM,KAAK,OAAO,cAAc,MAAM,WAAW,GAAG;AACpD,WAAO;AAAA,EACT;AACF;AAgBO,SAAS,aACd,QACA,YACA,QAC0E;AAC1E,SAAO;AAAA,IACL;AAAA,IACA,QAAQ,EAAE,MAAM,OAAO,OAAO;AAAA,IAC9B,SAAS,OAAO,OAAO,QACrB,OAAO,YAAY,WAAW,MAAM,OAAO;AAAA,MACzC,WAAW,WAAW,QAAQ,aAAa,KAAK,GAAG,KAAK,IAAI,CAAC;AAAA,MAC7D,UAAU,IAAI;AAAA,IAChB,CAAC;AAAA,EACL;AACF;","names":[]}

package/dist/chunk-PGGWSUTM.js

@@ -0,0 +1,33 @@
+import {
+  adaptMcpTool
+} from "./chunk-NN7DATXA.js";
+
+// src/mcp-bridge.ts
+import { z } from "zod";
+var ctxSchema = z.object({
+  tenantId: z.string().trim().min(1, "tenantId is required (fail-closed)"),
+  plan: z.string().min(1).optional()
+});
+async function activateMcpTools(registry, catalog, client, ctx) {
+  const scope = ctxSchema.parse(ctx);
+  const entries = await catalog.listTools(
+    scope.plan === void 0 ? { tenantId: scope.tenantId } : { tenantId: scope.tenantId, plan: scope.plan }
+  );
+  const registered = [];
+  const skipped = [];
+  for (const { server, definition } of entries) {
+    if (registry.list().some((r) => r.definition.name === definition.name)) {
+      skipped.push(definition.name);
+      continue;
+    }
+    const adapted = adaptMcpTool(server, definition, client);
+    registry.register(adapted.definition, adapted.handler, adapted.origin);
+    registered.push(definition.name);
+  }
+  return { registered, skipped };
+}
+
+export {
+  activateMcpTools
+};
+//# sourceMappingURL=chunk-PGGWSUTM.js.map

package/dist/chunk-PGGWSUTM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mcp-bridge.ts"],"sourcesContent":["/**\n * MCP activation bridge (WRAP — capability #9, activation seam).\n *\n * Concrete bridge that registers external MCP-server tools into the runtime's\n * uniform tool model. It does NOT import `@nebutra/mcp` (WIP / do-not-import):\n * instead it defines minimal injectable ports so callers wire `@nebutra/mcp`\n * (`serverRegistry` + `mcpClient`) without this package taking a hard dep.\n *\n * Tenant-scoped by construction: the catalog port is always queried with the\n * caller's `{ tenantId, plan }`, so a tenant only ever sees its own MCP\n * servers/tools. Fail-closed on missing tenant.\n */\n\nimport { z } from \"zod\";\n\nimport { adaptMcpTool, type McpClientLike, type ToolDefinition, type ToolRegistry } from \"./tools\";\n\n/**\n * Port over an MCP server catalog (satisfied by `@nebutra/mcp`'s\n * `serverRegistry` + plan middleware). Returns only the tools visible to the\n * given tenant/plan — visibility/plan-gating is the port's responsibility.\n */\nexport interface McpServerCatalogPort {\n  listTools(ctx: {\n    tenantId: string;\n    plan?: string;\n  }): Promise<{ server: string; definition: ToolDefinition }[]>;\n}\n\nconst ctxSchema = z.object({\n  tenantId: z.string().trim().min(1, \"tenantId is required (fail-closed)\"),\n  plan: z.string().min(1).optional(),\n});\n\nexport interface ActivateMcpToolsResult {\n  /** Tool names newly registered into the registry, in catalog order. */\n  readonly registered: readonly string[];\n  /** Tool names skipped because the name was already registered. */\n  readonly skipped: readonly string[];\n}\n\n/**\n * List the tenant/plan-visible MCP tools, adapt each via {@link adaptMcpTool},\n * and register them into the {@link ToolRegistry}. A tool whose name is already\n * registered is skipped (reported, never thrown). Empty/blank tenantId fails\n * closed before any catalog call.\n */\nexport async function activateMcpTools(\n  registry: ToolRegistry,\n  catalog: McpServerCatalogPort,\n  client: McpClientLike,\n  ctx: { tenantId: string; plan?: string },\n): Promise<ActivateMcpToolsResult> {\n  const scope = ctxSchema.parse(ctx);\n\n  const entries = await catalog.listTools(\n    scope.plan === undefined\n      ? { tenantId: scope.tenantId }\n      : { tenantId: scope.tenantId, plan: scope.plan },\n  );\n\n  const registered: string[] = [];\n  const skipped: string[] = [];\n\n  for (const { server, definition } of entries) {\n    if (registry.list().some((r) => r.definition.name === definition.name)) {\n      skipped.push(definition.name);\n      continue;\n    }\n    const adapted = adaptMcpTool(server, definition, client);\n    registry.register(adapted.definition, adapted.handler, adapted.origin);\n    registered.push(definition.name);\n  }\n\n  return { registered, skipped };\n}\n"],"mappings":";;;;;AAaA,SAAS,SAAS;AAgBlB,IAAM,YAAY,EAAE,OAAO;AAAA,EACzB,UAAU,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,GAAG,oCAAoC;AAAA,EACvE,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,SAAS;AACnC,CAAC;AAeD,eAAsB,iBACpB,UACA,SACA,QACA,KACiC;AACjC,QAAM,QAAQ,UAAU,MAAM,GAAG;AAEjC,QAAM,UAAU,MAAM,QAAQ;AAAA,IAC5B,MAAM,SAAS,SACX,EAAE,UAAU,MAAM,SAAS,IAC3B,EAAE,UAAU,MAAM,UAAU,MAAM,MAAM,KAAK;AAAA,EACnD;AAEA,QAAM,aAAuB,CAAC;AAC9B,QAAM,UAAoB,CAAC;AAE3B,aAAW,EAAE,QAAQ,WAAW,KAAK,SAAS;AAC5C,QAAI,SAAS,KAAK,EAAE,KAAK,CAAC,MAAM,EAAE,WAAW,SAAS,WAAW,IAAI,GAAG;AACtE,cAAQ,KAAK,WAAW,IAAI;AAC5B;AAAA,IACF;AACA,UAAM,UAAU,aAAa,QAAQ,YAAY,MAAM;AACvD,aAAS,SAAS,QAAQ,YAAY,QAAQ,SAAS,QAAQ,MAAM;AACrE,eAAW,KAAK,WAAW,IAAI;AAAA,EACjC;AAEA,SAAO,EAAE,YAAY,QAAQ;AAC/B;","names":[]}

package/dist/chunk-RDKYDMXT.js

@@ -0,0 +1,135 @@
+import {
+  METHOD_REGISTRY,
+  NOTIFICATIONS,
+  requestEnvelopeSchema,
+  resolveScope,
+  scopeKey
+} from "./chunk-FUG5DT2C.js";
+
+// src/dispatcher.ts
+var ERR_INVALID_REQUEST = -32600;
+var ERR_METHOD_NOT_FOUND = -32601;
+var ERR_INVALID_PARAMS = -32602;
+var ERR_INTERNAL = -32603;
+function success(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function failure(id, code, message) {
+  return { jsonrpc: "2.0", id, error: { code, message } };
+}
+var NOTIFICATION_NAMES = new Set(NOTIFICATIONS);
+var METHOD_SPEC_BY_WIRE = new Map(
+  Object.values(METHOD_REGISTRY).map((spec) => [spec.method, spec])
+);
+function extractId(raw) {
+  if (raw && typeof raw === "object" && "id" in raw) {
+    const id = raw.id;
+    if (typeof id === "string" || typeof id === "number") return id;
+  }
+  return null;
+}
+var ProtocolDispatcher = class {
+  #handlers = /* @__PURE__ */ new Map();
+  #notificationListeners = /* @__PURE__ */ new Map();
+  /** Per-scope-key serial promise chains (tail-of-lane). */
+  #lanes = /* @__PURE__ */ new Map();
+  /** Register a handler for a wire method name (e.g. `"turn/start"`). */
+  register(methodName, handler) {
+    this.#handlers.set(methodName, handler);
+    return this;
+  }
+  /** Subscribe to a server→client notification. */
+  onNotification(name, listener) {
+    let set = this.#notificationListeners.get(name);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.#notificationListeners.set(name, set);
+    }
+    set.add(listener);
+    return () => {
+      set?.delete(listener);
+    };
+  }
+  /**
+   * Emit a server→client notification. Validates the name against the
+   * `NOTIFICATIONS` allow-list (fail-closed: unknown name throws).
+   */
+  emitNotification(name, payload) {
+    if (!NOTIFICATION_NAMES.has(name)) {
+      throw new Error(`Unknown notification name: ${String(name)}`);
+    }
+    const listeners = this.#notificationListeners.get(name);
+    if (!listeners) return;
+    for (const listener of listeners) listener(payload);
+  }
+  /**
+   * Dispatch a single raw envelope. Never throws — every failure path maps
+   * to a JSON-RPC error response.
+   */
+  async dispatch(rawEnvelope) {
+    const parsed = requestEnvelopeSchema.safeParse(rawEnvelope);
+    if (!parsed.success) {
+      return failure(
+        extractId(rawEnvelope),
+        ERR_INVALID_REQUEST,
+        "Invalid request envelope (tenantId is mandatory)"
+      );
+    }
+    const envelope = parsed.data;
+    const spec = METHOD_SPEC_BY_WIRE.get(envelope.method);
+    if (!spec) {
+      return failure(envelope.id, ERR_METHOD_NOT_FOUND, `Method not found: ${envelope.method}`);
+    }
+    const handler = this.#handlers.get(envelope.method);
+    if (!handler) {
+      return failure(
+        envelope.id,
+        ERR_METHOD_NOT_FOUND,
+        `No handler registered for method: ${envelope.method}`
+      );
+    }
+    const params = envelope.params && typeof envelope.params === "object" ? envelope.params : {};
+    let scope;
+    try {
+      scope = resolveScope(spec, envelope.tenantId, params);
+    } catch {
+      return failure(
+        envelope.id,
+        ERR_INVALID_PARAMS,
+        `Method ${envelope.method} requires a threadId for scoping`
+      );
+    }
+    const key = scopeKey(scope);
+    return this.#runSerialized(key, async () => {
+      try {
+        const result = await handler(envelope.params, scope);
+        return success(envelope.id, result);
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Internal handler error";
+        return failure(envelope.id, ERR_INTERNAL, message);
+      }
+    });
+  }
+  /**
+   * Run `task` after every previously-enqueued task on the same scope key.
+   * A failing/slow task never poisons or blocks the lane permanently.
+   */
+  #runSerialized(key, task) {
+    const previous = this.#lanes.get(key) ?? Promise.resolve();
+    const run = previous.then(task, task);
+    const tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    this.#lanes.set(key, tail);
+    void tail.then(() => {
+      if (this.#lanes.get(key) === tail) this.#lanes.delete(key);
+    });
+    return run;
+  }
+};
+
+export {
+  ProtocolDispatcher
+};
+//# sourceMappingURL=chunk-RDKYDMXT.js.map

package/dist/chunk-RDKYDMXT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dispatcher.ts"],"sourcesContent":["/**\n * Transport-agnostic JSON-RPC dispatcher for the app-server protocol.\n *\n * Pure and testable: no sockets. WS/SSE/stdio adapters wrap this dispatcher\n * and are intentionally out of scope here.\n *\n * Faithful concurrency model (see `protocol.ts`): requests sharing a\n * `scopeKey` are serialized FIFO; distinct scope keys run concurrently.\n * Because every scope is tenant-prefixed, cross-tenant requests can never\n * share a serial lane (fail-closed multi-tenancy by construction).\n */\n\nimport {\n  METHOD_REGISTRY,\n  type MethodSpec,\n  NOTIFICATIONS,\n  type NotificationName,\n  requestEnvelopeSchema,\n  resolveScope,\n  type SerializationScope,\n  scopeKey,\n} from \"./protocol\";\n\n// ── Public types ─────────────────────────────────────────────────────────────\n\nexport type MethodHandler = (params: unknown, scope: SerializationScope) => Promise<unknown>;\n\nexport type NotificationListener = (payload: unknown) => void;\n\ninterface JsonRpcSuccess {\n  readonly jsonrpc: \"2.0\";\n  readonly id: string | number | null;\n  readonly result: unknown;\n}\n\ninterface JsonRpcFailure {\n  readonly jsonrpc: \"2.0\";\n  readonly id: string | number | null;\n  readonly error: { readonly code: number; readonly message: string };\n}\n\nexport type JsonRpcResponse = JsonRpcSuccess | JsonRpcFailure;\n\n// ── JSON-RPC error codes (spec-aligned) ──────────────────────────────────────\n\nconst ERR_INVALID_REQUEST = -32600;\nconst ERR_METHOD_NOT_FOUND = -32601;\nconst ERR_INVALID_PARAMS = -32602;\nconst ERR_INTERNAL = -32603;\n\nfunction success(id: string | number | null, result: unknown): JsonRpcSuccess {\n  return { jsonrpc: \"2.0\", id, result };\n}\n\nfunction failure(id: string | number | null, code: number, message: string): JsonRpcFailure {\n  return { jsonrpc: \"2.0\", id, error: { code, message } };\n}\n\nconst NOTIFICATION_NAMES: ReadonlySet<string> = new Set(NOTIFICATIONS);\n\nconst METHOD_SPEC_BY_WIRE: ReadonlyMap<string, MethodSpec> = new Map(\n  Object.values(METHOD_REGISTRY).map((spec) => [spec.method, spec]),\n);\n\n/** Recover a best-effort id from an unvalidated payload for error responses. */\nfunction extractId(raw: unknown): string | number | null {\n  if (raw && typeof raw === \"object\" && \"id\" in raw) {\n    const id = (raw as { id: unknown }).id;\n    if (typeof id === \"string\" || typeof id === \"number\") return id;\n  }\n  return null;\n}\n\nexport class ProtocolDispatcher {\n  readonly #handlers = new Map<string, MethodHandler>();\n  readonly #notificationListeners = new Map<NotificationName, Set<NotificationListener>>();\n  /** Per-scope-key serial promise chains (tail-of-lane). */\n  readonly #lanes = new Map<string, Promise<void>>();\n\n  /** Register a handler for a wire method name (e.g. `\"turn/start\"`). */\n  register(methodName: string, handler: MethodHandler): this {\n    this.#handlers.set(methodName, handler);\n    return this;\n  }\n\n  /** Subscribe to a server→client notification. */\n  onNotification(name: NotificationName, listener: NotificationListener): () => void {\n    let set = this.#notificationListeners.get(name);\n    if (!set) {\n      set = new Set();\n      this.#notificationListeners.set(name, set);\n    }\n    set.add(listener);\n    return () => {\n      set?.delete(listener);\n    };\n  }\n\n  /**\n   * Emit a server→client notification. Validates the name against the\n   * `NOTIFICATIONS` allow-list (fail-closed: unknown name throws).\n   */\n  emitNotification(name: NotificationName, payload: unknown): void {\n    if (!NOTIFICATION_NAMES.has(name)) {\n      throw new Error(`Unknown notification name: ${String(name)}`);\n    }\n    const listeners = this.#notificationListeners.get(name);\n    if (!listeners) return;\n    for (const listener of listeners) listener(payload);\n  }\n\n  /**\n   * Dispatch a single raw envelope. Never throws — every failure path maps\n   * to a JSON-RPC error response.\n   */\n  async dispatch(rawEnvelope: unknown): Promise<JsonRpcResponse> {\n    const parsed = requestEnvelopeSchema.safeParse(rawEnvelope);\n    if (!parsed.success) {\n      return failure(\n        extractId(rawEnvelope),\n        ERR_INVALID_REQUEST,\n        \"Invalid request envelope (tenantId is mandatory)\",\n      );\n    }\n    const envelope = parsed.data;\n\n    const spec = METHOD_SPEC_BY_WIRE.get(envelope.method);\n    if (!spec) {\n      return failure(envelope.id, ERR_METHOD_NOT_FOUND, `Method not found: ${envelope.method}`);\n    }\n\n    const handler = this.#handlers.get(envelope.method);\n    if (!handler) {\n      return failure(\n        envelope.id,\n        ERR_METHOD_NOT_FOUND,\n        `No handler registered for method: ${envelope.method}`,\n      );\n    }\n\n    const params: { threadId?: string } =\n      envelope.params && typeof envelope.params === \"object\"\n        ? (envelope.params as { threadId?: string })\n        : {};\n\n    let scope: SerializationScope;\n    try {\n      scope = resolveScope(spec, envelope.tenantId, params);\n    } catch {\n      return failure(\n        envelope.id,\n        ERR_INVALID_PARAMS,\n        `Method ${envelope.method} requires a threadId for scoping`,\n      );\n    }\n\n    const key = scopeKey(scope);\n    return this.#runSerialized(key, async () => {\n      try {\n        const result = await handler(envelope.params, scope);\n        return success(envelope.id, result);\n      } catch (error) {\n        const message = error instanceof Error ? error.message : \"Internal handler error\";\n        return failure(envelope.id, ERR_INTERNAL, message);\n      }\n    });\n  }\n\n  /**\n   * Run `task` after every previously-enqueued task on the same scope key.\n   * A failing/slow task never poisons or blocks the lane permanently.\n   */\n  #runSerialized<T>(key: string, task: () => Promise<T>): Promise<T> {\n    const previous = this.#lanes.get(key) ?? Promise.resolve();\n    const run = previous.then(task, task);\n    // Keep the lane's tail; swallow rejections in the chain link so a thrown\n    // task does not break FIFO ordering for the next request.\n    const tail = run.then(\n      () => undefined,\n      () => undefined,\n    );\n    this.#lanes.set(key, tail);\n    // Garbage-collect the lane once drained to avoid unbounded key growth.\n    void tail.then(() => {\n      if (this.#lanes.get(key) === tail) this.#lanes.delete(key);\n    });\n    return run;\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-YYFPDBJG.js

@@ -0,0 +1,63 @@
+import {
+  DefinitionResolver,
+  substituteArguments
+} from "./chunk-7BUOF367.js";
+
+// src/commands.ts
+function bindArgs(input, argNames) {
+  const tokens = input.trim().length > 0 ? input.trim().split(/\s+/) : [];
+  const args = {};
+  if (argNames.length === 0) {
+    args.ARGUMENTS = input.trim();
+    args["1"] = input.trim();
+    return args;
+  }
+  argNames.forEach((name, i) => {
+    if (i === argNames.length - 1) {
+      args[name] = tokens.slice(i).join(" ");
+    } else {
+      args[name] = tokens[i] ?? "";
+    }
+  });
+  return args;
+}
+async function expandCommand(cmd, argInput, variables, bodyLoader) {
+  const body = await bodyLoader(cmd);
+  const args = bindArgs(argInput, cmd.frontmatter.argNames);
+  const content = substituteArguments(body, args, { ...variables });
+  const model = cmd.frontmatter.model;
+  const modelOverride = model && model !== "inherit" ? model : void 0;
+  return Object.freeze({
+    contentBlocks: Object.freeze([
+      Object.freeze({ role: "user", content })
+    ]),
+    allowedTools: Object.freeze([...cmd.frontmatter.allowedTools]),
+    modelOverride,
+    effort: cmd.frontmatter.effort,
+    executionMode: cmd.frontmatter.executionMode
+  });
+}
+var CommandRegistry = class {
+  #resolver;
+  constructor(commands) {
+    this.#resolver = new DefinitionResolver(commands);
+  }
+  /** Commands a human may type as a slash command. */
+  listForUser(ctx) {
+    return this.#resolver.resolve(ctx).filter((c) => c.frontmatter.userInvocable !== false);
+  }
+  /** Commands the model may auto-trigger. */
+  listForModel(ctx) {
+    return this.#resolver.resolve(ctx).filter((c) => c.frontmatter.modelInvocable !== false);
+  }
+  /** Highest-precedence gated record for a slug (no invocability filter). */
+  resolveOne(slug, ctx) {
+    return this.#resolver.resolveOne(slug, ctx);
+  }
+};
+
+export {
+  expandCommand,
+  CommandRegistry
+};
+//# sourceMappingURL=chunk-YYFPDBJG.js.map

package/dist/chunk-YYFPDBJG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/commands.ts"],"sourcesContent":["/**\n * Slash-command registry — faithful re-expression of the unified command model.\n *\n * Semantic model:\n *  - A command and a skill are the SAME underlying type. `CommandRecord` is just\n *    a `Definition`. The only differences are carried in the record itself:\n *    `sourceTier`, and the `userInvocable` / `modelInvocable` frontmatter flags.\n *  - Slash invocation (a human types `/deploy`) and model invocation (the model\n *    auto-triggers) are two FRONT-DOORS to ONE expansion path.\n *  - The registry IS a `DefinitionResolver<CommandRecord>` (layered tier merge +\n *    precedence + dual gate are provided by definitions.ts — reused, not rebuilt).\n *    `CommandRegistry` is a thin wrapper exposing the two front-doors; both\n *    recompute per call so entitlement/flag changes apply live.\n *\n * Scope note: the source harness also has `local` / `local-jsx` command kinds\n * that run TUI-side JSX. Those are intentionally DROPPED here — a server runtime\n * only needs the prompt-expansion path. This module models that path only.\n *\n * Multi-tenant: `tenantId` is mandatory at every entry point; an empty tenant\n * throws (fail-closed); cross-tenant resolution is impossible (the underlying\n * resolver rejects foreign-tenant records).\n */\n\nimport {\n  type Definition,\n  DefinitionResolver,\n  type ResolveContext,\n  substituteArguments,\n} from \"./definitions\";\n\n/**\n * A command IS a Definition. No new fields — the distinction between \"command\"\n * and \"skill\" is purely the `sourceTier` + invocability flags already present.\n */\nexport type CommandRecord = Definition;\n\n/** Lazily loads a command's body text (FS / blob / remote — caller's choice). */\nexport type BodyLoader = (cmd: CommandRecord) => Promise<string>;\n\n/** One content block destined for the model turn. */\nexport interface ContentBlock {\n  readonly role: \"user\";\n  readonly content: string;\n}\n\n/** Result of expanding a command — declarative only; no enforcement here. */\nexport interface ExpandedCommand {\n  /** Prompt blocks to splice into the turn. */\n  readonly contentBlocks: readonly ContentBlock[];\n  /** Tools the command self-declares for the permission context. */\n  readonly allowedTools: readonly string[];\n  /** Model alias to switch to, if the command pins one (not \"inherit\"). */\n  readonly modelOverride?: string | undefined;\n  /** Reasoning effort hint, if declared. */\n  readonly effort?: \"low\" | \"medium\" | \"high\" | undefined;\n  /** inline = expand into current turn; fork = isolated child. */\n  readonly executionMode: \"inline\" | \"fork\";\n}\n\n/**\n * Split a positional argument string across declared arg names. Extra tokens\n * beyond the last declared name are folded into that last argument (matches the\n * source's \"rest goes to the last positional\" behaviour). With no declared\n * names the whole string is exposed as `${ARGUMENTS}` / `$1`.\n */\nfunction bindArgs(input: string, argNames: readonly string[]): Record<string, string> {\n  const tokens = input.trim().length > 0 ? input.trim().split(/\\s+/) : [];\n  const args: Record<string, string> = {};\n  if (argNames.length === 0) {\n    args.ARGUMENTS = input.trim();\n    args[\"1\"] = input.trim();\n    return args;\n  }\n  argNames.forEach((name, i) => {\n    if (i === argNames.length - 1) {\n      args[name] = tokens.slice(i).join(\" \");\n    } else {\n      args[name] = tokens[i] ?? \"\";\n    }\n  });\n  return args;\n}\n\n/**\n * Pure expansion. Loads the body lazily (exactly once), substitutes named args\n * and a tenant-safe variable map (only the explicitly injected `variables` —\n * never `process.env`), and returns the declarative execution context.\n */\nexport async function expandCommand(\n  cmd: CommandRecord,\n  argInput: string,\n  variables: Readonly<Record<string, string>>,\n  bodyLoader: BodyLoader,\n): Promise<ExpandedCommand> {\n  const body = await bodyLoader(cmd);\n  const args = bindArgs(argInput, cmd.frontmatter.argNames);\n  // Only injected variables are visible — host env is deliberately excluded.\n  const content = substituteArguments(body, args, { ...variables });\n\n  const model = cmd.frontmatter.model;\n  const modelOverride = model && model !== \"inherit\" ? model : undefined;\n\n  return Object.freeze({\n    contentBlocks: Object.freeze([\n      Object.freeze({ role: \"user\" as const, content }),\n    ]) as readonly ContentBlock[],\n    allowedTools: Object.freeze([...cmd.frontmatter.allowedTools]),\n    modelOverride,\n    effort: cmd.frontmatter.effort,\n    executionMode: cmd.frontmatter.executionMode,\n  });\n}\n\n/**\n * Thin tenant-scoped wrapper over `DefinitionResolver<CommandRecord>`. Exposes\n * the two front-doors. Tier merge / precedence / dual gate / tenant isolation\n * are delegated to the resolver — this class only filters by invocability.\n */\nexport class CommandRegistry {\n  readonly #resolver: DefinitionResolver<CommandRecord>;\n\n  constructor(commands: readonly CommandRecord[]) {\n    this.#resolver = new DefinitionResolver<CommandRecord>(commands);\n  }\n\n  /** Commands a human may type as a slash command. */\n  listForUser(ctx: ResolveContext): CommandRecord[] {\n    return this.#resolver.resolve(ctx).filter((c) => c.frontmatter.userInvocable !== false);\n  }\n\n  /** Commands the model may auto-trigger. */\n  listForModel(ctx: ResolveContext): CommandRecord[] {\n    return this.#resolver.resolve(ctx).filter((c) => c.frontmatter.modelInvocable !== false);\n  }\n\n  /** Highest-precedence gated record for a slug (no invocability filter). */\n  resolveOne(slug: string, ctx: ResolveContext): CommandRecord | undefined {\n    return this.#resolver.resolveOne(slug, ctx);\n  }\n}\n"],"mappings":";;;;;;AAiEA,SAAS,SAAS,OAAe,UAAqD;AACpF,QAAM,SAAS,MAAM,KAAK,EAAE,SAAS,IAAI,MAAM,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;AACtE,QAAM,OAA+B,CAAC;AACtC,MAAI,SAAS,WAAW,GAAG;AACzB,SAAK,YAAY,MAAM,KAAK;AAC5B,SAAK,GAAG,IAAI,MAAM,KAAK;AACvB,WAAO;AAAA,EACT;AACA,WAAS,QAAQ,CAAC,MAAM,MAAM;AAC5B,QAAI,MAAM,SAAS,SAAS,GAAG;AAC7B,WAAK,IAAI,IAAI,OAAO,MAAM,CAAC,EAAE,KAAK,GAAG;AAAA,IACvC,OAAO;AACL,WAAK,IAAI,IAAI,OAAO,CAAC,KAAK;AAAA,IAC5B;AAAA,EACF,CAAC;AACD,SAAO;AACT;AAOA,eAAsB,cACpB,KACA,UACA,WACA,YAC0B;AAC1B,QAAM,OAAO,MAAM,WAAW,GAAG;AACjC,QAAM,OAAO,SAAS,UAAU,IAAI,YAAY,QAAQ;AAExD,QAAM,UAAU,oBAAoB,MAAM,MAAM,EAAE,GAAG,UAAU,CAAC;AAEhE,QAAM,QAAQ,IAAI,YAAY;AAC9B,QAAM,gBAAgB,SAAS,UAAU,YAAY,QAAQ;AAE7D,SAAO,OAAO,OAAO;AAAA,IACnB,eAAe,OAAO,OAAO;AAAA,MAC3B,OAAO,OAAO,EAAE,MAAM,QAAiB,QAAQ,CAAC;AAAA,IAClD,CAAC;AAAA,IACD,cAAc,OAAO,OAAO,CAAC,GAAG,IAAI,YAAY,YAAY,CAAC;AAAA,IAC7D;AAAA,IACA,QAAQ,IAAI,YAAY;AAAA,IACxB,eAAe,IAAI,YAAY;AAAA,EACjC,CAAC;AACH;AAOO,IAAM,kBAAN,MAAsB;AAAA,EAClB;AAAA,EAET,YAAY,UAAoC;AAC9C,SAAK,YAAY,IAAI,mBAAkC,QAAQ;AAAA,EACjE;AAAA;AAAA,EAGA,YAAY,KAAsC;AAChD,WAAO,KAAK,UAAU,QAAQ,GAAG,EAAE,OAAO,CAAC,MAAM,EAAE,YAAY,kBAAkB,KAAK;AAAA,EACxF;AAAA;AAAA,EAGA,aAAa,KAAsC;AACjD,WAAO,KAAK,UAAU,QAAQ,GAAG,EAAE,OAAO,CAAC,MAAM,EAAE,YAAY,mBAAmB,KAAK;AAAA,EACzF;AAAA;AAAA,EAGA,WAAW,MAAc,KAAgD;AACvE,WAAO,KAAK,UAAU,WAAW,MAAM,GAAG;AAAA,EAC5C;AACF;","names":[]}

package/dist/chunk-ZMYX5VBU.js

@@ -0,0 +1,135 @@
+import {
+  substituteArguments
+} from "./chunk-7BUOF367.js";
+
+// src/skills.ts
+import { z } from "zod";
+var FIRST_PARTY_TIERS = /* @__PURE__ */ new Set(["bundled", "builtin"]);
+var isFirstParty = (s) => FIRST_PARTY_TIERS.has(s.sourceTier);
+var listingOptionsSchema = z.object({
+  maxListingDescChars: z.number().int().positive().default(250),
+  contextWindowTokens: z.number().int().positive().default(2e5),
+  budgetPercent: z.number().positive().max(1).default(0.01),
+  touchedPaths: z.array(z.string()).default([])
+});
+var estimateTokens = (text) => Math.ceil(text.length / 4);
+function globToRegExp(glob) {
+  let out = "^";
+  for (let i = 0; i < glob.length; i++) {
+    const c = glob[i];
+    if (c === "*") {
+      if (glob[i + 1] === "*") {
+        out += ".*";
+        i++;
+      } else {
+        out += "[^/]*";
+      }
+    } else if (".+?^${}()|[]\\".includes(c)) {
+      out += `\\${c}`;
+    } else {
+      out += c;
+    }
+  }
+  return new RegExp(`${out}$`);
+}
+var pathMatches = (globs, touched) => globs.some((g) => {
+  const re = globToRegExp(g);
+  return touched.some((p) => re.test(p));
+});
+function orderSkills(skills) {
+  return [...skills].sort((a, b) => {
+    const fa = isFirstParty(a) ? 0 : 1;
+    const fb = isFirstParty(b) ? 0 : 1;
+    if (fa !== fb) return fa - fb;
+    return a.slug.localeCompare(b.slug);
+  });
+}
+var truncate = (s, max) => s.length <= max ? s : s.slice(0, max);
+function renderEntry(e) {
+  const head = e.whenToUse ? `- ${e.name} \u2014 ${e.whenToUse}` : `- ${e.name}`;
+  return e.description ? `${head}
+  ${e.description}` : head;
+}
+function buildSkillListing(resolver, ctx, options = {}) {
+  if (!ctx.tenantId) throw new Error("buildSkillListing: tenantId is required");
+  const opts = listingOptionsSchema.parse(options);
+  const loaded = ctx.loadedSlugs ?? /* @__PURE__ */ new Set();
+  const visible = resolver.resolve(ctx).filter((s) => !loaded.has(s.slug)).filter((s) => {
+    const paths = s.frontmatter.paths;
+    return paths.length === 0 || pathMatches(paths, opts.touchedPaths);
+  });
+  const budget = Math.max(1, Math.floor(opts.contextWindowTokens * opts.budgetPercent));
+  const entries = [];
+  let used = 0;
+  for (const s of orderSkills(visible)) {
+    const fp = isFirstParty(s);
+    const fm = s.frontmatter;
+    const fullDesc = fp ? fm.description : truncate(fm.description, opts.maxListingDescChars);
+    if (fp) {
+      const entry = {
+        name: fm.name,
+        description: fm.description,
+        whenToUse: fm.whenToUse,
+        degraded: false,
+        firstParty: true
+      };
+      entries.push(entry);
+      used += estimateTokens(renderEntry(entry));
+      continue;
+    }
+    const full = {
+      name: fm.name,
+      description: fullDesc,
+      whenToUse: fm.whenToUse,
+      degraded: false,
+      firstParty: false
+    };
+    const fullCost = estimateTokens(renderEntry(full));
+    if (used + fullCost <= budget) {
+      entries.push(full);
+      used += fullCost;
+      continue;
+    }
+    const nameOnly = {
+      name: fm.name,
+      description: "",
+      whenToUse: void 0,
+      degraded: true,
+      firstParty: false
+    };
+    const nameCost = estimateTokens(renderEntry(nameOnly));
+    if (used + nameCost <= budget) {
+      entries.push(nameOnly);
+      used += nameCost;
+    }
+  }
+  const text = entries.map(renderEntry).join("\n");
+  return { entries, text };
+}
+async function expandSkill(skill, ctx) {
+  if (!ctx.tenantId) throw new Error("expandSkill: tenantId is required");
+  if (skill.tenantId !== ctx.tenantId) {
+    throw new Error("expandSkill: cross-tenant skill access rejected");
+  }
+  const rawBody = await ctx.bodyLoader(skill.bodyRef);
+  const body = substituteArguments(rawBody, ctx.args, ctx.vars);
+  const baseLine = `Base directory for this skill: ${ctx.skillResourceBase(skill.slug)}`;
+  const messages = [
+    { role: "system", content: baseLine },
+    { role: "user", content: body }
+  ];
+  const allowedTools = [...skill.frontmatter.allowedTools];
+  return {
+    messages,
+    allowedTools,
+    modelOverride: skill.frontmatter.model,
+    effort: skill.frontmatter.effort,
+    executionMode: skill.frontmatter.executionMode
+  };
+}
+
+export {
+  buildSkillListing,
+  expandSkill
+};
+//# sourceMappingURL=chunk-ZMYX5VBU.js.map

package/dist/chunk-ZMYX5VBU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/skills.ts"],"sourcesContent":["/**\n * Skills system (WRAP — progressive-disclosure capability).\n *\n * Faithful re-expression of the source harness's two-phase skill model:\n *\n *   Phase 1 — Listing (cheap, always in context): a budget-bounded catalog\n *     exposing only {name, description, whenToUse} per skill. First-party\n *     skills (bundled/builtin tier) are never truncated and never dropped;\n *     lower-tier skills degrade to names-only, then drop, as the context\n *     budget is exhausted. Path-activated skills stay hidden until a touched\n *     file matches one of their globs.\n *\n *   Phase 2 — Invocation (lazy, on demand): expand the chosen skill's body\n *     into turn messages, with arg/var substitution and a merged tool\n *     allowlist contributed to the permission context.\n *\n * A skill IS a `Definition` — the same tenant-scoped layered resolver backs\n * the command registry and the subagent registry (see ./definitions).\n *\n * SECURITY: this re-expression intentionally drops the source's body-side\n * command-substitution (the upstream \"!`…`\" inline-shell facility). Skill\n * bodies are inert text; they NEVER trigger host shell execution here. All\n * entry points require a non-empty `tenantId` and fail closed; cross-tenant\n * inputs are rejected by the underlying `DefinitionResolver`. Pure data/logic\n * — no host filesystem access (resource base is an injected indirection).\n */\n\nimport { z } from \"zod\";\nimport {\n  type Definition,\n  type DefinitionResolver,\n  type ResolveContext,\n  substituteArguments,\n} from \"./definitions\";\n\n/** A skill is just a resolvable `Definition`. */\nexport type SkillRecord = Definition;\n\n/** Tiers treated as first-party (never truncated, never dropped). */\nconst FIRST_PARTY_TIERS: ReadonlySet<string> = new Set([\"bundled\", \"builtin\"]);\n\nconst isFirstParty = (s: SkillRecord): boolean => FIRST_PARTY_TIERS.has(s.sourceTier);\n\n// ── Phase 1: listing ─────────────────────────────────────────────────────────\n\n/** One catalog entry — only the cheap, always-in-context surface. */\nexport interface SkillListingEntry {\n  readonly name: string;\n  readonly description: string;\n  readonly whenToUse?: string | undefined;\n  /** True when this entry was degraded to names-only by the budget. */\n  readonly degraded: boolean;\n  readonly firstParty: boolean;\n}\n\nexport interface SkillListing {\n  readonly entries: readonly SkillListingEntry[];\n  readonly text: string;\n}\n\nconst listingOptionsSchema = z.object({\n  maxListingDescChars: z.number().int().positive().default(250),\n  contextWindowTokens: z.number().int().positive().default(200_000),\n  budgetPercent: z.number().positive().max(1).default(0.01),\n  touchedPaths: z.array(z.string()).default([]),\n});\nexport type SkillListingOptions = z.input<typeof listingOptionsSchema>;\n\n/** Cheap, deterministic token estimate (≈4 chars/token). */\nconst estimateTokens = (text: string): number => Math.ceil(text.length / 4);\n\n/** Minimal glob: `**` = any chars, `*` = any chars except `/`, else exact. */\nfunction globToRegExp(glob: string): RegExp {\n  let out = \"^\";\n  for (let i = 0; i < glob.length; i++) {\n    const c = glob[i]!;\n    if (c === \"*\") {\n      if (glob[i + 1] === \"*\") {\n        out += \".*\";\n        i++;\n      } else {\n        out += \"[^/]*\";\n      }\n    } else if (\".+?^${}()|[]\\\\\".includes(c)) {\n      out += `\\\\${c}`;\n    } else {\n      out += c;\n    }\n  }\n  return new RegExp(`${out}$`);\n}\n\nconst pathMatches = (globs: readonly string[], touched: readonly string[]): boolean =>\n  globs.some((g) => {\n    const re = globToRegExp(g);\n    return touched.some((p) => re.test(p));\n  });\n\n/** Stable order: first-party first, then by slug — deterministic output. */\nfunction orderSkills(skills: readonly SkillRecord[]): SkillRecord[] {\n  return [...skills].sort((a, b) => {\n    const fa = isFirstParty(a) ? 0 : 1;\n    const fb = isFirstParty(b) ? 0 : 1;\n    if (fa !== fb) return fa - fb;\n    return a.slug.localeCompare(b.slug);\n  });\n}\n\nconst truncate = (s: string, max: number): string => (s.length <= max ? s : s.slice(0, max));\n\nfunction renderEntry(e: SkillListingEntry): string {\n  const head = e.whenToUse ? `- ${e.name} — ${e.whenToUse}` : `- ${e.name}`;\n  return e.description ? `${head}\\n  ${e.description}` : head;\n}\n\n/**\n * Phase 1 — build the always-in-context skill catalog. Pure & deterministic.\n *\n * Budget = `contextWindowTokens * budgetPercent`. First-party skills are\n * emitted in full and do NOT consume budget against being dropped. Each\n * remaining skill is tried at full description; if it would overflow it is\n * degraded to names-only; if even that overflows it is dropped. Skills in\n * `ctx.loadedSlugs` and unactivated path-gated skills are suppressed.\n */\nexport function buildSkillListing(\n  resolver: DefinitionResolver<SkillRecord>,\n  ctx: ResolveContext,\n  options: SkillListingOptions = {},\n): SkillListing {\n  if (!ctx.tenantId) throw new Error(\"buildSkillListing: tenantId is required\");\n  const opts = listingOptionsSchema.parse(options);\n\n  const loaded = ctx.loadedSlugs ?? new Set<string>();\n  const visible = resolver\n    .resolve(ctx)\n    .filter((s) => !loaded.has(s.slug))\n    .filter((s) => {\n      const paths = s.frontmatter.paths;\n      return paths.length === 0 || pathMatches(paths, opts.touchedPaths);\n    });\n\n  const budget = Math.max(1, Math.floor(opts.contextWindowTokens * opts.budgetPercent));\n\n  const entries: SkillListingEntry[] = [];\n  let used = 0;\n\n  for (const s of orderSkills(visible)) {\n    const fp = isFirstParty(s);\n    const fm = s.frontmatter;\n    const fullDesc = fp ? fm.description : truncate(fm.description, opts.maxListingDescChars);\n\n    if (fp) {\n      const entry: SkillListingEntry = {\n        name: fm.name,\n        description: fm.description,\n        whenToUse: fm.whenToUse,\n        degraded: false,\n        firstParty: true,\n      };\n      entries.push(entry);\n      used += estimateTokens(renderEntry(entry));\n      continue;\n    }\n\n    const full: SkillListingEntry = {\n      name: fm.name,\n      description: fullDesc,\n      whenToUse: fm.whenToUse,\n      degraded: false,\n      firstParty: false,\n    };\n    const fullCost = estimateTokens(renderEntry(full));\n    if (used + fullCost <= budget) {\n      entries.push(full);\n      used += fullCost;\n      continue;\n    }\n\n    const nameOnly: SkillListingEntry = {\n      name: fm.name,\n      description: \"\",\n      whenToUse: undefined,\n      degraded: true,\n      firstParty: false,\n    };\n    const nameCost = estimateTokens(renderEntry(nameOnly));\n    if (used + nameCost <= budget) {\n      entries.push(nameOnly);\n      used += nameCost;\n    }\n    // else: drop entirely.\n  }\n\n  const text = entries.map(renderEntry).join(\"\\n\");\n  return { entries, text };\n}\n\n// ── Phase 2: invocation ──────────────────────────────────────────────────────\n\nexport interface SkillMessage {\n  readonly role: \"system\" | \"user\";\n  readonly content: string;\n}\n\nexport interface ExpandedSkill {\n  readonly messages: readonly SkillMessage[];\n  readonly allowedTools: readonly string[];\n  readonly modelOverride?: string | undefined;\n  readonly effort?: \"low\" | \"medium\" | \"high\" | undefined;\n  readonly executionMode: \"inline\" | \"fork\";\n}\n\nexport interface ExpandContext {\n  readonly tenantId: string;\n  readonly args: Record<string, string>;\n  readonly vars: Record<string, string>;\n  /** Lazy body fetch — host supplies; called only here, only once. */\n  readonly bodyLoader: (bodyRef: string) => Promise<string>;\n  /** Host-injected resource-base indirection (NO host FS access here). */\n  readonly skillResourceBase: (slug: string) => string;\n}\n\n/**\n * Phase 2 — expand a skill into turn messages. Body is loaded lazily via the\n * injected `bodyLoader` (never during listing). A `Base directory…` line is\n * prepended via the injected `skillResourceBase` indirection. Args + vars are\n * substituted with `substituteArguments`. The skill's `allowedTools` are\n * returned for the caller to merge into the permission context — this never\n * mutates global state and never executes anything from the body.\n */\nexport async function expandSkill(skill: SkillRecord, ctx: ExpandContext): Promise<ExpandedSkill> {\n  if (!ctx.tenantId) throw new Error(\"expandSkill: tenantId is required\");\n  if (skill.tenantId !== ctx.tenantId) {\n    throw new Error(\"expandSkill: cross-tenant skill access rejected\");\n  }\n\n  const rawBody = await ctx.bodyLoader(skill.bodyRef);\n  const body = substituteArguments(rawBody, ctx.args, ctx.vars);\n  const baseLine = `Base directory for this skill: ${ctx.skillResourceBase(skill.slug)}`;\n\n  const messages: readonly SkillMessage[] = [\n    { role: \"system\", content: baseLine },\n    { role: \"user\", content: body },\n  ];\n\n  const allowedTools = [...skill.frontmatter.allowedTools];\n\n  return {\n    messages,\n    allowedTools,\n    modelOverride: skill.frontmatter.model,\n    effort: skill.frontmatter.effort,\n    executionMode: skill.frontmatter.executionMode,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-ZTSKS42I.js

@@ -0,0 +1,131 @@
+// src/adapters/dispatcher-sse.ts
+var ERR_PARSE = -32700;
+var JSON_HEADERS = {
+  "content-type": "application/json; charset=utf-8"
+};
+function parseErrorEnvelope(message) {
+  return { jsonrpc: "2.0", id: null, error: { code: ERR_PARSE, message } };
+}
+function jsonResponse(payload, status) {
+  return new Response(JSON.stringify(payload), { status, headers: { ...JSON_HEADERS } });
+}
+function createRpcHandler(dispatcher) {
+  return async (request) => {
+    let raw;
+    try {
+      raw = await request.json();
+    } catch {
+      return jsonResponse(parseErrorEnvelope("Request body is not valid JSON"), 400);
+    }
+    try {
+      const envelope = await dispatcher.dispatch(raw);
+      return jsonResponse(envelope, 200);
+    } catch {
+      return jsonResponse(parseErrorEnvelope("Dispatcher failure"), 400);
+    }
+  };
+}
+function frame(event) {
+  return `event: ${event.type}
+data: ${JSON.stringify(event)}
+
+`;
+}
+function errorFrame(message) {
+  return `event: error
+data: ${JSON.stringify({ type: "error", message })}
+
+`;
+}
+function sseResponse(stream, opts) {
+  const encoder = new TextEncoder();
+  const signal = opts?.signal;
+  const body = new ReadableStream({
+    async start(controller) {
+      const iterator = stream[Symbol.asyncIterator]();
+      const onAbort = () => {
+        void iterator.return?.(void 0);
+      };
+      if (signal) {
+        if (signal.aborted) {
+          await iterator.return?.(void 0);
+          controller.close();
+          return;
+        }
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      try {
+        for (; ; ) {
+          if (signal?.aborted) break;
+          const next = await iterator.next();
+          if (next.done) break;
+          controller.enqueue(encoder.encode(frame(next.value)));
+        }
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Stream error";
+        controller.enqueue(encoder.encode(errorFrame(message)));
+      } finally {
+        signal?.removeEventListener("abort", onAbort);
+        controller.close();
+      }
+    },
+    cancel() {
+      void stream[Symbol.asyncIterator]().return?.(void 0);
+    }
+  });
+  return new Response(body, {
+    status: 200,
+    headers: {
+      "content-type": "text/event-stream; charset=utf-8",
+      "cache-control": "no-cache, no-transform",
+      connection: "keep-alive"
+    }
+  });
+}
+function subscribeNotifications(dispatcher, names) {
+  return {
+    [Symbol.asyncIterator]() {
+      const backlog = [];
+      const waiters = [];
+      let closed = false;
+      const unsubscribers = names.map(
+        (name) => dispatcher.onNotification(name, (payload) => {
+          if (closed) return;
+          const value = { name, payload };
+          const waiter = waiters.shift();
+          if (waiter) waiter({ value, done: false });
+          else backlog.push(value);
+        })
+      );
+      const teardown = () => {
+        if (closed) return;
+        closed = true;
+        for (const off of unsubscribers) off();
+        let waiter = waiters.shift();
+        while (waiter) {
+          waiter({ value: void 0, done: true });
+          waiter = waiters.shift();
+        }
+      };
+      return {
+        next() {
+          const buffered = backlog.shift();
+          if (buffered) return Promise.resolve({ value: buffered, done: false });
+          if (closed) return Promise.resolve({ value: void 0, done: true });
+          return new Promise((resolve) => waiters.push(resolve));
+        },
+        return() {
+          teardown();
+          return Promise.resolve({ value: void 0, done: true });
+        }
+      };
+    }
+  };
+}
+
+export {
+  createRpcHandler,
+  sseResponse,
+  subscribeNotifications
+};
+//# sourceMappingURL=chunk-ZTSKS42I.js.map