glasspane-mcp 1.16.3 → 1.18.0

package/README.md

@@ -36,9 +36,13 @@ MCP 客户端配置：
 
 ## What ships in this package / 包里有什么
 
-`dist/index.js` 是 esbuild 单文件产物：`@iterate/kernel`（schema 真源）在发布时
-已捆绑内联，包内不存在指向源码仓库的 `file:` 依赖；`schemas/` 是 kernel schema
-的发布副本，每次 `npm run bundle` 重新同步。
+`dist/index.js` 是 esbuild 单文件产物：已发布的 `iterate-kernel`（schema 真源，devDependency，
+只按 `iterate-kernel/<module>` 子路径引入）在发布时已捆绑内联，包内不存在指向源码仓库的
+`file:` 依赖，也不残留一个裸的 `import "iterate-kernel"`——后者会让装到本机的产物去解析一份
+没人拿这份产物对照过的内核，比 `ERR_MODULE_NOT_FOUND` 安静，但不更安全；发布档的
+bundle-shape 闸专拒这一条。`schemas/` 是内核契约的发布副本，每次 `npm run bundle` 由
+`scripts/bundle-kernel-schemas.mjs` 从**装好的那一份包**重新同步，并核
+manifest 声明 = 装到的 = fork 的 pin 三者同号。
 
 两个入口，各自是什么就按什么用 / two entries, each with one job：
 

package/dist/dispatch.d.ts

@@ -26,7 +26,7 @@ export declare const MCP_PROTOCOL_VERSION: "2025-06-18";
 export declare const SUPPORTED_PROTOCOL_VERSIONS: readonly string[];
 export declare const SERVER_INFO: {
     readonly name: "glasspane-mcp";
-    readonly version: "1.16.3";
+    readonly version: "1.18.0";
 };
 export declare const PARSE_ERROR = -32700;
 export declare const INVALID_REQUEST = -32600;
@@ -92,6 +92,22 @@ export declare class McpServer {
     private asParams;
     private isRequestBody;
     private result;
+    /**
+     * The example for the two `tools/call` **shape** refusals, taken from the list this server
+     * actually answers. A JSON-RPC reader cannot open a source symbol, and an example naming a
+     * tool this surface does not publish would be a second refusal waiting to happen — so the
+     * preference is a published tool that is legal to call with an empty `arguments`.
+     * `test/dispatch.test.mjs` checks every name in this sentence against `tools/list`, and
+     * checks it again on a server deliberately built with a one-tool list.
+     */
+    private callShapeRemedy;
+    /**
+     * The names this server actually answers with, nearest the caller's guess first. Every
+     * name offered here is one `tools/list` just advertised: a suggestion the caller cannot
+     * call is worse than no suggestion, and the point of the sentence is to end the guessing
+     * loop a bare `Unknown tool: gp_acti` left the caller in.
+     */
+    private publishedNamesNear;
     private error;
 }
 /**

package/dist/engine-client.d.ts

@@ -184,6 +184,28 @@ export declare const RESTORE_BASE_DEADLINE_MS = 30000;
 export declare function isReplayUnsafeMethod(method: string): boolean;
 /** The non-replayable methods, for gates that must see the set change on purpose. */
 export declare const REPLAY_UNSAFE_METHOD_NAMES: readonly string[];
+/**
+ * The answer this shell gives when the daemon's error frame carries no remedy at all.
+ *
+ * It used to be one sentence for every method — "check the daemon log (stderr) and retry" —
+ * which made the transport order by words the re-send it refuses by behaviour: `act`,
+ * `restore` and `attach` are the methods {@link REPLAY_UNSAFE_REASONS} exists to keep off
+ * the wire a second time, `slowEngineRemedy` says *do NOT re-issue* for them, and
+ * `writeBacklogRemedy` refuses even to name a probe while one is outstanding. An error
+ * frame is the daemon's answer to *this* request, so the request did reach the service —
+ * and whether the change took effect before the error was raised is a thing no error frame
+ * says, which is exactly why the sentence may not spend that unknown on a second copy.
+ * `snapshot` is the third case and the one a blanket "retry" also got wrong: nothing is
+ * pressed twice, but every accepted copy writes another entry into the daemon's bounded
+ * ring and can evict the baseline an earlier snapshot returned — the one a later restore
+ * still needs. Membership comes from the two lists this file already keeps, so a method
+ * moving between them moves this answer with it.
+ *
+ * `null` is the unattributed case: an id-less frame this client could not tie to a request
+ * it still tracks, where naming a method would be a guess and authorising a re-send on top
+ * of the guess would be worse.
+ */
+export declare function noRemedyFallback(method: string | null): string;
 /**
  * `hello.capabilities` 的第一个读者（2026-10-11）。
  *
@@ -410,6 +432,13 @@ export declare class EngineJsonRpcClient {
      * unexposed; `index.ts` supplies the real list.
      */
     expectedDaemonMethods?: readonly string[]);
+    /**
+     * The state root the daemon named in its own `hello` (additive since 1.15.0), or null
+     * when no handshake answered that key. `null` means "this daemon does not report it" —
+     * never "therefore it is the home default"; callers say which of the two they used.
+     */
+    private helloStateRoot;
+    get reportedStateRoot(): string | null;
     /**
      * Sink for facts that cannot be attached to any request of the caller: a
      * late reply, a frame with an id this client never issued, a daemon that

package/dist/evidence-report.d.ts

@@ -1,4 +1,4 @@
-import type { EvidencePack } from "@iterate/kernel";
+import type { EvidencePack } from "iterate-kernel/evidence-pack";
 /**
  * What a report may be handed: a validated pack, or the same structure with
  * `schemaVersion` widened so it can carry provenance text

package/dist/http-gateway-cli.js

@@ -269,6 +269,20 @@ function isReplayUnsafeMethod(method) {
   return Object.prototype.hasOwnProperty.call(REPLAY_UNSAFE_REASONS, method);
 }
 var REPLAY_UNSAFE_METHOD_NAMES = Object.keys(REPLAY_UNSAFE_REASONS);
+function noRemedyFallback(method) {
+  const readTheLog = "the engine sent no remedy for this error code, and the daemon's own log (stderr) is the only side that can say what it refused; this shell cannot see past the frame it was handed";
+  if (method === null) {
+    return `${readTheLog}. This frame was not attributed to a request this client still tracks, so nothing here says which method it answers, and this line authorises no re-send`;
+  }
+  const unsafe = REPLAY_UNSAFE_REASONS[method];
+  if (unsafe !== void 0) {
+    return `${readTheLog}. Do not re-issue '${method}' on the strength of this answer: the frame is proof the request reached the daemon, and no error frame says whether the change took effect before it was raised \u2014 this shell never replays it on its own either, because ${unsafe}`;
+  }
+  if (STATE_CHANGING_ON_RETRY_METHOD_NAMES.includes(method)) {
+    return `${readTheLog}. A second '${method}' is not a cheaper copy of the first: it writes daemon state again, the snapshot ring the daemon keeps is bounded, and one more entry can evict the baseline an earlier snapshot returned \u2014 the one a later restore still needs. Read what the first answer said before asking for another`;
+  }
+  return `${readTheLog}, and a retry is the plain next step: '${method}' is not a method this shell refuses to replay, so nothing is performed twice. Change what the request carries if a different answer is wanted \u2014 nothing here says the daemon will answer this one differently`;
+}
 function describeCapabilityDrift(advertised, forwarded) {
   if (advertised === null) {
     return "engine self-report carries no capabilities list, so this shell cannot say which daemon methods it measured; every tool result in this session is unverified against the daemon's own method table (an engine older than the capability list, or a hello that was cut short)";
@@ -429,6 +443,15 @@ var EngineJsonRpcClient = class {
     lateReplyHandler: null
   };
   pending = /* @__PURE__ */ new Map();
+  /**
+   * The state root the daemon named in its own `hello` (additive since 1.15.0), or null
+   * when no handshake answered that key. `null` means "this daemon does not report it" —
+   * never "therefore it is the home default"; callers say which of the two they used.
+   */
+  helloStateRoot = null;
+  get reportedStateRoot() {
+    return this.helloStateRoot;
+  }
   /**
    * Sink for facts that cannot be attached to any request of the caller: a
    * late reply, a frame with an id this client never issued, a daemon that
@@ -599,7 +622,7 @@ var EngineJsonRpcClient = class {
           return;
         }
         if (frame.error) {
-          this.reject(target, attribute(this.engineError(frame.error), target));
+          this.reject(target, attribute(this.engineError(frame.error, target.method), target));
           target.arrivalOrderConsumed = true;
           this.retainForLateReply();
           return;
@@ -607,20 +630,20 @@ var EngineJsonRpcClient = class {
         this.report(`engine sent an id-less frame with a result while '${target.method}' (id ${target.id}) is still waiting for its answer; an id-less answer from this daemon is an error frame, so this one was not delivered to any caller: ${truncate(line)}`);
         return;
       }
-      this.report(frame.error ? `engine reported ${this.engineError(frame.error).code} with no request in flight: ${truncate(line)}` : `engine sent an id-less frame with no request in flight: ${truncate(line)}`);
+      this.report(frame.error ? `engine reported ${this.engineError(frame.error, null).code} with no request in flight: ${truncate(line)}` : `engine sent an id-less frame with no request in flight: ${truncate(line)}`);
       return;
     }
     this.report(`engine sent a frame with a non-numeric request id (${jsonOrString(id)}), which this client never issues: ${truncate(line)}`);
   }
   settleFromFrame(entry, frame) {
     if (frame.error) {
-      this.reject(entry, this.engineError(frame.error));
+      this.reject(entry, this.engineError(frame.error, entry.method));
       return;
     }
-    if (!("result" in frame)) {
+    if (!("result" in frame) || frame.result === null) {
       this.reject(entry, new EngineCallError(
         GP_E_INTERNAL,
-        `engine answered '${entry.method}' with a frame carrying neither result nor error`,
+        frame.result === null ? `engine answered '${entry.method}' with a frame whose result is null: the key is present but carries no answer` : `engine answered '${entry.method}' with a frame carrying neither result nor error`,
         "do not read this call as successful: the engine answered nothing. Retry once, then check the daemon log (stderr) for what it died before answering"
       ));
       return;
@@ -654,11 +677,11 @@ var EngineJsonRpcClient = class {
       "narrow this request or ask for less of it; the tool's own schema names the parameters that can shrink a reply, and this shell rewrites this line into that advice when it can (the transport layer deliberately does not guess them)"
     ), entry, inferred));
   }
-  engineError(body) {
+  engineError(body, method) {
     return new EngineCallError(
       String(body.code ?? GP_E_UNKNOWN),
       String(body.message ?? "the engine sent an error frame without a message"),
-      typeof body.remedy === "string" && body.remedy !== "" ? body.remedy : "the engine sent no remedy for this error code; check the daemon log (stderr) and retry"
+      typeof body.remedy === "string" && body.remedy !== "" ? body.remedy : noRemedyFallback(method)
     );
   }
   /**
@@ -815,6 +838,10 @@ var EngineJsonRpcClient = class {
       return;
     }
     const version = typeof report.version === "string" ? report.version : null;
+    const reportedRoot = typeof report.stateRoot === "string" ? report.stateRoot.trim() : "";
+    if (reportedRoot !== "") {
+      this.helloStateRoot = reportedRoot;
+    }
     const wantVersion = this.identity?.version;
     if (version !== null && wantVersion !== void 0 && version !== wantVersion) {
       this.report(`version mismatch: engine self-reports '${version}', this MCP shell ships '${wantVersion}' (single version line) \u2014 one side is stale`);
@@ -1154,22 +1181,7 @@ function exponentialFromDigits(digits, power) {
 // src/tools.ts
 import { z as z10 } 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");
-var RUN_PLAN_JSON_SCHEMA = loadSchema("../schemas/run-plan.schema.json");
-var INVARIANT_REPORT_JSON_SCHEMA = loadSchema("../schemas/invariant-report.schema.json");
-var REVERIFICATION_REQUEST_JSON_SCHEMA = loadSchema("../schemas/reverification-request.schema.json");
-var CONVERGENCE_ROUND_STATE_JSON_SCHEMA = loadSchema("../schemas/convergence-round-state.schema.json");
-var PROVIDER_REGISTRATION_JSON_SCHEMA = loadSchema("../schemas/provider-registration.schema.json");
-
-// ../kernel/dist/evidence-pack.js
+// ../node_modules/iterate-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$/;
@@ -1338,10 +1350,28 @@ function normalizeEvidencePackForRead(input) {
 }
 var EvidencePackReadSchema = z.preprocess(normalizeEvidencePackForRead, EvidencePackSchema);
 
-// ../kernel/dist/decision-log-entry.js
+// ../node_modules/iterate-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;
+  }
+};
+function schemaErrorFrom(label, error) {
+  return new KernelSchemaError(label, error.issues.map((issue) => ({
+    path: issue.path.map((segment) => String(segment)).join("."),
+    message: issue.message
+  })));
+}
+
+// ../node_modules/iterate-kernel/dist/decision-log-entry.js
 import { z as z3 } from "zod";
 
-// ../kernel/dist/canonical-json.js
+// ../node_modules/iterate-kernel/dist/canonical-json.js
 function canonicalJson(value) {
   if (value === null || typeof value !== "object") {
     return JSON.stringify(value);
@@ -1354,7 +1384,7 @@ function canonicalJson(value) {
   return "{" + keys.map((key) => JSON.stringify(key) + ":" + canonicalJson(record[key])).join(",") + "}";
 }
 
-// ../kernel/dist/dimension-context.js
+// ../node_modules/iterate-kernel/dist/dimension-context.js
 import { z as z2 } from "zod";
 var DIMENSION_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
 var DIMENSION_ID_MAX_LENGTH = 64;
@@ -1397,7 +1427,7 @@ var DimensionContextInputSchema = z2.strictObject({
   recorded: z2.record(z2.string().regex(DIMENSION_ID_PATTERN).max(DIMENSION_ID_MAX_LENGTH), DimensionEvidenceSchema)
 });
 
-// ../kernel/dist/decision-log-entry.js
+// ../node_modules/iterate-kernel/dist/decision-log-entry.js
 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;
@@ -1418,25 +1448,7 @@ var DecisionLogEntrySchema = z3.strictObject({
   payload: z3.record(z3.string(), z3.unknown()).optional().refine((value) => value === void 0 || canonicalJson(value).length <= PAYLOAD_MAX_CANONICAL_LENGTH, { message: `payload must stay within ${PAYLOAD_MAX_CANONICAL_LENGTH} characters of canonical JSON` })
 });
 
-// ../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;
-  }
-};
-function schemaErrorFrom(label, error) {
-  return new KernelSchemaError(label, error.issues.map((issue) => ({
-    path: issue.path.map((segment) => String(segment)).join("."),
-    message: issue.message
-  })));
-}
-
-// ../kernel/dist/recipe-config.js
+// ../node_modules/iterate-kernel/dist/recipe-config.js
 import { z as z4 } from "zod";
 var RECIPE_SCHEMA_VERSION = "glasspane.recipe/0.1-draft";
 var RECIPE_NAME_MAX_LENGTH = 256;
@@ -1457,7 +1469,7 @@ var RecipeConfigSchema = z4.strictObject({
   steps: z4.array(RecipeStepSchema).min(RECIPE_MIN_STEPS).max(RECIPE_MAX_STEPS)
 });
 
-// ../kernel/dist/run-plan.js
+// ../node_modules/iterate-kernel/dist/run-plan.js
 import { z as z5 } from "zod";
 var RUN_PLAN_SCHEMA_VERSION = "iterate.run-plan/0.1";
 var RUN_PLAN_SOURCES = ["config", "recipe", "session", "manual"];
@@ -1492,7 +1504,7 @@ var RunPlanSchema = z5.strictObject({
   });
 });
 
-// ../kernel/dist/invariant-report.js
+// ../node_modules/iterate-kernel/dist/invariant-report.js
 import { z as z6 } from "zod";
 var INVARIANT_REPORT_SCHEMA_VERSION = "iterate.invariant-report/0.1";
 var REVERIFICATION_SCHEMA_VERSION = "iterate.reverification/0.1";
@@ -1552,7 +1564,7 @@ var ReverificationRequestSchema = z6.strictObject({
   targets: ReverificationTargetsSchema
 });
 
-// ../kernel/dist/convergence.js
+// ../node_modules/iterate-kernel/dist/convergence.js
 import { z as z7 } from "zod";
 var CONVERGENCE_SCHEMA_VERSION = "iterate.convergence/0.1";
 var InvariantStateSchema = z7.enum(["pass", "fail", "error", "unmeasured"]);
@@ -1564,8 +1576,17 @@ var RoundStateSchema = z7.strictObject({
   openFindings: z7.number().int().min(0),
   /** False when the engine never got to evidence something (refused, crashed, unattached). */
   evidenceComplete: z7.boolean(),
-  /** The engine's own circuit-breaker level for this run; 3 is tripped. */
-  breakerLevel: z7.number().int().min(0).max(3)
+  /**
+   * The engine's own circuit-breaker level for this run; 3 is tripped.
+   *
+   * OPTIONAL, and absence is not the same claim as 0. `0` says "a breaker exists and it has
+   * not tripped"; absence says "this run has no breaker channel at all" — which is the normal
+   * shape of an iterate loop that never touched the GUI engine. The distinction changes no
+   * verdict today (only `>= 3` halts), but collapsing it would force a producer that never
+   * looked to assert a measurement it did not take, and that is the exact failure this
+   * contract's `unmeasured` state exists to prevent.
+   */
+  breakerLevel: z7.number().int().min(0).max(3).optional()
 });
 var ConvergenceActionSchema = z7.enum(["fix", "verify", "converged", "halt"]);
 var CONVERGENCE_REASONS = {
@@ -1594,7 +1615,7 @@ var ConvergenceDecisionSchema = z7.strictObject({
   maxRounds: z7.number().int().min(1)
 });
 
-// ../kernel/dist/provider-registration.js
+// ../node_modules/iterate-kernel/dist/provider-registration.js
 import { z as z8 } from "zod";
 var PROVIDER_SCHEMA_VERSION = "iterate.provider/0.1";
 var PROVIDER_ID_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
@@ -1632,7 +1653,7 @@ var ProviderRegistrationSchema = z8.strictObject({
   });
 });
 
-// ../kernel/dist/parse.js
+// ../node_modules/iterate-kernel/dist/parse.js
 function parseEvidencePackRead(input) {
   const result = EvidencePackReadSchema.safeParse(input);
   if (result.success) {
@@ -1641,12 +1662,6 @@ function parseEvidencePackRead(input) {
   throw schemaErrorFrom("evidence pack", result.error);
 }
 
-// ../kernel/dist/decision-log.js
-var DecisionLogDraftSchema = DecisionLogEntrySchema.omit({
-  sequence: true,
-  prevEntryHash: true
-});
-
 // src/canonical.ts
 function canonicalJson2(value) {
   return JSON.stringify(sortKeys(value));
@@ -1691,6 +1706,7 @@ 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 BUNDLE_ID_MAX_LENGTH = 512;
 var PID_RANGE = [1, 2147483647];
 var PATH_FIELDS = [
   "recipeConfigPath",
@@ -1733,7 +1749,9 @@ function systemHome() {
     );
   }
 }
-function daemonProjectsPath() {
+function daemonProjectsPath(daemonStateRoot) {
+  const named2 = typeof daemonStateRoot === "string" ? daemonStateRoot.trim() : "";
+  if (named2 !== "") return path2.join(named2, "projects.json");
   return path2.join(systemHome(), ".glasspane", "projects.json");
 }
 var FIRMLINK_PREFIX = "/System/Volumes/Data";
@@ -1751,16 +1769,16 @@ var ProjectSetArgs = z9.strictObject({
   // rule deliberately is not a check on this object — it holds of the MERGED
   // entry, and an update that clears one field while setting the other only
   // becomes legal after the merge (`assertSingleIdentity`).
-  bundleId: z9.string().max(256).nullish(),
+  bundleId: z9.string().max(BUNDLE_ID_MAX_LENGTH).nullish(),
   pid: z9.number().int().min(PID_RANGE[0]).max(PID_RANGE[1]).nullish(),
   recipeConfigPath: z9.string().max(MAX_FIELD_LENGTH).nullish(),
   calibrationAssetsPath: z9.string().max(MAX_FIELD_LENGTH).nullish(),
   evidenceStoragePath: z9.string().max(MAX_FIELD_LENGTH).nullish()
 });
-function projectsPath() {
+function projectsPath(daemonStateRoot) {
   const envPath = process.env[PROJECTS_FILE_ENV];
   if (envPath) return envPath;
-  return daemonProjectsPath();
+  return daemonProjectsPath(daemonStateRoot);
 }
 function loadRegistry(filePath) {
   let raw;
@@ -1843,11 +1861,14 @@ function requireUsableRegistry(filePath, snapshot) {
   }
   return { projects: [], discarded };
 }
+function registryReaders(target) {
+  return `\`/usr/bin/plutil -p ${target}\` or \`/bin/cat ${target}\` \u2014 both absolute, so they run from whatever directory the reader is in and need nothing that may be off PATH`;
+}
 function unreadableMessage(filePath, failure) {
-  return `projects.json at ${filePath} ${failure}. gp_project_set refused to write it: replacing an unreadable registry discards every registration in it. See the damage with \`python3 -m json.tool ${filePath}\` and repair that file, or set ${FORCE_OVERWRITE_ENV}=1 and retry to rebuild the registry from scratch \u2014 the unloadable file is moved aside as ${filePath}.unreadable-<id> rather than deleted, and every existing project entry is lost.`;
+  return `projects.json at ${filePath} ${failure}. gp_project_set refused to write it: replacing an unreadable registry discards every registration in it. See the damage with ${registryReaders(filePath)} and repair that file, or set ${FORCE_OVERWRITE_ENV}=1 and retry to rebuild the registry from scratch \u2014 the unloadable file is moved aside as ${filePath}.unreadable-<id> rather than deleted, and every existing project entry is lost.`;
 }
 function readFailureMessage(filePath, failure) {
-  return `projects.json at ${filePath} ${failure}. This is a read failure, not an empty registry: the entries that are registered cannot be listed. See the damage with \`python3 -m json.tool ${filePath}\`, then repair or replace that file. To rebuild the registry from scratch instead \u2014 which costs every existing entry \u2014 set ${FORCE_OVERWRITE_ENV}=1 and call gp_project_set again.`;
+  return `projects.json at ${filePath} ${failure}. This is a read failure, not an empty registry: the entries that are registered cannot be listed. See the damage with ${registryReaders(filePath)}, then repair or replace that file. To rebuild the registry from scratch instead \u2014 which costs every existing entry \u2014 set ${FORCE_OVERWRITE_ENV}=1 and call gp_project_set again.`;
 }
 var STATE_DIR_MODE = 448;
 var STATE_FILE_MODE = 384;
@@ -1949,20 +1970,20 @@ function uniqueToken() {
   tokenCounter += 1;
   return `${process.pid}-${Date.now().toString(36)}-${tokenCounter.toString(36)}-${randomBytes(4).toString("hex")}`;
 }
-function projectList() {
-  const filePath = projectsPath();
+function projectList(daemonStateRoot) {
+  const filePath = projectsPath(daemonStateRoot);
   const snapshot = loadRegistry(filePath);
   if (snapshot.failure !== null) {
     throw new ProjectRegistryError(GP_E_INTERNAL, readFailureMessage(filePath, snapshot.failure));
   }
   return snapshot.projects;
 }
-function projectGet(projectId) {
-  const projects = projectList();
+function projectGet(projectId, daemonStateRoot) {
+  const projects = projectList(daemonStateRoot);
   return projects.find((p) => p.projectId === projectId);
 }
-function projectSet(args) {
-  const filePath = projectsPath();
+function projectSet(args, daemonStateRoot) {
+  const filePath = projectsPath(daemonStateRoot);
   assertStorablePid(args.pid);
   const snapshot = loadRegistry(filePath);
   const { projects, discarded } = requireUsableRegistry(filePath, snapshot);
@@ -1997,7 +2018,7 @@ function projectSet(args) {
   return {
     ...entry,
     requiresDaemonRestart: true,
-    daemonRestartNotice: daemonRestartNotice(filePath),
+    daemonRestartNotice: daemonRestartNotice(filePath, daemonStateRoot),
     ...discarded !== void 0 ? { discardedUnreadableFile: discarded } : {}
   };
 }
@@ -2040,12 +2061,17 @@ function assertSingleIdentity(entry) {
     );
   }
 }
-function daemonRestartNotice(filePath) {
-  const daemonPath = daemonProjectsPath();
+function daemonRestartNotice(filePath, daemonStateRoot) {
+  const named2 = typeof daemonStateRoot === "string" && daemonStateRoot.trim() !== "" ? daemonStateRoot.trim() : null;
+  const daemonPath = daemonProjectsPath(named2);
+  const authority = named2 === null ? "its default root is the folder under this user's home record (where a service started with no --state-dir looks)" : `its root is the one the running daemon named in its hello (${named2})`;
   if (path2.resolve(filePath) !== path2.resolve(daemonPath)) {
-    return `Saved in ${filePath}. The background service does not read this path because of anything in its own configuration: its default root is the folder under this user's home record, where it loads ${daemonPath} once when it starts, and ${PROJECTS_FILE_ENV} \u2014 the variable that pointed this write here \u2014 is honoured by this MCP shell only, so as far as the service's own configuration goes it never reads that file, and no restart of the service will make it load this one. ${rootDiscriminator()} To land the entry where that default root looks: unset ${PROJECTS_FILE_ENV} for this shell (or point it at ${daemonPath}) and repeat gp_project_set, then restart the background service so it reloads \u2014 ${restartCommand()}`;
+    return `Saved in ${filePath}. The background service does not read this path because of anything in its own configuration: ${authority}. It loads ${daemonPath} once when it starts, and ${PROJECTS_FILE_ENV} \u2014 the variable that pointed this write here \u2014 is honoured by this MCP shell only, so as far as the service's own configuration goes it never reads that file, and no restart of the service will make it load this one. ${rootDiscriminator()} To land the entry where that root looks: unset ${PROJECTS_FILE_ENV} for this shell (or point it at ${daemonPath}) and repeat gp_project_set, then restart the background service so it reloads \u2014 ${restartCommand()}`;
   }
-  return `Saved in ${filePath}, the projects file under the home record this user's state root defaults to. If this is the root the service was started on \u2014 which is not knowable from here \u2014 then the running background service loaded that file once when it started, so gp_attach will keep returning GP_E_NOT_FOUND for this projectId until the service restarts: ${restartCommand()}. ${rootDiscriminator()}`;
+  if (named2 !== null) {
+    return `Saved in ${filePath} \u2014 the projects file of the state root the running daemon reported in its own hello (${named2}), so this is the file that service loads. It read that file once when it started, so gp_attach will keep returning GP_E_NOT_FOUND for this projectId until the service restarts: ${restartCommand()}`;
+  }
+  return `Saved in ${filePath}, the projects file under the home record this user's state root defaults to. If this is the root the service was started on \u2014 which is not knowable from here, because this daemon's hello reported no stateRoot \u2014 then the running background service loaded that file once when it started, so gp_attach will keep returning GP_E_NOT_FOUND for this projectId until the service restarts: ${restartCommand()}. ${rootDiscriminator()}`;
 }
 function rootDiscriminator() {
   return 'Tell the two cases apart with the service\'s own answer: gp_project_list reads the file this call wrote, so an entry it lists is on disk, and gp_attach {projectId} is answered by the running service \u2014 an entry the list shows plus an attach that answers GP_E_NOT_FOUND means the service is loading a different projects.json than the one this write reached, not that the write failed. Which file the running service loads is not something this shell guesses from $HOME: `glasspaned --state-dir <root>` moves it to <root>/projects.json, and the daemon reports the root it resolved \u2014 `hello` names the state root under its `stateRoot` key. A daemon predating 1.15.0 omits the key, and an omitted key means "that daemon does not report it", never "so it must be the home default": for those binaries the discriminator below is the only read. Cross-check either way \u2014 `launchctl print gui/' + currentUid() + "/com.glasspane.daemon` prints the arguments the job was started with. If those arguments name a --state-dir, the entry has to go into that root's projects.json (repeat gp_project_set with " + PROJECTS_FILE_ENV + " pointed at <that root>/projects.json): no restart of the service will make it read anywhere else, so restarting again changes nothing. If they name no --state-dir, the service is on the default root and simply predates this write, and one restart with the command in this notice is what surfaces it.";
@@ -2236,7 +2262,7 @@ var PID_INT32_MAX = 2147483647;
 var OptionalPidSchema = z10.number().int().min(1).max(PID_INT32_MAX).optional();
 var OptionalDepthSchema = z10.number().int().min(1).max(10).optional();
 var OptionalRoleSchema = z10.string().min(1).max(SELECTOR_MAX_LENGTH).optional();
-var OptionalBundleIdSchema = z10.string().max(512).optional();
+var OptionalBundleIdSchema = z10.string().max(BUNDLE_ID_MAX_LENGTH).optional();
 var OPERATION_ID_PATTERN2 = /^op_[0-9A-HJKMNP-TV-Z]{26}$/;
 var OptionalOperationIdSchema = z10.string().regex(OPERATION_ID_PATTERN2).optional();
 var OptionalProjectIdSchema = z10.string().regex(/^prj_[0-9A-HJKMNP-TV-Z]{26}$/).optional();
@@ -2352,7 +2378,7 @@ var TOOL_SPECS = [
       type: "object",
       additionalProperties: false,
       properties: {
-        bundleId: { type: "string", maxLength: 512 },
+        bundleId: { type: "string", maxLength: BUNDLE_ID_MAX_LENGTH },
         pid: { type: "integer", minimum: 1, maximum: PID_INT32_MAX },
         projectId: { type: "string", pattern: "^prj_[0-9A-HJKMNP-TV-Z]{26}$" }
       },
@@ -2578,7 +2604,9 @@ var TOOL_SPECS = [
         displayName: { type: "string", minLength: 1, maxLength: 256 },
         // `null` clears the field on update, so these mirror
         // ProjectSetArgs' `.nullish()` rather than the old optional-string form.
-        bundleId: { type: ["string", "null"], maxLength: 256 },
+        // The ceiling is `gp_attach`'s, from the daemon's own bound — the identity a
+        // caller can attach with has to be one the registry can store.
+        bundleId: { type: ["string", "null"], maxLength: BUNDLE_ID_MAX_LENGTH },
         // Matches ProjectSetArgs.pid, which is bounded to the same Int32 domain
         // the daemon stores (an out-of-range pid made Swift fail to decode the
         // whole registry file, which then got rewritten as an empty table).
@@ -2654,6 +2682,14 @@ function narrowingKnobsFor(spec, params) {
       knobs.push({ name, kind: "scale", minimum: schema.minimum, maximum: schema.maximum, sent });
     } else if (name === "limit") {
       knobs.push({ name, kind: "limit", minimum: schema.minimum, maximum: schema.maximum, sent });
+    } else if (name === "steps") {
+      knobs.push({
+        name,
+        kind: "steps",
+        minimum: schema.minItems,
+        maximum: schema.maxItems,
+        sent: Array.isArray(sentValue) ? sentValue.length : void 0
+      });
     } else if (name === "selector" || name === "role" || name === "title") {
       const target = targetSelectingKnob(spec.name, name);
       knobs.push(target === null ? { name, kind: "selector", sent: void 0 } : { name, kind: "target", sent: void 0, picks: target.picks, substitute: target.substitute });
@@ -2681,6 +2717,8 @@ function knobSubject(kind) {
       return "the number of entries it collects";
     case "scale":
       return "the image";
+    case "steps":
+      return "the replay it performs";
     case "selector":
       return "the reply";
     case "target":
@@ -2701,6 +2739,8 @@ function describeKnob(knob) {
       return knob.name === "selector" ? "a more specific selector (aim at one element)" : `a tighter ${knob.name} filter`;
     case "scale":
       return `a smaller scale${bounds}${knob.sent !== void 0 ? `, currently ${knob.sent}` : ""}`;
+    case "steps":
+      return `a shorter steps array${bounds}${knob.sent !== void 0 ? `, currently ${knob.sent} ${knob.sent === 1 ? "step" : "steps"}` : ""}`;
     case "target":
       return describeTargetKnob(knob);
   }
@@ -2870,9 +2910,9 @@ function mapEvidenceReadError(error) {
   }
   return void 0;
 }
-async function projectListTool() {
+async function projectListTool(_args, context) {
   try {
-    const projects = projectList();
+    const projects = projectList(context.engine.reportedStateRoot);
     return {
       content: [{ type: "text", text: canonicalJson2({ projects }) }],
       isError: false
@@ -2881,18 +2921,18 @@ async function projectListTool() {
     return mapProjectError(error);
   }
 }
-async function projectSetTool(args) {
+async function projectSetTool(args, context) {
   try {
-    const entry = projectSet(args);
+    const entry = projectSet(args, context.engine.reportedStateRoot);
     return { content: [{ type: "text", text: canonicalJson2({ project: entry }) }], isError: false };
   } catch (error) {
     return mapProjectError(error);
   }
 }
-async function projectGetTool(args) {
+async function projectGetTool(args, context) {
   const argv = args;
   try {
-    const entry = projectGet(argv.projectId);
+    const entry = projectGet(argv.projectId, context.engine.reportedStateRoot);
     if (entry === void 0) {
       return {
         content: [{ type: "text", text: formatToolError(
@@ -2945,7 +2985,7 @@ function projectErrorRemedy(code) {
     return "this process has no entry in the password database, so neither it nor the daemon can know which user's state directory is meant; run the shell as a user that has one (`id -u` / `dscl . -read /Users/<name> NFSHomeDirectory`). Nothing in ~/.glasspane needs repairing for this";
   }
   if (code === GP_E_INTERNAL) {
-    return `the projects file is the problem, not your arguments: the message above names its path, so read it with \`/usr/bin/plutil -p <that path>\` or \`/bin/cat <that path>\` \u2014 both absolute, so they run from whatever directory the reader is in and need nothing that may be off PATH \u2014 repair or restore the damaged entry, and retry \u2014 or set ${FORCE_OVERWRITE_ENV}=1 and call gp_project_set to rebuild the registry from scratch (the unloadable file is moved aside as <path>.unreadable-<id>, never deleted, and every entry still in it is lost). Do not retry the same read-only call unchanged: it will keep failing.`;
+    return `the projects file is the problem, not your arguments: the message above names its path, so read it with ${registryReaders("<that path>")}; repair or restore the damaged entry, and retry \u2014 or set ${FORCE_OVERWRITE_ENV}=1 and call gp_project_set to rebuild the registry from scratch (the unloadable file is moved aside as <path>.unreadable-<id>, never deleted, and every entry still in it is lost). Do not retry the same read-only call unchanged: it will keep failing.`;
   }
   return "check the tool's input schema and retry";
 }
@@ -3052,7 +3092,14 @@ function describeFetchFailure(error) {
   const mapped = mapEvidenceReadError(error);
   if (mapped !== void 0) {
     const [first] = mapped.content;
-    return first !== void 0 && first.type === "text" ? first.text : "the evidence read failed";
+    if (first !== void 0 && first.type === "text") {
+      return first.text;
+    }
+    return formatToolError(
+      GP_E_INTERNAL,
+      "a mapped evidence-read refusal reached gp_recent_reports without any text part, so its own message could not be carried",
+      "read that operation on its own with gp_last_evidence {operationId}, which reports its own fault in the three-field shape; do not re-run gp_act"
+    );
   }
   return formatToolError(
     GP_E_INTERNAL,
@@ -3585,8 +3632,8 @@ async function handleEvidenceAggregate(url, client, res) {
       res,
       404,
       GP_E_NO_EVIDENCE,
-      "none of the requested operations have evidence in the daemon history",
-      `the engine may have restarted, or those operationIds never produced evidence; each id named here was fetched and missed, and this gateway keeps no operation trail of its own, so it cannot list what ran. Producing a fresh pack means performing another action, which a read like this one does not do for you: see what the attached app is doing now with POST /v1/tools/observe, POST /v1/tools/assert_element or POST /v1/tools/probe_status, re-fetch one id with GET /v1/evidence/<operationId>, and the routes this surface answers are ${TOOL_ROUTES_TEXT}`
+      `none of the ${ids.length} requested ${ids.length === 1 ? "operation has" : "operations have"} a pack in the daemon history: each id this request named was fetched and answered with that code`,
+      `the daemon holding no pack for these operations is a fact about its bounded history, not evidence that they did not run, and this request measured nothing about a restart, so no cause is claimed here. Each id named above was fetched and missed, and this gateway keeps no operation trail of its own, so it cannot list what ran. Producing a fresh pack means performing another action, which a read like this one does not do for you: see what the attached app is doing now with POST /v1/tools/observe, POST /v1/tools/assert_element or POST /v1/tools/probe_status, re-fetch one id with GET /v1/evidence/<operationId>, ask again with fewer ids (at most ${MAX_EVIDENCE_IDS} per request), and the routes this surface answers are ${TOOL_ROUTES_TEXT}`
     );
     return;
   }