@intentius/chant 0.57.0 → 0.59.0

package/src/cli/mcp/resource-handlers.ts

@@ -4,9 +4,7 @@ import type { ResourceDefinition } from "./types";
 import { getContext } from "./resources/context";
 import { readSnapshot, readEnvironmentSnapshots } from "../../lifecycle/git";
 import { discoverOps } from "../../op/discover";
-import { makeTemporalClient } from "../handlers/run";
-import { resolveWorkflowId, fetchNormalizedHistory } from "../handlers/run-client";
-import { extractStepRecords, countActivities, queryGateState } from "../handlers/op-progress";
+import { createLocalOpRuntime } from "../../op/runtimes/local";
 import { loadOkfBundle } from "../../okf-read";
 import { loadChantConfigUpward, resolveKnowledgeDir } from "../../config";
 
@@ -37,7 +35,7 @@ export const coreResourceDefinitions: ResourceDefinition[] = [
   {
     uri: "chant://ops/{name}/runs",
     name: "Op run history",
-    description: "Workflow run history for a named Op",
+    description: "Run history for a named Op, newest first",
     mimeType: "application/json",
   },
   {
@@ -95,10 +93,6 @@ export function collectExamples(
   return examples;
 }
 
-function opWorkflowFnName(opName: string): string {
-  return opName.replace(/-([a-z])/g, (_, c: string) => c.toUpperCase()) + "Workflow";
-}
-
 /**
  * Handle resources/read request — checks plugin resources after core
  */
@@ -167,7 +161,7 @@ export async function handleResourcesRead(
       name: config.name,
       overview: config.overview,
       phases: config.phases.length,
-      taskQueue: config.taskQueue ?? config.name,
+      labels: config.labels ?? {},
       depends: config.depends ?? [],
     }));
     return {
@@ -175,33 +169,16 @@ export async function handleResourcesRead(
     };
   }
 
+  // Both run resources read the built-in local runtime (#2121, #2116) — the
+  // one an MCP client can address without naming a lexicon. `status` and `log`
+  // answer from the run ledger (#2118), so a run that ended in an earlier
+  // process still reads back here.
   if (uri.startsWith("chant://ops/") && uri.endsWith("/runs/latest")) {
     const name = uri.replace("chant://ops/", "").replace("/runs/latest", "");
     try {
-      const { ops } = await discoverOps();
-      const config = ops.get(name)?.config;
-
-      const { client } = await makeTemporalClient(undefined, resolve("."));
-      const handle = client.workflow.getHandle(resolveWorkflowId(name));
-      const desc = await handle.describe();
-      const history = await fetchNormalizedHistory(handle);
-      const { completed: activitiesCompleted, scheduled: activitiesScheduled } = countActivities(history);
-      const progress = config ? extractStepRecords(config, history, { final: Boolean(desc.closeTime) }) : undefined;
-      const gate = await queryGateState(handle);
-      const result = {
-        workflowId: desc.workflowId,
-        runId: desc.runId,
-        status: desc.status.name,
-        startTime: desc.startTime,
-        closeTime: desc.closeTime ?? null,
-        taskQueue: desc.taskQueue,
-        activitiesCompleted,
-        activitiesScheduled,
-        ...(progress ? { progress } : {}),
-        gate: gate ?? null,
-      };
+      const status = await createLocalOpRuntime({ projectPath: resolve(".") }).status(name);
       return {
-        contents: [{ uri, mimeType: "application/json", text: JSON.stringify(result, null, 2) }],
+        contents: [{ uri, mimeType: "application/json", text: JSON.stringify(status ?? null, null, 2) }],
       };
     } catch (err) {
       return {
@@ -213,11 +190,7 @@ export async function handleResourcesRead(
   if (uri.startsWith("chant://ops/") && uri.endsWith("/runs")) {
     const name = uri.replace("chant://ops/", "").replace("/runs", "");
     try {
-      const { client } = await makeTemporalClient(undefined, resolve("."));
-      const runs: unknown[] = [];
-      for await (const run of client.workflow.list({ query: `WorkflowType = "${opWorkflowFnName(name)}"` })) {
-        runs.push({ runId: run.runId, status: run.status.name, startTime: run.startTime, closeTime: run.closeTime ?? null });
-      }
+      const runs = await createLocalOpRuntime({ projectPath: resolve(".") }).log(name);
       return {
         contents: [{ uri, mimeType: "application/json", text: JSON.stringify(runs, null, 2) }],
       };

package/src/cli/mcp/resources/context.ts

@@ -49,32 +49,31 @@ chant import template.json    # Convert external template
 chant import template.json -o ./src/  # Custom output dir
 \`\`\`
 
-## Ops (Temporal Workflows)
+## Ops
 
-Ops are durable workflow definitions backed by Temporal. Each \`*.op.ts\` file declares an Op with named phases and activity steps.
+An Op is a convergent verb. Each \`*.op.ts\` file declares one with named phases and activity steps; \`--on <lexicon>\` picks the runtime that hosts the run, and the built-in local runtime runs it in-process otherwise.
 
 ### Op MCP Tools
 
 | Tool | Description |
 |---|---|
-| \`op-list\` | List all discovered Ops with current run status. Optional \`profile\` param. |
-| \`op-run\` | Submit an Op workflow. Requires \`name\`. Worker must already be running via \`chant run <name>\`. |
-| \`op-status\` | Get current run state (status, activity counts, times). Requires \`name\`. |
-| \`op-signal\` | Send a signal to unblock a gate step. Requires \`name\` and \`signal\`. |
-| \`op-report\` | Return a markdown deployment report for the latest run. Requires \`name\`. |
+| \`op-list\` | List all discovered Ops with their current run state. |
+| \`op-run\` | Run an Op and return its result. Requires \`name\`. |
+| \`op-status\` | Get current run state (state, step records, times). Requires \`name\`. |
+| \`op-approve\` | Record a gate's resolution and wake the runtime hosting the run. Requires \`name\` and \`gate\`. |
+| \`op-report\` | Return a markdown report for the latest run. Requires \`name\`. |
 
-All Op tools accept an optional \`profile\` parameter matching a profile name in \`chant.config.ts\` \`temporal.profiles\`.
+All Op tools accept an optional \`runtime\` parameter: a lexicon name whose \`opRuntime\` hosts the run, or \`local\` (the default) for the built-in in-process runtime.
 
 ### Op MCP Resources
 
 | URI | Description |
 |---|---|
-| \`chant://ops\` | JSON array of all Op definitions (name, overview, phases, taskQueue, depends) |
-| \`chant://ops/{name}/runs\` | Workflow run history for a named Op |
+| \`chant://ops\` | JSON array of all Op definitions (name, overview, phase count, labels, depends) |
+| \`chant://ops/{name}/runs\` | Run ledger history for a named Op, newest first |
 | \`chant://ops/{name}/runs/latest\` | Latest run state for a named Op |
 
-### Workflow IDs
-Ops use deterministic workflow IDs: \`chant-op-<opName>\` (e.g. \`chant-op-alb-deploy\`).
+Both run resources read the built-in local runtime, the one an MCP client can address without naming a lexicon.
 
 ## Best Practices
 

package/src/cli/mcp/server.test.ts

@@ -467,50 +467,50 @@ describe("McpServer", () => {
         return tool.inputSchema.properties as Record<string, unknown>;
       }
 
-      test("op-list has profile property", async () => {
+      test("op-list has a runtime property", async () => {
         const props = await getToolProps("op-list");
-        expect(props.profile).toBeDefined();
+        expect(props.runtime).toBeDefined();
       });
 
-      test("op-run has name (required) and profile", async () => {
+      test("op-run has name (required) and runtime", async () => {
         const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
         const result = response.result as { tools: Array<{ name: string; inputSchema: Record<string, unknown> }> };
         const tool = result.tools.find((t) => t.name === "op-run")!;
         const props = tool.inputSchema.properties as Record<string, unknown>;
         expect(props.name).toBeDefined();
-        expect(props.profile).toBeDefined();
+        expect(props.runtime).toBeDefined();
         expect(tool.inputSchema.required).toContain("name");
       });
 
-      test("op-status has name (required) and profile", async () => {
+      test("op-status has name (required) and runtime", async () => {
         const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
         const result = response.result as { tools: Array<{ name: string; inputSchema: Record<string, unknown> }> };
         const tool = result.tools.find((t) => t.name === "op-status")!;
         const props = tool.inputSchema.properties as Record<string, unknown>;
         expect(props.name).toBeDefined();
-        expect(props.profile).toBeDefined();
+        expect(props.runtime).toBeDefined();
         expect(tool.inputSchema.required).toContain("name");
       });
 
-      test("op-signal has name and signal (both required) and profile", async () => {
+      test("op-approve has name and gate (both required), plus runtime (#2121)", async () => {
         const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
         const result = response.result as { tools: Array<{ name: string; inputSchema: Record<string, unknown> }> };
-        const tool = result.tools.find((t) => t.name === "op-signal")!;
+        const tool = result.tools.find((t) => t.name === "op-approve")!;
         const props = tool.inputSchema.properties as Record<string, unknown>;
         expect(props.name).toBeDefined();
-        expect(props.signal).toBeDefined();
-        expect(props.profile).toBeDefined();
+        expect(props.gate).toBeDefined();
+        expect(props.runtime).toBeDefined();
         expect(tool.inputSchema.required).toContain("name");
-        expect(tool.inputSchema.required).toContain("signal");
+        expect(tool.inputSchema.required).toContain("gate");
       });
 
-      test("op-report has name (required) and profile", async () => {
+      test("op-report has name (required) and runtime", async () => {
         const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "tools/list" });
         const result = response.result as { tools: Array<{ name: string; inputSchema: Record<string, unknown> }> };
         const tool = result.tools.find((t) => t.name === "op-report")!;
         const props = tool.inputSchema.properties as Record<string, unknown>;
         expect(props.name).toBeDefined();
-        expect(props.profile).toBeDefined();
+        expect(props.runtime).toBeDefined();
         expect(tool.inputSchema.required).toContain("name");
       });
     });
@@ -640,7 +640,7 @@ describe("McpServer", () => {
     });
 
     describe("Op tool handlers", () => {
-      test("op-list returns list without throwing when Temporal unavailable", async () => {
+      test("op-list returns list without throwing when no runtime has a record", async () => {
         const response = await server.handleRequest({
           jsonrpc: "2.0",
           id: 1,
@@ -654,7 +654,7 @@ describe("McpServer", () => {
         expect(result.isError).toBeUndefined();
       });
 
-      test("op-run returns isError when Temporal unavailable", async () => {
+      test("op-run answers for an Op that does not exist", async () => {
         const response = await server.handleRequest({
           jsonrpc: "2.0",
           id: 1,
@@ -663,11 +663,11 @@ describe("McpServer", () => {
         });
         expect(response.error).toBeUndefined();
         const result = response.result as { content: Array<{ text: string }>; isError?: boolean };
-        // Either "not found" or Temporal error — either way should not be a protocol error
+        // Either "not found" or a runtime error — either way, not a protocol error
         expect(result.content[0].text.length).toBeGreaterThan(0);
       });
 
-      test("op-status returns isError when Temporal unavailable", async () => {
+      test("op-status returns isError for an Op that does not exist", async () => {
         const response = await server.handleRequest({
           jsonrpc: "2.0",
           id: 1,
@@ -680,12 +680,12 @@ describe("McpServer", () => {
         expect(result.content[0].text).toContain("Error:");
       });
 
-      test("op-signal returns isError when Temporal unavailable", async () => {
+      test("op-approve returns isError without a gate name (#2121)", async () => {
         const response = await server.handleRequest({
           jsonrpc: "2.0",
           id: 1,
           method: "tools/call",
-          params: { name: "op-signal", arguments: { name: "nonexistent-op", signal: "gate" } },
+          params: { name: "op-approve", arguments: { name: "nonexistent-op" } },
         });
         expect(response.error).toBeUndefined();
         const result = response.result as { content: Array<{ text: string }>; isError: boolean };
@@ -702,7 +702,7 @@ describe("McpServer", () => {
         });
         expect(response.error).toBeUndefined();
         const result = response.result as { content: Array<{ text: string }>; isError?: boolean };
-        // Op not found → returns a "not found" message or Temporal error, not a protocol error
+        // Op not found → returns a "not found" message or a runtime error, not a protocol error
         expect(result.content[0].text.length).toBeGreaterThan(0);
       });
     });
@@ -973,7 +973,7 @@ describe("McpServer", () => {
         expect(Array.isArray(ops)).toBe(true);
       });
 
-      test("chant://ops/{name}/runs degrades gracefully when Temporal unavailable", async () => {
+      test("chant://ops/{name}/runs is an empty list for an Op with no recorded run", async () => {
         const response = await server.handleRequest({
           jsonrpc: "2.0",
           id: 1,
@@ -982,11 +982,10 @@ describe("McpServer", () => {
         });
         expect(response.error).toBeUndefined();
         const result = response.result as { contents: Array<{ text: string }> };
-        const data = JSON.parse(result.contents[0].text);
-        expect(data.error).toBeDefined();
+        expect(JSON.parse(result.contents[0].text)).toEqual([]);
       });
 
-      test("chant://ops/{name}/runs/latest degrades gracefully when Temporal unavailable", async () => {
+      test("chant://ops/{name}/runs/latest is null for an Op with no recorded run", async () => {
         const response = await server.handleRequest({
           jsonrpc: "2.0",
           id: 1,
@@ -995,8 +994,7 @@ describe("McpServer", () => {
         });
         expect(response.error).toBeUndefined();
         const result = response.result as { contents: Array<{ text: string }> };
-        const data = JSON.parse(result.contents[0].text);
-        expect(data.error).toBeDefined();
+        expect(JSON.parse(result.contents[0].text)).toBeNull();
       });
     });
 
@@ -1471,7 +1469,7 @@ describe("McpServer", () => {
       expect(tools).toHaveLength(13);
       expect(tools.map((t) => t.name).sort()).toEqual([
         "build", "explain", "import", "lifecycle-diff", "lifecycle-snapshot", "lint",
-        "op-list", "op-report", "op-run", "op-signal", "op-status",
+        "op-approve", "op-list", "op-report", "op-run", "op-status",
         "scaffold", "search",
       ]);
 

package/src/cli/mcp/server.ts

@@ -9,7 +9,7 @@ import { searchTool, createSearchHandler } from "./tools/search";
 import type { LexiconPlugin } from "../../lexicon";
 import type { McpRequest, McpResponse, McpRequestMeta, ToolDefinition, ToolHandler, ResourceDefinition } from "./types";
 import { createSnapshotTool, createDiffTool } from "./lifecycle-tools";
-import { createOpListTool, createOpRunTool, createOpStatusTool, createOpSignalTool, createOpReportTool } from "./op-tools";
+import { createOpListTool, createOpRunTool, createOpStatusTool, createOpApproveTool, createOpReportTool } from "./op-tools";
 import { buildResourcesList, handleResourcesRead } from "./resource-handlers";
 
 /**
@@ -103,7 +103,7 @@ export class McpServer {
     this.registerTool(diff.definition, diff.handler);
 
     // Register Op tools
-    for (const factory of [createOpListTool, createOpRunTool, createOpStatusTool, createOpSignalTool, createOpReportTool]) {
+    for (const factory of [createOpListTool, createOpRunTool, createOpStatusTool, createOpApproveTool, createOpReportTool]) {
       const t = factory();
       this.registerTool(t.definition, t.handler);
     }

package/src/cli/plugins.test.ts

@@ -1,6 +1,6 @@
 import { describe, test, expect } from "vitest";
-import { loadPlugin, loadPlugins, resolveLexiconVersions } from "./plugins";
-import { isLexiconPlugin } from "../lexicon";
+import { collectChangeSubscribers, loadPlugin, loadPlugins, resolveLexiconVersions } from "./plugins";
+import { isLexiconPlugin, type LexiconPlugin } from "../lexicon";
 
 describe("loadPlugin", () => {
   test("loads aws plugin with full LexiconPlugin interface", async () => {
@@ -61,3 +61,69 @@ describe("resolveLexiconVersions", () => {
     expect(resolveLexiconVersions([])).toEqual({});
   });
 });
+
+describe("collectChangeSubscribers (#1981)", () => {
+  function fakePlugin(name: string, withSeam: boolean): LexiconPlugin {
+    const plugin = {
+      name,
+      serializer: { name, serialize: () => "" },
+      generate: async () => {},
+      validate: async () => {},
+      coverage: async () => {},
+      package: async () => {},
+    } as unknown as LexiconPlugin;
+    if (withSeam) {
+      plugin.subscribeChanges = async () => ({ close: async () => {} });
+    }
+    return plugin;
+  }
+
+  const entitiesFor = (lexicon: string) =>
+    new Map([[lexicon, new Map([["web", { entityType: "K8s::Apps::Deployment", props: {} }]])]]);
+
+  test("a lexicon without the seam contributes nothing", () => {
+    expect(
+      collectChangeSubscribers([fakePlugin("aws", false)], {
+        environment: "prod",
+        entities: entitiesFor("aws"),
+      }),
+    ).toEqual([]);
+  });
+
+  test("a lexicon with the seam but no declared entities is skipped rather than handed an empty scope", () => {
+    expect(
+      collectChangeSubscribers([fakePlugin("k8s", true)], {
+        environment: "prod",
+        entities: new Map(),
+      }),
+    ).toEqual([]);
+  });
+
+  test("binds the environment, cwd and this lexicon's own entity slice", async () => {
+    const plugin = fakePlugin("k8s", true);
+    let seen: Record<string, unknown> | undefined;
+    plugin.subscribeChanges = async (options) => {
+      seen = options as unknown as Record<string, unknown>;
+      return { close: async () => {} };
+    };
+
+    const entities = new Map([
+      ["k8s", new Map([["web", { entityType: "K8s::Apps::Deployment", props: {} }]])],
+      ["aws", new Map([["bucket", { entityType: "AWS::S3::Bucket", props: {} }]])],
+    ]);
+    const subscribers = collectChangeSubscribers([plugin], { environment: "prod", cwd: "/proj", entities });
+    expect(subscribers).toHaveLength(1);
+    expect(subscribers[0].lexicon).toBe("k8s");
+
+    const controller = new AbortController();
+    const onChange = () => {};
+    const onError = () => {};
+    await subscribers[0].subscribe({ onChange, onError, signal: controller.signal });
+    expect(seen!.environment).toBe("prod");
+    expect(seen!.cwd).toBe("/proj");
+    expect(seen!.onChange).toBe(onChange);
+    expect(seen!.signal).toBe(controller.signal);
+    // This lexicon's slice only: aws's bucket is not in scope for k8s.
+    expect([...(seen!.entities as Map<string, unknown>).keys()]).toEqual(["web"]);
+  });
+});

package/src/cli/plugins.ts

@@ -114,6 +114,45 @@ export function collectBuildRootContributors(
     .map((plugin) => (ctx) => plugin.buildRoots!({ projectRoot, config, entities: ctx?.entities }));
 }
 
+/**
+ * Bind each loaded plugin's `subscribeChanges` seam (#1981) to one environment
+ * and its declared entities, producing the `ChangeSubscriber` list `chant
+ * operator`'s loop takes, in the same extract-then-thread shape
+ * {@link collectBuildRootContributors} uses, and for the same reason: core's
+ * operator must not import plugins.
+ *
+ * Plugins without the seam contribute nothing, so a project whose lexicons all
+ * lack it gets a loop that is exactly the timer it always was. `entities` is
+ * the per-lexicon slice of a build's declared entities, which is the bound on
+ * what a subscription may watch; a lexicon with no declared entities is
+ * skipped rather than handed an empty scope to widen.
+ */
+export function collectChangeSubscribers(
+  plugins: readonly LexiconPlugin[] | undefined,
+  options: {
+    environment: string;
+    cwd?: string;
+    /** Declared entities per lexicon name, from a build. */
+    entities: Map<string, Map<string, { entityType: string; props: Record<string, unknown> }>>;
+  },
+): Array<import("../op/operator").ChangeSubscriber> {
+  return (plugins ?? [])
+    .filter((plugin) => typeof plugin.subscribeChanges === "function")
+    .filter((plugin) => (options.entities.get(plugin.name)?.size ?? 0) > 0)
+    .map((plugin) => ({
+      lexicon: plugin.name,
+      subscribe: (ctx) =>
+        plugin.subscribeChanges!({
+          environment: options.environment,
+          ...(options.cwd ? { cwd: options.cwd } : {}),
+          entities: options.entities.get(plugin.name),
+          onChange: ctx.onChange,
+          onError: ctx.onError,
+          signal: ctx.signal,
+        }),
+    }));
+}
+
 /**
  * Load plugins for all detected lexicon names.
  * Calls `init()` on each plugin if present.

package/src/cli/registry.ts

@@ -18,24 +18,51 @@ export interface ParsedArgs {
   watch: boolean;
   verbose: boolean;
   help: boolean;
-  profile?: string;
   report?: boolean;
   /** `chant run` — force the local in-process executor (the default). */
   local?: boolean;
-  /** `chant run` — run via a Temporal cluster instead of the local executor. */
-  temporal?: boolean;
+  /**
+   * `chant run <op> --on <lexicon>` (#2121) — which runtime hosts the run.
+   * The named lexicon's `opRuntime` (`../lexicon.ts`) takes it; omitted, core's
+   * built-in `local` provider does. Applies to every `run` subcommand, so
+   * `run status`/`log`/`list`/`cancel`/`approve` all address the same runtime
+   * the run started on.
+   */
+  on?: string;
+  /**
+   * `-p, --profile <name>` (#2124, restored in #2192) — which named connection
+   * profile the hosting runtime targets, handed to it as
+   * {@link OpRunStartOptions.profile}. Only a runtime that declares profiles
+   * reads it: fountain resolves it through `fountain.profiles` in
+   * `chant.config.ts` and refuses a name it does not find. Omitted, each
+   * runtime keeps its own default (fountain's `defaultProfile`).
+   */
+  profile?: string;
   /** `chant run` — emit the structured OpRunResult as JSON on stdout. */
   json?: boolean;
+  /**
+   * `chant run <op> --gated-exit <code>` (#2243) — the process exit code a
+   * run that stopped at an unapproved gate returns, instead of the default 3.
+   *
+   * Only the gated outcome is remapped. A run that fails still returns 1 and a
+   * run that completes still returns 0, so `--gated-exit 0` on a CI job means
+   * "a pending approval is not a broken build" and nothing more. The `--json`
+   * payload is untouched by it: the record still says `status: "gated"` and
+   * still carries the gate and the `chant approve` line, so a job that maps the
+   * code to success can still tell the two apart.
+   *
+   * Accepts 0-255 (a POSIX exit status). Anything else is refused by name.
+   */
+  gatedExit?: number;
   /**
    * `chant run --components <name|all> --progress-json` (local executor) —
    * stream one NDJSON `RunProgressEvent` (../../components/run-progress.ts)
    * per line to stdout while the run executes, so a consumer can render live
    * wave/component/phase/step progress instead of tailing raw logs.
    *
-   * `chant run <name> --temporal --progress-json` (chant #1676) — the same
-   * flag on an Op's durable path streams one NDJSON `StepRecord`
-   * (../../op/local-executor.ts, reconstructed from workflow history by
-   * ../handlers/op-progress.ts) per settled step instead.
+   * `chant run <name> --progress-json` streams one NDJSON `StepRecord`
+   * (../../op/local-executor.ts) per settled step instead, fed by whatever
+   * the resolved runtime reports through its `progress` hook (#2121).
    *
    * Both are purely additive: run semantics, ordering, and exit code are
    * unchanged; omitted (undefined, not false) when the flag isn't passed.
@@ -173,7 +200,7 @@ export interface ParsedArgs {
    * registered in `~/.claude.json`, not just the path argument.
    */
   allProjects?: boolean;
-  /** `chant audit --fail-on merge-worthy|warning|none` */
+  /** `chant audit --fail-on merge-worthy|warning|error|none` */
   failOn?: string;
   /** `chant audit --theme <file>` — JSON theme knobs for the HTML report */
   theme?: string;
@@ -251,8 +278,10 @@ export interface ParsedArgs {
   runId?: string;
   /** `chant components release record --actor <name>` (#568) — who/what triggered the deploy. */
   actor?: string;
-  /** `--approver <name>` (#1035) — who approved a gated change. Supplied to `chant run signal` (rides the gate signal payload into workflow history) and to `chant components release` (recorded on the release ledger). Optional; absent for ungated changes. */
+  /** `--approver <name>` (#1035) — who approved a gated change. Read by `chant approve` and `chant run approve` (recorded as `resolvedBy` on the gate-resolution fact, taking precedence over `--actor`) and by `chant components release` (recorded on the release ledger). Optional; absent for ungated changes. */
   approver?: string;
+  /** `chant run approve <op> <gate> --on <lexicon> --durable-requests` (#2126) — reserved. It would resolve the gate by answering the hosting runtime's own pending request instead of posting a follow-up prompt. No runtime implements it: fountain's needs the request-answer path from BinaryBourbon/fountain#1635, which has not shipped, and refuses by name rather than reporting a resolution it did not make. */
+  durableRequests?: boolean;
   /** `chant components status <env> --compare-to <env>` (#568) — a second environment to cross-check the same component's recorded digest against. */
   compareTo?: string;
   /** `chant run --components <name> --env <env> --no-release-record` (#597) — opt out of auto-emitting a release-ledger record after a successful component deploy. Default (flag omitted): recording is ON. Also settable project-wide via `chant.config.ts`'s `release.autoRecord: false`. */
@@ -287,6 +316,8 @@ export interface ParsedArgs {
   once?: boolean;
   /** `chant approve <op> <gate> --note <text>` (#1485) — optional free-text prose recorded on the gate-resolution fact. The PR link belongs in `--url` since #2028; this is for everything that isn't the link. */
   note?: string;
+  /** `chant approve <op> <gate> --expire` (#2119) — clear the gate's standing pending fact instead of approving it, so the next run decides the gate from scratch and records a fresh one. Writes no resolution: nothing is approved, the wait is only restarted. */
+  expire?: boolean;
   /** `chant operator log --op <name>` (#2029) — restrict the tick history to one ConvergeOp by name. Omitted, every discovered ConvergeOp's ticks are merged into one timeline. */
   op?: string;
   /** `chant operator log --since <iso>` (#2029) — only entries at or after this ISO-8601 instant. */

package/src/codegen/docs.ts

@@ -325,7 +325,7 @@ export function writeDocsSite(config: DocsConfig, result: DocsResult): void {
   // Starlight does not auto-discover pages, so a page absent from the sidebar
   // is reachable only by typing its URL. The pipeline deliberately preserves
   // hand-written pages it did not emit (above), which makes it easy to add one
-  // and never wire it up — azure, temporal, helm and github each accumulated
+  // and never wire it up — azure, helm and github each accumulated
   // several that way (#1312). Report them; `chant dev check-lexicon` gates on
   // the same condition.
   const unreachable = unreachablePages(contentDir, sidebar);

package/src/codegen/generate-post-synth-barrel.test.ts

@@ -12,7 +12,7 @@ describe("generatePostSynthBarrel", () => {
 
     expect(out).toContain("// Code generated by chant generate. DO NOT EDIT.");
     expect(out).toContain('import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";');
-    // Export name may differ from the module name (docker/helm/temporal).
+    // Export name may differ from the module name (docker/helm).
     expect(out).toContain('import { dkrd010 } from "./apt-no-recommends";');
     // Array is ordered by id, not insertion order.
     const arrayBody = out.slice(out.indexOf("postSynthChecks: PostSynthCheck[] = ["));

package/src/codegen/generate-post-synth-barrel.ts

@@ -9,7 +9,7 @@
  *
  * Detection reuses the runtime's own `isPostSynthCheck`, so the barrel contains
  * exactly the checks discovery would — including files whose export name differs
- * from the filename (docker/helm/temporal) and excluding helper modules
+ * from the filename (docker/helm) and excluding helper modules
  * (cf-refs, arm-refs, …) that export no check.
  */
 

package/src/components/README.md

@@ -50,8 +50,9 @@ adopting chant.
   be a nested `Phase`, which is how fan-out (e.g. a Neo4j cluster seeding one
   node then rolling through the rest) is expressed as composition rather than
   orchestrator knowledge.
-- **Gates** — a distinct step shape (`kind: "gate"`, `signalName`) for a
-  durable, human-approval wait.
+- **Gates** — a distinct step shape (`kind: "gate"`, `gate`) for a human
+  approval, decided against the gate ledger: a run that reaches one with no
+  resolution stops there with status `gated` and the pending fact recorded.
 - **Wiring reference forms**, all resolved by the graph, never by orchestrator
   code:
   - `$env.<path>` — environment config (e.g. `$env.registry`).
@@ -88,7 +89,7 @@ Lambda function. `component-schema.test.ts` validates every fixture against
 `component.schema.json` with [ajv](https://ajv.js.org/) (`ajv/dist/2020` — the
 draft 2020-12 build) and exercises the schema's negative cases (missing
 required fields, malformed wiring references, an invalid archetype, a gate
-missing `signalName`, and so on).
+naming neither `gate` nor its deprecated `signalName` spelling, and so on).
 
 ## Typed authoring form (`component.ts`, #560)
 

package/src/components/__fixtures__/neo4j-fanout.json

@@ -16,7 +16,7 @@
     {
       "phase": "Node 1",
       "steps": [
-        { "kind": "gate", "signalName": "approve-neo4j-node-1", "description": "Confirm the seed node is healthy before rolling to node 1", "timeout": "24h" },
+        { "kind": "gate", "gate": "approve-neo4j-node-1", "description": "Confirm the seed node is healthy before rolling to node 1", "timeout": "24h" },
         { "kind": "cfn-deploy", "template": "archive:neo4j-1.template.json" },
         { "kind": "code-deploy", "instance": 1, "revision": "@Seed.templateUri" },
         { "kind": "wait-cluster-healthy", "quorum": true }