@intentius/chant 0.124.1 → 0.124.3

package/src/lifecycle/gate-ledger.ts

@@ -48,6 +48,9 @@ import type { GateApprover, GatePolicyDecision, ResolvedGateApproval } from "../
 import type { GateRunLocator } from "../op/gate-resume";
 import { readBlobFromPath, readPathSha, readBlobBySha, writeBlobToPath, RefCASConflictError } from "./git";
 
+// The facts a pending record is written with live apart, so a bundle can import them without git (#3816).
+export { DEFAULT_GATE_EXPIRY, isApprovalUrl, resolveApprovalUrl } from "./gate-pending";
+
 // The selection rules a gate decides by live apart, so a bundle can import them without git (#3763).
 export {
   isPendingGateExpired,
@@ -63,57 +66,6 @@ const DIR = "_gates";
 export const GATES_DIR = DIR;
 const APPEND_RETRY_ATTEMPTS = 5;
 
-/**
- * The address of the approval surface for a gate, resolved from the CI
- * environment (#2028).
- *
- * #1485's argument for gate-as-fact was that approval gets an address:
- * "gate-as-PR gives approval a URL, a review surface, and CODEOWNERS as the
- * authorization model." What shipped recorded the gate and not the address,
- * so a pending-approval card had nothing to link to and gate-as-PR stayed a
- * convention. This is the narrow, honest half of that: when a tick (or a
- * `chant approve`) runs inside the PR/MR job that carries the change, the
- * loop genuinely knows where approval happens, and says so. Anywhere else it
- * returns `undefined` and the field is simply absent — never a guess, never a
- * synthesized link.
- *
- * The env-var fallback chain is the same one `--actor` and `--run-id` already
- * use (`../cli/handlers/components.ts`): GitHub Actions first, then GitLab CI.
- *
- * - GitHub Actions on a `pull_request` event: `GITHUB_SERVER_URL` +
- *   `GITHUB_REPOSITORY` + the PR number, which `GITHUB_REF_NAME` carries as
- *   `<n>/merge`. A push-event run has no PR, so it resolves to nothing.
- * - GitLab CI on a merge-request pipeline: `CI_MERGE_REQUEST_PROJECT_URL` +
- *   `CI_MERGE_REQUEST_IID`.
- */
-export function resolveApprovalUrl(env: NodeJS.ProcessEnv = process.env): string | undefined {
-  const prNumber = /^(\d+)\/(merge|head)$/.exec(env.GITHUB_REF_NAME ?? "")?.[1];
-  if (prNumber && env.GITHUB_REPOSITORY) {
-    const server = (env.GITHUB_SERVER_URL ?? "https://github.com").replace(/\/$/, "");
-    return `${server}/${env.GITHUB_REPOSITORY}/pull/${prNumber}`;
-  }
-
-  if (env.CI_MERGE_REQUEST_PROJECT_URL && env.CI_MERGE_REQUEST_IID) {
-    return `${env.CI_MERGE_REQUEST_PROJECT_URL.replace(/\/$/, "")}/-/merge_requests/${env.CI_MERGE_REQUEST_IID}`;
-  }
-
-  return undefined;
-}
-
-/**
- * Whether `raw` is an address worth recording as one: an absolute `http`/
- * `https` URL. A gate's address is a link a reader is expected to follow, so
- * a relative path or a `file:`/`javascript:` scheme is refused at the CLI
- * boundary rather than written into an immutable record.
- */
-export function isApprovalUrl(raw: string): boolean {
-  try {
-    const parsed = new URL(raw);
-    return parsed.protocol === "http:" || parsed.protocol === "https:";
-  } catch {
-    return false;
-  }
-}
 
 /**
  * The answer record a gate that asks a decision point cites (#3170): the
@@ -342,8 +294,6 @@ export type PendingGateInput = Omit<PendingGateRecord, "version" | "kind">;
 /** Either kind of line in `_gates/<op>.jsonl`. */
 export type GateLedgerRecord = GateResolutionRecord | PendingGateRecord;
 
-/** The default a gate's pending fact expires after when its `GateStep` declares no `timeout` — the same 48h `GateStep.timeout` documents as its own default. */
-export const DEFAULT_GATE_EXPIRY = "48h";
 
 function filename(op: string): string {
   return `${op}.jsonl`;

package/src/lifecycle/gate-origin.ts

@@ -66,23 +66,40 @@ export const UNATTESTED_APPROVER = "unattested";
 
 let ambient: GateOrigin = "cli";
 
+/**
+ * The environment variable a model-authored channel carries into child
+ * processes (chant#3817), as a steward's turn carries `CHANT_STEWARD`: a
+ * `chant workspace points answer` or `chant approve` a process on MCP or ACP
+ * starts is that channel's too. Only `mcp` and `acp` are read from it, so it
+ * can make a process model-authored and never make one a person's.
+ */
+export const GATE_ORIGIN_ENV = "CHANT_GATE_ORIGIN";
+
 /**
  * Declare the channel this process serves. Called once at an entry point, not
  * per call: `chant mcp` sets `"mcp"` before it serves anything, `chant acp`
- * sets `"acp"`, and the CLI leaves the default.
+ * sets `"acp"`, and the CLI leaves the default. A model-authored channel is
+ * also exported as {@link GATE_ORIGIN_ENV}, so a child process knows it too.
  */
 export function setGateOrigin(origin: GateOrigin): void {
   ambient = origin;
+  if (isModelAuthored(origin)) process.env[GATE_ORIGIN_ENV] = origin;
 }
 
-/** The channel this process serves. `"cli"` unless an entry point said otherwise. */
+/**
+ * The channel this process serves. `"cli"` unless an entry point said
+ * otherwise, or this process was started by one on MCP or ACP.
+ */
 export function currentGateOrigin(): GateOrigin {
-  return ambient;
+  if (ambient !== "cli") return ambient;
+  const inherited = process.env[GATE_ORIGIN_ENV];
+  return inherited === "mcp" || inherited === "acp" ? inherited : ambient;
 }
 
 /** Restore the default. For tests, which must not leak a channel into each other. */
 export function resetGateOrigin(): void {
   ambient = "cli";
+  delete process.env[GATE_ORIGIN_ENV];
 }
 
 /**

package/src/lifecycle/gate-pending.ts

@@ -0,0 +1,62 @@
+/**
+ * What a pending gate fact is written with, apart from the ledger's git code
+ * (#3816): its default expiry and the address of its approval surface. A
+ * bundle that records a pending fact through its own port, such as
+ * `@intentius/chant/point-decision`, imports these without git.
+ * `./gate-ledger.ts` re-exports them.
+ */
+
+/** The default a gate's pending fact expires after when its `GateStep` declares no `timeout` — the same 48h `GateStep.timeout` documents as its own default. */
+export const DEFAULT_GATE_EXPIRY = "48h";
+
+/**
+ * The address of the approval surface for a gate, resolved from the CI
+ * environment (#2028).
+ *
+ * #1485's argument for gate-as-fact was that approval gets an address:
+ * "gate-as-PR gives approval a URL, a review surface, and CODEOWNERS as the
+ * authorization model." What shipped recorded the gate and not the address,
+ * so a pending-approval card had nothing to link to and gate-as-PR stayed a
+ * convention. This is the narrow, honest half of that: when a tick (or a
+ * `chant approve`) runs inside the PR/MR job that carries the change, the
+ * loop genuinely knows where approval happens, and says so. Anywhere else it
+ * returns `undefined` and the field is simply absent — never a guess, never a
+ * synthesized link.
+ *
+ * The env-var fallback chain is the same one `--actor` and `--run-id` already
+ * use (`../cli/handlers/components.ts`): GitHub Actions first, then GitLab CI.
+ *
+ * - GitHub Actions on a `pull_request` event: `GITHUB_SERVER_URL` +
+ *   `GITHUB_REPOSITORY` + the PR number, which `GITHUB_REF_NAME` carries as
+ *   `<n>/merge`. A push-event run has no PR, so it resolves to nothing.
+ * - GitLab CI on a merge-request pipeline: `CI_MERGE_REQUEST_PROJECT_URL` +
+ *   `CI_MERGE_REQUEST_IID`.
+ */
+export function resolveApprovalUrl(env: NodeJS.ProcessEnv = process.env): string | undefined {
+  const prNumber = /^(\d+)\/(merge|head)$/.exec(env.GITHUB_REF_NAME ?? "")?.[1];
+  if (prNumber && env.GITHUB_REPOSITORY) {
+    const server = (env.GITHUB_SERVER_URL ?? "https://github.com").replace(/\/$/, "");
+    return `${server}/${env.GITHUB_REPOSITORY}/pull/${prNumber}`;
+  }
+
+  if (env.CI_MERGE_REQUEST_PROJECT_URL && env.CI_MERGE_REQUEST_IID) {
+    return `${env.CI_MERGE_REQUEST_PROJECT_URL.replace(/\/$/, "")}/-/merge_requests/${env.CI_MERGE_REQUEST_IID}`;
+  }
+
+  return undefined;
+}
+
+/**
+ * Whether `raw` is an address worth recording as one: an absolute `http`/
+ * `https` URL. A gate's address is a link a reader is expected to follow, so
+ * a relative path or a `file:`/`javascript:` scheme is refused at the CLI
+ * boundary rather than written into an immutable record.
+ */
+export function isApprovalUrl(raw: string): boolean {
+  try {
+    const parsed = new URL(raw);
+    return parsed.protocol === "http:" || parsed.protocol === "https:";
+  } catch {
+    return false;
+  }
+}

package/src/op/activities/activity-contracts.ts

@@ -320,6 +320,7 @@ export const decideContract = activityContract(
     cwd: z.string().optional(),
     backends: z.record(z.string(), backendSchema).optional(),
     dryRun: z.boolean().optional(),
+    store: z.enum(["tree", "ledger"]).optional(),
   }),
   z.strictObject({
     id: z.string(),

package/src/op/activities/decide.ts

@@ -65,6 +65,8 @@ export interface DecideArgs {
   backends?: Record<string, DecideBackend>;
   /** Ask, but write nothing, and return the question whatever its state: an open one does not stop the run. */
   dryRun?: boolean;
+  /** Where a new question goes (#3815): `"ledger"` holds it on chant/lifecycle, for a run whose checkout does not outlive it. Default: the ledger in a steward's turn, the tree otherwise. */
+  store?: "tree" | "ledger";
 }
 
 export interface DecideResult {
@@ -234,6 +236,7 @@ export async function runDecide(args: DecideArgs, deps: DecideDeps = {}, signal?
     inputs,
     ...(args.subject !== undefined ? { subject: args.subject } : {}),
     ...(args.kind !== undefined ? { kind: args.kind } : {}),
+    ...(args.store !== undefined ? { store: args.store } : {}),
     ...(deps.on ? { on: deps.on } : {}),
   };
 

package/src/op/gate-point-ci.e2e.test.ts

@@ -0,0 +1,171 @@
+/**
+ * #3815: a gate's decision-point question survives a CI job. Outside a
+ * steward's turn a question used to go to the working tree, which a CI
+ * checkout throws away, so `points answer` elsewhere found nothing and the
+ * next run asked again. Asked into the ledger (`--store ledger`, a gate's
+ * `point.store`, or by default when `CI` is set), it lands on
+ * `chant/lifecycle`, is pushed, and is found and answered from another clone;
+ * the job's next run, in a fresh clone, passes on that answer.
+ *
+ * Three clones of one bare remote stand for the CI job's checkout, the
+ * person's clone the answer comes from, and the next job's checkout. The gate
+ * ledger the runs write is the in-memory port, so only the question and its
+ * answer travel through the remote.
+ */
+
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdtempSync, readdirSync, realpathSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, afterEach, beforeAll, describe, expect, test, vi } from "vitest";
+import { cleanScratch, git, workspace } from "../workspace/__fixtures__/decide-workspace";
+import { runWorkspacePoints } from "../workspace/points-cli";
+import type { CommandContext } from "../cli/registry";
+import { ApplyOp } from "./composites/apply-op";
+import { memoryGateLedgerPort } from "./gate";
+import { defaultGatePointStore, type GatePoint } from "./gate-point";
+import { runOpLocally } from "./local-executor";
+import type { ActivityFn } from "./activity-registry";
+import type { OpConfig } from "./types";
+
+const PLAN = `jcs1-sha256:${"4".repeat(64)}`;
+
+const POINTS = {
+  points: {
+    "prod-apply": {
+      title: "Apply this plan to prod",
+      question: { type: "noul", instructions: "Should this plan be applied to prod?", criteria: { true: "Apply it.", false: "Do not apply it." } },
+      inputs: { "gate.component": "the Op the gate belongs to", "gate.planDigest": "the plan the gate binds" },
+      deciders: [{ kind: "quorum", count: 1 }],
+    },
+    "ship-it": {
+      title: "Ship it",
+      question: { type: "noul", instructions: "Ship it?", criteria: { true: "Ship.", false: "Hold." } },
+      inputs: { "release.version": "the version" },
+      deciders: [{ kind: "quorum", count: 1 }],
+    },
+  },
+};
+
+const applied: string[] = [];
+const activities = new Map<string, ActivityFn>([
+  ["chantBuild", async () => ({ ok: true })],
+  ["lifecycleDiff", async () => ({ planDigest: PLAN, drifted: true })],
+  ["nativeApply", async () => {
+    applied.push(PLAN);
+    return { ok: true };
+  }],
+]);
+
+const config = (name: string, point: string | GatePoint): OpConfig =>
+  (ApplyOp({ name, env: "prod", target: "kubectl", gate: { gate: "approve-apply", point } }).op as unknown as { props: OpConfig }).props;
+
+let home: string;
+let remote: string;
+
+/** A fresh clone of the remote: a CI job's checkout, or a person's. */
+function clone(name: string): string {
+  const dir = join(home, name);
+  execFileSync("git", ["clone", "-q", remote, dir], { stdio: "ignore" });
+  return dir;
+}
+
+/** `chant workspace points <argv>` through the command's handler, in `cwd`. Returns the document it prints. */
+async function points(cwd: string, args: Record<string, unknown>): Promise<Record<string, unknown> & { error?: { code: string } }> {
+  const printed: string[] = [];
+  const log = vi.spyOn(console, "log").mockImplementation((line: unknown) => {
+    printed.push(String(line));
+  });
+  const was = process.cwd();
+  process.chdir(cwd);
+  try {
+    await runWorkspacePoints({ args, plugins: [], serializers: [] } as unknown as CommandContext);
+  } finally {
+    process.chdir(was);
+    log.mockRestore();
+  }
+  return JSON.parse(printed.join("\n"));
+}
+
+const answersIn = (dir: string): string[] => (existsSync(join(dir, "answers")) ? readdirSync(join(dir, "answers")).filter((f) => f.endsWith(".md")) : []);
+const run = (op: OpConfig, cwd: string) => runOpLocally(op, activities, {}, undefined, { gates: memoryGateLedgerPort(), cwd, now: "2026-10-11T12:00:00.000Z" });
+
+beforeAll(() => {
+  home = realpathSync(mkdtempSync(join(tmpdir(), "chant-gate-ci-")));
+  const root = workspace(POINTS);
+  remote = join(home, "remote.git");
+  execFileSync("git", ["clone", "-q", "--bare", root, remote], { stdio: "ignore" });
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+});
+
+afterAll(() => {
+  cleanScratch();
+  rmSync(home, { recursive: true, force: true });
+});
+
+describe("a gate's question outlives the CI job that asked it (#3815)", () => {
+  test("a gate with point.store ledger: asked in one clone, answered from another, and the next job's clone passes on it", async () => {
+    vi.stubEnv("CI", "");
+    const op = config("prod-apply", { name: "prod-apply", store: "ledger" });
+
+    const job = clone("job-1");
+    const first = await run(op, job);
+    expect(first.status).toBe("waiting");
+    const id = first.point!.id;
+    // Nothing was written to the job's working tree, which goes away with the job.
+    expect(answersIn(job)).toEqual([]);
+    expect(git(job, "status", "--porcelain")).toBe("");
+
+    // A person's clone, which never ran the job, finds the question and answers it.
+    const person = clone("person");
+    const answered = await points(person, { extraPositional: "answer", extraPositional2: id, answer: "yes", bys: ["alice"] });
+    expect(answered).toMatchObject({ verb: "answer", id, written: true, question: { state: "answered", answer: true, ledger: expect.stringContaining("chant/lifecycle:") } });
+
+    // The next job, in a fresh checkout, passes on that answer.
+    const next = await run(op, clone("job-2"));
+    expect(next.status).toBe("ok");
+    expect(applied).toEqual([PLAN]);
+  });
+
+  test("with CI set, a gate that names no store asks into the ledger", async () => {
+    expect(defaultGatePointStore({ CI: "true" })).toBe("ledger");
+    expect(defaultGatePointStore({ CI: "false" })).toBeUndefined();
+    expect(defaultGatePointStore({})).toBeUndefined();
+
+    vi.stubEnv("CI", "true");
+    const op = config("ci-apply", "prod-apply");
+    const job = clone("job-3");
+    const first = await run(op, job);
+    expect(first.status).toBe("waiting");
+    expect(answersIn(job)).toEqual([]);
+
+    const person = clone("person-2");
+    expect(await points(person, { extraPositional: "answer", extraPositional2: first.point!.id, answer: "yes", bys: ["alice"] })).toMatchObject({ written: true });
+    expect((await run(op, clone("job-4"))).status).toBe("ok");
+  });
+
+  test("chant workspace points ask --store ledger holds the question on chant/lifecycle, and another clone answers it", async () => {
+    vi.stubEnv("CI", "");
+    const job = clone("ask-job");
+    const asked = await points(job, { extraPositional: "ask", extraPositional2: "ship-it", inputs: JSON.stringify({ "release.version": "1.2.3" }), store: "ledger" });
+    expect(asked).toMatchObject({ verb: "ask", written: true, question: { state: "escalated", ledger: expect.stringContaining("chant/lifecycle:") } });
+    expect(answersIn(job)).toEqual([]);
+
+    const id = asked.id as string;
+    const person = clone("ask-person");
+    expect(await points(person, { extraPositional: "answer", extraPositional2: id, answer: "no", bys: ["bob"] })).toMatchObject({ written: true, question: { state: "answered", answer: false } });
+
+    // Asked again from a fresh checkout, the question is the answered one.
+    const again = await points(clone("ask-job-2"), { extraPositional: "ask", extraPositional2: "ship-it", inputs: JSON.stringify({ "release.version": "1.2.3" }), store: "ledger" });
+    expect(again).toMatchObject({ reused: true, question: { state: "answered", answer: false } });
+
+    // Without --store ledger the same ask in a clone with no ledger history goes to the tree, as before.
+    const tree = clone("ask-tree");
+    const local = await points(tree, { extraPositional: "ask", extraPositional2: "ship-it", inputs: JSON.stringify({ "release.version": "9.9.9" }) });
+    expect(local).toMatchObject({ written: true, question: { ledger: null } });
+    expect(answersIn(tree)).toHaveLength(1);
+  });
+});

package/src/op/gate-point-mcp.e2e.test.ts

@@ -0,0 +1,163 @@
+/**
+ * #3817: a gate that asks a decision point is not passed by an answer sent
+ * over MCP or ACP. The answer there is an agent's, so nobody it names counts
+ * toward a human quorum and the gate keeps waiting; a question whose gate is
+ * `neverOverMcp` is refused outright. The same answer from a shell answers
+ * it, and the next run passes.
+ *
+ * The workspace is real (a git repository with the reference workspace's
+ * answer kind, a points file and a trust policy at base). The MCP answer goes
+ * through the `points-answer` tool's own handler with this process serving
+ * MCP, the shell answer through `runWorkspacePoints`. The gate ledger the run
+ * writes is the in-memory port; the `neverOverMcp` pending fact is on the
+ * workspace's own `chant/lifecycle`, where `points answer` reads it.
+ */
+
+import { writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { afterAll, afterEach, beforeAll, describe, expect, test, vi } from "vitest";
+import { cleanScratch, git, workspace } from "../workspace/__fixtures__/decide-workspace";
+import { runWorkspacePoints } from "../workspace/points-cli";
+import type { CommandContext } from "../cli/registry";
+import { createWorkspaceTools } from "../cli/mcp/workspace-tools";
+import { GATE_ORIGIN_ENV, resetGateOrigin, setGateOrigin } from "../lifecycle/gate-origin";
+import { appendPendingGate } from "../lifecycle/gate-ledger";
+import { ApplyOp } from "./composites/apply-op";
+import { memoryGateLedgerPort } from "./gate";
+import { runOpLocally } from "./local-executor";
+import type { ActivityFn } from "./activity-registry";
+import type { OpConfig } from "./types";
+
+const PLAN = `jcs1-sha256:${"3".repeat(64)}`;
+
+const POINTS = {
+  points: {
+    "prod-apply": {
+      title: "Apply this plan to prod",
+      question: { type: "noul", instructions: "Should this plan be applied to prod?", criteria: { true: "Apply it.", false: "Do not apply it." } },
+      inputs: { "gate.component": "the Op the gate belongs to", "gate.planDigest": "the plan the gate binds" },
+      deciders: [{ kind: "quorum", count: 2, roles: ["lead"] }],
+    },
+  },
+};
+
+let root: string;
+const applied: string[] = [];
+const activities = new Map<string, ActivityFn>([
+  ["chantBuild", async () => ({ ok: true })],
+  ["lifecycleDiff", async () => ({ planDigest: PLAN, drifted: true })],
+  ["nativeApply", async () => {
+    applied.push(PLAN);
+    return { ok: true };
+  }],
+]);
+
+const config = (name: string): OpConfig =>
+  (ApplyOp({ name, env: "prod", target: "kubectl", gate: { gate: "approve-apply", point: "prod-apply" } }).op as unknown as { props: OpConfig }).props;
+
+type Doc = Record<string, unknown> & { error?: { code: string; message: string } };
+
+/** The `points-answer` and `points-retract` tools, as `chant serve mcp` serves them in the workspace. */
+function mcpTool(name: "points-answer" | "points-retract"): (params: Record<string, unknown>) => Promise<Doc> {
+  const tool = createWorkspaceTools({ cwd: root }).find((t) => t.definition.name === name)!;
+  return async (params) => (await tool.handler(params, {} as never)) as Doc;
+}
+
+/** `chant workspace points <verb> <id> ...` through the command's handler, in the workspace. Returns the document it prints. */
+async function shell(verb: "answer" | "retract", id: string, by: string[], answer?: string): Promise<Doc> {
+  const printed: string[] = [];
+  const log = vi.spyOn(console, "log").mockImplementation((line: unknown) => {
+    printed.push(String(line));
+  });
+  const err = vi.spyOn(console, "error").mockImplementation(() => {});
+  const was = process.cwd();
+  process.chdir(root);
+  try {
+    const ctx = { args: { extraPositional: verb, extraPositional2: id, ...(answer !== undefined ? { answer } : {}), bys: by, json: true }, plugins: [], serializers: [] } as unknown as CommandContext;
+    await runWorkspacePoints(ctx);
+  } finally {
+    process.chdir(was);
+    log.mockRestore();
+    err.mockRestore();
+  }
+  return JSON.parse(printed.join("\n")) as Doc;
+}
+
+beforeAll(() => {
+  root = workspace(POINTS);
+  // The questions go to the working tree, as outside CI: a CI job asks into the ledger by default (#3815).
+  vi.stubEnv("CI", "");
+  mkdirSync(join(root, ".chant"), { recursive: true });
+  writeFileSync(join(root, ".chant", "trust.json"), JSON.stringify({ schema: 1, roles: { agent: ["bot"], lead: ["alice", "bob"] } }));
+  git(root, "add", "-A");
+  git(root, "commit", "-q", "-m", "trust");
+});
+
+afterEach(() => resetGateOrigin());
+afterAll(cleanScratch);
+
+describe("an answer over MCP or ACP never passes a gate that needs a human quorum (#3817)", () => {
+  test("points-answer over MCP naming the quorum's people does not answer; the gate keeps waiting; the same answer from a shell passes it", async () => {
+    const port = memoryGateLedgerPort();
+    const op = config("prod-apply");
+
+    const first = await runOpLocally(op, activities, {}, undefined, { gates: port, cwd: root, now: "2026-10-11T10:00:00.000Z" });
+    expect(first.status).toBe("waiting");
+    const id = first.point!.id;
+
+    // This process now serves MCP: alice and bob both hold lead, and neither counts.
+    setGateOrigin("mcp");
+    const overMcp = await mcpTool("points-answer")({ id, answer: true, by: ["alice", "bob"] });
+    expect(overMcp.error?.code).toBe("quorum-not-met");
+    expect(overMcp.error?.message).toContain("alice, who was named over MCP");
+    expect(overMcp.error?.message).toContain("bob, who was named over MCP");
+
+    // ACP is the same, and so is `chant workspace points answer` in a process a session on either started.
+    setGateOrigin("acp");
+    expect((await mcpTool("points-answer")({ id, answer: true, by: ["alice", "bob"] })).error?.code).toBe("quorum-not-met");
+    resetGateOrigin();
+    process.env[GATE_ORIGIN_ENV] = "mcp";
+    expect((await shell("answer", id, ["alice", "bob"], "yes")).error?.code).toBe("quorum-not-met");
+    resetGateOrigin();
+
+    const still = await runOpLocally(op, activities, {}, undefined, { gates: port, cwd: root, now: "2026-10-11T10:05:00.000Z" });
+    expect(still.status).toBe("waiting");
+    expect(still.point?.id).toBe(id);
+    expect(applied).toEqual([]);
+    expect(port.resolved).toHaveLength(0);
+
+    // From a shell the same people answer it, and the next run passes on the answer.
+    const answered = await shell("answer", id, ["alice", "bob"], "yes");
+    expect(answered).toMatchObject({ verb: "answer", id, written: true, question: { state: "answered", answer: true, answeredBy: ["alice", "bob"] } });
+    const passed = await runOpLocally(op, activities, {}, undefined, { gates: port, cwd: root, now: "2026-10-11T10:10:00.000Z" });
+    expect(passed.status).toBe("ok");
+    expect(applied).toEqual([PLAN]);
+
+    // Taking the answer back follows the same rule.
+    setGateOrigin("mcp");
+    expect((await mcpTool("points-retract")({ id, by: ["alice", "bob"] })).error?.code).toBe("quorum-not-met");
+  });
+
+  test("a question whose gate is neverOverMcp is refused over MCP outright, and answered from a shell", async () => {
+    const port = memoryGateLedgerPort();
+    const op = config("tf-apply");
+
+    const first = await runOpLocally(op, activities, {}, undefined, { gates: port, cwd: root, now: "2026-10-11T11:00:00.000Z" });
+    expect(first.status).toBe("waiting");
+    const id = first.point!.id;
+    // The gate's pending fact on chant/lifecycle says it is never resolved over MCP, as terragucci's tf-apply records it.
+    await appendPendingGate({ op: "tf-apply", gate: "approve-apply", timestamp: "2026-10-11T11:00:00.000Z", expiresAt: "2026-10-13T11:00:00.000Z", planDigest: PLAN, neverOverMcp: true, answer: { point: "prod-apply", id, path: first.point!.path } }, { cwd: root });
+
+    setGateOrigin("mcp");
+    const overMcp = await mcpTool("points-answer")({ id, answer: true, by: ["alice", "bob"] });
+    expect(overMcp.error?.code).toBe("answer-never-over-mcp");
+    expect(overMcp.error?.message).toContain('gate "approve-apply" on "tf-apply"');
+    resetGateOrigin();
+
+    const answered = await shell("answer", id, ["alice", "bob"], "yes");
+    expect(answered).toMatchObject({ verb: "answer", id, written: true, question: { state: "answered" } });
+
+    setGateOrigin("acp");
+    expect((await mcpTool("points-retract")({ id, by: ["alice", "bob"] })).error?.code).toBe("answer-never-over-mcp");
+  });
+});