@intentius/chant 0.105.1 → 0.106.3

package/src/cli/handlers/run.test.ts

@@ -75,8 +75,9 @@ vi.mock("./operator", () => ({
 // gate handling, and a unit test must never write a fact to the real repo.
 vi.mock("../../op/gate", async () => {
   const actual = await vi.importActual<typeof import("../../op/gate")>("../../op/gate");
-  return { ...actual, gitGateLedgerPort: () => gateLedger };
+  return { ...actual, gitGateLedgerPort: () => gateLedger, gateIsSealed: async (gate: string) => sealedGates.has(gate) };
 });
+const sealedGates = new Set<string>();
 // The local runtime appends each run's record to that same branch (#2118).
 // Real behavior in a project, and exactly what this suite must not do in
 // chant's own checkout, since the append is against `process.cwd()`. Only the
@@ -264,9 +265,28 @@ describe("runOp dispatcher", () => {
     stderrWrite.mockRestore();
     expect(out).toContain('is gated on "approve-prod"');
     expect(out).toContain("chant approve gated approve-prod");
+    expect(out).not.toContain("--sign");
     expect(gateLedger.appended).toHaveLength(1);
   });
 
+  test("gate in local mode on a sealed gate: the approve line carries --sign (#3521)", async () => {
+    gateLedger = memoryGateLedgerPort();
+    sealedGates.add("approve-prod");
+    discoverOpsMock.mockResolvedValue({
+      ops: new Map([localOp("gated", [{ kind: "gate", gate: "approve-prod" }])]),
+      errors: [],
+    });
+    const stderrWrite = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+    try {
+      expect(await runOp({ args: makeArgs({ path: "gated" }), plugins: [], serializers: [] })).toBe(3);
+      const out = stderrWrite.mock.calls.map((c) => String(c[0])).join("");
+      expect(out).toContain("approve : chant approve gated approve-prod --sign");
+    } finally {
+      stderrWrite.mockRestore();
+      sealedGates.clear();
+    }
+  });
+
   test("an approved gate lets the run through and exits 0", async () => {
     gateLedger = memoryGateLedgerPort({
       pending: [{
@@ -448,6 +468,57 @@ describe("runOp: a steward's turn (#2750)", () => {
     expect(acquireStewardTurnMock).not.toHaveBeenCalled();
   });
 
+  // #3555: a runtime that carries the work item (fountain) is handed what the
+  // caller named, and nothing else; one that does not refuses --work by name.
+  function leasedOp(name: string) {
+    return [name, { config: { name, overview: `${name} overview`, phases: [], workLease: {} } }] as const;
+  }
+
+  test("--work on a runtime that carries work: start gets the item and holder the caller named (#3555)", async () => {
+    const runtime = {
+      name: "fountain",
+      carriesWork: true,
+      start: vi.fn(async (op: { name: string }, _opts: { work?: { item?: string; holder?: string } }) => ({
+        op: op.name,
+        runId: "f-1",
+        result: async () => ({ op: op.name, runId: "f-1", state: "completed" as const, startedAt: "t", endedAt: "t" }),
+      })),
+      status: vi.fn(), log: vi.fn(), list: vi.fn(), cancel: vi.fn(),
+    };
+    discoverOpsMock.mockResolvedValue({ ops: new Map([leasedOp("leased")]), errors: [] });
+    discoverStewardsMock.mockResolvedValueOnce(stewardOwning("leased", "box-steward", "fountain"));
+    loadChantConfigMock.mockResolvedValue({ config: { lexicons: ["fountain"] } });
+    makeStdoutSpy();
+    const exit = await runOp({
+      args: makeArgs({ path: "leased", on: "fountain", work: "ISSUE-7" }),
+      plugins: [{ name: "fountain", opRuntime: runtime } as never], serializers: [],
+    });
+
+    expect(exit).toBe(0);
+    expect(runtime.start).toHaveBeenCalledTimes(1);
+    expect(runtime.start.mock.calls[0][1].work).toEqual({ item: "ISSUE-7" });
+  });
+
+  test("--work on a runtime that does not carry work: exit 1 naming the runtime, nothing started (#3555)", async () => {
+    const runtime = {
+      name: "fountain",
+      start: vi.fn(),
+      status: vi.fn(), log: vi.fn(), list: vi.fn(), cancel: vi.fn(),
+    };
+    discoverOpsMock.mockResolvedValue({ ops: new Map([leasedOp("leased")]), errors: [] });
+    discoverStewardsMock.mockResolvedValueOnce(stewardOwning("leased", "box-steward", "fountain"));
+    loadChantConfigMock.mockResolvedValue({ config: { lexicons: ["fountain"] } });
+    const stderr = makeStderrSpy();
+    const exit = await runOp({
+      args: makeArgs({ path: "leased", on: "fountain", work: "ISSUE-7" }),
+      plugins: [{ name: "fountain", opRuntime: runtime } as never], serializers: [],
+    });
+
+    expect(exit).toBe(1);
+    expect(runtime.start).not.toHaveBeenCalled();
+    expect(stderr.join("\n")).toContain('--work and --holder run on the local runtime; "fountain" takes the work lease');
+  });
+
   test("local form, the turn lease's own acquire throws (a stale .lock): refused as a lease error, not an uncaught exception, and nothing runs", async () => {
     discoverOpsMock.mockResolvedValue({
       ops: new Map([localOp("release", [{ kind: "activity", fn: "shellCmd", args: { cmd: "true" } }])]),
@@ -616,6 +687,25 @@ describe("runOp: --gated-exit (#2243)", () => {
     expect(readFileSync(file, "utf8")).toContain("chant approve gated approve-prod");
   });
 
+  test("a sealed gate: the --json approve field and the summary carry --sign (#3521)", async () => {
+    const file = summaryFile();
+    process.env.GITHUB_STEP_SUMMARY = file;
+    sealedGates.add("approve-prod");
+    discoverOpsMock.mockResolvedValue({ ops: new Map([localOp("gated", [gateStep])]), errors: [] });
+    const stdoutWrite = vi.spyOn(process.stdout, "write").mockImplementation(() => true);
+    vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+    makeStderrSpy();
+
+    try {
+      await runOp({ args: makeArgs({ path: "gated", gatedExit: 0, json: true }), plugins: [], serializers: [] });
+      const parsed = JSON.parse(stdoutWrite.mock.calls.map((c) => String(c[0])).join("").trim());
+      expect(parsed.approve).toBe("chant approve gated approve-prod --sign");
+      expect(readFileSync(file, "utf8")).toContain("chant approve gated approve-prod --sign --approver <you>");
+    } finally {
+      sealedGates.clear();
+    }
+  });
+
   test("a run that fails for any other reason is still red under the flag", async () => {
     discoverOpsMock.mockResolvedValue({
       // atMostOnce: one attempt. The default profile retries twice with 5s and
@@ -776,6 +866,45 @@ describe("runOp: --sandbox with a policyGate step (chant #2003)", () => {
     expect(seen).not.toHaveProperty("profile");
   });
 
+  // #3521: a hosted runtime that reports only a gate name gets a hint whose
+  // approve command names `--sign` when the workspace seals that gate.
+  describe("a runtime that reports a gated state with only the gate name (#3521)", () => {
+    async function runGatedOnStub(): Promise<string> {
+      discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("prod-apply")]), errors: [] });
+      const start = vi.fn(async () => ({
+        op: "prod-apply",
+        runId: "stub-1",
+        result: async () => ({
+          op: "prod-apply", runId: "stub-1", state: "gated", startedAt: "2026-01-01T00:00:00.000Z",
+          gate: { name: "approve-prod", since: "2026-01-01T00:00:00.000Z" },
+        }),
+      }));
+      makeStdoutSpy();
+      const stderr = makeStderrSpy();
+      const exit = await runOp({
+        args: makeArgs({ path: "prod-apply", on: "stub" }),
+        plugins: [{ name: "stub", opRuntime: { name: "stub", start } } as never], serializers: [],
+      });
+      expect(exit).toBe(3);
+      return stderr.join("\n");
+    }
+
+    test("unsealed gate: the hint's approve command has no --sign", async () => {
+      const out = await runGatedOnStub();
+      expect(out).toContain("Record the resolution with: chant approve prod-apply approve-prod");
+      expect(out).not.toContain("--sign");
+    });
+
+    test("sealed gate: the hint's approve command ends in --sign", async () => {
+      sealedGates.add("approve-prod");
+      try {
+        expect(await runGatedOnStub()).toContain("Record the resolution with: chant approve prod-apply approve-prod --sign");
+      } finally {
+        sealedGates.clear();
+      }
+    });
+  });
+
   test("--sandbox on an Op with no policyGate step is untouched", async () => {
     discoverOpsMock.mockResolvedValue({
       ops: new Map([localOp("hello", [{ kind: "activity", fn: "shellCmd", args: { cmd: "true" } }])]),
@@ -878,6 +1007,29 @@ describe("run subcommands on the resolved runtime", () => {
     expect((runtime.start.mock.calls[0][0] as { name: string }).name).toBe("hello");
   });
 
+  test("--param reaches the runtime's start as params (#3539)", async () => {
+    const runtime = makeStubRuntime();
+    discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("hello")]), errors: [] });
+    makeStdoutSpy();
+    const exit = await runOp({
+      args: makeArgs({ path: "hello", on: "stub", env: "staging", param: ["agent=ops-bot", "tier=gold plus"] }),
+      plugins: [stubPlugin(runtime)], serializers: [],
+    });
+    expect(exit).toBe(0);
+    expect((runtime.start.mock.calls[0] as unknown[])[1]).toMatchObject({
+      env: "staging",
+      params: { agent: "ops-bot", tier: "gold plus" },
+    });
+  });
+
+  test("no --param hands start no params", async () => {
+    const runtime = makeStubRuntime();
+    discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("hello")]), errors: [] });
+    makeStdoutSpy();
+    await runOp({ args: makeArgs({ path: "hello", on: "stub" }), plugins: [stubPlugin(runtime)], serializers: [] });
+    expect((runtime.start.mock.calls[0] as unknown[])[1]).not.toHaveProperty("params");
+  });
+
   test("run status/log/list/cancel --on stub reach their methods", async () => {
     const runtime = makeStubRuntime();
     discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("hello")]), errors: [] });
@@ -1060,6 +1212,21 @@ describe("runOpApprove", () => {
     expect(stderr.join("\n")).toContain('Runtime "stub" was notified');
   });
 
+  test("--env on the approve line reaches resolveGate (#3539)", async () => {
+    const record = { version: 1, op: "alb-deploy", gate: "release", resolvedBy: "alex", timestamp: "2026-01-01T00:00:00.000Z" };
+    recordGateApprovalMock.mockResolvedValue({ ok: true, record });
+    const resolveGate = vi.fn(async () => undefined);
+    makeStderrSpy();
+
+    const exit = await runOpApprove({
+      args: makeArgs({ on: "stub", extraPositional: "alb-deploy", extraPositional2: "release", approver: "alex", env: "prod" }),
+      plugins: [{ name: "stub", opRuntime: { name: "stub", resolveGate } } as never], serializers: [],
+    });
+
+    expect(exit).toBe(0);
+    expect(resolveGate).toHaveBeenCalledWith("alb-deploy", "release", record, { env: "prod" });
+  });
+
   test("a provider with no resolveGate still records the fact and exits 0", async () => {
     const record = { version: 1, op: "alb-deploy", gate: "release", resolvedBy: "ci", timestamp: "2026-01-01T00:00:00.000Z" };
     recordGateApprovalMock.mockResolvedValue({ ok: true, record });
@@ -1141,6 +1308,53 @@ describe("runOp dispatcher: --components routes to runOpComponents", () => {
   });
 });
 
+// #3521: a gated component's approve line and mismatch line name `--sign` on
+// a sealed gate and leave it off otherwise.
+describe("runOp --components gate hints (#3521)", () => {
+  beforeEach(() => {
+    runComponentsMock.mockReset();
+    loadChantConfigMock.mockReset().mockResolvedValue({ config: {} });
+    maybeRecordAutoReleaseMock.mockReset().mockResolvedValue({ recorded: false, reason: "no-digest" });
+    maybePersistBuildManifestMock.mockReset().mockResolvedValue({ persisted: false, reason: "no-manifest" });
+  });
+
+  async function runGatedComponent(): Promise<string> {
+    runComponentsMock.mockResolvedValue({
+      success: false,
+      selected: ["svc"],
+      gated: {
+        component: "svc",
+        gate: {
+          version: 1, kind: "pending", op: "svc", gate: "approve-prod", environment: "prod",
+          timestamp: "2026-09-05T10:00:00.000Z", expiresAt: "2099-01-01T00:00:00.000Z",
+        },
+        mismatch: { approved: "sha256:aaa", planned: "sha256:bbb", resolvedBy: "alex", timestamp: "2026-09-05T11:00:00.000Z", environment: "prod" },
+      },
+    });
+    const stderr = makeStderrSpy();
+    expect(await runOp({ args: makeArgs({ path: "svc", components: true }), plugins: [], serializers: [] })).toBe(3);
+    return stderr.join("\n");
+  }
+
+  test("unsealed gate: the approve line and the mismatch line carry no --sign", async () => {
+    const out = await runGatedComponent();
+    expect(out).toContain("approve : chant approve svc approve-prod --env prod");
+    expect(out).toContain("needs a fresh one: chant approve svc approve-prod --env prod");
+    expect(out).not.toContain("--sign");
+  });
+
+  test("sealed gate: the approve line and the mismatch line end in --sign", async () => {
+    sealedGates.add("approve-prod");
+    try {
+      const out = await runGatedComponent();
+      expect(out).toContain("approve : chant approve svc approve-prod --env prod --sign");
+      expect(out).toContain("needs a fresh one: chant approve svc approve-prod --env prod --sign");
+    } finally {
+      sealedGates.clear();
+    }
+  });
+});
+
 describe("runOpComponents", () => {
   beforeEach(() => {
     runComponentsMock.mockReset();

package/src/cli/handlers/run.ts

@@ -7,7 +7,7 @@ import { stewardWorkHolder } from "../../op/work-lease-run";
 import type { OpConfig } from "../../op/types";
 import { loadActivities, loadProfiles } from "../../op/activity-registry";
 import { runOpLocally, findPolicyGateStep, OpRunFailure, type StepRecord } from "../../op/local-executor";
-import { approveCommand, describeGateMismatch } from "../../op/gate";
+import { approveCommand, describeGateMismatch, gateIsSealed } from "../../op/gate";
 import { summaryLedgerPrefix, writeGatedRunSummary, type GatedRunSummary } from "../../op/gate-summary";
 import { createLocalOpRuntime } from "../../op/runtimes/local";
 import type { OpRuntimeProvider, OpRunStatus } from "../../op/runtime";
@@ -77,8 +77,8 @@ function resolveGatedExitCode(ctx: CommandContext): number | undefined {
  * passes `--gated-exit 0` reports success, and the one line that explains why
  * a zero-exit run applied nothing belongs next to the gate itself.
  */
-function reportGatedRun(summary: GatedRunSummary, exitCode: number): void {
-  writeGatedRunSummary(summary);
+async function reportGatedRun(summary: GatedRunSummary, exitCode: number): Promise<void> {
+  writeGatedRunSummary({ ...summary, sealed: await gateIsSealed(summary.gate) });
   if (exitCode !== GATED_EXIT_CODE) {
     console.error(formatInfo(
       `gated: exiting ${exitCode} because --gated-exit asked for it. Nothing after the gate ran.`,
@@ -466,7 +466,10 @@ export async function runOpApprove(ctx: CommandContext): Promise<number> {
   }
 
   try {
-    await runtime.resolveGate(opName, gate, outcome.record);
+    // `--env` on the approve line names the environment the woken run runs
+    // in (#3539); without it the runtime keeps the gated run's.
+    if (ctx.args.env !== undefined) await runtime.resolveGate(opName, gate, outcome.record, { env: ctx.args.env });
+    else await runtime.resolveGate(opName, gate, outcome.record);
   } catch (err) {
     console.error(formatWarning({
       message:
@@ -962,10 +965,11 @@ export async function runOpComponents(ctx: CommandContext): Promise<number> {
     }));
     // #2574: an approval stands, but for another plan or for none. Say so,
     // with the command that replaces it.
+    const sealed = await gateIsSealed(gate.gate);
     if (result.gated.mismatch) {
-      console.error(formatWarning({ message: describeGateMismatch(gate.op, gate.gate, result.gated.mismatch) }));
+      console.error(formatWarning({ message: describeGateMismatch(gate.op, gate.gate, result.gated.mismatch, sealed) }));
     }
-    console.error(formatInfo(`approve : ${approveCommand(gate.op, gate.gate, gate.environment)}`));
+    console.error(formatInfo(`approve : ${approveCommand(gate.op, gate.gate, gate.environment, undefined, sealed)}`));
     if (gate.url) console.error(formatInfo(`approve at: ${gate.url}`));
     console.error(formatInfo(`expires : ${gate.expiresAt}`));
     // #2310: this run's own append reached only the local chant/lifecycle
@@ -978,7 +982,7 @@ export async function runOpComponents(ctx: CommandContext): Promise<number> {
         hint: "an operator working from a clone of the remote cannot approve it until it does",
       }));
     }
-    reportGatedRun(
+    await reportGatedRun(
       {
         op: gate.op,
         gate: gate.gate,
@@ -1074,8 +1078,8 @@ export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
 
   // The work lease (#2748). `--work` names the item an Op with a work lease
   // runs under; it is taken where the run executes, which for a hosted
-  // runtime is not this process.
-  const work = await resolveRunWork(ctx, config, runtime.name);
+  // runtime that carries it (fountain, #3555) is not this process.
+  const work = await resolveRunWork(ctx, config, runtime);
   if (work === null) {
     await stewardGate?.release?.();
     return 1;
@@ -1107,8 +1111,13 @@ export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
   process.on("SIGTERM", onSigint);
 
   try {
+    // `--param name=value` reaches the runtime (#3539). The local runtime
+    // has no use for it; fountain reads `agent` to pick the steward and posts
+    // the rest on the command line it hands the sandbox.
+    const params = parseParamFlags(ctx.args.param);
     const handle = await runtime.start(config, {
       env: ctx.args.env,
+      ...(params ? { params } : {}),
       ...(ctx.args.profile !== undefined ? { profile: ctx.args.profile } : {}),
       progress,
       signal: controller.signal,
@@ -1119,13 +1128,14 @@ export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
     if (status.result) {
       // The executor's own render already prints a gate, its approve line
       // and its expiry (#2119).
-      if (ctx.args.json) renderJson(status.result); else renderHuman(status.result);
+      const sealed = status.result.gate ? await gateIsSealed(status.result.gate.gate) : false;
+      if (ctx.args.json) renderJson(status.result, undefined, sealed); else renderHuman(status.result, undefined, sealed);
     } else {
       renderRuntimeStatus("Op", opName, runtime.name, status);
       if (status.state === "gated" && status.gate) {
         console.error(formatWarning({
           message: `Op "${opName}" is waiting on gate "${status.gate.name}"`,
-          hint: `Record the resolution with: ${approveCommand(opName, status.gate.name)}`,
+          hint: `Record the resolution with: ${approveCommand(opName, status.gate.name, undefined, undefined, await gateIsSealed(status.gate.name))}`,
         }));
       }
     }
@@ -1140,7 +1150,7 @@ export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
       const pending = status.result?.gate;
       const gate = pending?.gate ?? status.gate?.name;
       if (gate) {
-        reportGatedRun(
+        await reportGatedRun(
           {
             op: opName,
             gate,
@@ -1175,7 +1185,8 @@ export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
     return status.state === "completed" ? 0 : 1;
   } catch (err) {
     if (err instanceof OpRunFailure) {
-      if (ctx.args.json) renderJson(err.result); else renderHuman(err.result);
+      const sealed = err.result.gate ? await gateIsSealed(err.result.gate.gate) : false;
+      if (ctx.args.json) renderJson(err.result, undefined, sealed); else renderHuman(err.result, undefined, sealed);
       return 1;
     }
     console.error(formatError({ message: err instanceof Error ? err.message : String(err) }));
@@ -1197,12 +1208,17 @@ export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
  * `null` after printing why the run is refused. The holder is `--holder`, or,
  * for an Op a steward lists, `<steward>/<op>@<process>` so `workspace status`
  * shows the lease beside the steward's Ops, or this process's id.
+ *
+ * A non-local runtime takes `--work` only when it declares `carriesWork`
+ * (#3555), and then gets just what the caller named: the holder is chosen
+ * where the run executes, not after this process.
  */
 async function resolveRunWork(
   ctx: CommandContext,
   config: OpConfig,
-  runtime: string,
+  provider: Pick<OpRuntimeProvider, "name" | "carriesWork">,
 ): Promise<{ item?: string; holder?: string } | undefined | null> {
+  const runtime = provider.name;
   const item = ctx.args.work;
   if (!config.workLease) {
     if (item === undefined) return undefined;
@@ -1212,13 +1228,18 @@ async function resolveRunWork(
     }));
     return null;
   }
-  if (runtime !== "local" && (item !== undefined || ctx.args.holder !== undefined)) {
+  if (runtime !== "local" && provider.carriesWork !== true && (item !== undefined || ctx.args.holder !== undefined)) {
     console.error(formatError({
       message: `--work and --holder run on the local runtime; "${runtime}" takes the work lease where it executes the run`,
       hint: "Omit --on, or name the item in the Op's workLease.",
     }));
     return null;
   }
+  if (runtime !== "local" && provider.carriesWork === true) {
+    const holderArg = ctx.args.holder;
+    if (item === undefined && holderArg === undefined) return undefined;
+    return { ...(item !== undefined ? { item } : {}), ...(holderArg !== undefined ? { holder: holderArg } : {}) };
+  }
   let holder = ctx.args.holder;
   if (holder === undefined) {
     try {

package/src/cli/main.ts

@@ -606,6 +606,10 @@ export function parseArgs(args: string[]): ParsedArgs {
       // didn't support joined forms at all — now that it does, the joined
       // form is just as valid as the space-separated one).
       (result.param ??= []).push(args[++i]);
+    } else if (arg === "--lexicon-output") {
+      // `--lexicon-output <lexicon>=<path>` (repeatable); the joined form
+      // `--lexicon-output=otel=a.yml` arrives here already split at the first `=`.
+      (result.lexiconOutput ??= []).push(args[++i]);
     } else if (arg === "--params-file") {
       result.paramsFile = args[++i];
     } else if (arg === "--projection") {
@@ -1308,7 +1312,11 @@ Component release ledger + status:
                             (chant approve pr-<n> pr-apply --plan <digest>);
                             a moved plan refuses with exit 3
                             (--require-review: the approver must have
-                            approved the pull request on the forge)
+                            approved the pull request on the forge;
+                            --member <name>, both commands: a workspace
+                            member's loop, gate op pr-<n>-<member>;
+                            --resume <file> finishes an apply that failed
+                            partway under the same approval)
   components release <env> Append one immutable release record
                             (--component <name> --digest <sha256:...>
                              [--git-sha <sha>] [--run-id <id>] [--actor <name>]);
@@ -1376,6 +1384,10 @@ Options:
                         - build: json (default) or yaml
                         - list: text (default) or json
                         - lint: stylish (default), json, or sarif
+      --lexicon-output <lexicon>=<path>
+                        build: write that lexicon's output to its own file
+                        (repeatable). Lexicons not named go to --output when
+                        given, and are skipped otherwise
   -d, --lexicon <name>  Build only the specified lexicon (e.g. aws, gitlab);
                         import: use this lexicon instead of detecting one
       --env <name>      Active environment: sets CHANT_ENV so env-aware source

package/src/cli/mcp/never-over-mcp.test.ts

@@ -100,6 +100,52 @@ describe("neverOverMcp (chant#3447)", () => {
     await expect(createOpReportTool().handler({ name: "tf-apply" })).resolves.toContain("# tf-apply");
   });
 
+  // chant#3555: op-approve hands the runtime the env it was given, as `chant
+  // run approve --env` does, and nothing when it was given none.
+  async function repoWithPlainGate(dir: string): Promise<void> {
+    git(["init", "-q", "-b", "main"], dir);
+    git(["config", "user.email", "t@chant.dev"], dir);
+    git(["config", "user.name", "T"], dir);
+    writeFileSync(join(dir, "README.md"), "x\n");
+    git(["add", "."], dir);
+    git(["commit", "-q", "-m", "init"], dir);
+    await appendPendingGate(
+      {
+        op: "plain-op",
+        gate: "release",
+        timestamp: "2026-01-01T00:00:00.000Z",
+        origin: "cli",
+        expiresAt: "2999-01-01T00:00:00.000Z",
+        planDigest: `sha256:${"d".repeat(64)}`,
+      },
+      { cwd: dir },
+    );
+  }
+
+  test("op-approve passes env to the runtime's resolveGate (chant#3555)", async () => {
+    await withTestDir(async (dir) => {
+      await repoWithPlainGate(dir);
+      process.chdir(dir);
+      const result = (await createOpApproveTool().handler({ name: "plain-op", gate: "release", env: "prod" })) as {
+        runtimeNotified: boolean;
+      };
+      expect(result.runtimeNotified).toBe(true);
+      expect(resolveGate).toHaveBeenCalledWith("plain-op", "release", expect.objectContaining({ gate: "release" }), {
+        env: "prod",
+      });
+    });
+  });
+
+  test("op-approve with no env leaves the runtime to keep the gated run's (chant#3555)", async () => {
+    await withTestDir(async (dir) => {
+      await repoWithPlainGate(dir);
+      process.chdir(dir);
+      await createOpApproveTool().handler({ name: "plain-op", gate: "release" });
+      expect(resolveGate).toHaveBeenCalledTimes(1);
+      expect(resolveGate.mock.calls[0]).toHaveLength(3);
+    });
+  });
+
   async function repoWithFanOutGate(dir: string): Promise<void> {
     git(["init", "-q", "-b", "main"], dir);
     git(["config", "user.email", "t@chant.dev"], dir);
@@ -166,4 +212,78 @@ describe("neverOverMcp (chant#3447)", () => {
       expect(outcome.ok).toBe(true);
     });
   });
+
+  // chant#3513: workspace-upgrade and the pull-request gate are undiscovered too.
+  const gateOnlyOps: Array<{ op: string; gate: string }> = [
+    { op: "workspace-upgrade", gate: "." },
+    { op: "pr-12", gate: "pr-apply" },
+  ];
+
+  for (const { op, gate } of gateOnlyOps) {
+    async function repoWithGate(dir: string): Promise<void> {
+      git(["init", "-q", "-b", "main"], dir);
+      git(["config", "user.email", "t@chant.dev"], dir);
+      git(["config", "user.name", "T"], dir);
+      writeFileSync(join(dir, "README.md"), "x\n");
+      git(["add", "."], dir);
+      git(["commit", "-q", "-m", "init"], dir);
+      await appendPendingGate(
+        {
+          op,
+          gate,
+          timestamp: "2026-01-01T00:00:00.000Z",
+          origin: "cli",
+          expiresAt: "2999-01-01T00:00:00.000Z",
+          planDigest: `sha256:${"c".repeat(64)}`,
+        },
+        { cwd: dir },
+      );
+    }
+
+    test(`${op}: the gate record carries neverOverMcp (chant#3513)`, async () => {
+      await withTestDir(async (dir) => {
+        await repoWithGate(dir);
+        const { pending } = await readGateLedger(op, { cwd: dir });
+        expect(pending[0].neverOverMcp).toBe(true);
+      });
+    });
+
+    test(`${op}: op-approve over MCP is refused and the ledger is unchanged (chant#3513)`, async () => {
+      await withTestDir(async (dir) => {
+        await repoWithGate(dir);
+        const before = await readGateLedger(op, { cwd: dir });
+        process.chdir(dir);
+        await expect(createOpApproveTool().handler({ name: op, gate })).rejects.toThrow(
+          /neverOverMcp.*whichever channel/s,
+        );
+        expect(await readGateLedger(op, { cwd: dir })).toEqual(before);
+        expect(resolveGate).not.toHaveBeenCalled();
+      });
+    });
+
+    test(`${op}: ACP is refused even with the same-origin override (chant#3513)`, async () => {
+      await withTestDir(async (dir) => {
+        await repoWithGate(dir);
+        const before = await readGateLedger(op, { cwd: dir });
+        process.chdir(dir);
+        const outcome = await recordGateApproval(op, gate, {
+          origin: "acp",
+          actor: "agent",
+          allowSameOrigin: true,
+          cwd: dir,
+        });
+        expect(outcome.ok).toBe(false);
+        expect(await readGateLedger(op, { cwd: dir })).toEqual(before);
+      });
+    });
+
+    test(`${op}: a person at a shell can still approve (chant#3513)`, async () => {
+      await withTestDir(async (dir) => {
+        await repoWithGate(dir);
+        process.chdir(dir);
+        const outcome = await recordGateApproval(op, gate, { origin: "cli", actor: "alex", cwd: dir });
+        expect(outcome.ok).toBe(true);
+      });
+    });
+  }
 });

package/src/cli/mcp/op-approve-origin.test.ts

@@ -37,7 +37,7 @@ describe("op-approve on the MCP channel (chant#2384)", () => {
     // The rest of the tool is unchanged — this narrows one field, it does not
     // remove the tool. The narrower alternative in the issue was to drop
     // op-approve entirely; this keeps it useful for the cross-channel case.
-    expect(Object.keys(schema.properties).sort()).toEqual(["gate", "name", "note", "runtime", "url"]);
+    expect(Object.keys(schema.properties).sort()).toEqual(["env", "gate", "name", "note", "runtime", "url"]);
     expect(schema.required.sort()).toEqual(["gate", "name"]);
   });
 

package/src/cli/mcp/op-tools.ts

@@ -136,6 +136,9 @@ export function createOpRunTool(): ToolRegistration {
         type: "object",
         properties: {
           name: { type: "string", description: "Op name (e.g. alb-deploy)" },
+          // chant#3560 — what `chant run --env` passes: the environment the
+          // run targets. Omitted, the runtime uses its own default.
+          env: { type: "string", description: "Environment the run targets (defaults to the runtime's own)" },
           runtime: RUNTIME_PARAM,
         },
         required: ["name"],
@@ -153,7 +156,8 @@ export function createOpRunTool(): ToolRegistration {
       }
 
       const runtime = await runtimeFor(params.runtime);
-      const handle = await runtime.start(ops.get(name)!.config, {});
+      const env = typeof params.env === "string" && params.env !== "" ? params.env : undefined;
+      const handle = await runtime.start(ops.get(name)!.config, env !== undefined ? { env } : {});
       const status = await handle.result();
 
       return {
@@ -227,6 +231,10 @@ export function createOpApproveTool(): ToolRegistration {
           // the ledger recorded it indistinguishably from a name a person gave.
           note: { type: "string", description: "Free-text context recorded on the resolution" },
           url: { type: "string", description: "Absolute http/https URL this resolution happened at" },
+          // chant#3555 — what `chant run approve --env` passes: the
+          // environment the woken run runs in. Omitted, the runtime keeps the
+          // gated run's.
+          env: { type: "string", description: "Environment the woken run runs in (defaults to the gated run's)" },
           runtime: RUNTIME_PARAM,
         },
         required: ["name", "gate"],
@@ -256,7 +264,11 @@ export function createOpApproveTool(): ToolRegistration {
         );
       }
 
-      if (runtime.resolveGate) await runtime.resolveGate(name, gate, outcome.record);
+      if (runtime.resolveGate) {
+        const env = typeof params.env === "string" && params.env !== "" ? params.env : undefined;
+        if (env !== undefined) await runtime.resolveGate(name, gate, outcome.record, { env });
+        else await runtime.resolveGate(name, gate, outcome.record);
+      }
 
       return {
         op: name,

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

@@ -499,12 +499,13 @@ describe("McpServer", () => {
         expect(props.runtime).toBeDefined();
       });
 
-      test("op-run has name (required) and runtime", async () => {
+      test("op-run has name (required), env 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.env).toBeDefined();
         expect(props.runtime).toBeDefined();
         expect(tool.inputSchema.required).toContain("name");
       });