hcifootprint 0.2.0

package/dist/presence/presence.js

@@ -0,0 +1,126 @@
+/**
+ * PresenceIndex — the pure presence sensor (D18).
+ *
+ * Registration observes MOUNTED, nothing more. This index is deliberately a
+ * plain refcounted data structure that knows nothing about sessions, trees,
+ * routers, or footprint — the meaning of presence (dormancy below the router,
+ * overlay masking, tab exclusivity, assumed-active defaults) lives one layer
+ * up in NavSession, which COMPOSES this with the authored tree.
+ *
+ * Contract points that make React StrictMode/HMR safe by construction:
+ * - Handles are identities: open() returns a token, close(token) is
+ *   idempotent per token. setup→cleanup→setup nets to one open handle.
+ * - Instance handles (repeats containers) are tracked separately and are
+ *   EXCLUDED from the fingerprint — a scrolling virtualized list must never
+ *   look like world motion (that scoping rule is enforced here, at the
+ *   lowest layer that can).
+ * - Visibility is an EXPLICIT signal store (set by show()/setVisible()/the
+ *   `visible:` mount option). No amount of mount-counting can see CSS; when
+ *   no signal exists the layer above serves honesty markers instead of
+ *   guessing.
+ */
+export class PresenceIndex {
+    #nextToken = 1;
+    /** token → what it holds open. */
+    #open = new Map();
+    /** node → count of open NODE handles (instance handles excluded). */
+    #nodeCounts = new Map();
+    /** node → instance key → count of open instance handles. */
+    #instanceCounts = new Map();
+    /** node → last explicit visibility signal. */
+    #visibility = new Map();
+    open(node, instance) {
+        const token = this.#nextToken++;
+        this.#open.set(token, { node, instance });
+        if (instance === undefined) {
+            this.#nodeCounts.set(node, (this.#nodeCounts.get(node) ?? 0) + 1);
+        }
+        else {
+            const byInstance = this.#instanceCounts.get(node) ?? new Map();
+            byInstance.set(instance, (byInstance.get(instance) ?? 0) + 1);
+            this.#instanceCounts.set(node, byInstance);
+        }
+        const index = this;
+        return {
+            node,
+            instance,
+            release() {
+                index.#release(token);
+            },
+        };
+    }
+    #release(token) {
+        const held = this.#open.get(token);
+        if (!held)
+            return; // idempotent per handle
+        this.#open.delete(token);
+        if (held.instance === undefined) {
+            const next = (this.#nodeCounts.get(held.node) ?? 1) - 1;
+            if (next <= 0) {
+                this.#nodeCounts.delete(held.node);
+                // A visibility signal describes a mounted thing. When the last handle
+                // leaves, the signal leaves with it — otherwise a released modal whose
+                // app once said visible:true would mask its page FOREVER (ghost mask).
+                // Signals set on never-mounted nodes (the pure-L0 wire) are untouched.
+                this.#visibility.delete(held.node);
+            }
+            else {
+                this.#nodeCounts.set(held.node, next);
+            }
+        }
+        else {
+            const byInstance = this.#instanceCounts.get(held.node);
+            if (!byInstance)
+                return;
+            const next = (byInstance.get(held.instance) ?? 1) - 1;
+            if (next <= 0)
+                byInstance.delete(held.instance);
+            else
+                byInstance.set(held.instance, next);
+            if (byInstance.size === 0)
+                this.#instanceCounts.delete(held.node);
+        }
+    }
+    /** A node is present when at least one NODE handle is open on it. */
+    isPresent(node) {
+        return (this.#nodeCounts.get(node) ?? 0) > 0;
+    }
+    presentNodes() {
+        return [...this.#nodeCounts.keys()];
+    }
+    /** Mounted instance keys of a repeats node (the mounted WINDOW, not existence). */
+    instancesOf(node) {
+        return [...(this.#instanceCounts.get(node)?.keys() ?? [])];
+    }
+    hasInstance(node, instance) {
+        return (this.#instanceCounts.get(node)?.get(instance) ?? 0) > 0;
+    }
+    /** True when ANY node handle is open — the signal that presence is in use at all. */
+    hasAnyHandles() {
+        return this.#nodeCounts.size > 0;
+    }
+    /** True when ANY handle (node OR instance) is open — "the mount layer is in use". */
+    hasAny() {
+        return this.#open.size > 0;
+    }
+    setVisible(node, visible) {
+        this.#visibility.set(node, visible);
+    }
+    /** The explicit signal, or undefined when none was ever given (→ honesty markers above). */
+    visibility(node) {
+        return this.#visibility.get(node);
+    }
+    /**
+     * The served-structure identity used for coalesced world-motion detection:
+     * node presence + visibility signals. Instance churn is EXCLUDED by design.
+     */
+    fingerprint() {
+        const nodes = [...this.#nodeCounts.keys()].sort().join('|');
+        const vis = [...this.#visibility.entries()]
+            .map(([node, visible]) => `${node}=${visible ? 1 : 0}`)
+            .sort()
+            .join('|');
+        return `${nodes}::${vis}`;
+    }
+}
+//# sourceMappingURL=presence.js.map

package/dist/presence/presence.js.map

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

package/dist/registry/registry.d.ts

@@ -0,0 +1,53 @@
+/**
+ * ToolRegistry — the LIVE-BINDING layer (D13: declare statically, bind dynamically).
+ *
+ * The declared graph is the map; this registry is what's actually wired right
+ * now: affordanceId → the app's real handler function, registered in GROUPS
+ * (one per component/section) so unmount cleanup is a single call.
+ *
+ * Deliberately knows nothing about sessions, guards, or footprint — a plain
+ * data structure so this layer tests in isolation.
+ *
+ * Semantics:
+ * - Last registration wins per affordance (React StrictMode double-mounts;
+ *   a dev warning fires so real duplicates are visible).
+ * - unregisterGroup(g) removes only registrations whose CURRENT owner is g —
+ *   if group B re-registered an id after group A, A's unmount cannot tear
+ *   down B's live binding.
+ * - Registration carries NO planner-facing strings (descriptions/guards live
+ *   in the declared spec — the prompt-injection firewall).
+ */
+export type ToolHandler = (payload?: unknown) => unknown | Promise<unknown>;
+export interface Registration {
+    affordanceId: string;
+    group: string;
+    handler: ToolHandler;
+    registeredAt: number;
+    /**
+     * False when the control is on screen but not currently clickable (a greyed
+     * button). The tool is still SERVED to the agent — with an honesty marker —
+     * but firing it is refused as TOOL_DISABLED. Default true.
+     */
+    enabled: boolean;
+}
+export declare class ToolRegistry {
+    #private;
+    constructor(warn?: (message: string) => void);
+    register(group: string, affordanceId: string, handler: ToolHandler, enabled?: boolean): void;
+    /**
+     * Flip a registered tool between clickable and greyed-out. Returns true if
+     * the state actually changed (so the caller can bump the version / emit only
+     * on a real change). No-op + false if the id isn't registered.
+     */
+    setEnabled(affordanceId: string, enabled: boolean): boolean;
+    /** Whether a registered tool is currently clickable. Undefined if not registered. */
+    isEnabled(affordanceId: string): boolean | undefined;
+    /** Remove every registration currently owned by `group`. Returns the removed ids. */
+    unregisterGroup(group: string): string[];
+    handlerFor(affordanceId: string): ToolHandler | undefined;
+    isRegistered(affordanceId: string): boolean;
+    /** True when anything is registered — the signal that materialization is meaningful. */
+    hasAny(): boolean;
+    registrations(): Registration[];
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/registry/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,CAAC,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAE5E,MAAM,WAAW,YAAY;IAC3B,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,WAAW,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,qBAAa,YAAY;;gBAIX,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IAI5C,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,OAAO,UAAO,GAAG,IAAI;IAYzF;;;;OAIG;IACH,UAAU,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO;IAO3D,qFAAqF;IACrF,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAIpD,qFAAqF;IACrF,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE;IAWxC,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS;IAIzD,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAI3C,wFAAwF;IACxF,MAAM,IAAI,OAAO;IAIjB,aAAa,IAAI,YAAY,EAAE;CAGhC"}

package/dist/registry/registry.js

@@ -0,0 +1,76 @@
+/**
+ * ToolRegistry — the LIVE-BINDING layer (D13: declare statically, bind dynamically).
+ *
+ * The declared graph is the map; this registry is what's actually wired right
+ * now: affordanceId → the app's real handler function, registered in GROUPS
+ * (one per component/section) so unmount cleanup is a single call.
+ *
+ * Deliberately knows nothing about sessions, guards, or footprint — a plain
+ * data structure so this layer tests in isolation.
+ *
+ * Semantics:
+ * - Last registration wins per affordance (React StrictMode double-mounts;
+ *   a dev warning fires so real duplicates are visible).
+ * - unregisterGroup(g) removes only registrations whose CURRENT owner is g —
+ *   if group B re-registered an id after group A, A's unmount cannot tear
+ *   down B's live binding.
+ * - Registration carries NO planner-facing strings (descriptions/guards live
+ *   in the declared spec — the prompt-injection firewall).
+ */
+export class ToolRegistry {
+    #byAffordance = new Map();
+    #warn;
+    constructor(warn) {
+        this.#warn = warn ?? ((message) => console.warn(message));
+    }
+    register(group, affordanceId, handler, enabled = true) {
+        const existing = this.#byAffordance.get(affordanceId);
+        if (existing) {
+            this.#warn(`hcifootprint: '${affordanceId}' re-registered by group '${group}' (previously '${existing.group}') — ` +
+                `last registration wins. Common causes: a component mounted twice without unregistering, or two ` +
+                `components claiming the same action.`);
+        }
+        this.#byAffordance.set(affordanceId, { affordanceId, group, handler, registeredAt: Date.now(), enabled });
+    }
+    /**
+     * Flip a registered tool between clickable and greyed-out. Returns true if
+     * the state actually changed (so the caller can bump the version / emit only
+     * on a real change). No-op + false if the id isn't registered.
+     */
+    setEnabled(affordanceId, enabled) {
+        const reg = this.#byAffordance.get(affordanceId);
+        if (!reg || reg.enabled === enabled)
+            return false;
+        reg.enabled = enabled;
+        return true;
+    }
+    /** Whether a registered tool is currently clickable. Undefined if not registered. */
+    isEnabled(affordanceId) {
+        return this.#byAffordance.get(affordanceId)?.enabled;
+    }
+    /** Remove every registration currently owned by `group`. Returns the removed ids. */
+    unregisterGroup(group) {
+        const removed = [];
+        for (const [id, reg] of this.#byAffordance) {
+            if (reg.group === group) {
+                this.#byAffordance.delete(id);
+                removed.push(id);
+            }
+        }
+        return removed;
+    }
+    handlerFor(affordanceId) {
+        return this.#byAffordance.get(affordanceId)?.handler;
+    }
+    isRegistered(affordanceId) {
+        return this.#byAffordance.has(affordanceId);
+    }
+    /** True when anything is registered — the signal that materialization is meaningful. */
+    hasAny() {
+        return this.#byAffordance.size > 0;
+    }
+    registrations() {
+        return [...this.#byAffordance.values()].map((r) => ({ ...r }));
+    }
+}
+//# sourceMappingURL=registry.js.map

package/dist/registry/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","sourceRoot":"","sources":["../../src/registry/registry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAiBH,MAAM,OAAO,YAAY;IACd,aAAa,GAAG,IAAI,GAAG,EAAwB,CAAC;IAChD,KAAK,CAA4B;IAE1C,YAAY,IAAgC;QAC1C,IAAI,CAAC,KAAK,GAAG,IAAI,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;IAC5D,CAAC;IAED,QAAQ,CAAC,KAAa,EAAE,YAAoB,EAAE,OAAoB,EAAE,OAAO,GAAG,IAAI;QAChF,MAAM,QAAQ,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QACtD,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,CAAC,KAAK,CACR,kBAAkB,YAAY,6BAA6B,KAAK,kBAAkB,QAAQ,CAAC,KAAK,OAAO;gBACrG,iGAAiG;gBACjG,sCAAsC,CACzC,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;IAC5G,CAAC;IAED;;;;OAIG;IACH,UAAU,CAAC,YAAoB,EAAE,OAAgB;QAC/C,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;QACjD,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,OAAO,KAAK,OAAO;YAAE,OAAO,KAAK,CAAC;QAClD,GAAG,CAAC,OAAO,GAAG,OAAO,CAAC;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,qFAAqF;IACrF,SAAS,CAAC,YAAoB;QAC5B,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvD,CAAC;IAED,qFAAqF;IACrF,eAAe,CAAC,KAAa;QAC3B,MAAM,OAAO,GAAa,EAAE,CAAC;QAC7B,KAAK,MAAM,CAAC,EAAE,EAAE,GAAG,CAAC,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YAC3C,IAAI,GAAG,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;gBACxB,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAC9B,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACnB,CAAC;QACH,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,UAAU,CAAC,YAAoB;QAC7B,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvD,CAAC;IAED,YAAY,CAAC,YAAoB;QAC/B,OAAO,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAC9C,CAAC;IAED,wFAAwF;IACxF,MAAM;QACJ,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,GAAG,CAAC,CAAC;IACrC,CAAC;IAED,aAAa;QACX,OAAO,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC,CAAC;IACjE,CAAC;CACF"}

package/dist/serve/mcp-server.d.ts

@@ -0,0 +1,40 @@
+/**
+ * mcpServer(session) — expose the session as a real MODEL CONTEXT PROTOCOL
+ * server, so ANY MCP host (Claude Desktop, a LangGraph MCP client, Cursor, …)
+ * can drive your app without a line of framework-specific glue.
+ *
+ * It wraps {@link skillsAsTools} (Mode B): `tools/list` returns the FIXED tool
+ * array (one per skill + whats_here / do_action / why), and `tools/call` routes to
+ * the port. Because the tool set never changes, a plain MCP server works with
+ * no `tools/list_changed` churn — that is the whole point of the fixed-tool
+ * design. High-effect steps come back as `judgment: 'needs-confirm'` in the
+ * result; the HOST decides how to get human approval, then calls again with
+ * `confirm: true` — a portable, framework-agnostic human-in-the-loop.
+ *
+ * This module lives behind the `hcifootprint/mcp` subpath and is the ONLY
+ * place `@modelcontextprotocol/sdk` (an OPTIONAL peer dependency) is imported —
+ * the core entry stays zero-dependency. You pick the transport (stdio, SSE,
+ * streamable HTTP) and connect it yourself; the topology (where the live
+ * session runs) is yours.
+ *
+ * @example
+ *   import { mcpServer } from 'hcifootprint/mcp';
+ *   import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+ *   const server = mcpServer(session);
+ *   await server.connect(new StdioServerTransport());
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import type { SkillToolsOptions } from './modes.js';
+import type { Session } from '../traverse/session.js';
+export interface McpServerOptions extends SkillToolsOptions {
+    /** Server name advertised over MCP. Default: the graph id. */
+    name?: string;
+    /** Server version advertised over MCP. Default '0.1.0'. */
+    version?: string;
+}
+/**
+ * Build an MCP `Server` backed by a live InteractionSession. Attach any
+ * transport with `server.connect(transport)`.
+ */
+export declare function mcpServer(session: Session, opts?: McpServerOptions): Server;
+//# sourceMappingURL=mcp-server.d.ts.map

package/dist/serve/mcp-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../src/serve/mcp-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAInE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEtD,MAAM,WAAW,gBAAiB,SAAQ,iBAAiB;IACzD,8DAA8D;IAC9D,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,MAAM,CA0C3E"}

package/dist/serve/mcp-server.js

@@ -0,0 +1,72 @@
+/**
+ * mcpServer(session) — expose the session as a real MODEL CONTEXT PROTOCOL
+ * server, so ANY MCP host (Claude Desktop, a LangGraph MCP client, Cursor, …)
+ * can drive your app without a line of framework-specific glue.
+ *
+ * It wraps {@link skillsAsTools} (Mode B): `tools/list` returns the FIXED tool
+ * array (one per skill + whats_here / do_action / why), and `tools/call` routes to
+ * the port. Because the tool set never changes, a plain MCP server works with
+ * no `tools/list_changed` churn — that is the whole point of the fixed-tool
+ * design. High-effect steps come back as `judgment: 'needs-confirm'` in the
+ * result; the HOST decides how to get human approval, then calls again with
+ * `confirm: true` — a portable, framework-agnostic human-in-the-loop.
+ *
+ * This module lives behind the `hcifootprint/mcp` subpath and is the ONLY
+ * place `@modelcontextprotocol/sdk` (an OPTIONAL peer dependency) is imported —
+ * the core entry stays zero-dependency. You pick the transport (stdio, SSE,
+ * streamable HTTP) and connect it yourself; the topology (where the live
+ * session runs) is yours.
+ *
+ * @example
+ *   import { mcpServer } from 'hcifootprint/mcp';
+ *   import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+ *   const server = mcpServer(session);
+ *   await server.connect(new StdioServerTransport());
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { skillsAsTools } from './modes.js';
+/**
+ * Build an MCP `Server` backed by a live InteractionSession. Attach any
+ * transport with `server.connect(transport)`.
+ */
+export function mcpServer(session, opts) {
+    const port = skillsAsTools(session, opts);
+    const server = new Server({ name: opts?.name ?? session.graphId, version: opts?.version ?? '0.1.0' }, { capabilities: { tools: {} } });
+    // Fixed tool list — identical every request (Mode B), so no list_changed.
+    server.setRequestHandler(ListToolsRequestSchema, () => ({
+        tools: port.tools(),
+    }));
+    // Route a call to the port; a domain rejection is a normal result the model
+    // reads (needs-confirm, GUARD_FAILED, …). Only a genuinely unknown tool — or
+    // an unexpected throw — is surfaced as isError.
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            const result = port.call(name, args ?? {});
+            // Act → data back, over the wire: if the call fired something, let the
+            // handler settle and fold any produced data (search results, a looked-up
+            // record) INTO the result — so a remote MCP client sees it, not just an
+            // in-process caller.
+            if (typeof result['transitionId'] === 'string') {
+                await new Promise((resolve) => setTimeout(resolve, 0));
+                const produced = session.producedFor(result['transitionId']);
+                if (produced !== undefined)
+                    result['data'] = produced;
+            }
+            const misused = result['reason'] === 'UNKNOWN_TOOL';
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result) }],
+                ...(misused ? { isError: true } : {}),
+            };
+        }
+        catch (error) {
+            return {
+                content: [{ type: 'text', text: `hcifootprint: tool '${name}' failed: ${String(error)}` }],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}
+//# sourceMappingURL=mcp-server.js.map

package/dist/serve/mcp-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-server.js","sourceRoot":"","sources":["../../src/serve/mcp-server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACnE,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAEnG,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAW3C;;;GAGG;AACH,MAAM,UAAU,SAAS,CAAC,OAAgB,EAAE,IAAuB;IACjE,MAAM,IAAI,GAAG,aAAa,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC1C,MAAM,MAAM,GAAG,IAAI,MAAM,CACvB,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,IAAI,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,IAAI,OAAO,EAAE,EAC1E,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,EAAE,CAChC,CAAC;IAEF,0EAA0E;IAC1E,MAAM,CAAC,iBAAiB,CAAC,sBAAsB,EAAE,GAAG,EAAE,CAAC,CAAC;QACtD,KAAK,EAAE,IAAI,CAAC,KAAK,EAAuB;KACzC,CAAC,CAAC,CAAC;IAEJ,4EAA4E;IAC5E,6EAA6E;IAC7E,gDAAgD;IAChD,MAAM,CAAC,iBAAiB,CAAC,qBAAqB,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE;QAChE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC;QACjD,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,IAAI,EAAE,CAA4B,CAAC;YACtE,uEAAuE;YACvE,yEAAyE;YACzE,wEAAwE;YACxE,qBAAqB;YACrB,IAAI,OAAO,MAAM,CAAC,cAAc,CAAC,KAAK,QAAQ,EAAE,CAAC;gBAC/C,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC;gBACvD,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC;gBAC7D,IAAI,QAAQ,KAAK,SAAS;oBAAE,MAAM,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC;YACxD,CAAC;YACD,MAAM,OAAO,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,cAAc,CAAC;YACpD,OAAO;gBACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;gBAClE,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;aACtC,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO;gBACL,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,uBAAuB,IAAI,aAAa,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,CAAC;gBACnG,OAAO,EAAE,IAAI;aACd,CAAC;QACJ,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/serve/mcp.d.ts

@@ -0,0 +1,12 @@
+import type { MCPToolDescription } from 'footprintjs';
+import type { AvailableEdge, SkillGraphSpec } from '../atom/types.js';
+/**
+ * Synthetic escape tool served whenever a skill frame is open — the acting
+ * agent must always be able to collapse back to skill-level planning. The
+ * description is an authored-class constant (two-string-class safe).
+ */
+export declare function leaveSkillTool(spec: SkillGraphSpec, skillId: string): MCPToolDescription;
+export declare function edgesToMCPTools(spec: SkillGraphSpec, edges: AvailableEdge[], opts?: {
+    lossySchemas?: boolean;
+}): MCPToolDescription[];
+//# sourceMappingURL=mcp.d.ts.map

package/dist/serve/mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/serve/mcp.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAOtE;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,GAAG,kBAAkB,CAMxF;AAED,wBAAgB,eAAe,CAC7B,IAAI,EAAE,cAAc,EACpB,KAAK,EAAE,aAAa,EAAE,EACtB,IAAI,CAAC,EAAE;IAAE,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,GAChC,kBAAkB,EAAE,CAStB"}

package/dist/serve/mcp.js

@@ -0,0 +1,62 @@
+/**
+ * Per-edge MCP tool emission.
+ *
+ * footprint's toMCPTool() is one-tool-per-CHART with a permanent cache — the
+ * wrong grain for an action space that changes on every available() call. This
+ * follows the repo's own multi-tool precedent (the MCP triage socket example):
+ * hand-shaped {name, description, inputSchema} descriptors, reusing only the
+ * pure schema layer (detectSchema + normalizeSchema).
+ *
+ * Two-string-class invariant: `description` is ALWAYS the authored affordance
+ * description. Runtime-resolved strings (DOM labels, user content) are data —
+ * they never reach a descriptor, so attacker-controlled page text cannot
+ * inject instructions into the planner's action space.
+ */
+import { detectSchema } from 'footprintjs';
+import { normalizeSchema } from 'footprintjs/advanced';
+const NO_PARAMS = { type: 'object', properties: {}, additionalProperties: false };
+/** Appended (authored-class constant) so MCP-only planners see the step-up marker. */
+const HIGH_EFFECT_SUFFIX = ' [high-effect: requires explicit confirmation]';
+/**
+ * Synthetic escape tool served whenever a skill frame is open — the acting
+ * agent must always be able to collapse back to skill-level planning. The
+ * description is an authored-class constant (two-string-class safe).
+ */
+export function leaveSkillTool(spec, skillId) {
+    return {
+        name: sanitizeMCPName(`${spec.id}.leave-skill`),
+        description: `Leave the current skill (${skillId}) without completing it and return to skill-level planning.`,
+        inputSchema: structuredClone(NO_PARAMS),
+    };
+}
+export function edgesToMCPTools(spec, edges, opts) {
+    return edges.map((edge) => ({
+        name: sanitizeMCPName(`${spec.id}.${edge.affordanceId}`),
+        description: edge.highEffect ? edge.description + HIGH_EFFECT_SUFFIX : edge.description,
+        inputSchema: edge.schema === undefined
+            ? structuredClone(NO_PARAMS)
+            : gateSchema(edge.affordanceId, edge.schema, opts?.lossySchemas ?? false),
+    }));
+}
+function gateSchema(affordanceId, schema, lossy) {
+    const kind = detectSchema(schema);
+    if (kind === 'zod')
+        return normalizeSchema(schema);
+    // Clone: descriptors must never hand out live references into the spec —
+    // an MCP host normalizing inputSchema in place would corrupt the graph.
+    if (kind === 'json-schema')
+        return structuredClone(schema);
+    // 'parseable' (yup/superstruct/...): validates payloads at fire() but cannot
+    // be serialized to JSON Schema — emitting the raw validator would hand an
+    // MCP client garbage. Fail loudly unless the caller opts into lossy output.
+    if (!lossy) {
+        throw new Error(`hcifootprint: affordance '${affordanceId}' has a 'parseable' schema (non-Zod validator). It validates ` +
+            `payloads at fire() but cannot be serialized to JSON Schema for MCP. Declare a Zod or JSON-Schema ` +
+            `schema, or pass { lossySchemas: true } to emit a permissive object schema.`);
+    }
+    return { type: 'object' };
+}
+function sanitizeMCPName(name) {
+    return name.replace(/[^A-Za-z0-9_.-]/g, '_');
+}
+//# sourceMappingURL=mcp.js.map

package/dist/serve/mcp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.js","sourceRoot":"","sources":["../../src/serve/mcp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGvD,MAAM,SAAS,GAAG,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,EAAE,EAAE,oBAAoB,EAAE,KAAK,EAAE,CAAC;AAElF,sFAAsF;AACtF,MAAM,kBAAkB,GAAG,gDAAgD,CAAC;AAE5E;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,IAAoB,EAAE,OAAe;IAClE,OAAO;QACL,IAAI,EAAE,eAAe,CAAC,GAAG,IAAI,CAAC,EAAE,cAAc,CAAC;QAC/C,WAAW,EAAE,4BAA4B,OAAO,6DAA6D;QAC7G,WAAW,EAAE,eAAe,CAAC,SAAS,CAAC;KAClB,CAAC;AAC1B,CAAC;AAED,MAAM,UAAU,eAAe,CAC7B,IAAoB,EACpB,KAAsB,EACtB,IAAiC;IAEjC,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;QAC1B,IAAI,EAAE,eAAe,CAAC,GAAG,IAAI,CAAC,EAAE,IAAI,IAAI,CAAC,YAAY,EAAE,CAAC;QACxD,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,GAAG,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW;QACvF,WAAW,EACT,IAAI,CAAC,MAAM,KAAK,SAAS;YACvB,CAAC,CAAC,eAAe,CAAC,SAAS,CAAC;YAC5B,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,MAAM,EAAE,IAAI,EAAE,YAAY,IAAI,KAAK,CAAC;KAC9E,CAAC,CAAyB,CAAC;AAC9B,CAAC;AAED,SAAS,UAAU,CAAC,YAAoB,EAAE,MAAe,EAAE,KAAc;IACvE,MAAM,IAAI,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;IAClC,IAAI,IAAI,KAAK,KAAK;QAAE,OAAO,eAAe,CAAC,MAAe,CAAW,CAAC;IACtE,yEAAyE;IACzE,wEAAwE;IACxE,IAAI,IAAI,KAAK,aAAa;QAAE,OAAO,eAAe,CAAC,MAAM,CAAW,CAAC;IACrE,6EAA6E;IAC7E,0EAA0E;IAC1E,4EAA4E;IAC5E,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,MAAM,IAAI,KAAK,CACb,6BAA6B,YAAY,+DAA+D;YACtG,mGAAmG;YACnG,4EAA4E,CAC/E,CAAC;IACJ,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAC5B,CAAC;AAED,SAAS,eAAe,CAAC,IAAY;IACnC,OAAO,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,GAAG,CAAC,CAAC;AAC/C,CAAC"}

package/dist/serve/modes.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Mode B — skills as FIXED tools (the default serving mode, D18 §7).
+ *
+ * The tool array an LLM sees contains ONE tool per skill plus three fixed
+ * generics (whats_here, do_action, why) and NEVER changes for the life of a
+ * conversation. Disclosure rides the RESULT channel: every call returns
+ * readySteps — what is fireable at the current navigation cursor, right now —
+ * and the model acts by calling the SAME skill tool again with {step}.
+ * Between-turn grounding rides the same channel: whats_here accepts
+ * {sinceVersion} and narrates only the delta (who did what since the model's
+ * last look), and `why` serves the causal backward slice for a state key —
+ * the mixed-initiative attribution query.
+ *
+ * Why: tools render first in the prompt; any tool-set change busts every
+ * prompt-cache tier. Result payloads are ordinary messages — cache-stable.
+ * ("JIT disclosure moved from the tool channel to the result channel.")
+ * It also makes the library a PLAIN MCP server for any host: no
+ * tools/list_changed, no dynamic-tool support required.
+ *
+ * The stated trade-off: the static schema cannot enforce each step's exact
+ * input shape at the API layer — `input` is free-form and fire() validates.
+ * A wrong input returns a structured error RESULT carrying what was expected,
+ * and the model corrects on the next call.
+ *
+ * Layering: this file consumes ONLY the public Session surface (available /
+ * availableSkills / skillPlan / frames / fire / contextBrief) — it is a pure
+ * projection, independently testable, swappable per conversation. One
+ * conversation = one mode (a mid-conversation mode flip is a tool-set change
+ * = a full cache bust).
+ *
+ * Two-string-class invariant: every text field in tools AND results is either
+ * an authored description or a fixed authored-constant sentence. Runtime
+ * values (state, payloads, instance keys, evidence) are structured DATA fields.
+ */
+import type { MCPToolDescription } from 'footprintjs';
+import type { Principal } from '../atom/types.js';
+import type { Session } from '../traverse/session.js';
+export interface SkillToolsOptions {
+    /** Require confirm:true before firing high-effect steps/actions. Default true. */
+    confirmHighEffect?: boolean;
+    /** Principal stamped on fires made through this port. Default 'agent'. */
+    source?: Principal;
+}
+export interface SkillCallArgs {
+    step?: string;
+    input?: unknown;
+    confirm?: boolean;
+    /** Instance key for steps on repeats containers (from `instances` in results). */
+    instance?: string;
+}
+export interface DoActionArgs {
+    action: string;
+    input?: unknown;
+    confirm?: boolean;
+    instance?: string;
+}
+/** Results are plain data objects — serialize one as the tool_result body. */
+export type ServeResult = Record<string, unknown>;
+export interface SkillToolsPort {
+    /** The STATIC tool array — identical bytes for the life of the conversation. */
+    tools(): MCPToolDescription[];
+    /** Route a tool_use by name. Unknown names return a structured error result. */
+    call(name: string, args?: unknown): ServeResult;
+}
+export declare function skillsAsTools(session: Session, opts?: SkillToolsOptions): SkillToolsPort;
+//# sourceMappingURL=modes.d.ts.map

package/dist/serve/modes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modes.d.ts","sourceRoot":"","sources":["../../src/serve/modes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAGtD,OAAO,KAAK,EAA6B,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AAEtD,MAAM,WAAW,iBAAiB;IAChC,kFAAkF;IAClF,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,0EAA0E;IAC1E,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,kFAAkF;IAClF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,8EAA8E;AAC9E,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAElD,MAAM,WAAW,cAAc;IAC7B,gFAAgF;IAChF,KAAK,IAAI,kBAAkB,EAAE,CAAC;IAC9B,gFAAgF;IAChF,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,WAAW,CAAC;CACjD;AAmCD,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,iBAAiB,GAAG,cAAc,CA2UxF"}