@honua/mcp-server 0.0.20-alpha.0 → 0.1.0-beta.0

package/dist/src/certification/operator-catalog.js

@@ -286,8 +286,46 @@ export function buildOperatorTools() {
             readOnly: false,
             sampleOutput: { appPackageId: "app-001", uri: "honua://apps/app-001" },
         },
+        {
+            // OPTIONAL mutation-profile tool (geospatial-mcp `mutation` profile) — matched
+            // as an advertised-only known gap, never round-tripped by the read-only path;
+            // the mutating-round-trip contract drives its insert→update→delete lifecycle.
+            // This fixture opts into the optional mutation profile so that path stays
+            // certified; the real honua-server surface does NOT advertise this tool —
+            // Honua does not support AI operational data editing (honua-server ADR-0028).
+            name: "honua_edit_features",
+            title: "Edit features",
+            description: "Apply feature inserts, updates, and deletes to a published editable layer.",
+            inputSchema: OBJECT_SCHEMA({
+                serviceId: { type: "string", minLength: 1 },
+                layerId: { type: "integer", minimum: 0 },
+                adds: {
+                    type: "array",
+                    items: OBJECT_SCHEMA({ attributes: { type: "object" } }, ["attributes"]),
+                },
+                updates: {
+                    type: "array",
+                    items: OBJECT_SCHEMA({ objectId: { type: "integer" }, attributes: { type: "object" } }, [
+                        "objectId",
+                        "attributes",
+                    ]),
+                },
+                deletes: { type: "array", items: { type: "integer" } },
+            }, ["serviceId", "layerId"]),
+            outputSchema: OBJECT_SCHEMA({
+                addResults: { type: "array", items: EDIT_RESULT_SCHEMA },
+                updateResults: { type: "array", items: EDIT_RESULT_SCHEMA },
+                deleteResults: { type: "array", items: EDIT_RESULT_SCHEMA },
+            }),
+            readOnly: false,
+            sampleOutput: { addResults: [], updateResults: [], deleteResults: [] },
+        },
     ];
 }
+const EDIT_RESULT_SCHEMA = OBJECT_SCHEMA({ objectId: { type: "integer" }, success: { type: "boolean" } }, [
+    "objectId",
+    "success",
+]);
 export function buildOperatorResources() {
     return [
         {
@@ -347,6 +385,88 @@ function validateToolArgs(tool, args) {
         fieldPath: e.instancePath || undefined,
     }));
 }
+/** Feature-store key seeded so the pagination + mutation contracts have real rows. */
+const SEED_SERVICE = "svc-parks";
+const SEED_LAYER = 0;
+function seedFeatureStore() {
+    const layer = new Map();
+    // OBJECTID 1 first so the existing single-feature round-trip fixture is stable.
+    const names = ["Central Park", "Riverside Park", "Lincoln Park", "Golden Gate Park", "Prospect Park"];
+    names.forEach((name, i) => layer.set(i + 1, { OBJECTID: i + 1, NAME: name }));
+    return new Map([[`${SEED_SERVICE}::${SEED_LAYER}`, layer]]);
+}
+function newCatalogState() {
+    return { features: seedFeatureStore(), nextObjectId: 1000, jobs: new Map(), nextJobSeq: 1 };
+}
+/** Number of polls before the job lifecycle mock reports `Succeeded`. */
+const JOB_SUCCESS_AFTER_POLLS = 3;
+/** Stateful tool handlers keyed by tool name; absent ⇒ echo the tool's sampleOutput. */
+function buildToolHandlers(state) {
+    const handlers = new Map();
+    handlers.set("honua_query_features", (args) => {
+        const key = `${String(args.serviceId)}::${Number(args.layerId)}`;
+        const layer = state.features.get(key) ?? new Map();
+        let rows = [...layer.values()].sort((a, b) => Number(a.OBJECTID) - Number(b.OBJECTID));
+        if (Array.isArray(args.objectIds)) {
+            const wanted = new Set(args.objectIds.map((v) => Number(v)));
+            rows = rows.filter((r) => wanted.has(Number(r.OBJECTID)));
+        }
+        const total = rows.length;
+        const offset = decodeFeatureOffset(args);
+        const limit = clampLimit(args.limit);
+        const page = rows.slice(offset, offset + limit);
+        const nextOffset = offset + page.length;
+        const out = {
+            features: page.map((attributes) => ({ attributes })),
+            count: page.length,
+            totalCount: total,
+            resultOffset: offset,
+        };
+        if (nextOffset < total) {
+            out.nextCursor = encodeCursor(nextOffset);
+            out.exceededTransferLimit = true;
+        }
+        else {
+            out.exceededTransferLimit = false;
+        }
+        return out;
+    });
+    handlers.set("honua_edit_features", (args) => {
+        const key = `${String(args.serviceId)}::${Number(args.layerId)}`;
+        let layer = state.features.get(key);
+        if (!layer) {
+            layer = new Map();
+            state.features.set(key, layer);
+        }
+        const addResults = asArray(args.adds).map((add) => {
+            const objectId = state.nextObjectId++;
+            layer.set(objectId, { ...(add.attributes ?? {}), OBJECTID: objectId });
+            return { objectId, success: true };
+        });
+        const updateResults = asArray(args.updates).map((u) => {
+            const objectId = Number(u.objectId);
+            const existing = layer.get(objectId);
+            if (!existing) {
+                return { objectId, success: false };
+            }
+            layer.set(objectId, { ...existing, ...(u.attributes ?? {}), OBJECTID: objectId });
+            return { objectId, success: true };
+        });
+        const deleteResults = asArray(args.deletes).map((raw) => {
+            const objectId = Number(raw);
+            return { objectId, success: layer.delete(objectId) };
+        });
+        return { addResults, updateResults, deleteResults };
+    });
+    handlers.set("honua_execute_plan", () => {
+        const seq = state.nextJobSeq++;
+        const jobId = `job-${String(seq).padStart(3, "0")}`;
+        const resultPackageId = `res-${jobId}`;
+        state.jobs.set(jobId, { jobId, polls: 0, resultPackageId });
+        return { jobId, status: "Submitted" };
+    });
+    return handlers;
+}
 /**
  * Build the low-level MCP `Server` for the mock operator catalog. Auth is
  * enforced per request from `extra.authInfo` (populated by the HTTP transport
@@ -358,6 +478,8 @@ export function createOperatorCatalogServer(options = {}) {
     const tools = buildOperatorTools();
     const resources = buildOperatorResources();
     const toolsByName = new Map(tools.map((t) => [t.name, t]));
+    const state = newCatalogState();
+    const handlers = buildToolHandlers(state);
     const server = new Server({ name: "honua", version: "operator-mcp-mock" }, {
         capabilities: { tools: { listChanged: true }, resources: { listChanged: true } },
         instructions: "Mock honua /mcp operator surface for offline certification.",
@@ -391,9 +513,11 @@ export function createOperatorCatalogServer(options = {}) {
         if (violations.length > 0) {
             return toolErrorResult(invalidArgumentError(violations));
         }
+        const handler = handlers.get(tool.name);
+        const output = handler ? handler(request.params.arguments ?? {}) : tool.sampleOutput;
         return {
-            content: [{ type: "text", text: JSON.stringify(tool.sampleOutput) }],
-            structuredContent: tool.sampleOutput,
+            content: [{ type: "text", text: JSON.stringify(output) }],
+            structuredContent: output,
             isError: false,
         };
     });
@@ -408,11 +532,27 @@ export function createOperatorCatalogServer(options = {}) {
         if (!extra.authInfo) {
             throw new McpError(ErrorCode.InvalidRequest, UNAUTHENTICATED_ERROR.error.message, UNAUTHENTICATED_ERROR);
         }
-        const resource = resources.find((r) => r.uri === request.params.uri);
+        const uri = request.params.uri;
+        // Dynamic job lifecycle resource: honua://jobs/{id} advances a documented
+        // Submitted→Running→Succeeded state machine on each poll.
+        const jobMatch = /^honua:\/\/jobs\/([^/]+)$/.exec(uri);
+        if (jobMatch) {
+            return readJobResource(state, jobMatch[1], uri);
+        }
+        // Dynamic result package (produced by a Succeeded job) or the seeded packages.
+        const resultMatch = /^honua:\/\/results\/([^/]+)$/.exec(uri);
+        if (resultMatch && !resources.some((r) => r.uri === uri)) {
+            return jsonResource(uri, {
+                resultPackageId: resultMatch[1],
+                status: "Ready",
+                artifacts: [{ kind: "FeatureService", uri: `honua://services/svc-pub-${resultMatch[1]}` }],
+            });
+        }
+        const resource = resources.find((r) => r.uri === uri);
         if (!resource) {
-            throw new McpError(ErrorCode.InvalidParams, `Unknown resource: ${request.params.uri}`, {
+            throw new McpError(ErrorCode.InvalidParams, `Unknown resource: ${uri}`, {
                 code: "not_found",
-                error: { kind: "UnknownDataset", message: `Unknown resource: ${request.params.uri}` },
+                error: { kind: "UnknownDataset", message: `Unknown resource: ${uri}` },
             });
         }
         return {
@@ -421,6 +561,50 @@ export function createOperatorCatalogServer(options = {}) {
     });
     return server;
 }
+function readJobResource(state, jobId, uri) {
+    const job = state.jobs.get(jobId);
+    if (!job) {
+        throw new McpError(ErrorCode.InvalidParams, `Unknown job: ${jobId}`, {
+            code: "not_found",
+            error: { kind: "UnknownProcess", message: `Unknown job: ${jobId}` },
+        });
+    }
+    job.polls++;
+    const succeeded = job.polls >= JOB_SUCCESS_AFTER_POLLS;
+    const status = succeeded ? "Succeeded" : "Running";
+    const fraction = Math.min(job.polls / JOB_SUCCESS_AFTER_POLLS, 1);
+    const body = {
+        jobId: job.jobId,
+        status,
+        progress: { fraction: Number(fraction.toFixed(4)), message: `step ${job.polls}` },
+    };
+    if (succeeded) {
+        body.resultPackageId = job.resultPackageId;
+        body.resultUri = `honua://results/${job.resultPackageId}`;
+    }
+    return jsonResource(uri, body);
+}
+function jsonResource(uri, body) {
+    return { contents: [{ uri, mimeType: "application/json", text: JSON.stringify(body) }] };
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+function clampLimit(raw) {
+    const n = Number(raw);
+    if (!Number.isFinite(n) || n < 1) {
+        return 100;
+    }
+    return Math.min(Math.floor(n), 1000);
+}
+/** Resolve a feature-page offset from an explicit `resultOffset` or a page `cursor`. */
+function decodeFeatureOffset(args) {
+    if (typeof args.cursor === "string") {
+        return decodeCursor(args.cursor);
+    }
+    const off = Number(args.resultOffset);
+    return Number.isFinite(off) && off >= 0 ? Math.floor(off) : 0;
+}
 function toolErrorResult(error) {
     return {
         content: [{ type: "text", text: error.error.message }],

package/dist/src/certification/report.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/certification/report.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,0EAA0E;AAC1E,wBAAgB,cAAc,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CA6GlE"}
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/certification/report.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAE1D,0EAA0E;AAC1E,wBAAgB,cAAc,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CA2HlE"}

package/dist/src/certification/report.js

@@ -14,6 +14,18 @@ export function renderMarkdown(report) {
     lines.push(`- Backend: \`${report.protocol.backend}\`${report.protocol.honuaTransport ? ` (Honua transport: \`${report.protocol.honuaTransport}\`)` : ""}`);
     lines.push(`- Standard: \`${report.standard.source}\` (index ${report.standard.indexDate}, ${report.standard.dialect})`);
     lines.push("");
+    const p = report.provenance;
+    lines.push("## Provenance");
+    lines.push("");
+    lines.push("| Field | Value |");
+    lines.push("| --- | --- |");
+    lines.push(`| Target | ${p.targetUrl} |`);
+    lines.push(`| Auth mode | \`${p.authMode}\` |`);
+    lines.push(`| Negotiated protocol | \`${p.protocolVersion ?? "n/a"}\` |`);
+    lines.push(`| Tools advertised | ${p.toolCount} |`);
+    lines.push(`| Suite git SHA | \`${p.suiteGitSha}\` (${p.suiteGitShaSource}) |`);
+    lines.push(`| Generated | \`${report.generatedAt}\` |`);
+    lines.push("");
     lines.push("## Summary");
     lines.push("");
     lines.push("| Metric | Value |");
@@ -27,6 +39,7 @@ export function renderMarkdown(report) {
     lines.push(`| Resources discovered | ${s.resourcesDiscovered} |`);
     lines.push(`| Prompts discovered | ${s.promptsDiscovered} |`);
     lines.push(`| Contracts checked | ${s.contractsPassed} / ${s.contractsChecked} passed |`);
+    lines.push(`| Contracts skipped | ${s.contractsSkipped} |`);
     lines.push(`| Known gaps | ${s.knownGaps} |`);
     lines.push(`| Failures | ${s.failures} |`);
     lines.push("");

package/dist/src/certification/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/certification/run.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,gBAAgB,CAAC;AAEnE,OAAO,EAAE,KAAK,mBAAmB,EAA2B,MAAM,aAAa,CAAC;AAEhF;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AAED,wBAAsB,gBAAgB,CAAC,OAAO,GAAE,UAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAI7F;AAED,8DAA8D;AAC9D,wBAAsB,aAAa,CACjC,MAAM,EAAE,mBAAmB,EAC3B,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,OAAO,CAAC,mBAAmB,CAAC,CAc9B;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,MAAM,EAAE,mBAAmB,EAAE,KAAK,EAAE,aAAa,GAAG,IAAI,CAGtF"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/certification/run.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,mBAAmB,EAAW,MAAM,gBAAgB,CAAC;AAEnE,OAAO,EAAE,KAAK,mBAAmB,EAA2B,MAAM,aAAa,CAAC;AAEhF;;;;;;;;;;;;GAYG;AAEH,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;CACzB;AAED,wBAAsB,gBAAgB,CAAC,OAAO,GAAE,UAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAI7F;AAED,8DAA8D;AAC9D,wBAAsB,aAAa,CACjC,MAAM,EAAE,mBAAmB,EAC3B,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,OAAO,CAAC,mBAAmB,CAAC,CAe9B;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,iEAAiE;AACjE,wBAAgB,cAAc,CAAC,MAAM,EAAE,mBAAmB,EAAE,KAAK,EAAE,aAAa,GAAG,IAAI,CAGtF"}

package/dist/src/certification/run.js

@@ -16,6 +16,7 @@ export async function certifyTarget(target, env = process.env) {
             backend: target.backend,
             surface: target.serverLabel,
             honuaTransport: target.honuaTransport,
+            authMode: target.authMode,
             connectUnauthenticated: target.supportsUnauthenticatedPass ? () => target.connectUnauthenticated() : undefined,
             env,
         });

package/dist/src/certification/schema-index.d.ts

@@ -51,6 +51,31 @@ export interface SchemaIndex {
  * lives here in code instead.
  */
 export declare const REFERENCE_TOOL_ALIASES: Readonly<Record<string, string>>;
+/**
+ * Platform-gated degradations (SDK-local, NOT part of the vendored standard).
+ *
+ * Some reference-shape tools require standard properties that are *platform
+ * bindings* — identifiers that only have meaning against a Honua
+ * publishing/authoring surface. The platform-free (standalone) front door
+ * (issue #369) has no such surface, so it intentionally degrades these tools to
+ * a non-error, client-side projection and legitimately omits the binding
+ * identifiers, keeping only the taxonomy essence.
+ *
+ * This maps an advertised reference tool name to the required standard
+ * properties it may shed WITHOUT counting as non-conformant on a platform-free
+ * target. It is deliberately narrow: it never relaxes read-addressing required
+ * properties (e.g. `honua_query_features` still must require serviceId+layerId),
+ * only true platform-authoring bindings. The vendored `index.json` and schema
+ * files are byte-exact copies of the upstream standard and must never be
+ * hand-edited to encode this, so the decision lives here in code instead.
+ *
+ * `honua_apply_style_preset`: the reference shape binds a StyleRef preset onto a
+ * PUBLISHED layer (serviceId+layerId) via the server OGC API – Styles authoring
+ * surface (ADR-0048). The platform-free surface resolves a preset for
+ * client-side application keyed on `styleId` alone (ADR-0028: never mutates
+ * server state), so it sheds serviceId+layerId.
+ */
+export declare const PLATFORM_FREE_DEGRADATIONS: Readonly<Record<string, readonly string[]>>;
 export type JsonSchema = Record<string, unknown>;
 export declare const SCHEMA_ROOT: URL;
 /** Load and cache the machine-readable schema index. */

package/dist/src/certification/schema-index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema-index.d.ts","sourceRoot":"","sources":["../../../src/certification/schema-index.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AAEH,MAAM,WAAW,iBAAiB;IAChC,0DAA0D;IAC1D,YAAY,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,MAAM,EAAE,MAAM,CAAC;IACf,oBAAoB,EAAE,aAAa,GAAG,WAAW,CAAC;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,CAAC,EAAE,aAAa,GAAG,WAAW,CAAC;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,SAAS,EAAE,qBAAqB,EAAE,CAAC;IACnC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACzD,WAAW,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAChE;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEnE,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAwBjD,eAAO,MAAM,WAAW,KAAsB,CAAC;AAK/C,wDAAwD;AACxD,wBAAgB,eAAe,IAAI,WAAW,CAM7C;AAED,0EAA0E;AAC1E,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,UAAU,CAS/D;AAED,uFAAuF;AACvF,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAc3F"}
+{"version":3,"file":"schema-index.d.ts","sourceRoot":"","sources":["../../../src/certification/schema-index.ts"],"names":[],"mappings":"AAGA;;;;;;GAMG;AAEH,MAAM,WAAW,iBAAiB;IAChC,0DAA0D;IAC1D,YAAY,EAAE,MAAM,CAAC;IACrB,gFAAgF;IAChF,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,MAAM,EAAE,MAAM,CAAC;IACf,oBAAoB,EAAE,aAAa,GAAG,WAAW,CAAC;IAClD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,oBAAoB,CAAC,EAAE,aAAa,GAAG,WAAW,CAAC;IACnD,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAC3B,SAAS,EAAE,qBAAqB,EAAE,CAAC;IACnC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACzD,WAAW,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAChE;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEnE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAElF,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAwBjD,eAAO,MAAM,WAAW,KAAsB,CAAC;AAK/C,wDAAwD;AACxD,wBAAgB,eAAe,IAAI,WAAW,CAM7C;AAED,0EAA0E;AAC1E,wBAAgB,cAAc,CAAC,YAAY,EAAE,MAAM,GAAG,UAAU,CAS/D;AAED,uFAAuF;AACvF,wBAAgB,cAAc,IAAI,MAAM,CAEvC;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAc3F"}

package/dist/src/certification/schema-index.js

@@ -12,6 +12,33 @@ import { fileURLToPath } from "node:url";
 export const REFERENCE_TOOL_ALIASES = {
     honua_dry_run_plan: "honua_validate_plan",
 };
+/**
+ * Platform-gated degradations (SDK-local, NOT part of the vendored standard).
+ *
+ * Some reference-shape tools require standard properties that are *platform
+ * bindings* — identifiers that only have meaning against a Honua
+ * publishing/authoring surface. The platform-free (standalone) front door
+ * (issue #369) has no such surface, so it intentionally degrades these tools to
+ * a non-error, client-side projection and legitimately omits the binding
+ * identifiers, keeping only the taxonomy essence.
+ *
+ * This maps an advertised reference tool name to the required standard
+ * properties it may shed WITHOUT counting as non-conformant on a platform-free
+ * target. It is deliberately narrow: it never relaxes read-addressing required
+ * properties (e.g. `honua_query_features` still must require serviceId+layerId),
+ * only true platform-authoring bindings. The vendored `index.json` and schema
+ * files are byte-exact copies of the upstream standard and must never be
+ * hand-edited to encode this, so the decision lives here in code instead.
+ *
+ * `honua_apply_style_preset`: the reference shape binds a StyleRef preset onto a
+ * PUBLISHED layer (serviceId+layerId) via the server OGC API – Styles authoring
+ * surface (ADR-0048). The platform-free surface resolves a preset for
+ * client-side application keyed on `styleId` alone (ADR-0028: never mutates
+ * server state), so it sheds serviceId+layerId.
+ */
+export const PLATFORM_FREE_DEGRADATIONS = {
+    honua_apply_style_preset: ["serviceId", "layerId"],
+};
 /**
  * Resolved root of the vendored schema tree.
  *

package/dist/src/certification/target.d.ts

@@ -1,4 +1,5 @@
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { AuthMode } from "../provenance.js";
 import { type ProxyOptions } from "../proxy.js";
 /**
  * Certification target selection.
@@ -14,13 +15,20 @@ import { type ProxyOptions } from "../proxy.js";
  *                    Reuses the proxy's upstream connection logic verbatim.
  *   - `stdio-proxy` : spawns the `honua-mcp-proxy` binary against an upstream and
  *                     certifies through stdio, proving the proxy chain end-to-end.
+ *   - `standalone`  : the PLATFORM-FREE front door (issue #369). Certifies the
+ *                     direct-SDK `createServer` surface against an in-process fixture
+ *                     of a PLAIN public FeatureServer (recorded census layer, no
+ *                     Honua surfaces). Proves the tools certify green against a
+ *                     non-Honua endpoint, with Honua-only tools skip-with-reason.
  */
-export type CertTargetMode = "offline" | "remote" | "stdio-proxy";
+export type CertTargetMode = "offline" | "remote" | "stdio-proxy" | "standalone";
 export interface CertificationTarget {
     mode: CertTargetMode;
     backend: "mock-upstream" | "live";
     /** Human-readable label for the certified surface (artifact provenance). */
     serverLabel: string;
+    /** How the authenticated client reached the surface (recorded in provenance). */
+    authMode: AuthMode;
     honuaTransport: string | null;
     /** Authenticated, connected MCP client. */
     client: Client;

package/dist/src/certification/target.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../../src/certification/target.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAEnE,OAAO,EAAE,KAAK,YAAY,EAAmB,MAAM,aAAa,CAAC;AAGjE;;;;;;;;;;;;;;GAcG;AAEH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,CAAC;AAElE,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,eAAe,GAAG,MAAM,CAAC;IAClC,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,2BAA2B,EAAE,OAAO,CAAC;IACrC,gFAAgF;IAChF,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,cAAc,CAMtF;AAED,6EAA6E;AAC7E,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,YAAY,CAc9E;AAED,kFAAkF;AAClF,wBAAgB,iBAAiB,IAAI,MAAM,CAc1C;AAED,gDAAgD;AAChD,wBAAsB,uBAAuB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAShH"}
+{"version":3,"file":"target.d.ts","sourceRoot":"","sources":["../../../src/certification/target.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAInE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AACjD,OAAO,EAAE,KAAK,YAAY,EAAmB,MAAM,aAAa,CAAC;AAIjE;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,aAAa,GAAG,YAAY,CAAC;AAEjF,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,cAAc,CAAC;IACrB,OAAO,EAAE,eAAe,GAAG,MAAM,CAAC;IAClC,4EAA4E;IAC5E,WAAW,EAAE,MAAM,CAAC;IACpB,iFAAiF;IACjF,QAAQ,EAAE,QAAQ,CAAC;IACnB,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,yEAAyE;IACzE,2BAA2B,EAAE,OAAO,CAAC;IACrC,gFAAgF;IAChF,sBAAsB,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB;AAED,wBAAgB,iBAAiB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,cAAc,CAQtF;AAED,6EAA6E;AAC7E,wBAAgB,yBAAyB,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,GAAG,YAAY,CAc9E;AAED,kFAAkF;AAClF,wBAAgB,iBAAiB,IAAI,MAAM,CAc1C;AAED,gDAAgD;AAChD,wBAAsB,uBAAuB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAYhH"}

package/dist/src/certification/target.js

@@ -2,14 +2,17 @@ import { existsSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { createClientFromEnv, createServer } from "../index.js";
 import { connectUpstream } from "../proxy.js";
+import { createStandaloneFixtureClient } from "./census-fixture-client.js";
 import { startMockUpstream } from "./mock-upstream.js";
 export function resolveTargetMode(env = process.env) {
     const raw = (env.HONUA_MCP_CERT_TARGET ?? "offline").trim().toLowerCase();
-    if (raw === "offline" || raw === "remote" || raw === "stdio-proxy") {
+    if (raw === "offline" || raw === "remote" || raw === "stdio-proxy" || raw === "standalone") {
         return raw;
     }
-    throw new Error(`HONUA_MCP_CERT_TARGET must be "offline", "remote", or "stdio-proxy", received "${raw}"`);
+    throw new Error(`HONUA_MCP_CERT_TARGET must be "offline", "remote", "stdio-proxy", or "standalone", received "${raw}"`);
 }
 /** Resolve the remote `/mcp` endpoint + credentials from the environment. */
 export function resolveRemoteProxyOptions(env) {
@@ -50,8 +53,51 @@ export async function openCertificationTarget(env = process.env) {
     if (mode === "stdio-proxy") {
         return openStdioProxyTarget(env);
     }
+    if (mode === "standalone") {
+        return openStandaloneTarget(env);
+    }
     return openOfflineTarget(env);
 }
+/**
+ * Open the platform-free standalone target: the direct-SDK `createServer` surface,
+ * reached over an in-memory MCP transport. By default it is wired to an in-process
+ * fixture of a plain public FeatureServer (recorded census layer, no Honua
+ * surfaces) — deterministic, no network, gates CI. When `HONUA_BASE_URL` is set
+ * (the scheduled live variant) it drives a REAL `HonuaClient` against that public
+ * FeatureServer/OGC endpoint instead. Either way there is no transport auth
+ * boundary, so the auth contracts skip-with-reason and the Honua-only style tools
+ * degrade to structured "not available on this target" results.
+ */
+async function openStandaloneTarget(env) {
+    const live = typeof env.HONUA_BASE_URL === "string" && env.HONUA_BASE_URL.length > 0;
+    const client_ = live ? createClientFromEnv(env) : createStandaloneFixtureClient();
+    const server = createServer(client_);
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    const client = new Client({ name: "honua-mcp-certifier", version: "1.0.0" });
+    await server.connect(serverTransport);
+    await client.connect(clientTransport);
+    return {
+        mode: "standalone",
+        backend: live ? "live" : "mock-upstream",
+        serverLabel: live
+            ? `honua-mcp standalone → ${env.HONUA_BASE_URL} (live public FeatureServer, no Honua surfaces)`
+            : "honua-mcp standalone → plain public FeatureServer (recorded census fixture, no Honua surfaces)",
+        authMode: "anonymous",
+        honuaTransport: env.HONUA_TRANSPORT ?? null,
+        client,
+        // A plain FeatureServer has no MCP transport auth boundary — the auth
+        // contracts skip-with-reason rather than assert an enforcement that a
+        // platform-free target does not (and should not) provide.
+        supportsUnauthenticatedPass: false,
+        connectUnauthenticated() {
+            return Promise.reject(new Error("standalone target has no auth boundary"));
+        },
+        async close() {
+            await client.close().catch(() => { });
+            await server.close().catch(() => { });
+        },
+    };
+}
 async function openOfflineTarget(env) {
     const mock = await startMockUpstream();
     const authedClients = [];
@@ -61,6 +107,7 @@ async function openOfflineTarget(env) {
         mode: "offline",
         backend: "mock-upstream",
         serverLabel: "honua /mcp operator catalog (in-process streamable-HTTP mock)",
+        authMode: "bearer",
         honuaTransport: env.HONUA_TRANSPORT ?? null,
         client,
         supportsUnauthenticatedPass: true,
@@ -77,6 +124,9 @@ async function openOfflineTarget(env) {
         },
     };
 }
+function resolveAuthMode(options) {
+    return options.authToken ? "bearer" : options.apiKey ? "api-key" : "anonymous";
+}
 async function openRemoteTarget(env) {
     const options = resolveRemoteProxyOptions(env);
     const clients = [];
@@ -86,6 +136,7 @@ async function openRemoteTarget(env) {
         mode: "remote",
         backend: "live",
         serverLabel: `live honua /mcp (${options.remoteUrl})`,
+        authMode: resolveAuthMode(options),
         honuaTransport: env.HONUA_TRANSPORT ?? null,
         client,
         supportsUnauthenticatedPass: true,
@@ -149,6 +200,7 @@ async function openStdioProxyTarget(env) {
         mode: "stdio-proxy",
         backend,
         serverLabel: `honua-mcp-proxy → ${backend === "live" ? upstreamUrl : "in-process mock /mcp"}`,
+        authMode: upstreamToken ? "bearer" : env.HONUA_API_KEY ? "api-key" : "anonymous",
         honuaTransport: env.HONUA_TRANSPORT ?? null,
         client,
         supportsUnauthenticatedPass: true,

package/dist/src/eval/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { writeFileSync } from "node:fs";
+import { mkdirSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { resolveCorpus } from "./corpus.js";
@@ -37,7 +37,7 @@ import { runEval } from "./runner.js";
  * chain), and live remote MCP runs when HONUA_MCP_REMOTE_URL is set. Keys are
  * never hardcoded — they come from the environment.
  */
-const CORPUS_NAMES = ["analyst", "operator", "northstar", "all"];
+const CORPUS_NAMES = ["analyst", "operator", "northstar", "standalone", "all"];
 function parseArgs(argv) {
     let artifactOnly = false;
     let offline = false;
@@ -92,7 +92,9 @@ async function main() {
         forceOffline: offline,
         ...(drivers.length > 0 ? { drivers: selectDrivers(drivers) } : {}),
         ...(corpus ? { corpus: corpusForName(corpus) } : {}),
+        ...(corpus === "standalone" ? { forceStandaloneSurface: true } : {}),
     });
+    mkdirSync(outDir, { recursive: true });
     const jsonPath = resolve(outDir, "mcp-eval-results.json");
     const mdPath = resolve(outDir, "mcp-eval-results.md");
     writeFileSync(jsonPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");

package/dist/src/eval/corpus.d.ts

@@ -24,4 +24,11 @@ export declare const CORPUS: Scenario[];
  * is set explicitly.
  */
 export declare function resolveCorpus(env?: NodeJS.ProcessEnv): Scenario[];
+/**
+ * Whether a corpus selection targets the PLATFORM-FREE standalone surface (a plain
+ * public FeatureServer fixture) rather than the Honua operator/analyst surface.
+ * The offline runner uses this to pick the census fixture client so the standalone
+ * corpus resolves against real recorded non-Honua data.
+ */
+export declare function isStandaloneCorpus(env?: NodeJS.ProcessEnv): boolean;
 //# sourceMappingURL=corpus.d.ts.map

package/dist/src/eval/corpus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"corpus.d.ts","sourceRoot":"","sources":["../../../src/eval/corpus.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,EAAE,QAAQ,EAkG5B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,QAAQ,EAAE,CAW9E"}
+{"version":3,"file":"corpus.d.ts","sourceRoot":"","sources":["../../../src/eval/corpus.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM,EAAE,QAAQ,EAkG5B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,QAAQ,EAAE,CAiB9E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,OAAO,CAEhF"}

package/dist/src/eval/corpus.js

@@ -1,5 +1,6 @@
 import { NORTHSTAR_CORPUS } from "./northstar-corpus.js";
 import { OPERATOR_CORPUS } from "./operator-corpus.js";
+import { STANDALONE_CORPUS } from "./standalone-corpus.js";
 /**
  * Held-out corpus of GIS workflows for the cross-model eval (honua-server #1956).
  *
@@ -126,9 +127,24 @@ export function resolveCorpus(env = process.env) {
             return OPERATOR_CORPUS;
         case "northstar":
             return NORTHSTAR_CORPUS;
+        case "standalone":
+            return STANDALONE_CORPUS;
         case "all":
+            // `all` spans the Honua-surface corpora only. The platform-free standalone
+            // corpus targets a DIFFERENT surface (a plain FeatureServer fixture) and is
+            // selected explicitly via `standalone`; mixing it here would run its
+            // census-specific scenarios against an operator surface.
             return [...CORPUS, ...OPERATOR_CORPUS, ...NORTHSTAR_CORPUS];
         default:
             return CORPUS;
     }
 }
+/**
+ * Whether a corpus selection targets the PLATFORM-FREE standalone surface (a plain
+ * public FeatureServer fixture) rather than the Honua operator/analyst surface.
+ * The offline runner uses this to pick the census fixture client so the standalone
+ * corpus resolves against real recorded non-Honua data.
+ */
+export function isStandaloneCorpus(env = process.env) {
+    return (env.HONUA_EVAL_CORPUS ?? "").trim().toLowerCase() === "standalone";
+}

package/dist/src/eval/drivers/deterministic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deterministic.d.ts","sourceRoot":"","sources":["../../../../src/eval/drivers/deterministic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAkB,eAAe,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAE9G;;;;;;;;GAQG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IACrD,QAAQ,CAAC,EAAE,mBAAmB;IAC9B,QAAQ,CAAC,MAAM,EAAG,eAAe,CAAU;IAE3C,WAAW,IAAI,OAAO;IAIhB,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAsCzF"}
+{"version":3,"file":"deterministic.d.ts","sourceRoot":"","sources":["../../../../src/eval/drivers/deterministic.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,QAAQ,EAAkB,eAAe,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAE9G;;;;;;;;GAQG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IACrD,QAAQ,CAAC,EAAE,mBAAmB;IAC9B,QAAQ,CAAC,MAAM,EAAG,eAAe,CAAU;IAE3C,WAAW,IAAI,OAAO;IAIhB,WAAW,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAoDzF"}

package/dist/src/eval/drivers/deterministic.js

@@ -18,6 +18,19 @@ export class DeterministicDriver {
         const steps = [];
         const answerParts = [];
         let errorCount = 0;
+        // Ambiguity/refusal scenarios: the ideal client asks for clarification rather
+        // than guessing. Honoring this deterministically lets the offline control
+        // exercise refusal/clarification behavior, not just happy-path trajectories.
+        if (scenario.clarify) {
+            return {
+                scenarioId: scenario.id,
+                modelId: this.id,
+                steps,
+                finalAnswer: scenario.clarify.question,
+                clarificationRequested: true,
+                errorCount,
+            };
+        }
         for (const planned of scenario.script) {
             if (!advertised.has(planned.tool)) {
                 // The scripted tool is not on the surface — record a driver-visible error

package/dist/src/eval/grade.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"grade.d.ts","sourceRoot":"","sources":["../../../src/eval/grade.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE9E,oGAAoG;AACpG,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAQjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,kBAAkB,GAAG,aAAa,CA2CvF"}
+{"version":3,"file":"grade.d.ts","sourceRoot":"","sources":["../../../src/eval/grade.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,aAAa,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE9E,oGAAoG;AACpG,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAQjF;AAED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,kBAAkB,GAAG,aAAa,CAgEvF"}