@procedures/client 0.1.0 → 0.2.1

package/src/procedures/capability.ts

@@ -0,0 +1,333 @@
+/**
+ * Invocation capabilities (packages/documentation/CAPABILITIES-2026-10.md).
+ *
+ * Each invocation operates with a capability: a clearance (the data that it can see), the
+ * effects that it can have, and a deadline. A nested call gets the same capability or a
+ * narrower one: `narrowCapability()` calculates it, so a request for more has no effect. Only
+ * the host makes a capability, from its authentication.
+ *
+ * A procedure declares its effects in `metadata.effects`. The admission (`capabilityRefusal()`)
+ * compares them with the permitted effects. It examines each call of a host, each nested call
+ * of a data-driven procedure (its caller chose the refs), and each nested call with a narrowed
+ * capability. A procedure of code that declares its effects answers for its own nested calls:
+ * `checkEffects()` examines those declarations against the call graph, as `metadata.calls`
+ * makes the reach of a procedure visible.
+ */
+
+import type {
+  AnyProcedure,
+  Capability,
+  CapabilityRequest,
+  ClearanceOrder,
+  Effects,
+  PermittedEffects,
+  ProcedurePath,
+} from "./types.js";
+import { pathToKey } from "./types.js";
+import { isDataDriven } from "./ref.js";
+import { callMatches } from "./policy.js";
+
+/** The standard resource names. An application adds its own names. */
+export const STANDARD_RESOURCES = ["fs", "network", "process", "registry"] as const;
+
+/**
+ * The metadata key of the remaining time of a remote call, in milliseconds. A server uses it
+ * only to make its deadline earlier.
+ */
+export const TIMEOUT_METADATA_KEY = "procedure-timeout";
+
+/** The capability without limits: the capability of a host that sets none. */
+export const UNLIMITED_CAPABILITY: Capability = Object.freeze({});
+
+// =============================================================================
+// Clearance orders
+// =============================================================================
+
+/**
+ * This function gives the order of a ladder: each value is higher than the values before it.
+ * `ladder(["public", "shared", "private"])`.
+ */
+export function ladder<C>(levels: readonly C[]): ClearanceOrder<C> {
+  const rank = (value: C): number => {
+    const index = levels.indexOf(value);
+    if (index === -1) throw new Error(`Not a clearance value of the ladder: ${String(value)}`);
+    return index;
+  };
+  return {
+    leq: (a, b) => rank(a) <= rank(b),
+    meet: (a, b) => (rank(a) <= rank(b) ? a : b),
+  };
+}
+
+// =============================================================================
+// Effects
+// =============================================================================
+
+/** The declared effects of a procedure, or undefined when it declares none. */
+export function effectsOf(procedure: { readonly metadata?: unknown }): Effects | undefined {
+  const effects = (procedure.metadata as { effects?: unknown } | undefined)?.effects;
+  return effects !== null && typeof effects === "object" ? (effects as Effects) : undefined;
+}
+
+/** True when the effects say that the procedure changes nothing (`writes: []`). */
+export function isReadOnly(effects: Effects | undefined): boolean {
+  return effects?.writes !== undefined && effects.writes.length === 0;
+}
+
+/** True when the procedure can delete or overwrite data. Not known: true (as in MCP). */
+export function isDestructive(effects: Effects | undefined): boolean {
+  if (isReadOnly(effects)) return false;
+  return effects?.destructive ?? true;
+}
+
+/** True when the procedure can reach systems outside the host. Not known: true (as in MCP). */
+export function isOpenWorld(effects: Effects | undefined): boolean {
+  if (effects?.reads === undefined || effects.writes === undefined) return true;
+  return effects.reads.includes("network") || effects.writes.includes("network") || effects.writes.includes("process");
+}
+
+/** The MCP hints of a tool. */
+export interface ToolHints {
+  readonly readOnlyHint?: boolean;
+  readonly destructiveHint?: boolean;
+  readonly idempotentHint?: boolean;
+  readonly openWorldHint?: boolean;
+}
+
+/**
+ * The MCP hints of a procedure, from its declared effects. A procedure without a declaration,
+ * or a data-driven one (its operands decide what it does), gets no hints: then the MCP defaults
+ * apply (not read-only, destructive, open world).
+ */
+export function toolHints(procedure: AnyProcedure): ToolHints {
+  const effects = effectsOf(procedure);
+  if (!effects || isDataDriven(procedure)) return {};
+  if (isReadOnly(effects)) {
+    return { readOnlyHint: true, openWorldHint: isOpenWorld(effects) };
+  }
+  return {
+    readOnlyHint: false,
+    destructiveHint: isDestructive(effects),
+    idempotentHint: effects.idempotent ?? false,
+    openWorldHint: isOpenWorld(effects),
+  };
+}
+
+// =============================================================================
+// Narrowing
+// =============================================================================
+
+type Permit = readonly string[] | "any" | undefined;
+
+function intersect(current: Permit, requested: Permit): Permit {
+  if (current === undefined || current === "any") return requested ?? current;
+  if (requested === undefined || requested === "any") return current;
+  return Object.freeze(current.filter((name) => requested.includes(name)));
+}
+
+function narrowEffects(current: PermittedEffects | undefined, requested: PermittedEffects | undefined): PermittedEffects | undefined {
+  if (!requested) return current;
+  const reads = intersect(current?.reads, requested.reads);
+  const writes = intersect(current?.writes, requested.writes);
+  const destructive = current?.destructive === false || requested.destructive === false ? false : undefined;
+  const result: { reads?: Permit; writes?: Permit; destructive?: boolean } = {};
+  if (reads !== undefined) result.reads = reads;
+  if (writes !== undefined) result.writes = writes;
+  if (destructive !== undefined) result.destructive = destructive;
+  return Object.freeze(result) as PermittedEffects;
+}
+
+/**
+ * This function gives the capability for a request: the same as `current`, or narrower. The
+ * clearance is the meet of the two values (a ladder: the lower one). The permitted effects are
+ * the intersection. The deadline is the earlier one. Two different clearances need an order.
+ */
+export function narrowCapability<C>(
+  current: Capability<C> | undefined,
+  request: CapabilityRequest<C> | undefined,
+  order?: ClearanceOrder<C>,
+  now: number = Date.now()
+): Capability<C> {
+  const base = current ?? (UNLIMITED_CAPABILITY as Capability<C>);
+  if (!request) return base;
+  const result: { clearance?: C; effects?: PermittedEffects; deadline?: number } = {};
+
+  if (request.clearance === undefined) {
+    if (base.clearance !== undefined) result.clearance = base.clearance;
+  } else if (base.clearance === undefined) {
+    result.clearance = request.clearance;
+  } else if (Object.is(base.clearance, request.clearance)) {
+    result.clearance = base.clearance;
+  } else {
+    if (!order) {
+      throw new Error("Two different clearances need a clearance order: give clearanceOrder to the host (hostPolicy)");
+    }
+    result.clearance = order.meet(base.clearance, request.clearance);
+  }
+
+  const effects = narrowEffects(base.effects, request.effects);
+  if (effects !== undefined) result.effects = effects;
+
+  const requestedDeadline = request.timeoutMs !== undefined ? now + request.timeoutMs : undefined;
+  const deadline =
+    base.deadline === undefined ? requestedDeadline : requestedDeadline === undefined ? base.deadline : Math.min(base.deadline, requestedDeadline);
+  if (deadline !== undefined) result.deadline = deadline;
+
+  return Object.freeze(result) as Capability<C>;
+}
+
+// =============================================================================
+// Admission
+// =============================================================================
+
+/** The reason of a refusal. */
+export type CapabilityRefusalReason = "effects-undeclared" | "effects-exceeded" | "clearance" | "deadline";
+
+/** A refused invocation: the reason and a message for the caller. */
+export interface CapabilityRefusal {
+  readonly reason: CapabilityRefusalReason;
+  readonly message: string;
+}
+
+const VERB = { reads: "reads", writes: "changes" } as const;
+
+/**
+ * This function gives the refusal of an invocation under a capability, or undefined when the
+ * capability permits it. It compares the declared effects with the permitted effects, and the
+ * time with the deadline. The clearance does not refuse an invocation: it limits the data.
+ */
+export function capabilityRefusal(
+  procedure: AnyProcedure,
+  capability: Capability<unknown> | undefined,
+  now: number = Date.now()
+): CapabilityRefusal | undefined {
+  if (!capability) return undefined;
+  const key = pathToKey(procedure.path);
+  if (capability.deadline !== undefined && now >= capability.deadline) {
+    return { reason: "deadline", message: `The deadline of the call passed before ${key} started` };
+  }
+  const permitted = capability.effects;
+  if (!permitted) return undefined;
+  const effects = effectsOf(procedure);
+  for (const kind of ["reads", "writes"] as const) {
+    const allowed = permitted[kind];
+    if (allowed === undefined || allowed === "any") continue;
+    const declared = effects?.[kind];
+    const limit = allowed.length > 0 ? `only ${allowed.join(", ")}` : "nothing";
+    if (declared === undefined) {
+      return {
+        reason: "effects-undeclared",
+        message: `${key} does not declare what it ${VERB[kind]}, and this call ${VERB[kind]} ${limit}`,
+      };
+    }
+    const extra = declared.filter((name) => !allowed.includes(name));
+    if (extra.length > 0) {
+      return {
+        reason: "effects-exceeded",
+        message: `${key} ${VERB[kind]} ${extra.join(", ")}, and this call ${VERB[kind]} ${limit}`,
+      };
+    }
+  }
+  if (permitted.destructive === false && isDestructive(effects)) {
+    return {
+      reason: "effects-exceeded",
+      message: `${key} can delete or overwrite data, and this call cannot start such a procedure`,
+    };
+  }
+  return undefined;
+}
+
+/**
+ * True when the admission examines a nested call: the caller is data-driven (its caller chose
+ * the refs), the caller declares no effects, or the capability of the nested call is narrower
+ * than the capability of its caller. A procedure of code with declared effects answers for its
+ * own nested calls (`checkEffects()` examines them).
+ */
+export function examinesNestedCall(caller: AnyProcedure, callerCapability: Capability<unknown>, capability: Capability<unknown>): boolean {
+  return isDataDriven(caller) || effectsOf(caller) === undefined || capability !== callerCapability;
+}
+
+/** The result of `explainInvocation()`. */
+export interface InvocationExplanation {
+  readonly permitted: boolean;
+  readonly reason?: CapabilityRefusalReason | "not-found";
+  readonly message: string;
+}
+
+/**
+ * This function tells, without a call, if a host call of a path is permitted under a
+ * capability, and why. An application can show it to a user.
+ */
+export function explainInvocation(
+  path: ProcedurePath,
+  capability: Capability<unknown> | undefined,
+  registry: { get(path: ProcedurePath): AnyProcedure | undefined },
+  now: number = Date.now()
+): InvocationExplanation {
+  const procedure = registry.get(path);
+  if (!procedure) return { permitted: false, reason: "not-found", message: `No procedure at ${pathToKey(path)}` };
+  const refusal = capabilityRefusal(procedure, capability, now);
+  if (refusal) return { permitted: false, reason: refusal.reason, message: refusal.message };
+  return { permitted: true, message: `${pathToKey(path)} is permitted` };
+}
+
+// =============================================================================
+// The static check
+// =============================================================================
+
+/** A declaration of effects that does not include the effects of a procedure that it calls. */
+export interface EffectsViolation {
+  readonly path: ProcedurePath;
+  readonly callee: string;
+  readonly message: string;
+}
+
+/**
+ * This function examines each procedure of code that declares its effects and its calls
+ * (`metadata.calls`). Its declaration must include the reads and the writes of each procedure
+ * that it calls: the resources are structural, so a caller cannot touch less than its callees.
+ *
+ * Two things are the caller's own claim, and the check does not compare them. A callee that
+ * writes `process` starts any program, and its caller declares what that program does. The
+ * flags `destructive` and `idempotent` depend on the input that the caller gives: `lib.new`
+ * creates new files with `fs.write`, which can overwrite. The effects snapshot of the MCP tools
+ * shows these claims in a review.
+ */
+export function checkEffects(procedures: readonly AnyProcedure[]): EffectsViolation[] {
+  const byKey = new Map(procedures.map((procedure) => [pathToKey(procedure.path), procedure]));
+  const violations: EffectsViolation[] = [];
+  for (const procedure of procedures) {
+    const own = effectsOf(procedure);
+    const calls = (procedure.metadata as { calls?: unknown } | undefined)?.calls;
+    if (!own || !Array.isArray(calls) || isDataDriven(procedure)) continue;
+    const key = pathToKey(procedure.path);
+    const callees = new Set<string>();
+    for (const entry of calls as string[]) {
+      for (const candidate of byKey.keys()) if (callMatches(entry, candidate)) callees.add(candidate);
+    }
+    for (const calleeKey of [...callees].sort()) {
+      const callee = byKey.get(calleeKey)!;
+      const theirs = effectsOf(callee);
+      const report = (message: string): void => {
+        violations.push({ path: procedure.path, callee: calleeKey, message: `${key} calls ${calleeKey}: ${message}` });
+      };
+      if (!theirs) {
+        report("the callee declares no effects");
+        continue;
+      }
+      for (const kind of ["reads", "writes"] as const) {
+        const mine = own[kind];
+        const needed = (theirs[kind] ?? []).filter((name) => name !== "process");
+        if (theirs[kind] === undefined) {
+          report(`the callee does not declare what it ${VERB[kind]}`);
+        } else if (mine === undefined) {
+          continue;
+        } else {
+          const missing = needed.filter((name) => !mine.includes(name));
+          if (missing.length > 0) report(`the declaration does not include ${missing.join(", ")} in ${kind}`);
+        }
+      }
+    }
+  }
+  return violations;
+}

package/src/procedures/cli/discover.ts

@@ -61,9 +61,9 @@ function exportTargets(value: unknown): string[] {
 /**
  * The specifier that imports the procedures file of a package. With an `exports` map, a bare
  * `pkg/dist/register.js` import fails unless the map exports that path: the function looks for
- * the subpath (also a `./*` pattern) whose target is the file. When the map has none, it
- * imports the package root, which registers the procedures of the packages of this repository.
- * (Before, the generated import ignored the map, and failed: deep dive CORE-17.)
+ * the subpath (also a `./*` pattern) whose target is the file: for the packages of this
+ * repository, `./register`. When the map has none, it imports the package root. (Before, the
+ * generated import ignored the map, and failed: deep dive CORE-17.)
  *
  * @param name - Package name
  * @param manifest - The package.json of the package

package/src/procedures/cli/index.ts

@@ -10,6 +10,7 @@
  * - init: Initialize a new library with procedure support
  */
 
+import { readFileSync } from "node:fs";
 import { parseArgs } from "node:util";
 import { discover } from "./discover.js";
 import { init } from "./init.js";
@@ -151,13 +152,14 @@ How it works:
 
   4. App runs "client-registry discover" to generate imports from the registry
 
-For more information, visit: https://github.com/your-org/client
+For more information, visit: https://mark1russell7.github.io/client/
 `);
 }
 
 function printVersion(): void {
-  // Read version from package.json at runtime
-  console.log("client v1.0.0");
+  // This file is dist/procedures/cli/index.js: the package.json is three folders up
+  const manifest = JSON.parse(readFileSync(new URL("../../../package.json", import.meta.url), "utf8")) as { version: string };
+  console.log(`client-registry v${manifest.version}`);
 }
 
 // =============================================================================

package/src/procedures/cli/init.ts

@@ -235,7 +235,7 @@ npm install ${name}
 
 ## How It Works
 
-This library automatically registers its procedures when installed:
+This library announces its procedures when installed:
 
 1. The \`postinstall\` script runs \`client-registry announce\`
 2. This writes to \`.client-registry.json\` at your project root

package/src/procedures/collection/procedures.ts

@@ -84,6 +84,8 @@ function getStorage<T>(ctx: ProcedureContext): ReturnType<NonNullable<ProcedureC
  */
 export function createCollectionProcedures(collectionName: string): AnyProcedure[] {
   const basePath = ["collections", collectionName];
+  // Each collection is a resource of its own (CAPABILITIES-2026-10): a capability can permit one
+  const resource = `collection:${collectionName}`;
 
   return [
     // Get
@@ -92,6 +94,7 @@ export function createCollectionProcedures(collectionName: string): AnyProcedure
       input: getInputSchema,
       output: getOutputSchema,
       metadata: {
+        effects: { reads: [resource], writes: [] },
         description: `Get item from ${collectionName} by ID`,
         tags: ["collections", collectionName, "read"],
       },
@@ -107,6 +110,7 @@ export function createCollectionProcedures(collectionName: string): AnyProcedure
       input: setInputSchema,
       output: setOutputSchema,
       metadata: {
+        effects: { reads: [resource], writes: [resource], idempotent: true },
         description: `Set item in ${collectionName}`,
         tags: ["collections", collectionName, "write"],
       },
@@ -122,6 +126,7 @@ export function createCollectionProcedures(collectionName: string): AnyProcedure
       input: deleteInputSchema,
       output: deleteOutputSchema,
       metadata: {
+        effects: { reads: [resource], writes: [resource], idempotent: true },
         description: `Delete item from ${collectionName}`,
         tags: ["collections", collectionName, "write"],
       },
@@ -137,6 +142,7 @@ export function createCollectionProcedures(collectionName: string): AnyProcedure
       input: hasInputSchema,
       output: hasOutputSchema,
       metadata: {
+        effects: { reads: [resource], writes: [] },
         description: `Check if item exists in ${collectionName}`,
         tags: ["collections", collectionName, "read"],
       },
@@ -152,6 +158,7 @@ export function createCollectionProcedures(collectionName: string): AnyProcedure
       input: getAllInputSchema,
       output: getAllOutputSchema,
       metadata: {
+        effects: { reads: [resource], writes: [] },
         description: `Get all items from ${collectionName}`,
         tags: ["collections", collectionName, "read"],
       },
@@ -167,6 +174,7 @@ export function createCollectionProcedures(collectionName: string): AnyProcedure
       input: sizeInputSchema,
       output: sizeOutputSchema,
       metadata: {
+        effects: { reads: [resource], writes: [] },
         description: `Get number of items in ${collectionName}`,
         tags: ["collections", collectionName, "read"],
       },
@@ -182,6 +190,7 @@ export function createCollectionProcedures(collectionName: string): AnyProcedure
       input: clearInputSchema,
       output: clearOutputSchema,
       metadata: {
+        effects: { reads: [resource], writes: [resource], idempotent: true },
         description: `Clear all items from ${collectionName}`,
         tags: ["collections", collectionName, "write"],
       },
@@ -197,6 +206,7 @@ export function createCollectionProcedures(collectionName: string): AnyProcedure
       input: getBatchInputSchema,
       output: getBatchOutputSchema,
       metadata: {
+        effects: { reads: [resource], writes: [] },
         description: `Get multiple items from ${collectionName}`,
         tags: ["collections", collectionName, "read", "batch"],
       },
@@ -214,6 +224,7 @@ export function createCollectionProcedures(collectionName: string): AnyProcedure
       input: setBatchInputSchema,
       output: setBatchOutputSchema,
       metadata: {
+        effects: { reads: [resource], writes: [resource], idempotent: true },
         description: `Set multiple items in ${collectionName}`,
         tags: ["collections", collectionName, "write", "batch"],
       },
@@ -233,6 +244,7 @@ export function createCollectionProcedures(collectionName: string): AnyProcedure
       input: deleteBatchInputSchema,
       output: deleteBatchOutputSchema,
       metadata: {
+        effects: { reads: [resource], writes: [resource], idempotent: true },
         description: `Delete multiple items from ${collectionName}`,
         tags: ["collections", collectionName, "write", "batch"],
       },

package/src/procedures/core/array.ts

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { anyOutput, arrayOutput, booleanOutput, numberOutput } from "./outputs.js";
 import { defineProcedure, namespace } from "../define.js";
 import type { AnyProcedure, Procedure } from "../types.js";
+import { PURE_EFFECTS, withEffects } from "../effects.js";
 
 // =============================================================================
 // First Procedure
@@ -978,7 +979,8 @@ const arrayProceduresRaw: AnyProcedure[] = [
 /**
  * All array procedures namespaced under "client".
  */
-export const arrayProcedures: AnyProcedure[] = namespace(["client"], arrayProceduresRaw);
+// Each one calculates its output from its input: no reads, no changes (CAPABILITIES-2026-10)
+export const arrayProcedures: AnyProcedure[] = namespace(["client"], withEffects(PURE_EFFECTS, arrayProceduresRaw));
 
 /**
  * Array procedures module for registration.

package/src/procedures/core/comparison.ts

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { booleanOutput } from "./outputs.js";
 import { defineProcedure, namespace } from "../define.js";
 import type { AnyProcedure, Procedure } from "../types.js";
+import { PURE_EFFECTS, withEffects } from "../effects.js";
 
 // =============================================================================
 // Eq Procedure (Strict Equality)
@@ -241,7 +242,8 @@ const comparisonProceduresRaw: AnyProcedure[] = [
 /**
  * All comparison procedures namespaced under "client".
  */
-export const comparisonProcedures: AnyProcedure[] = namespace(["client"], comparisonProceduresRaw);
+// Each one calculates its output from its input: no reads, no changes (CAPABILITIES-2026-10)
+export const comparisonProcedures: AnyProcedure[] = namespace(["client"], withEffects(PURE_EFFECTS, comparisonProceduresRaw));
 
 /**
  * Comparison procedures module for registration.

package/src/procedures/core/index.ts

@@ -45,6 +45,7 @@
  * ```
  */
 
+import { PURE_EFFECTS, withEffects } from "../effects.js";
 import { z } from "zod";
 import { anyOutput, booleanOutput } from "./outputs.js";
 import { defineProcedure, namespace } from "../define.js";
@@ -786,7 +787,9 @@ const tryCatchProcedure: TryCatchProcedure = defineProcedure({
 /**
  * All core language procedures namespaced under "client".
  */
-export const coreProcedures: AnyProcedure[] = namespace(["client"], [
+// Control flow and the operators: no effects of their own. The admission examines each nested
+// call of a data-driven procedure (CAPABILITIES-2026-10).
+export const coreProcedures: AnyProcedure[] = namespace(["client"], withEffects(PURE_EFFECTS, [
   chainProcedure as AnyProcedure,
   parallelProcedure as AnyProcedure,
   conditionalProcedure as AnyProcedure,
@@ -805,7 +808,7 @@ export const coreProcedures: AnyProcedure[] = namespace(["client"], [
   constantProcedure as AnyProcedure,
   throwProcedure as AnyProcedure,
   tryCatchProcedure as AnyProcedure,
-]);
+]));
 
 /**
  * Core procedures module for registration.

package/src/procedures/core/math.ts

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { numberOutput } from "./outputs.js";
 import { defineProcedure, namespace } from "../define.js";
 import type { AnyProcedure, Procedure } from "../types.js";
+import { PURE_EFFECTS, withEffects } from "../effects.js";
 
 // =============================================================================
 // Add Procedure
@@ -440,7 +441,8 @@ const mathProceduresRaw: AnyProcedure[] = [
 /**
  * All math procedures namespaced under "client".
  */
-export const mathProcedures: AnyProcedure[] = namespace(["client"], mathProceduresRaw);
+// Each one calculates its output from its input: no reads, no changes (CAPABILITIES-2026-10)
+export const mathProcedures: AnyProcedure[] = namespace(["client"], withEffects(PURE_EFFECTS, mathProceduresRaw));
 
 /**
  * Math procedures module for registration.

package/src/procedures/core/meta.ts

@@ -23,6 +23,7 @@ import {
 } from "../ref.js";
 import { callOperand } from "./operands.js";
 import { PROCEDURE_REGISTRY } from "../registry.js";
+import { PURE_EFFECTS, REGISTRY_READ_EFFECTS, withEffects } from "../effects.js";
 
 // =============================================================================
 // Import Procedure
@@ -352,12 +353,16 @@ const lookupProcedure: LookupProcedure = defineProcedure({
  * All meta procedures (before namespacing).
  */
 const metaProceduresRaw: AnyProcedure[] = [
-  importProcedure as AnyProcedure,
-  exportProcedure as AnyProcedure,
-  evalProcedure as AnyProcedure,
-  parseJsonProcedure as AnyProcedure,
-  stringifyJsonProcedure as AnyProcedure,
-  lookupProcedure as AnyProcedure,
+  // These parse, serialize or run programs: no effects of their own (CAPABILITIES-2026-10)
+  ...withEffects(PURE_EFFECTS, [
+    importProcedure as AnyProcedure,
+    exportProcedure as AnyProcedure,
+    evalProcedure as AnyProcedure,
+    parseJsonProcedure as AnyProcedure,
+    stringifyJsonProcedure as AnyProcedure,
+  ]),
+  // It reads the registry
+  ...withEffects(REGISTRY_READ_EFFECTS, [lookupProcedure as AnyProcedure]),
 ];
 
 /**

package/src/procedures/core/object.ts

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { anyOutput, arrayOutput, booleanOutput, recordOutput } from "./outputs.js";
 import { defineProcedure, namespace } from "../define.js";
 import type { AnyProcedure, Procedure } from "../types.js";
+import { PURE_EFFECTS, withEffects } from "../effects.js";
 
 // =============================================================================
 // Helper: Get nested value by path
@@ -402,7 +403,8 @@ const objectProceduresRaw: AnyProcedure[] = [
 /**
  * All object procedures namespaced under "client".
  */
-export const objectProcedures: AnyProcedure[] = namespace(["client"], objectProceduresRaw);
+// Each one calculates its output from its input: no reads, no changes (CAPABILITIES-2026-10)
+export const objectProcedures: AnyProcedure[] = namespace(["client"], withEffects(PURE_EFFECTS, objectProceduresRaw));
 
 /**
  * Object procedures module for registration.

package/src/procedures/core/string.ts

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { booleanOutput, numberOutput, stringOutput } from "./outputs.js";
 import { defineProcedure, namespace } from "../define.js";
 import type { AnyProcedure, Procedure } from "../types.js";
+import { PURE_EFFECTS, withEffects } from "../effects.js";
 
 // =============================================================================
 // Concat Procedure
@@ -430,7 +431,8 @@ const stringProceduresRaw: AnyProcedure[] = [
 /**
  * All string procedures namespaced under "client".
  */
-export const stringProcedures: AnyProcedure[] = namespace(["client"], stringProceduresRaw);
+// Each one calculates its output from its input: no reads, no changes (CAPABILITIES-2026-10)
+export const stringProcedures: AnyProcedure[] = namespace(["client"], withEffects(PURE_EFFECTS, stringProceduresRaw));
 
 /**
  * String procedures module for registration.

package/src/procedures/core/type.ts

@@ -9,6 +9,7 @@ import { z } from "zod";
 import { anyOutput, booleanOutput, stringOutput } from "./outputs.js";
 import { defineProcedure, namespace } from "../define.js";
 import type { AnyProcedure, Procedure } from "../types.js";
+import { PURE_EFFECTS, withEffects } from "../effects.js";
 
 // =============================================================================
 // Typeof Procedure
@@ -319,7 +320,8 @@ const typeProceduresRaw: AnyProcedure[] = [
 /**
  * All type procedures namespaced under "client".
  */
-export const typeProcedures: AnyProcedure[] = namespace(["client"], typeProceduresRaw);
+// Each one calculates its output from its input: no reads, no changes (CAPABILITIES-2026-10)
+export const typeProcedures: AnyProcedure[] = namespace(["client"], withEffects(PURE_EFFECTS, typeProceduresRaw));
 
 /**
  * Type procedures module for registration.

package/src/procedures/define-procedure.ts

@@ -47,6 +47,7 @@ import {
   rawInputRule,
   RUNS_REFS_TAG,
 } from "./ref.js";
+import { REGISTRY_READ_EFFECTS, withEffects } from "./effects.js";
 
 // Input schemas of procedure.define and procedure.delete (roadmap 2.1)
 const procedurePathField = z.array(z.string().min(1)).min(1);
@@ -524,8 +525,8 @@ export const deleteProcedureProcedure: Procedure<
  * All meta-procedures for procedure management.
  */
 export const metaProcedures: AnyProcedure[] = [
-  defineProcedureProcedure as AnyProcedure,
-  getProcedureProcedure as AnyProcedure,
-  listProceduresProcedure as AnyProcedure,
-  deleteProcedureProcedure as AnyProcedure,
+  // They read the registry. define and delete change it (CAPABILITIES-2026-10).
+  ...withEffects({ reads: ["registry"], writes: ["registry"] }, [defineProcedureProcedure as AnyProcedure]),
+  ...withEffects(REGISTRY_READ_EFFECTS, [getProcedureProcedure as AnyProcedure, listProceduresProcedure as AnyProcedure]),
+  ...withEffects({ reads: ["registry"], writes: ["registry"] }, [deleteProcedureProcedure as AnyProcedure]),
 ];