charness 0.0.0-stage → 3.0.0

package/dist/scheduler/mcpBoot.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startSchedulerMcpForBoot = startSchedulerMcpForBoot;
+exports.runSessionBootPhase = runSessionBootPhase;
+const injection_1 = require("./injection");
+const mcpSurface_1 = require("./mcpSurface");
+/**
+ * @description Bind the bot MCP server and configure injection toward the bound
+ * port. Resolves `true` when the server is up. A bind failure (port busy) is
+ * logged and resolves `false`: the bot still boots and injection stays inert,
+ * so sessions spawned this run get no bot tools — a Claude one keeps lacking
+ * them after a later restart too (its process is adopted, and the heal never
+ * adds an absent server). Persisting the port is best-effort: it only serves the
+ * NEXT boot, so a failed write is logged and the bound server is still used.
+ */
+async function startSchedulerMcpForBoot(deps) {
+    try {
+        await deps.handle.start();
+    }
+    catch (e) {
+        console.error('[scheduler] MCP server failed to start; scheduling tools unavailable this run:', e instanceof Error ? e.message : e);
+        return false;
+    }
+    const boundPort = deps.handle.port;
+    // Persist the actually-bound port so the next boot reuses it (registrations
+    // stay valid). Skip when the operator fixed the port via env (nothing to
+    // reuse) or when it is unchanged (avoid a needless flush).
+    if (deps.envPort === mcpSurface_1.defaultSchedulerMcpPort && deps.getPersistedPort() !== boundPort) {
+        try {
+            await deps.persistPort(boundPort);
+        }
+        catch (e) {
+            console.warn(`[scheduler] could not persist MCP port ${boundPort}; the next boot binds a fresh one:`, e instanceof Error ? e.message : e);
+        }
+    }
+    (0, injection_1.configureSchedulerMcpInjection)({ getSecret: deps.getSecret, port: boundPort });
+    console.log(`[scheduler] MCP server listening on 127.0.0.1:${boundPort}`);
+    return true;
+}
+/**
+ * @description Run the session phase of the boot in the order the module header
+ * explains. Resolves whether the bot MCP server started, for the shutdown path.
+ */
+async function runSessionBootPhase(steps) {
+    const isBotMcpStarted = await steps.startBotMcp();
+    await steps.reattachSessions();
+    steps.restoreAfterReattach();
+    steps.onSessionsRestored();
+    if (isBotMcpStarted) {
+        try {
+            steps.healActiveSessions();
+        }
+        catch (e) {
+            console.warn('[scheduler] MCP heal of active sessions failed:', e instanceof Error ? e.message : e);
+        }
+    }
+    await steps.rearmSchedules();
+    return isBotMcpStarted;
+}
+//# sourceMappingURL=mcpBoot.js.map

package/dist/scheduler/mcpBoot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpBoot.js","sourceRoot":"","sources":["../../src/scheduler/mcpBoot.ts"],"names":[],"mappings":";;AA4CA,4DA2BC;AAyBD,kDAcC;AA9GD,2CAA6D;AAC7D,6CAAgF;AAkChF;;;;;;;;GAQG;AACI,KAAK,UAAU,wBAAwB,CAAC,IAA0B;IACvE,IAAI,CAAC;QACH,MAAM,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;IAC5B,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,CAAC,KAAK,CACX,gFAAgF,EAChF,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CACnC,CAAC;QACF,OAAO,KAAK,CAAC;IACf,CAAC;IACD,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;IACnC,4EAA4E;IAC5E,yEAAyE;IACzE,2DAA2D;IAC3D,IAAI,IAAI,CAAC,OAAO,KAAK,oCAAuB,IAAI,IAAI,CAAC,gBAAgB,EAAE,KAAK,SAAS,EAAE,CAAC;QACtF,IAAI,CAAC;YACH,MAAM,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;QACpC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CACV,0CAA0C,SAAS,oCAAoC,EACvF,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CACnC,CAAC;QACJ,CAAC;IACH,CAAC;IACD,IAAA,0CAA8B,EAAC,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;IAC/E,OAAO,CAAC,GAAG,CAAC,iDAAiD,SAAS,EAAE,CAAC,CAAC;IAC1E,OAAO,IAAI,CAAC;AACd,CAAC;AAqBD;;;GAGG;AACI,KAAK,UAAU,mBAAmB,CAAC,KAA4B;IACpE,MAAM,eAAe,GAAG,MAAM,KAAK,CAAC,WAAW,EAAE,CAAC;IAClD,MAAM,KAAK,CAAC,gBAAgB,EAAE,CAAC;IAC/B,KAAK,CAAC,oBAAoB,EAAE,CAAC;IAC7B,KAAK,CAAC,kBAAkB,EAAE,CAAC;IAC3B,IAAI,eAAe,EAAE,CAAC;QACpB,IAAI,CAAC;YACH,KAAK,CAAC,kBAAkB,EAAE,CAAC;QAC7B,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,IAAI,CAAC,iDAAiD,EAAE,CAAC,YAAY,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACtG,CAAC;IACH,CAAC;IACD,MAAM,KAAK,CAAC,cAAc,EAAE,CAAC;IAC7B,OAAO,eAAe,CAAC;AACzB,CAAC"}

package/dist/scheduler/mcpSurface.d.ts

@@ -0,0 +1,355 @@
+import { type RequestId } from '@modelcontextprotocol/sdk/types.js';
+import type { StateStore } from '../state';
+import { type PlatformId } from '../sessionKey';
+import type { SendFilesToThread } from '../utils/fileSendService';
+import { type SendMessagesToThread } from '../utils/messageSendService';
+import type { ScheduleRecord, ScheduleSpec } from './types';
+import { type AnswerRequestArgs, type AnswerRequestOutcome } from '../requests/answerRequest';
+/**
+ * @description The bot-owned MCP server exposes the agent-facing tools —
+ * `schedule_create`, `schedule_list`, `schedule_cancel`, `send_file_to_user`,
+ * `send_messages_to_user`, `compact_conversation` and `answer_request` — over
+ * streamable HTTP on a loopback port. The server is
+ * INERT until `bot.ts` wires {@link createSchedulerMcpServer}; this module
+ * imports nothing from `bot.ts` (every side effect is injected via
+ * {@link SchedulerMcpDeps}).
+ *
+ * Transport: STATELESS streamable HTTP (`sessionIdGenerator: undefined`) — a
+ * research-locked choice (plan S5) that dodges the SDK's session-loss bugs and
+ * suits a single local host. The SDK binds one `McpServer` to one transport per
+ * connection, so every request builds a FRESH `McpServer` + transport (see
+ * {@link buildRequestServer}) that registers the same handlers, and they
+ * are closed when the response finishes. MCP cancellation arrives as a separate
+ * HTTP notification, so {@link createSchedulerMcpServer} keeps only the active
+ * request abort controllers plus one bounded, expiring lifecycle-tombstone cache
+ * across those otherwise-stateless transports. A pending-cancellation tombstone
+ * handles a cancellation that genuinely leads first registration; a
+ * recently-completed tombstone suppresses an unmatched late cancellation only
+ * while that key is inactive. An active request always takes precedence so its
+ * own legitimate cancellation can abort it even after typed JSON-RPC id reuse.
+ *
+ * Auth/scoping: a request carries `Authorization: Bearer <token>`. The token is
+ * self-describing — `<scopeB64url>.<hmacHex>` — so the bot need not know every
+ * valid scope up front (an OpenCode directory scope is any bound folder). The
+ * scope rides in cleartext (base64url) next to an HMAC-SHA256 signature over the
+ * decoded scope string; {@link verifySchedulerMcpToken} recomputes the HMAC and
+ * compares it timing-safely. A scope is one of:
+ *   - `thread:<threadKey>` — a Claude session, pinned to its exact thread.
+ *   - `dir:<directory>`    — an OpenCode instance, granular to a bound folder.
+ * Every tool call resolves a single target thread from the scope (see
+ * {@link resolveTargetThreadKey}) and can only touch that thread's jobs —
+ * except `answer_request`, whose request id already names the conversation: it
+ * only checks that conversation is inside the scope
+ * ({@link checkIsConversationInScope}).
+ */
+/**
+ * Default loopback port for the scheduler MCP server. Zero asks the OS for a
+ * free ephemeral port, so independent bot instances never compete for 4097.
+ */
+export declare const defaultSchedulerMcpPort = 0;
+/** HTTP path the streamable transport is served on (matches the injected `--mcp-config` url, S6). */
+export declare const schedulerMcpPath = "/mcp";
+/** Per-registration identity used to isolate equal JSON-RPC request IDs. */
+export declare const schedulerMcpClientIdHeader = "x-telegramcode-mcp-client-id";
+/**
+ * A port that is in use at the start is retried this many times, this far apart,
+ * before the bot binds another one. Another port orphans every Claude session
+ * launched before (it keeps the MCP address of its launch), and the holder may
+ * let go soon: the previous process still exiting, or a short connection of
+ * another process that was handed the port as its local one while the bot was
+ * down. Together they span the shutdown watchdog's bound (`DEFAULT_WATCHDOG_MS`),
+ * the longest the previous generation can take to exit.
+ */
+export declare const schedulerMcpBindRetryCount = 20;
+export declare const schedulerMcpBindRetryDelayMs = 500;
+/** Pending cancellations and recent completions remain correlatable for this window. */
+export declare const schedulerMcpPendingCancellationTtlMs = 30000;
+/** Global memory bound shared by pending-cancellation and recent-completion tombstones. */
+export declare const schedulerMcpPendingCancellationMax = 1000;
+/**
+ * Connect-time `instructions` returned in the MCP `initialize` handshake — a
+ * short, high-level pointer the client surfaces to the agent BEFORE any call.
+ * Deliberately use-case oriented (when to reach for this server, what it can do)
+ * and does NOT repeat the per-tool argument recipes: each tool's own description
+ * already carries those in full. Kept terse on purpose.
+ *
+ * @description The connect-time instructions for a session of `platform`: only
+ * a Telegram session has the scheduling and send-to-topic tools, so only its
+ * instructions name them (Jira connector plan J2, D18).
+ */
+export declare function buildMcpServerInstructions(platform: PlatformId | null, isJiraAttachmentToolOffered?: boolean): string;
+/**
+ * @name SchedulerScope
+ * @description The authorisation scope a token grants. `thread` pins to one exact
+ * thread (Claude); `dir` grants the whole bound directory (OpenCode), where a
+ * single bound thread is implicit and >1 forces an explicit `threadKey` arg.
+ */
+export type SchedulerScope = {
+    kind: 'thread';
+    threadKey: string;
+} | {
+    kind: 'dir';
+    directory: string;
+};
+/** Read the configured scheduler MCP port once, mirroring the OPENCODE_URL env read. */
+export declare function getSchedulerMcpPort(): number;
+/**
+ * @description Resolve the scheduler MCP listen port with a fixed precedence:
+ * an explicit env port (`SCHEDULER_MCP_PORT`, a non-zero {@link getSchedulerMcpPort})
+ * WINS; else the port persisted from a prior boot (so an ephemeral port, once
+ * chosen, is reused — the registrations injected into agent sessions point at
+ * it, and an ephemeral port changing every restart would orphan them); else `0`
+ * (ask the OS for a fresh ephemeral port). A persisted `0` / non-positive value
+ * is ignored (nothing worth reusing).
+ */
+export declare function resolveSchedulerMcpPort(envPort: number, persistedPort: number | undefined): number;
+/**
+ * @description The platform of the conversations a scope reaches. A `dir:`
+ * scope is an OpenCode registration, which only Telegram topics use today. A
+ * thread key no codec reads gets the narrower, platform-neutral tool set.
+ */
+export declare function getSchedulerScopePlatform(scope: SchedulerScope): PlatformId | null;
+/** Serialise a scope to its canonical cleartext form (the string the HMAC signs). */
+export declare function serializeSchedulerScope(scope: SchedulerScope): string;
+/** Parse the canonical cleartext scope string back into a {@link SchedulerScope}, or `null`. */
+export declare function parseSchedulerScope(serialized: string): SchedulerScope | null;
+/**
+ * @description Mint a bearer token for a scope: `<scopeB64url>.<hmacHex>`. The
+ * scope rides in cleartext (base64url of the canonical scope string) so the
+ * verifier can recover it without a lookup table; the HMAC over the DECODED
+ * scope string is the unforgeable part. Document/keep in sync with
+ * {@link verifySchedulerMcpToken}.
+ */
+export declare function buildSchedulerMcpToken(secret: string, scope: SchedulerScope): string;
+/**
+ * @description Verify a bearer token and recover its scope. Splits on the single
+ * `.`, base64url-decodes the scope half, recomputes the HMAC over the decoded
+ * scope string, and compares it to the token's signature with a constant-time
+ * {@link timingSafeEqual} (equal-length hex buffers). Returns the parsed scope on
+ * success, or `null` for any malformed / tampered token. A tampered scope half
+ * changes the HMAC input so the recomputed signature won't match; a tampered
+ * signature half fails the compare directly.
+ */
+export declare function verifySchedulerMcpToken(secret: string, token: string): SchedulerScope | null;
+/** Pull the bearer token out of an `Authorization` header value, or `null`. */
+export declare function extractBearerToken(authorizationHeader: string | undefined): string | null;
+/**
+ * @name SchedulerMcpDeps
+ * @description Everything the MCP server needs from the outside, injected so the
+ * module stays free of `bot.ts` imports. `store` is the real {@link StateStore}
+ * (schedule getters + the create path live on it / its store helper); `armJob`
+ * and `disarmJob` are the engine's timer controls; `getThreadsForDirectory`
+ * resolves a `dir` scope to the threads bound to that folder; `getThreadAdapterName`
+ * snapshots the adapter to start after a rebind; `getSecret` returns the persisted
+ * HMAC secret; `port` overrides the env-derived listen port (tests pass `0`).
+ */
+export interface SchedulerMcpDeps {
+    store: StateStore;
+    armJob: (record: ScheduleRecord) => void;
+    disarmJob: (jobId: string) => void;
+    /** Thread keys bound to a directory (OpenCode instance), serialised strings. */
+    getThreadsForDirectory: (directory: string) => string[];
+    /** Last-used adapter name for a thread, for the `lastAdapterName` snapshot. */
+    getThreadAdapterName: (threadKey: string) => string | undefined;
+    /**
+     * Send 1..10 files/images from the thread's bound folder back into the topic.
+     * Path-safety, type classification, and the album/size decision live in the
+     * reusable `fileSendService`; this surface only routes the resolved thread +
+     * args and relays the `{ ok }` summary/error to the agent.
+     */
+    sendFilesToThread: SendFilesToThread;
+    /**
+     * Deliver a batch of DISCRETE messages into the thread's topic — each string
+     * becomes its OWN Telegram message (never merged), for cases where the agent
+     * wants several separate messages (e.g. a per-item news digest). The paced
+     * send + `/clear` tracking live in the injected `bot.ts` closure; this surface
+     * only routes the resolved thread + messages and relays the `{ ok }` summary.
+     */
+    sendMessagesToThread: SendMessagesToThread;
+    /**
+     * Arm an agent-triggered compaction for the resolved thread (F1). The bot
+     * compacts the session's context once the CURRENT turn finishes (it never
+     * compacts mid-turn). Returns a short status the tool relays to the agent —
+     * `ok:false` when there is no active agent session to compact.
+     */
+    compactConversation: (threadKey: string) => {
+        ok: boolean;
+        message: string;
+    };
+    /**
+     * `jira_get_attachment`: download one attachment of the Jira issue the conversation `threadKey` names (Jira
+     * prompt context C10). Supplied by the Jira connector, which stays lazily loaded; absent on an instance
+     * without it, and then the tool is not offered.
+     */
+    fetchJiraAttachment?: (threadKey: string, attachmentId: string) => Promise<{
+        ok: true;
+        message: string;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    /**
+     * Deliver an agent's answer to a request and apply the close rules
+     * (`answer_request`). The surface passes the scope check in; the rules live in
+     * `requests/answerRequest.ts`.
+     */
+    answerRequest: (args: AnswerRequestArgs) => Promise<AnswerRequestOutcome>;
+    /**
+     * Resolves once the boot has re-attached the surviving sessions and rebuilt
+     * their per-thread state. The server serves BEFORE that (so a session spawned
+     * at boot is born with it), and a tool that reads session state awaits this
+     * first — otherwise a surviving session calling it in that window would be
+     * told it has no active session.
+     */
+    whenSessionsRestored: () => Promise<void>;
+    getSecret: () => Promise<string>;
+    /** Listen port; defaults to {@link getSchedulerMcpPort}. Tests pass `0` for ephemeral. */
+    port?: number;
+    /** How a `port` in use is waited out before falling back; defaults to {@link schedulerMcpBindRetryCount} × {@link schedulerMcpBindRetryDelayMs}. */
+    portBindRetry?: {
+        count: number;
+        delayMs: number;
+    };
+}
+/**
+ * @name SchedulerMcpHandle
+ * @description The running server's control surface. `port` is the actually-bound
+ * port (resolved after `start`, important when the caller passed `0`).
+ */
+export interface SchedulerMcpHandle {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    /** The bound port, available after `start` resolves. */
+    readonly port: number;
+    /** The digest of the tool definitions a session of `platform` connects to (see {@link getBotMcpToolDigest}). */
+    getToolDigest(platform: PlatformId | null): string;
+}
+/** The parts of a tool definition an MCP client sees — what {@link getBotMcpToolDigest} hashes. */
+export interface BotMcpToolDefinition {
+    name: string;
+    title: string | undefined;
+    description: string | undefined;
+    /** The input schema's top-level parameter names, sorted. */
+    inputKeys: string[];
+}
+/**
+ * @description Hash what a client caches when it connects — the server
+ * instructions and the tool definitions it would list — into a stable id of
+ * "what this bot build offers a session of one platform". Lifecycle plan L4:
+ * persisted when a json-stream process starts and compared when the process is
+ * adopted after a bot restart, since the stateless server cannot tell a running
+ * client that any of it changed.
+ */
+export declare function buildBotMcpToolDigest(instructions: string, definitions: readonly BotMcpToolDefinition[]): string;
+/**
+ * @description The digest of the tools a session of `platform` gets — built by
+ * the SAME registration the request path runs, recorded instead of served, so
+ * a tool added, renamed, re-described or re-shaped changes it and nothing else
+ * has to be kept in step by hand.
+ */
+export declare function getBotMcpToolDigest(deps: SchedulerMcpDeps, platform: PlatformId | null): string;
+/**
+ * @name ResolveThreadResult
+ * @description Outcome of mapping a scope (+ optional `threadKey` arg) to a single
+ * target thread. `error` carries a readable message surfaced as an MCP tool error.
+ */
+type ResolveThreadResult = {
+    ok: true;
+    threadKey: string;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * @description Resolve the single thread a tool call targets, from its scope and
+ * an optional caller-supplied `threadKey`:
+ *  - `thread` scope → that exact thread; a supplied `threadKey` must match it.
+ *  - `dir` scope → the threads bound to the directory: exactly 1 → implicit;
+ *    >1 → `threadKey` REQUIRED and must be one of them; 0 → error.
+ * Pure given the injected `getThreadsForDirectory`.
+ */
+export declare function resolveTargetThreadKey(scope: SchedulerScope, suppliedThreadKey: string | undefined, getThreadsForDirectory: (directory: string) => string[]): ResolveThreadResult;
+/**
+ * @name BuildSpecResult
+ * @description Outcome of turning the create-tool args into a {@link ScheduleSpec}.
+ * `note` carries a non-fatal advisory surfaced alongside a successful create
+ * (e.g. a `repeatCount` ignored on a one-shot). `error` is a readable validation
+ * message (exactly-one-of, bad cron / past one-shot) surfaced as an MCP tool error.
+ */
+type BuildSpecResult = {
+    ok: true;
+    spec: ScheduleSpec;
+    note?: string;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * @description Validate the create args and build a {@link ScheduleSpec}: exactly
+ * one of `cron`/`onceAt` (empty/whitespace fields normalised away first); then run
+ * the shared {@link validateScheduleSpec} (cron parse + min-interval + past-one-shot).
+ * `nowMs` is injected so the past-one-shot check is deterministic.
+ *
+ * A `repeatCount` supplied alongside `onceAt` is IGNORED (not rejected): a one-shot
+ * is by definition a single run, so the count is meaningless there. The model
+ * naturally reaches for `repeatCount: 1` to express "run once" and, when that was
+ * a hard error, spiralled into absurd counts / a wrong-year cron workaround
+ * (live transcript). Accepting the natural call removes that failure mode; the
+ * returned `note` teaches the agent the field was redundant.
+ */
+export declare function buildSpecFromCreateArgs(args: {
+    cron?: string;
+    onceAt?: string;
+    repeatCount?: number;
+}, nowMs: number): BuildSpecResult;
+/**
+ * @description Whether a token's scope covers a conversation (serialized key): a
+ * `thread:` token covers exactly its thread, a `dir:` token every thread bound to
+ * its directory. Unlike {@link resolveTargetThreadKey} it never picks a target —
+ * the request id already names the conversation, this only checks the caller may
+ * act on it.
+ */
+export declare function checkIsConversationInScope(scope: SchedulerScope, conversationKey: string, getThreadsForDirectory: (directory: string) => string[]): boolean;
+interface SchedulerMcpRegisteredRequest {
+    controller: AbortController;
+    markTerminal: () => void;
+    unregister: () => void;
+}
+interface SchedulerMcpCancellationLifecycle {
+    registerRequest: (clientIdentity: string, requestId: RequestId) => SchedulerMcpRegisteredRequest;
+    cancelRequest: (clientIdentity: string, requestId: RequestId, reason: string | undefined) => void;
+}
+/** Deterministic seams for lifecycle-cache expiry and bound verification. */
+export interface SchedulerMcpCancellationLifecycleOptions {
+    getNowMs?: () => number;
+    maxTombstones?: number;
+}
+/**
+ * @description Correlate stateless MCP requests with cancellation notifications.
+ * Active controllers are isolated by verified token + validated client identity
+ * + typed JSON-RPC id. One bounded TTL cache stores mutually-exclusive terminal
+ * states for inactive keys:
+ *
+ * - `pendingCancellation` aborts the first matching registration, then is consumed.
+ * - `recentlyCompleted` ignores only an unmatched late cancellation while no
+ *   matching request is active, preventing it from becoming pending poison.
+ *
+ * Active controllers always take precedence over tombstones because generations
+ * that reuse one client identity and request id are otherwise indistinguishable.
+ *
+ * The clock and cache limit are injectable only at construction so expiry and
+ * oldest-entry eviction stay deterministic in tests; production uses the fixed
+ * exported defaults.
+ */
+export declare function createSchedulerMcpCancellationLifecycle(options?: SchedulerMcpCancellationLifecycleOptions): SchedulerMcpCancellationLifecycle;
+/**
+ * @description Create the bot-owned scheduler MCP server. Returns a handle with
+ * `start`/`stop` and the bound `port`. The HTTP listener is plain `node:http`
+ * (no web framework) on `127.0.0.1`; each request verifies the bearer token,
+ * builds a fresh stateless transport + `McpServer`, and tears them down when the
+ * response finishes. Invalid/missing tokens get a JSON-RPC 401 without touching
+ * any tool.
+ */
+export declare function createSchedulerMcpServer(deps: SchedulerMcpDeps): SchedulerMcpHandle;
+export {};
+//# sourceMappingURL=mcpSurface.d.ts.map

package/dist/scheduler/mcpSurface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpSurface.d.ts","sourceRoot":"","sources":["../../src/scheduler/mcpSurface.ts"],"names":[],"mappings":"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"}