glasspane-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,1476 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import process2 from "node:process";
+
+// src/canonical.ts
+function canonicalJson(value) {
+  return JSON.stringify(sortKeys(value));
+}
+function sortKeys(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => sortKeys(entry));
+  }
+  if (value !== null && typeof value === "object") {
+    const record = value;
+    const sorted = {};
+    for (const key of Object.keys(record).sort()) {
+      sorted[key] = sortKeys(record[key]);
+    }
+    return sorted;
+  }
+  return value;
+}
+
+// src/tools.ts
+import { z as z5 } from "zod";
+
+// ../kernel/dist/schemas.js
+import { createRequire } from "node:module";
+var nodeRequire = createRequire(import.meta.url);
+function loadSchema(relativePath) {
+  return nodeRequire(relativePath);
+}
+var EVIDENCE_PACK_JSON_SCHEMA = loadSchema("../schemas/evidence-pack.schema.json");
+var DECISION_LOG_ENTRY_JSON_SCHEMA = loadSchema("../schemas/decision-log-entry.schema.json");
+var RECIPE_CONFIG_JSON_SCHEMA = loadSchema("../schemas/recipe-config.schema.json");
+
+// ../kernel/dist/evidence-pack.js
+import { z } from "zod";
+var OPERATION_ID_PATTERN = /^op_[0-9A-HJKMNP-TV-Z]{26}$/;
+var ISO_MILLIS_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+var TREE_DIGEST_PATTERN = /^[0-9a-f]{32}$/;
+var SELECTOR_MAX_LENGTH = 512;
+var EVIDENCE_SCHEMA_VERSION = "glasspane.evidence/0.1-draft";
+var AttributionLevelSchema = z.enum(["soft", "strong", "weak"]);
+var CircuitBreakerLevelSchema = z.number().int().min(0).max(3);
+var SelectorSchema = z.strictObject({
+  role: z.string().max(SELECTOR_MAX_LENGTH),
+  title: z.string().max(SELECTOR_MAX_LENGTH).optional(),
+  identifier: z.string().max(SELECTOR_MAX_LENGTH).optional()
+});
+var ActionSchema = z.enum([
+  "press",
+  "increment",
+  "decrement",
+  "showMenu",
+  "confirm",
+  "cancel",
+  "pick"
+]);
+var AssertionPropertySchema = z.enum([
+  "title",
+  "value",
+  "role",
+  "enabled",
+  "focused"
+]);
+var StringOrBoolSchema = z.union([z.string(), z.boolean()]);
+var BoundsSchema = z.strictObject({
+  x: z.number(),
+  y: z.number(),
+  width: z.number(),
+  height: z.number()
+});
+var AxEventSignalSchema = z.strictObject({
+  treeDigestBefore: z.string().regex(TREE_DIGEST_PATTERN),
+  treeDigestAfter: z.string().regex(TREE_DIGEST_PATTERN),
+  nodeCount: z.number().int().min(0),
+  axChanged: z.boolean(),
+  latencyMs: z.number().min(0)
+});
+var PixelDiffSignalSchema = z.strictObject({
+  changedPixelRatio: z.number().min(0).max(1),
+  bounds: z.union([BoundsSchema, z.null()]),
+  windowId: z.number().int().min(0)
+});
+var ResponsivenessSignalSchema = z.strictObject({
+  responsive: z.boolean(),
+  pingMs: z.number().min(0)
+});
+var CrashSignalSchema = z.strictObject({
+  processAliveBefore: z.boolean(),
+  processAliveAfter: z.boolean()
+});
+var ActSignalSchema = z.strictObject({
+  selector: SelectorSchema,
+  action: ActionSchema,
+  actConfirmed: z.boolean()
+});
+var HandlerRefSchema = z.strictObject({
+  file: z.string().min(1).max(512),
+  line: z.number().int().min(0)
+});
+var HandlerProbeSignalSchema = z.strictObject({
+  probeVersion: z.string().min(1).max(64),
+  hitCount: z.number().int().min(0),
+  handlers: z.array(HandlerRefSchema).max(32),
+  lateCount: z.number().int().min(0)
+});
+var StateEntrySchema = z.strictObject({
+  key: z.string().min(1).max(512),
+  before: z.string().max(1024),
+  after: z.string().max(1024)
+});
+var StateDiffSignalSchema = z.strictObject({
+  source: z.enum(["z1-macro", "z2-mirror", "z3-kvc"]),
+  changed: z.boolean(),
+  entries: z.array(StateEntrySchema).max(64)
+});
+var SignalsSchema = z.strictObject({
+  act: ActSignalSchema,
+  axEvent: AxEventSignalSchema.optional(),
+  // Z5 channel has no in-process probes: explicit null is the honest boundary;
+  // P6 §3.1 opens the object alternative once a GlassPaneProbe connects.
+  handlerProbe: z.union([HandlerProbeSignalSchema, z.null()]),
+  stateDiff: z.union([StateDiffSignalSchema, z.null()]),
+  pixelDiff: PixelDiffSignalSchema.optional(),
+  responsiveness: ResponsivenessSignalSchema.optional(),
+  crash: CrashSignalSchema.optional()
+});
+var AttributionSchema = z.strictObject({
+  level: AttributionLevelSchema,
+  contaminated: z.boolean()
+});
+var CircuitBreakerSchema = z.strictObject({
+  level: CircuitBreakerLevelSchema,
+  reason: z.string().optional()
+});
+var AssertionSchema = z.strictObject({
+  kind: z.literal("element_property"),
+  selector: SelectorSchema,
+  property: AssertionPropertySchema,
+  expected: StringOrBoolSchema,
+  actual: StringOrBoolSchema,
+  passed: z.boolean()
+});
+var DiagnosisClassSchema = z.enum([
+  "T0",
+  "T1",
+  "T2",
+  "T3",
+  "T4",
+  "T5",
+  "T6",
+  "T7",
+  "T8",
+  "T9",
+  "NO_ANOMALY",
+  "INCONCLUSIVE"
+]);
+var DiagnosisReportSchema = z.strictObject({
+  path: z.string(),
+  anomaly: z.string(),
+  evidence: z.string(),
+  next: z.string()
+});
+var DiagnosisSchema = z.strictObject({
+  class: DiagnosisClassSchema,
+  report: DiagnosisReportSchema
+});
+var EvidencePackSchema = z.strictObject({
+  schemaVersion: z.literal(EVIDENCE_SCHEMA_VERSION),
+  operationId: z.string().regex(OPERATION_ID_PATTERN),
+  createdAt: z.string().regex(ISO_MILLIS_PATTERN),
+  attribution: AttributionSchema,
+  circuitBreaker: CircuitBreakerSchema,
+  signals: SignalsSchema,
+  assertion: z.union([AssertionSchema, z.null()]).optional(),
+  diagnosis: z.union([DiagnosisSchema, z.null()]).optional()
+});
+
+// ../kernel/dist/decision-log-entry.js
+import { z as z2 } from "zod";
+var DECISION_ENTRY_ID_PATTERN = /^dl_[0-9A-HJKMNP-TV-Z]{26}$/;
+var PREV_ENTRY_HASH_PATTERN = /^([0-9a-f]{64})?$/;
+var SUMMARY_MAX_LENGTH = 2048;
+var DecisionOutcomeSchema = z2.enum(["pass", "fail", "blocked", "inconclusive"]);
+var DecisionLogEntrySchema = z2.strictObject({
+  entryId: z2.string().regex(DECISION_ENTRY_ID_PATTERN),
+  sequence: z2.number().int().min(0),
+  prevEntryHash: z2.string().regex(PREV_ENTRY_HASH_PATTERN),
+  operationId: z2.string().regex(OPERATION_ID_PATTERN).optional(),
+  summary: z2.string().max(SUMMARY_MAX_LENGTH),
+  outcome: DecisionOutcomeSchema,
+  createdAt: z2.string().regex(ISO_MILLIS_PATTERN)
+});
+
+// ../kernel/dist/recipe-config.js
+import { z as z3 } from "zod";
+var RECIPE_SCHEMA_VERSION = "glasspane.recipe/0.1-draft";
+var RECIPE_NAME_MAX_LENGTH = 256;
+var RECIPE_MIN_STEPS = 1;
+var RECIPE_MAX_STEPS = 64;
+var RecipeStepKindSchema = z3.enum(["act", "observe", "assert", "diagnose"]);
+var RecipeStepSchema = z3.strictObject({
+  kind: RecipeStepKindSchema,
+  params: z3.record(z3.unknown())
+});
+var RecipeConfigSchema = z3.strictObject({
+  schemaVersion: z3.literal(RECIPE_SCHEMA_VERSION),
+  name: z3.string().max(RECIPE_NAME_MAX_LENGTH),
+  steps: z3.array(RecipeStepSchema).min(RECIPE_MIN_STEPS).max(RECIPE_MAX_STEPS)
+});
+
+// ../kernel/dist/errors.js
+var KernelSchemaError = class extends Error {
+  code = "KERNEL_E_SCHEMA";
+  issues;
+  constructor(label, issues) {
+    const detail = issues.map((issue) => `${issue.path.length > 0 ? issue.path : "<root>"}: ${issue.message}`).join("; ");
+    super(`invalid ${label}: ${detail}`);
+    this.name = "KernelSchemaError";
+    this.issues = issues;
+  }
+};
+
+// ../kernel/dist/parse.js
+function parseOrThrow(schema, input, label) {
+  const result = schema.safeParse(input);
+  if (result.success) {
+    return result.data;
+  }
+  const issues = result.error.issues.map((issue) => ({
+    path: issue.path.map((segment) => String(segment)).join("."),
+    message: issue.message
+  }));
+  throw new KernelSchemaError(label, issues);
+}
+function parseEvidencePack(input) {
+  return parseOrThrow(EvidencePackSchema, input, "evidence pack");
+}
+
+// src/engine-client.ts
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+
+// src/io.ts
+var MAX_FRAME_BYTES = 4 * 1024 * 1024;
+var LineReader = class {
+  constructor(sink) {
+    this.sink = sink;
+  }
+  sink;
+  buffer = "";
+  /** @param chunk UTF-8 text fragment received from the stream. */
+  push(chunk) {
+    this.buffer += chunk;
+    let nl;
+    while ((nl = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, nl);
+      this.buffer = this.buffer.slice(nl + 1);
+      const bytes = Buffer.byteLength(line, "utf8");
+      if (bytes > MAX_FRAME_BYTES) {
+        this.sink.onOversize(bytes);
+      } else {
+        this.sink.onLine(line);
+      }
+    }
+  }
+  /** Unconsumed partial line (tests / graceful close inspection). */
+  pendingText() {
+    return this.buffer;
+  }
+};
+var StreamLineIo = class {
+  constructor(input, output) {
+    this.input = input;
+    this.output = output;
+    this.reader = new LineReader({
+      onLine: (line) => this.messageHandler?.(line),
+      onOversize: () => this.errorHandler?.(
+        new Error("frame exceeds " + MAX_FRAME_BYTES + " bytes")
+      )
+    });
+    input.setEncoding("utf8");
+    input.on("data", (chunk) => this.reader.push(chunk));
+    input.on("close", () => this.closeHandler?.());
+    input.on("error", (error) => this.errorHandler?.(error));
+  }
+  input;
+  output;
+  reader;
+  messageHandler = null;
+  closeHandler = null;
+  errorHandler = null;
+  writeLine(line) {
+    this.output.write(line + "\n");
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onClose(handler) {
+    this.closeHandler = handler;
+  }
+  onError(handler) {
+    this.errorHandler = handler;
+  }
+  close() {
+    this.input.destroy();
+  }
+};
+
+// src/errors.ts
+var GP_E_ENGINE_UNREACHABLE = "GP_E_ENGINE_UNREACHABLE";
+var GP_E_BAD_PARAMS = "GP_E_BAD_PARAMS";
+var GP_E_NO_EVIDENCE = "GP_E_NO_EVIDENCE";
+var GP_E_INTERNAL = "GP_E_INTERNAL";
+var GP_E_PROJECT_LIMIT = "GP_E_PROJECT_LIMIT";
+var GP_E_NOT_FOUND = "GP_E_NOT_FOUND";
+function formatToolError(code, message, remedy) {
+  return `${code}: ${message} | remedy: ${remedy}`;
+}
+function formatToolErrorShape(error) {
+  return formatToolError(error.code, error.message, error.remedy);
+}
+
+// src/engine-client.ts
+function daemonUnreachableRemedy() {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const installerCli = path.resolve(here, "..", "..", "installer", "cli.js");
+  if (fs.existsSync(installerCli)) {
+    return `run "node ${installerCli} --restore-launchd" (auto-restores and verifies the launchd-managed daemon), then retry`;
+  }
+  return "ensure the glasspane daemon is running (launchd job com.glasspane.daemon; in a repo checkout run `node installer/cli.js --restore-launchd`), then retry";
+}
+var ENGINE_SOCKET_ENV = "GLASSPANE_ENGINE_SOCK";
+var ENGINE_TIMEOUT_MS = 1e4;
+function defaultSocketPath() {
+  return process.env[ENGINE_SOCKET_ENV] ?? path.join(os.homedir(), ".glasspane", "engine.sock");
+}
+var EngineCallError = class extends Error {
+  code;
+  message;
+  remedy;
+  constructor(code, message, remedy) {
+    super(`${code}: ${message}`);
+    this.name = "EngineCallError";
+    this.code = code;
+    this.message = message;
+    this.remedy = remedy;
+  }
+  toBody() {
+    return { code: this.code, message: this.message, remedy: this.remedy };
+  }
+};
+var EngineJsonRpcClient = class {
+  constructor(io, timeoutMs = ENGINE_TIMEOUT_MS) {
+    this.io = io;
+    this.timeoutMs = timeoutMs;
+    this.io.onMessage((line) => this.handleMessage(line));
+    this.io.onError((error) => this.failAll(new EngineCallError(
+      GP_E_ENGINE_UNREACHABLE,
+      `engine transport error: ${error.message}`,
+      daemonUnreachableRemedy()
+    )));
+    this.io.onClose(() => this.failAll(new EngineCallError(
+      GP_E_ENGINE_UNREACHABLE,
+      "engine transport closed",
+      daemonUnreachableRemedy()
+    )));
+  }
+  io;
+  timeoutMs;
+  nextId = 0;
+  pending = /* @__PURE__ */ new Map();
+  /** Send a request and await its matching response frame. */
+  call(method, params) {
+    const id = this.nextId++;
+    const frame = { id, method, ...params === void 0 ? {} : { params } };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new EngineCallError(
+          GP_E_ENGINE_UNREACHABLE,
+          `engine request timed out after ${this.timeoutMs}ms (method ${method})`,
+          daemonUnreachableRemedy()
+        ));
+      }, this.timeoutMs);
+      this.pending.set(id, {
+        resolve,
+        reject: (reason) => {
+          clearTimeout(timer);
+          reject(reason);
+        }
+      });
+      this.io.writeLine(JSON.stringify(frame));
+    });
+  }
+  close() {
+    this.io.close();
+  }
+  handleMessage(line) {
+    let frame;
+    try {
+      frame = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const entry = this.pending.get(frame.id);
+    if (!entry) {
+      return;
+    }
+    this.pending.delete(frame.id);
+    if (frame.error) {
+      entry.reject(new EngineCallError(frame.error.code, frame.error.message, frame.error.remedy));
+    } else {
+      entry.resolve(frame.result);
+    }
+  }
+  failAll(reason) {
+    for (const entry of this.pending.values()) {
+      entry.reject(reason);
+    }
+    this.pending.clear();
+  }
+};
+function unixSocketEngineClient(socketPath) {
+  const socket = net.createConnection(socketPath);
+  const io = new StreamLineIo(socket, socket);
+  return new EngineJsonRpcClient(io);
+}
+
+// src/audit-session.ts
+var AUDIT_HISTORY_LIMIT = 20;
+var EvidenceAuditSession = class {
+  ids = [];
+  /** Record every operationId/evidenceId found in an engine result frame. */
+  record(result) {
+    for (const id of collectOperationIds(result)) {
+      if (!this.ids.includes(id)) {
+        this.ids.push(id);
+        if (this.ids.length > AUDIT_HISTORY_LIMIT) {
+          this.ids.splice(0, this.ids.length - AUDIT_HISTORY_LIMIT);
+        }
+      }
+    }
+  }
+  /** Clear the trail (called after a successful attach). */
+  reset() {
+    this.ids = [];
+  }
+  /** The most recent `limit` recorded operationIds, oldest first. */
+  recentIds(limit) {
+    return this.ids.slice(-limit);
+  }
+};
+function collectOperationIds(value, depth = 0) {
+  const out = [];
+  if (depth > 3 || value === null || typeof value !== "object") {
+    return out;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      out.push(...collectOperationIds(item, depth + 1));
+    }
+    return out;
+  }
+  const record = value;
+  for (const key of Object.keys(record)) {
+    const entry = record[key];
+    if ((key === "operationId" || key === "evidenceId") && typeof entry === "string") {
+      out.push(entry);
+    } else {
+      out.push(...collectOperationIds(entry, depth + 1));
+    }
+  }
+  return out;
+}
+
+// src/evidence-report.ts
+var PLACEHOLDER = "\u2014";
+function reportTitle(pack) {
+  return `${pack.operationId} \xB7 ${measureLabel(pack)} \xB7 ${levelLabel(pack.circuitBreaker.level)}`;
+}
+function evidenceSummaryLines(pack) {
+  const lines = [];
+  lines.push(`attribution: ${pack.attribution.level} | contaminated=${pack.attribution.contaminated}`);
+  const reason = pack.circuitBreaker.reason === void 0 ? "" : ` | reason: ${pack.circuitBreaker.reason}`;
+  lines.push(`circuitBreaker: level ${pack.circuitBreaker.level} (${levelLabel(pack.circuitBreaker.level)})${reason}`);
+  if (pack.assertion !== void 0 && pack.assertion !== null) {
+    const a = pack.assertion;
+    lines.push(
+      `assert ${a.property} on ${selectorText(a.selector)}: expected=${valueText(a.expected)} actual=${valueText(a.actual)} passed=${a.passed}`
+    );
+  }
+  const act = pack.signals.act;
+  lines.push(`act ${act.action} ${selectorText(act.selector)}: ${act.actConfirmed ? "confirmed" : "rejected"}`);
+  if (pack.signals.axEvent !== void 0) {
+    const ax = pack.signals.axEvent;
+    lines.push(`axEvent: changed=${ax.axChanged} nodes=${ax.nodeCount} latencyMs=${doubleText(ax.latencyMs)}`);
+  }
+  if (pack.signals.pixelDiff !== void 0) {
+    const px = pack.signals.pixelDiff;
+    let line = `pixelDiff: changedRatio=${doubleText(px.changedPixelRatio)} windowId=${px.windowId}`;
+    if (px.bounds !== null) {
+      const b = px.bounds;
+      line += ` bounds=${doubleText(b.x)},${doubleText(b.y)},${doubleText(b.width)},${doubleText(b.height)}`;
+    }
+    lines.push(line);
+  }
+  if (pack.signals.responsiveness !== void 0) {
+    const r = pack.signals.responsiveness;
+    lines.push(`responsiveness: responsive=${r.responsive} pingMs=${doubleText(r.pingMs)}`);
+  }
+  if (pack.signals.crash !== void 0) {
+    const c = pack.signals.crash;
+    lines.push(`crash: aliveBefore=${c.processAliveBefore} aliveAfter=${c.processAliveAfter}`);
+  }
+  return lines;
+}
+function renderMarkdown(pack, diagnostics) {
+  const out = [];
+  out.push(`# ${reportTitle(pack)}`);
+  out.push("");
+  out.push(`**operationId**: ${pack.operationId}`);
+  out.push(`**createdAt**: ${pack.createdAt}`);
+  out.push(`**schemaVersion**: ${pack.schemaVersion}`);
+  for (const line of evidenceSummaryLines(pack)) {
+    out.push(`* ${line}`);
+  }
+  out.push("");
+  for (const section of sections(pack, diagnostics)) {
+    out.push(`## ${section.title}`);
+    out.push("");
+    out.push(section.body);
+    out.push("");
+  }
+  return out.join("\n");
+}
+function renderHTML(pack, diagnostics) {
+  const out = [];
+  out.push(`<div class="gp-evidence" id="${escapeHTML(pack.operationId)}">`);
+  out.push(`<h1>${escapeHTML(reportTitle(pack))}</h1>`);
+  out.push(`<dl class="gp-summary">`);
+  out.push(`<dt>operationId</dt><dd>${escapeHTML(pack.operationId)}</dd>`);
+  out.push(`<dt>createdAt</dt><dd>${escapeHTML(pack.createdAt)}</dd>`);
+  out.push(`<dt>schemaVersion</dt><dd>${escapeHTML(pack.schemaVersion)}</dd>`);
+  for (const line of evidenceSummaryLines(pack)) {
+    out.push(`<dt class="gp-line">\xB7</dt><dd>${escapeHTML(line)}</dd>`);
+  }
+  out.push(`</dl>`);
+  for (const section of sections(pack, diagnostics)) {
+    out.push(`<section class="gp-section">`);
+    out.push(`<h2>${escapeHTML(section.title)}</h2>`);
+    if (section.preformatted) {
+      out.push(`<pre>${escapeHTML(section.body)}</pre>`);
+    } else {
+      out.push(`<p>${escapeHTML(section.body).replace(/\n/g, "<br>")}</p>`);
+    }
+    out.push(`</section>`);
+  }
+  out.push(`</div>`);
+  return out.join("\n");
+}
+function escapeHTML(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+}
+function sections(pack, diagnostics) {
+  const report = pack.diagnosis === null || pack.diagnosis === void 0 ? void 0 : pack.diagnosis.report;
+  const hasDiagnosticsText = diagnostics !== void 0 && diagnostics !== "";
+  const reportEvidence = nonEmpty(report?.evidence);
+  return [
+    { title: "PATH", body: nonEmpty(report?.path) ?? PLACEHOLDER, preformatted: false },
+    { title: "ANOMALY", body: nonEmpty(report?.anomaly) ?? PLACEHOLDER, preformatted: false },
+    {
+      title: "EVIDENCE",
+      body: reportEvidence ?? (hasDiagnosticsText && diagnostics !== void 0 ? diagnostics : PLACEHOLDER),
+      preformatted: reportEvidence === void 0 && hasDiagnosticsText
+    },
+    { title: "NEXT", body: nonEmpty(report?.next) ?? PLACEHOLDER, preformatted: false }
+  ];
+}
+function nonEmpty(value) {
+  return value !== void 0 && value !== "" ? value : void 0;
+}
+function measureLabel(pack) {
+  if (pack.diagnosis !== null && pack.diagnosis !== void 0) {
+    return pack.diagnosis.class;
+  }
+  if (pack.assertion !== null && pack.assertion !== void 0) {
+    return pack.assertion.property;
+  }
+  return pack.signals.act.action;
+}
+function levelLabel(level) {
+  switch (level) {
+    case 0:
+      return "normal";
+    case 1:
+      return "degraded";
+    case 2:
+      return "act_failed_channel_alive";
+    case 3:
+      return "channel_fault";
+    default:
+      return String(level);
+  }
+}
+function selectorText(selector) {
+  let text = selector.role;
+  if (selector.title !== void 0 && selector.title !== "") {
+    text += ` "${selector.title}"`;
+  }
+  if (selector.identifier !== void 0 && selector.identifier !== "") {
+    text += ` #${selector.identifier}`;
+  }
+  return text;
+}
+function valueText(value) {
+  return String(value);
+}
+function doubleText(value) {
+  return String(value);
+}
+
+// src/project-registry.ts
+import fs2 from "node:fs";
+import os2 from "node:os";
+import path2 from "node:path";
+import { z as z4 } from "zod";
+var CROCKFORD_BODY_RE = "[0-9A-HJKMNP-TV-Z]{26}";
+var PROJECT_ID_RE = new RegExp(`^prj_${CROCKFORD_BODY_RE}$`);
+var MAX_PROJECTS = 128;
+var MAX_DISPLAY_NAME_LENGTH = 256;
+var MAX_FIELD_LENGTH = 1024;
+var ProjectListArgs = z4.strictObject({});
+var ProjectGetArgs = z4.strictObject({
+  projectId: z4.string().regex(PROJECT_ID_RE, "projectId must match prj_ + 26 Crockford chars")
+});
+var ProjectSetArgs = z4.strictObject({
+  projectId: z4.string().regex(PROJECT_ID_RE).optional(),
+  displayName: z4.string().min(1).max(MAX_DISPLAY_NAME_LENGTH),
+  bundleId: z4.string().max(256).optional(),
+  pid: z4.number().int().nonnegative().optional(),
+  recipeConfigPath: z4.string().max(MAX_FIELD_LENGTH).optional(),
+  calibrationAssetsPath: z4.string().max(MAX_FIELD_LENGTH).optional(),
+  evidenceStoragePath: z4.string().max(MAX_FIELD_LENGTH).optional()
+}).refine(
+  (v) => v.bundleId !== void 0 !== (v.pid !== void 0),
+  { message: "exactly one of bundleId or pid is required" }
+);
+function projectsPath() {
+  const envPath = process.env["GLASSPANE_PROJECTS_FILE"];
+  if (envPath) return envPath;
+  return path2.join(os2.homedir(), ".glasspane", "projects.json");
+}
+function loadProjects(filePath) {
+  try {
+    const raw = fs2.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed;
+  } catch {
+    return [];
+  }
+}
+function saveProjects(filePath, entries) {
+  const dir = path2.dirname(filePath);
+  fs2.mkdirSync(dir, { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  fs2.writeFileSync(tmpPath, JSON.stringify(entries, null, 2), "utf8");
+  fs2.renameSync(tmpPath, filePath);
+}
+function projectList() {
+  return loadProjects(projectsPath());
+}
+function projectGet(projectId) {
+  const projects = loadProjects(projectsPath());
+  return projects.find((p) => p.projectId === projectId);
+}
+function projectSet(args) {
+  const filePath = projectsPath();
+  const projects = loadProjects(filePath);
+  let entry;
+  const projectId = args.projectId;
+  if (projectId) {
+    const idx = projects.findIndex((p) => p.projectId === projectId);
+    if (idx === -1) {
+      throw new ProjectRegistryError("GP_E_NOT_FOUND", `unknown projectId ${projectId}`);
+    }
+    const existing = projects[idx];
+    entry = {
+      ...existing,
+      displayName: args.displayName,
+      ...args.bundleId !== void 0 ? { bundleId: args.bundleId } : {},
+      ...args.pid !== void 0 ? { pid: args.pid } : {},
+      ...args.recipeConfigPath !== void 0 ? { recipeConfigPath: args.recipeConfigPath } : {},
+      ...args.calibrationAssetsPath !== void 0 ? { calibrationAssetsPath: args.calibrationAssetsPath } : {},
+      ...args.evidenceStoragePath !== void 0 ? { evidenceStoragePath: args.evidenceStoragePath } : {}
+    };
+    projects[idx] = entry;
+  } else {
+    if (projects.length >= MAX_PROJECTS) {
+      throw new ProjectRegistryError("GP_E_PROJECT_LIMIT", `project limit reached (${MAX_PROJECTS})`);
+    }
+    const projectId2 = generateProjectId();
+    entry = {
+      projectId: projectId2,
+      displayName: args.displayName,
+      bundleId: args.bundleId,
+      pid: args.pid,
+      recipeConfigPath: args.recipeConfigPath,
+      calibrationAssetsPath: args.calibrationAssetsPath,
+      evidenceStoragePath: args.evidenceStoragePath,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    projects.push(entry);
+  }
+  saveProjects(filePath, projects);
+  return entry;
+}
+function generateProjectId() {
+  const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+  const body = [];
+  const bytes = new Uint8Array(26);
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 26; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  for (let i = 0; i < 26; i++) {
+    const byte = bytes[i];
+    body.push(CROCKFORD.charAt(byte % 32));
+  }
+  return `prj_${body.join("")}`;
+}
+var ProjectRegistryError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ProjectRegistryError";
+    this.code = code;
+  }
+};
+
+// src/tools.ts
+var OptionalUintSchema = z5.number().int().nonnegative().optional();
+var OptionalDepthSchema = z5.number().int().min(1).max(10).optional();
+var OptionalRoleSchema = z5.string().max(128).optional();
+var OptionalBundleIdSchema = z5.string().max(256).optional();
+var OptionalOperationIdSchema = z5.string().regex(/^op_[0-9A-HJKMNP-TV-Z]{26}$/).optional();
+var OptionalProjectIdSchema = z5.string().regex(/^prj_[0-9A-HJKMNP-TV-Z]{26}$/).optional();
+var ExpectSchema = z5.union([z5.string().max(512), z5.boolean()]);
+var SnapshotIdSchema = z5.string().regex(/^snap_[0-9A-HJKMNP-TV-Z]{26}$/);
+var ActStepSchema = z5.strictObject({
+  selector: SelectorSchema,
+  action: ActionSchema
+});
+var RestoreStepsSchema = z5.array(ActStepSchema).min(1).max(64).optional();
+var RestoreModeSchema = z5.string().max(32).optional();
+var AttachArgs = z5.strictObject({
+  bundleId: OptionalBundleIdSchema,
+  pid: OptionalUintSchema,
+  projectId: OptionalProjectIdSchema
+}).refine((v) => v.bundleId !== void 0 || v.pid !== void 0, {
+  message: "attach requires either bundleId or pid"
+});
+var ObserveArgs = z5.strictObject({
+  maxDepth: OptionalDepthSchema,
+  role: OptionalRoleSchema
+});
+var ActArgs = z5.strictObject({
+  selector: SelectorSchema,
+  action: ActionSchema,
+  degrade: z5.boolean().optional()
+});
+var AssertElementArgs = z5.strictObject({
+  selector: SelectorSchema,
+  property: AssertionPropertySchema,
+  expected: ExpectSchema
+});
+var DiagnoseArgs = z5.strictObject({
+  operationId: OptionalOperationIdSchema
+});
+var LastEvidenceArgs = z5.strictObject({
+  operationId: OptionalOperationIdSchema
+});
+var SnapshotArgs = z5.strictObject({
+  maxDepth: OptionalDepthSchema
+});
+var RestoreArgs = z5.strictObject({
+  snapshotId: SnapshotIdSchema,
+  steps: RestoreStepsSchema,
+  mode: RestoreModeSchema
+});
+var ProbeStatusArgs = z5.strictObject({});
+var ReportFormatSchema = z5.enum(["html", "markdown"]).default("markdown");
+var ExportEvidenceArgs = z5.strictObject({
+  operationId: z5.string().regex(/^op_[0-9A-HJKMNP-TV-Z]{26}$/),
+  format: ReportFormatSchema
+});
+var RecentReportsArgs = z5.strictObject({
+  limit: z5.number().int().min(1).max(20).default(5),
+  format: ReportFormatSchema
+});
+function zodIssueText(error) {
+  return error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ");
+}
+function zodBridge(schema) {
+  return (raw) => {
+    const parsed = schema.safeParse(raw);
+    if (parsed.success) {
+      return { ok: true, value: parsed.data };
+    }
+    return { ok: false, issues: zodIssueText(parsed.error) };
+  };
+}
+var selectorJsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    role: { type: "string", maxLength: 512 },
+    title: { type: "string", maxLength: 512 },
+    identifier: { type: "string", maxLength: 512 }
+  },
+  required: ["role"]
+};
+var TOOL_SPECS = [
+  {
+    name: "gp_attach",
+    description: "Attach the engine to a running app by bundleId or pid.",
+    engineMethod: "attach",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        bundleId: { type: "string", maxLength: 256 },
+        pid: { type: "integer", minimum: 0 },
+        projectId: { type: "string", pattern: "^prj_[0-9A-HJKMNP-TV-Z]{26}$" }
+      },
+      oneOf: [
+        { required: ["bundleId"] },
+        { required: ["pid"] }
+      ]
+    },
+    validate: zodBridge(AttachArgs)
+  },
+  {
+    name: "gp_observe",
+    description: "Snapshot the attached app's accessibility tree.",
+    engineMethod: "observe",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        maxDepth: { type: "integer", minimum: 1, maximum: 10 },
+        role: { type: "string", maxLength: 128 }
+      }
+    },
+    validate: zodBridge(ObserveArgs)
+  },
+  {
+    name: "gp_act",
+    description: "Perform a UI action on the attached app and confirm it. If the daemon reports GP_E_BUSY_INPUT (real user input is contaminating the window), retry later, or set degrade: true to proceed immediately with the contamination recorded in evidence (attribution becomes weak + contaminated=true) \u2014 never silently clean.",
+    engineMethod: "act",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        selector: selectorJsonSchema,
+        action: {
+          type: "string",
+          enum: ["press", "increment", "decrement", "showMenu", "confirm", "cancel", "pick"]
+        },
+        degrade: { type: "boolean" }
+      },
+      required: ["selector", "action"]
+    },
+    validate: zodBridge(ActArgs)
+  },
+  {
+    name: "gp_assert_element",
+    description: "Assert a property of an element in the attached app.",
+    engineMethod: "assert_element",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        selector: selectorJsonSchema,
+        property: { type: "string", enum: ["title", "value", "role", "enabled", "focused"] },
+        expected: { oneOf: [{ type: "string", maxLength: 512 }, { type: "boolean" }] }
+      },
+      required: ["selector", "property", "expected"]
+    },
+    validate: zodBridge(AssertElementArgs)
+  },
+  {
+    name: "gp_diagnose",
+    description: "Diagnose the most recent (or the given) operation.",
+    engineMethod: "diagnose",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        operationId: { type: "string", pattern: "^op_[0-9A-HJKMNP-TV-Z]{26}$" }
+      }
+    },
+    validate: zodBridge(DiagnoseArgs)
+  },
+  {
+    name: "gp_last_evidence",
+    description: "Return the full evidence pack for the most recent (or given) operation.",
+    engineMethod: "last_evidence",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        operationId: { type: "string", pattern: "^op_[0-9A-HJKMNP-TV-Z]{26}$" }
+      }
+    },
+    validate: zodBridge(LastEvidenceArgs)
+  },
+  {
+    name: "gp_snapshot",
+    description: "Capture a digest-only baseline of the attached app's AX tree for later restore.",
+    engineMethod: "snapshot",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        maxDepth: { type: "integer", minimum: 1, maximum: 10 }
+      }
+    },
+    validate: zodBridge(SnapshotArgs)
+  },
+  {
+    name: "gp_restore",
+    description: "Restore from a snapshot: replay act steps over the baseline (tier-2 ffwd), or compare the current tree against it when steps are omitted.",
+    engineMethod: "restore",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        snapshotId: { type: "string", pattern: "^snap_[0-9A-HJKMNP-TV-Z]{26}$" },
+        steps: {
+          type: "array",
+          minItems: 1,
+          maxItems: 64,
+          items: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+              selector: selectorJsonSchema,
+              action: {
+                type: "string",
+                enum: ["press", "increment", "decrement", "showMenu", "confirm", "cancel", "pick"]
+              }
+            },
+            required: ["selector", "action"]
+          }
+        },
+        mode: { type: "string", maxLength: 32 }
+      },
+      required: ["snapshotId"]
+    },
+    validate: zodBridge(RestoreArgs)
+  },
+  {
+    name: "gp_probe_status",
+    description: "List GlassPaneProbe connections (pid, capabilities, events seen) and whether the attached app has a live probe \u2014 probe presence is what makes T4/T5/T7/T8 verdicts and tier-1 checkpoint restores decidable.",
+    engineMethod: "probe_status",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {}
+    },
+    validate: zodBridge(ProbeStatusArgs)
+  },
+  {
+    name: "gp_export_evidence",
+    description: "Render one operation's evidence pack as a human-readable report (HTML or Markdown) for the developer audit view.",
+    engineMethod: "export_evidence",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        operationId: { type: "string", pattern: "^op_[0-9A-HJKMNP-TV-Z]{26}$" },
+        format: { type: "string", enum: ["html", "markdown"] }
+      },
+      required: ["operationId"]
+    },
+    validate: zodBridge(ExportEvidenceArgs),
+    execute: exportEvidence
+  },
+  {
+    name: "gp_recent_reports",
+    description: "Aggregate the most recent operations' four-section reports (HTML or Markdown) into one audit view.",
+    engineMethod: "recent_reports",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        limit: { type: "integer", minimum: 1, maximum: 20 },
+        format: { type: "string", enum: ["html", "markdown"] }
+      }
+    },
+    validate: zodBridge(RecentReportsArgs),
+    execute: recentReports
+  },
+  {
+    name: "gp_project_list",
+    description: "List all registered GlassPane projects (P1 spec v1.4).",
+    engineMethod: "project_list",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {}
+    },
+    validate: zodBridge(ProjectListArgs),
+    execute: projectListTool
+  },
+  {
+    name: "gp_project_set",
+    description: "Create or update a GlassPane project. Omit projectId to register a new project; include it to update an existing one.",
+    engineMethod: "project_set",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        projectId: { type: "string", pattern: "^prj_[0-9A-HJKMNP-TV-Z]{26}$" },
+        displayName: { type: "string", minLength: 1, maxLength: 256 },
+        bundleId: { type: "string", maxLength: 256 },
+        pid: { type: "integer", minimum: 0 },
+        recipeConfigPath: { type: "string", maxLength: 1024 },
+        calibrationAssetsPath: { type: "string", maxLength: 1024 },
+        evidenceStoragePath: { type: "string", maxLength: 1024 }
+      },
+      required: ["displayName"],
+      oneOf: [
+        { required: ["bundleId"] },
+        { required: ["pid"] }
+      ]
+    },
+    validate: zodBridge(ProjectSetArgs),
+    execute: projectSetTool
+  },
+  {
+    name: "gp_project_get",
+    description: "Fetch one GlassPane project by its project ID.",
+    engineMethod: "project_get",
+    inputSchema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        projectId: { type: "string", pattern: "^prj_[0-9A-HJKMNP-TV-Z]{26}$" }
+      },
+      required: ["projectId"]
+    },
+    validate: zodBridge(ProjectGetArgs),
+    execute: projectGetTool
+  }
+];
+var TOOL_BY_NAME = new Map(
+  TOOL_SPECS.map((spec) => [spec.name, spec])
+);
+async function executeTool(spec, args, engine, session = new EvidenceAuditSession()) {
+  const checked = spec.validate(args);
+  if (!checked.ok) {
+    return {
+      content: [{ type: "text", text: formatToolError(
+        GP_E_BAD_PARAMS,
+        `invalid arguments for ${spec.name}`,
+        `check the tool's input schema; ${checked.issues}`
+      ) }],
+      isError: true
+    };
+  }
+  if (spec.execute !== void 0) {
+    return spec.execute(checked.value, { engine, session });
+  }
+  try {
+    const raw = await engine.call(spec.engineMethod, checked.value);
+    if (spec.name === "gp_attach") {
+      session.reset();
+    }
+    if (spec.engineMethod === "last_evidence") {
+      parseEvidenceFrame(raw);
+    }
+    session.record(raw);
+    return {
+      content: [{ type: "text", text: canonicalJson(raw) }],
+      isError: false
+    };
+  } catch (error) {
+    if (error instanceof EngineCallError) {
+      return {
+        content: [{ type: "text", text: formatToolErrorShape(error.toBody()) }],
+        isError: true
+      };
+    }
+    if (error instanceof KernelSchemaError) {
+      return {
+        content: [{ type: "text", text: formatToolError(
+          GP_E_INTERNAL,
+          `engine returned an invalid evidence pack: ${error.message}`,
+          "engine and kernel schema drifted; fix the common fixtures (assertion C35)"
+        ) }],
+        isError: true
+      };
+    }
+    return {
+      content: [{ type: "text", text: formatToolError(
+        GP_E_INTERNAL,
+        `internal shell error: ${String(error)}`,
+        "see the MCP server logs and retry"
+      ) }],
+      isError: true
+    };
+  }
+}
+function parseEvidenceFrame(raw) {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new KernelSchemaError("evidence pack", [{
+      path: "evidencePack",
+      message: "expected an object frame with a nested evidencePack field"
+    }]);
+  }
+  const frame = raw;
+  if (typeof frame.evidencePack !== "object" || frame.evidencePack === null) {
+    throw new KernelSchemaError("evidence pack", [{
+      path: "evidencePack",
+      message: "missing evidencePack field in last_evidence result"
+    }]);
+  }
+  return parseEvidencePack(frame.evidencePack);
+}
+async function projectListTool() {
+  const projects = projectList();
+  return {
+    content: [{ type: "text", text: canonicalJson({ projects }) }],
+    isError: false
+  };
+}
+async function projectSetTool(args) {
+  try {
+    const entry = projectSet(args);
+    return { content: [{ type: "text", text: canonicalJson({ project: entry }) }], isError: false };
+  } catch (error) {
+    return mapProjectError(error);
+  }
+}
+async function projectGetTool(args) {
+  const argv = args;
+  const entry = projectGet(argv.projectId);
+  if (entry === void 0) {
+    return {
+      content: [{ type: "text", text: formatToolError(
+        "GP_E_NOT_FOUND",
+        `unknown project ${argv.projectId}`,
+        "check the projectId; use gp_project_list to view available projects"
+      ) }],
+      isError: true
+    };
+  }
+  return { content: [{ type: "text", text: canonicalJson({ project: entry }) }], isError: false };
+}
+function mapProjectError(error) {
+  if (error instanceof ProjectRegistryError) {
+    return {
+      content: [{ type: "text", text: formatToolError(
+        error.code,
+        error.message,
+        error.code === GP_E_PROJECT_LIMIT ? "delete unused projects first, then retry" : error.code === GP_E_NOT_FOUND ? "check the projectId; use gp_project_list to view available projects" : "check the tool's input schema and retry"
+      ) }],
+      isError: true
+    };
+  }
+  return {
+    content: [{ type: "text", text: formatToolError(
+      GP_E_INTERNAL,
+      `internal shell error in project registry: ${String(error)}`,
+      "see the MCP server logs and retry"
+    ) }],
+    isError: true
+  };
+}
+async function exportEvidence(args, context) {
+  const argv = args;
+  const render = argv.format === "html" ? renderHTML : renderMarkdown;
+  try {
+    const raw = await context.engine.call("last_evidence", { operationId: argv.operationId });
+    const pack = parseEvidenceFrame(raw);
+    context.session.record(raw);
+    return { content: [{ type: "text", text: render(pack, void 0) }], isError: false };
+  } catch (error) {
+    return mapAuditError(error);
+  }
+}
+async function recentReports(args, context) {
+  const argv = args;
+  const ids = context.session.recentIds(argv.limit);
+  if (ids.length === 0) {
+    return {
+      content: [{ type: "text", text: formatToolError(
+        GP_E_NO_EVIDENCE,
+        "no operations recorded in this session",
+        "run gp_act / gp_assert_element first, then retry gp_recent_reports"
+      ) }],
+      isError: true
+    };
+  }
+  const packs = [];
+  const skipped = [];
+  for (const id of ids) {
+    try {
+      const raw = await context.engine.call("last_evidence", { operationId: id });
+      packs.push({ id, pack: parseEvidenceFrame(raw) });
+    } catch (error) {
+      if (error instanceof EngineCallError && error.code === GP_E_NO_EVIDENCE) {
+        skipped.push(id);
+      } else {
+        return mapAuditError(error);
+      }
+    }
+  }
+  if (packs.length === 0) {
+    return {
+      content: [{ type: "text", text: formatToolError(
+        GP_E_NO_EVIDENCE,
+        "no recent evidence is reachable in the daemon history",
+        "the engine may have restarted; re-run gp_act / gp_assert_element to regenerate evidence"
+      ) }],
+      isError: true
+    };
+  }
+  const render = argv.format === "html" ? renderHTML : renderMarkdown;
+  const header = argv.format === "html" ? `<h1>GlassPane recent reports (${packs.length})</h1>` : `# GlassPane recent reports (${packs.length})`;
+  const skipNote = skipped.length === 0 ? "" : argv.format === "html" ? `<p class="gp-skipped">skipped ${skipped.length} unreachable ${skipped.length === 1 ? "entry" : "entries"}: ${escapeHTML(skipped.join(", "))}</p>` : `> skipped ${skipped.length} unreachable ${skipped.length === 1 ? "entry" : "entries"}: ${skipped.join(", ")}`;
+  const separator = argv.format === "html" ? "\n<hr>\n" : "\n\n---\n";
+  const body = packs.map(({ pack }) => render(pack, void 0)).join(separator);
+  const sections2 = [header];
+  if (skipNote !== "") {
+    sections2.push(skipNote);
+  }
+  sections2.push(body);
+  return { content: [{ type: "text", text: sections2.join("\n") }], isError: false };
+}
+function mapAuditError(error) {
+  if (error instanceof EngineCallError) {
+    return {
+      content: [{ type: "text", text: formatToolErrorShape(error.toBody()) }],
+      isError: true
+    };
+  }
+  if (error instanceof KernelSchemaError) {
+    return {
+      content: [{ type: "text", text: formatToolError(
+        GP_E_INTERNAL,
+        `engine returned an invalid evidence pack: ${error.message}`,
+        "engine and kernel schema drifted; fix the common fixtures (assertion C35)"
+      ) }],
+      isError: true
+    };
+  }
+  return {
+    content: [{ type: "text", text: formatToolError(
+      GP_E_INTERNAL,
+      `internal shell error: ${String(error)}`,
+      "see the MCP server logs and retry"
+    ) }],
+    isError: true
+  };
+}
+
+// src/dispatch.ts
+var JSONRPC = "2.0";
+var MCP_PROTOCOL_VERSION = "2025-06-18";
+var SERVER_INFO = { name: "glasspane-mcp", version: "0.1.0" };
+var PARSE_ERROR = -32700;
+var INVALID_REQUEST = -32600;
+var METHOD_NOT_FOUND = -32601;
+var INVALID_PARAMS = -32602;
+var INTERNAL_ERROR = -32603;
+var McpServer = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.specs = deps.specs ?? TOOL_SPECS;
+    this.session = deps.session ?? new EvidenceAuditSession();
+  }
+  deps;
+  specs;
+  session;
+  /** Handle a single newline-delimited frame; returns a response or null. */
+  async handleLine(line) {
+    if (line.trim() === "") {
+      return null;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      return this.error(PARSE_ERROR, "Parse error", null);
+    }
+    if (!this.isRequestBody(parsed)) {
+      return this.error(INVALID_REQUEST, "Invalid Request", null);
+    }
+    const request = parsed;
+    if (request.id === void 0) {
+      await this.handleNotification(request);
+      return null;
+    }
+    if (typeof request.id !== "number" && typeof request.id !== "string") {
+      return this.error(INVALID_REQUEST, "Invalid Request", null);
+    }
+    try {
+      return await this.dispatch(request, request.id);
+    } catch (error) {
+      return this.error(INTERNAL_ERROR, `Internal error: ${String(error)}`, request.id);
+    }
+  }
+  async handleNotification(request) {
+  }
+  async dispatch(request, id) {
+    if (typeof request.method !== "string") {
+      return this.error(INVALID_REQUEST, "Invalid Request", id);
+    }
+    switch (request.method) {
+      case "initialize":
+        return this.result(id, {
+          protocolVersion: MCP_PROTOCOL_VERSION,
+          capabilities: { tools: { listChanged: false } },
+          serverInfo: SERVER_INFO
+        });
+      case "ping":
+        return this.result(id, {});
+      case "tools/list":
+        return this.result(id, {
+          tools: this.specs.map((spec) => ({
+            name: spec.name,
+            description: spec.description,
+            inputSchema: spec.inputSchema
+          }))
+        });
+      case "tools/call":
+        return this.callTool(id, request.params);
+      default:
+        return this.error(METHOD_NOT_FOUND, `Method not found: ${request.method}`, id);
+    }
+  }
+  async callTool(id, rawParams) {
+    const params = this.asParams(rawParams);
+    if (!params) {
+      return this.error(INVALID_PARAMS, "tools/call requires an object params", id);
+    }
+    const name = params.name;
+    if (typeof name !== "string") {
+      return this.error(INVALID_PARAMS, "tools/call requires a string name", id);
+    }
+    const spec = this.specs.find((candidate) => candidate.name === name);
+    if (!spec) {
+      return this.error(INVALID_PARAMS, `Unknown tool: ${name}`, id);
+    }
+    const outcome = await executeTool(spec, params.arguments, this.deps.engine, this.session);
+    return this.result(id, { content: outcome.content, isError: outcome.isError });
+  }
+  asParams(rawParams) {
+    if (typeof rawParams !== "object" || rawParams === null || Array.isArray(rawParams)) {
+      return null;
+    }
+    return rawParams;
+  }
+  isRequestBody(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      return false;
+    }
+    const candidate = value;
+    return candidate.jsonrpc === JSONRPC;
+  }
+  result(id, result) {
+    return { jsonrpc: JSONRPC, id, result };
+  }
+  error(code, message, id) {
+    return { jsonrpc: JSONRPC, id, error: { code, message } };
+  }
+};
+
+// src/index.ts
+function parseArgs(argv) {
+  const options = { socketPath: defaultSocketPath(), help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--help" || arg === "-h") {
+      options.help = true;
+    } else if (arg === "--socket-path" || arg === "-s") {
+      const value = argv[i + 1];
+      if (value === void 0) {
+        throw new Error("--socket-path requires a value");
+      }
+      options.socketPath = value;
+      i += 1;
+    } else if (arg.startsWith("--socket-path=")) {
+      options.socketPath = arg.slice("--socket-path=".length);
+    }
+  }
+  return options;
+}
+var USAGE = `usage: glasspane-mcp [--socket-path <path>]
+
+Bridges an AI agent (MCP stdio) to the GlassPane engine daemon.
+The daemon socket defaults to $HOME/.glasspane/engine.sock
+(override with GLASSPANE_ENGINE_SOCK or --socket-path).
+`;
+var ReplyQueue = class {
+  tail = Promise.resolve();
+  push(run) {
+    this.tail = this.tail.then(run);
+  }
+};
+function main() {
+  let options;
+  try {
+    options = parseArgs(process2.argv.slice(2));
+  } catch (error) {
+    process2.stderr.write(String(error) + "\n\n" + USAGE);
+    process2.exit(2);
+  }
+  if (options.help) {
+    process2.stdout.write(USAGE);
+    process2.exit(0);
+  }
+  process2.stdin.setEncoding("utf8");
+  const queue = new ReplyQueue();
+  let engine;
+  try {
+    engine = unixSocketEngineClient(options.socketPath);
+  } catch (error) {
+    process2.stderr.write(
+      `failed to create engine client on ${options.socketPath}: ${String(error)}
+`
+    );
+    process2.exit(2);
+  }
+  const server = new McpServer({ engine });
+  const reader = new LineReader({
+    onLine: (line) => {
+      queue.push(async () => {
+        const response = await server.handleLine(line);
+        if (response !== null) {
+          process2.stdout.write(canonicalJson(response) + "\n");
+        }
+      });
+    },
+    onOversize: (bytes) => {
+      process2.stderr.write(`dropping oversized stdio frame (${bytes} bytes)
+`);
+    }
+  });
+  process2.stdin.on("data", (chunk) => reader.push(chunk));
+  let shuttingDown = false;
+  const shutdown = () => {
+    if (shuttingDown) {
+      return;
+    }
+    shuttingDown = true;
+    engine.close();
+    process2.stdin.destroy();
+    process2.stdout.end();
+  };
+  process2.stdin.on("close", () => queue.push(async () => shutdown()));
+  process2.on("SIGINT", shutdown);
+  process2.on("SIGTERM", shutdown);
+}
+main();