@intentius/chant 0.90.0 → 0.93.0

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

@@ -5,6 +5,13 @@ import { join } from "node:path";
 import type { ParsedArgs } from "../registry";
 
 const discoverOpsMock = vi.fn();
+// Default: no steward owns anything discovered, so `stewardTurnGate` (#2750)
+// is a no-op for every test that doesn't explicitly set up a steward — a
+// `mockResolvedValueOnce` in those tests overrides it for one call and this
+// default is what every other call sees.
+const discoverStewardsMock = vi.fn().mockResolvedValue({ stewards: new Map(), errors: [], conflicts: [] });
+const acquireStewardTurnMock = vi.fn();
+const releaseLeaseMock = vi.fn();
 const loadChantConfigMock = vi.fn();
 const writeFileSyncMock = vi.fn();
 const mkdirSyncMock = vi.fn();
@@ -18,7 +25,18 @@ const recordGateApprovalMock = vi.fn();
 const { memoryGateLedgerPort } = await vi.importActual<typeof import("../../op/gate")>("../../op/gate");
 let gateLedger = memoryGateLedgerPort();
 
-vi.mock("../../op/discover", () => ({ discoverOps: () => discoverOpsMock() }));
+vi.mock("../../op/discover", () => ({
+  discoverOps: () => discoverOpsMock(),
+  discoverStewards: () => discoverStewardsMock(),
+}));
+vi.mock("../../op/operator", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../op/operator")>();
+  return { ...actual, acquireStewardTurn: (...args: unknown[]) => acquireStewardTurnMock(...args) };
+});
+vi.mock("../../lifecycle/lease", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("../../lifecycle/lease")>();
+  return { ...actual, releaseLease: (...args: unknown[]) => releaseLeaseMock(...args) };
+});
 vi.mock("../../config", async () => {
   const actual = await vi.importActual<typeof import("../../config")>("../../config");
   return { ...actual, loadChantConfig: (...args: unknown[]) => loadChantConfigMock(...args) };
@@ -199,6 +217,25 @@ describe("runOp dispatcher", () => {
     stderrWrite.mockRestore();
   });
 
+  test("--work on an Op with no work lease → exit 1, nothing run (#2748)", async () => {
+    discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("hello")]), errors: [] });
+    const stderr = makeStderrSpy();
+    const exit = await runOp({ args: makeArgs({ path: "hello", work: "W-1" }), plugins: [], serializers: [] });
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain('--work W-1: Op "hello" declares no work lease');
+  });
+
+  test("an Op whose work lease leaves the item to the run, run without --work → exit 1 naming the flag (#2748)", async () => {
+    discoverOpsMock.mockResolvedValue({
+      ops: new Map([["leased", { config: { name: "leased", overview: "leased", phases: [], workLease: {} } }]]),
+      errors: [],
+    });
+    const stderr = makeStderrSpy();
+    const exit = await runOp({ args: makeArgs({ path: "leased", holder: "me" }), plugins: [], serializers: [] });
+    expect(exit).toBe(1);
+    expect(stderr.join("\n")).toContain("chant run leased --work <id>");
+  });
+
   test("--report → exit 1 naming the removal, nothing run (#2116)", async () => {
     discoverOpsMock.mockResolvedValue({ ops: new Map([makeOp("hello")]), errors: [] });
     const stderr = makeStderrSpy();
@@ -269,6 +306,138 @@ describe("runOp dispatcher", () => {
   });
 });
 
+/**
+ * chant #2750 — an Op a declared steward lists is one of its turns, not a
+ * run beside one: `chant run <op>` for such an Op takes the steward's turn
+ * lease (in the local form) or is redirected to the steward's thread (on
+ * fountain), rather than running unaware of a turn already in progress.
+ *
+ * `acquireStewardTurn` and `releaseLease` are stubbed here (mocked above):
+ * the point of these tests is the CLI's own decision and its message, not
+ * the lease's git plumbing, which `op/steward.test.ts` and
+ * `lifecycle/lease.test.ts` already cover against a real repo.
+ */
+describe("runOp: a steward's turn (#2750)", () => {
+  function stewardOwning(opName: string, name: string, form: "local" | "fountain" = "local") {
+    return {
+      stewards: new Map([[name, {
+        declaration: {
+          kind: "Chant::Steward", name, ops: [{ name: opName, phases: [] }],
+          form: { default: form, environments: {} }, capabilities: [], vault: null,
+        },
+        filePath: "ops/steward.op.ts", exportName: "steward",
+      }]]),
+      errors: [], conflicts: [],
+    };
+  }
+
+  beforeEach(() => {
+    discoverOpsMock.mockReset();
+    loadChantConfigMock.mockReset().mockResolvedValue({ config: {} });
+    loadPluginsMock.mockReset().mockResolvedValue([]);
+    acquireStewardTurnMock.mockReset();
+    releaseLeaseMock.mockReset().mockResolvedValue(true);
+  });
+
+  test("local form, the turn is free: takes it, runs, and releases it once the run is over", async () => {
+    discoverOpsMock.mockResolvedValue({
+      ops: new Map([localOp("release", [{ kind: "activity", fn: "shellCmd", args: { cmd: "true" } }])]),
+      errors: [],
+    });
+    discoverStewardsMock.mockResolvedValueOnce(stewardOwning("release", "box-steward"));
+    acquireStewardTurnMock.mockResolvedValue({
+      acquired: true,
+      lease: { op: "_turns/box-steward", holder: "h", token: "t1", acquiredAt: "x", expiresAt: "y" },
+    });
+    const stderrWrite = vi.spyOn(process.stderr, "write").mockImplementation(() => true);
+    const exit = await runOp({ args: makeArgs({ path: "release" }), plugins: [], serializers: [] });
+    stderrWrite.mockRestore();
+
+    expect(exit).toBe(0);
+    expect(acquireStewardTurnMock).toHaveBeenCalledTimes(1);
+    expect(acquireStewardTurnMock.mock.calls[0]?.[0]).toBe("box-steward");
+    expect(releaseLeaseMock).toHaveBeenCalledTimes(1);
+    expect(releaseLeaseMock).toHaveBeenCalledWith("_turns/box-steward", expect.any(String), "t1");
+  });
+
+  test("local form, a turn is already in progress: refused, naming the steward and holder, nothing runs", async () => {
+    discoverOpsMock.mockResolvedValue({
+      ops: new Map([localOp("release", [{ kind: "activity", fn: "shellCmd", args: { cmd: "true" } }])]),
+      errors: [],
+    });
+    discoverStewardsMock.mockResolvedValueOnce(stewardOwning("release", "box-steward"));
+    acquireStewardTurnMock.mockResolvedValue({
+      acquired: false,
+      reason: "held",
+      heldBy: { op: "_turns/box-steward", holder: "other-host:123:abcd", token: "t0", acquiredAt: "x", expiresAt: "y" },
+    });
+    const stderr = makeStderrSpy();
+    const exit = await runOp({ args: makeArgs({ path: "release" }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(1);
+    const out = stderr.join("\n");
+    expect(out).toContain('steward "box-steward"');
+    expect(out).toContain("other-host:123:abcd");
+    expect(out).toContain("chant operator status --steward box-steward");
+    expect(releaseLeaseMock).not.toHaveBeenCalled();
+  });
+
+  test("fountain form without --on fountain: refused, naming the redirect, no turn lease touched", async () => {
+    discoverOpsMock.mockResolvedValue({ ops: new Map([localOp("release", [])]), errors: [] });
+    discoverStewardsMock.mockResolvedValueOnce(stewardOwning("release", "box-steward", "fountain"));
+    const stderr = makeStderrSpy();
+    const exit = await runOp({ args: makeArgs({ path: "release" }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(1);
+    const out = stderr.join("\n");
+    expect(out).toContain('steward "box-steward"');
+    expect(out).toContain("chant run release --on fountain");
+    expect(acquireStewardTurnMock).not.toHaveBeenCalled();
+  });
+
+  test("fountain form with --on fountain: the local turn-lease check is skipped and the fountain runtime runs it", async () => {
+    const runtime = {
+      name: "fountain",
+      start: vi.fn(async (op: { name: 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([localOp("release", [])]), errors: [] });
+    discoverStewardsMock.mockResolvedValueOnce(stewardOwning("release", "box-steward", "fountain"));
+    loadChantConfigMock.mockResolvedValue({ config: { lexicons: ["fountain"] } });
+    makeStdoutSpy();
+    const exit = await runOp({
+      args: makeArgs({ path: "release", on: "fountain" }),
+      plugins: [{ name: "fountain", opRuntime: runtime } as never], serializers: [],
+    });
+
+    expect(exit).toBe(0);
+    expect(runtime.start).toHaveBeenCalledTimes(1);
+    expect(acquireStewardTurnMock).not.toHaveBeenCalled();
+  });
+
+  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" } }])]),
+      errors: [],
+    });
+    discoverStewardsMock.mockResolvedValueOnce(stewardOwning("release", "box-steward"));
+    acquireStewardTurnMock.mockRejectedValue(new Error("cannot lock ref 'refs/chant/lease/_turns/box-steward': File exists"));
+    const stderr = makeStderrSpy();
+
+    const exit = await runOp({ args: makeArgs({ path: "release" }), plugins: [], serializers: [] });
+
+    expect(exit).toBe(1);
+    const out = stderr.join("\n");
+    expect(out).toContain('steward "box-steward"');
+    expect(out).toContain("cannot lock ref");
+    expect(releaseLeaseMock).not.toHaveBeenCalled();
+  });
+});
+
 /**
  * chant #2243 — a gated run's exit code is the one thing `--gated-exit`
  * remaps, and the gate is reported where CI can see it without opening a log.
@@ -354,7 +523,9 @@ describe("runOp: --gated-exit (#2243)", () => {
 
   test("a run that fails for any other reason is still red under the flag", async () => {
     discoverOpsMock.mockResolvedValue({
-      ops: new Map([localOp("broken", [{ kind: "activity", fn: "shellCmd", args: { cmd: "exit 7" } }])]),
+      // atMostOnce: one attempt. The default profile retries twice with 5s and
+      // 10s backoff, which put this test at 15s for waits it does not test (#2817).
+      ops: new Map([localOp("broken", [{ kind: "activity", fn: "shellCmd", profile: "atMostOnce", args: { cmd: "exit 7" } }])]),
       errors: [],
     });
     const file = summaryFile();

package/src/cli/handlers/run.ts

@@ -2,7 +2,8 @@ import { lexiconNames } from "../../lexicon-module";
 import { resolve, dirname } from "node:path";
 import { writeFileSync, mkdirSync, readFileSync } from "node:fs";
 import { loadChantConfig, resolveAutoReleaseDisabled, type ChantConfig } from "../../config";
-import { discoverOps } from "../../op/discover";
+import { discoverOps, discoverStewards } from "../../op/discover";
+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";
@@ -10,12 +11,16 @@ import { approveCommand, describeGateMismatch } 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";
-import { renderHuman, renderJson } from "../../op/local-output";
+import { pointAnswerCommand, renderHuman, renderJson } from "../../op/local-output";
 import { loadPlugins } from "../plugins";
 import { recordGateApproval } from "./operator";
 import { formatError, formatWarning, formatSuccess, formatBold, formatInfo } from "../format";
 import { resolveCliBuildParams, parseParamFlags } from "../build-params-cli";
 import type { CommandContext } from "../registry";
+import { stewardFormFor, stewardTurnLeaseName, DEFAULT_STEWARD_ENV, type StewardDeclaration } from "../../op/steward";
+import { acquireStewardTurn, STEWARD_TURN_WAIT_MS } from "../../op/operator";
+import { releaseLease, currentHolderId, type AcquireLeaseResult } from "../../lifecycle/lease";
+import { StaleLockError } from "../../lifecycle/git";
 import { renderDriverHuman, renderDriverJson } from "../../components/driver-output";
 import { ndjsonProgressSink } from "../../components/run-progress";
 import { maybeRecordAutoRelease } from "../../components/auto-release";
@@ -526,6 +531,94 @@ function refusesPolicyGateUnderSandbox(ctx: CommandContext, config: OpConfig, op
   return true;
 }
 
+/** What `stewardTurnGate` decided before `chant run <op>` is allowed to start. */
+type StewardTurnGate =
+  | { ok: true; release?: () => Promise<void> }
+  | { ok: false; message: string; hint: string };
+
+/**
+ * `chant run <op>` for an Op a declared steward lists is one of that
+ * steward's turns, not a run beside it (#2750, follow-up to #2731).
+ *
+ * On fountain, the run belongs on the steward's thread: without `--on
+ * fountain` this refuses outright, naming the command that posts it there
+ * instead (the fountain runtime's own turn already refuses a busy teammate,
+ * unretried — see chant-fountain-ops).
+ *
+ * In the local form, the run takes the steward's turn lease
+ * (`../../op/operator.ts`'s `acquireStewardTurn`) — the same lease a round's
+ * scheduled tick holds for the length of its own run. Held already, this
+ * waits up to {@link STEWARD_TURN_WAIT_MS} (long enough to ride out a race
+ * with a turn that's just ending) and then refuses, naming the steward and
+ * its holder. It never queues past that: a round's own leases skip and
+ * report rather than wait (`../../op/operator.ts`'s module doc), and a
+ * foreground CLI blocked with no visibility for however long a scheduled
+ * turn takes would be a worse answer than a clear refusal with a retry in
+ * hand. Ctrl-C already means "abort my own run" here; it must not also mean
+ * "give up waiting for someone else's turn".
+ *
+ * `undefined` (via the caller checking `owner`) when no steward lists this
+ * op — the ordinary, untouched path.
+ */
+async function stewardTurnGate(opName: string, ctx: CommandContext): Promise<StewardTurnGate | undefined> {
+  const { stewards } = await discoverStewards().catch(() => ({ stewards: new Map<string, { declaration: StewardDeclaration }>() }));
+  let owner: StewardDeclaration | undefined;
+  for (const { declaration } of stewards.values()) {
+    if (declaration.ops.some((op) => op.name === opName)) {
+      owner = declaration;
+      break;
+    }
+  }
+  if (!owner) return undefined;
+
+  const env = ctx.args.env ?? DEFAULT_STEWARD_ENV;
+  const form = stewardFormFor(owner, env);
+
+  if (form === "fountain") {
+    if (ctx.args.on === "fountain") return { ok: true };
+    return {
+      ok: false,
+      message: `Op "${opName}" is one of steward "${owner.name}"'s Ops, which runs on fountain in environment "${env}"`,
+      hint:
+        `Run \`chant run ${opName} --on fountain\` so it posts to "${owner.name}"'s thread. ` +
+        `A plain \`chant run ${opName}\` would run it outside that thread, beside the steward instead of one of its turns.`,
+    };
+  }
+
+  const holder = currentHolderId();
+  let turn: AcquireLeaseResult;
+  try {
+    turn = await acquireStewardTurn(owner.name, holder, { waitMs: STEWARD_TURN_WAIT_MS });
+  } catch (err) {
+    // Not turn contention — the acquire attempt itself failed (most likely a
+    // StaleLockError, a `.lock` left behind by a killed operator process).
+    // Report it as a refusal rather than letting it propagate uncaught out
+    // of `runOpOnRuntime`, before that function's own try/catch even starts.
+    return {
+      ok: false,
+      message: `Op "${opName}" is one of steward "${owner.name}"'s turns, and its lease could not be read`,
+      hint:
+        `${err instanceof StaleLockError ? err.message : err instanceof Error ? err.message : String(err)} ` +
+        `This can happen when an operator process was killed mid-write; check refs/chant/lease/_turns/${owner.name} for a stale lock.`,
+    };
+  }
+  if (!turn.acquired) {
+    const heldBy = turn.heldBy?.holder;
+    return {
+      ok: false,
+      message:
+        `Op "${opName}" is one of steward "${owner.name}"'s turns, and a turn is in progress` +
+        (heldBy ? ` (held by ${heldBy})` : ""),
+      hint:
+        `Wait for the turn to finish and re-run \`chant run ${opName}\`, or check \`chant operator status --steward ${owner.name}\`. ` +
+        `If it looks stuck, stop the operator process holding it (Ctrl-C, or kill it) — its lease also expires on its own.`,
+    };
+  }
+  const lease = turn.lease!;
+  const stewardName = owner.name;
+  return { ok: true, release: async () => { await releaseLease(stewardTurnLeaseName(stewardName), holder, lease.token).catch(() => false); } };
+}
+
 export async function runOp(ctx: CommandContext): Promise<number> {
   if (ctx.args.generate) {
     if (ctx.args.components) {
@@ -863,8 +956,26 @@ export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
   // Pre-flight: --sandbox cannot cover a policyGate step (#2003).
   if (refusesPolicyGateUnderSandbox(ctx, config, opName)) return 1;
 
+  // A hand run of an Op a declared steward lists is one of that steward's
+  // turns, not a run beside it (#2750). `undefined` when no steward lists
+  // this op at all — the ordinary path.
+  const stewardGate = await stewardTurnGate(opName, ctx);
+  if (stewardGate && !stewardGate.ok) {
+    console.error(formatError({ message: stewardGate.message, hint: stewardGate.hint }));
+    return 1;
+  }
+
   const runtime = await resolveOpRuntime(ctx);
-  if (!runtime) return 1;
+  if (!runtime) {
+    await stewardGate?.release?.();
+    return 1;
+  }
+
+  // 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);
+  if (work === null) return 1;
 
   // `--progress-json` streams one NDJSON StepRecord per settled step, fed by
   // whatever the runtime reports through `progress`.
@@ -885,6 +996,7 @@ export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
       ...(ctx.args.profile !== undefined ? { profile: ctx.args.profile } : {}),
       progress,
       signal: controller.signal,
+      ...(work ? { work } : {}),
     });
     const status = await handle.result();
 
@@ -932,6 +1044,18 @@ export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
       }
       return gatedExit;
     }
+    // A run waiting on an open decision point (#2749) is waiting on a person,
+    // like a gated one, and exits with the same code. Its answer comes through
+    // hud or `points answer`, never a `chant approve`.
+    if (status.state === "waiting") {
+      if (!status.result && status.point) {
+        console.error(formatWarning({
+          message: `Op "${opName}" is waiting on decision point "${status.point.point}" (${status.point.id})`,
+          hint: `A person answers it with: ${pointAnswerCommand(status.point.id)}`,
+        }));
+      }
+      return gatedExit;
+    }
     return status.state === "completed" ? 0 : 1;
   } catch (err) {
     if (err instanceof OpRunFailure) {
@@ -942,7 +1066,54 @@ export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
     return 1;
   } finally {
     process.removeListener("SIGINT", onSigint);
+    // The turn is over, win or lose — free it so the steward's next round,
+    // or the next hand run, doesn't wait out this run's own TTL (#2750).
+    await stewardGate?.release?.();
+  }
+}
+
+/**
+ * The work item and holder a `chant run` passes to the runtime (#2748), or
+ * `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.
+ */
+async function resolveRunWork(
+  ctx: CommandContext,
+  config: OpConfig,
+  runtime: string,
+): Promise<{ item?: string; holder?: string } | undefined | null> {
+  const item = ctx.args.work;
+  if (!config.workLease) {
+    if (item === undefined) return undefined;
+    console.error(formatError({
+      message: `--work ${item}: Op "${config.name}" declares no work lease`,
+      hint: "Declare workLease on the Op to run it under a work item's lease.",
+    }));
+    return null;
+  }
+  if (runtime !== "local" && (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;
+  }
+  let holder = ctx.args.holder;
+  if (holder === undefined) {
+    try {
+      const { stewards } = await discoverStewards();
+      for (const { declaration } of stewards.values()) {
+        if (declaration.ops.some((op) => op.name === config.name)) {
+          holder = stewardWorkHolder(declaration.name, config.name);
+          break;
+        }
+      }
+    } catch {
+      // No steward can be read: the run holds the lease as this process.
+    }
   }
+  return { ...(item !== undefined ? { item } : {}), ...(holder !== undefined ? { holder } : {}) };
 }
 
 // ── fallback ────────────────────────────────────────────────────────────────���─

package/src/cli/main.test.ts

@@ -276,6 +276,18 @@ describe("parseArgs", () => {
     expect(result.actor).toBe("alice");
   });
 
+  test("parses --release-plan for components release, distinct from --plan (#2300)'s approval-digest flag (ws-055, #2733)", () => {
+    const result = parseArgs([
+      "components", "release", "prod",
+      "--component", "search-service",
+      "--release-plan", "plan.json",
+      "--actor", "alice",
+    ]);
+    expect(result.releasePlanFile).toBe("plan.json");
+    expect(result.digest).toBeUndefined();
+    expect(result.plan).toBeUndefined();
+  });
+
   test("--digest repeats for components promote, and --digest-file is parsed (#2602)", () => {
     const promote = parseArgs([
       "components", "promote", "--from", "staging", "--to", "prod",
@@ -715,6 +727,16 @@ describe("workspace graph --intent (#2651)", () => {
   });
 });
 
+describe("workspace check --changes (#2773)", () => {
+  test("parses the range, the work item and the severity", () => {
+    const args = parseArgs(["workspace", "check", "--changes", "main..HEAD", "--work", "W-001", "--severity", "fail", "--json"]);
+    expect(args).toMatchObject({ command: "workspace", path: "check", changes: "main..HEAD", work: "W-001", severity: "fail", json: true });
+    expect(() => parseArgs(["workspace", "check", "--changes"])).toThrow(/--changes needs a range/);
+    expect(() => parseArgs(["workspace", "check", "--changes", "main", "--severity"])).toThrow(/--severity needs off, warn or fail/);
+    expect(resolveCommand(args, commandRegistry)?.def.name).toBe("workspace check");
+  });
+});
+
 describe("workspace init and ls (#2534)", () => {
   test("resolve to their commands in the one workspace group, with the directory as extra positional", () => {
     const ls = parseArgs(["workspace", "ls", "examples", "--at", "HEAD", "--json"]);
@@ -734,13 +756,28 @@ describe("workspace init and ls (#2534)", () => {
       "workspace lint",
       "workspace ls",
       "workspace member-run",
+      "workspace points",
       "workspace records",
       "workspace status",
       "workspace upgrade",
       "workspace verify",
+      "workspace work",
     ]);
   });
 
+  test("workspace work takes its verb, id and lease flags (#2732)", () => {
+    const claim = parseArgs(["workspace", "work", "claim", "W-001", "--holder", "a", "--ttl", "60", "--json"]);
+    expect(claim).toMatchObject({ command: "workspace", path: "work", extraPositional: "claim", extraPositional2: "W-001", holder: "a", ttl: "60", json: true });
+    expect(resolveCommand(claim, commandRegistry)?.def.name).toBe("workspace work");
+    expect(parseArgs(["workspace", "work", "release", "W-001", "--holder=a", "--token", "t", "--outcome", "done"])).toMatchObject({ holder: "a", token: "t", outcome: "done" });
+    expect(() => parseArgs(["workspace", "work", "claim", "W-001", "--holder"])).toThrow(/--holder needs a value/);
+  });
+
+  test("run takes --work <id> for an Op with a work lease (#2748)", () => {
+    expect(parseArgs(["run", "dispatch", "--work", "W-001", "--holder", "box/dispatch@h"])).toMatchObject({ command: "run", path: "dispatch", work: "W-001", holder: "box/dispatch@h" });
+    expect(() => parseArgs(["run", "dispatch", "--work"])).toThrow(/--work needs a work item id/);
+  });
+
   test("load their modules only when they run", () => {
     const source = readFileSync(join(import.meta.dirname, "main.ts"), "utf-8");
     expect(source).toMatch(/await import\("\.\.\/workspace\/init"\)/);
@@ -748,6 +785,19 @@ describe("workspace init and ls (#2534)", () => {
   });
 });
 
+describe("workspace points (ws-058, #2739)", () => {
+  test("ask and answer take their flags, and --by repeats", () => {
+    const ask = parseArgs(["workspace", "points", "ask", "slice-tier", "--inputs", "in.json", "--response", "r.json", "--subject", "W-001", "--dry-run"]);
+    expect(ask).toMatchObject({ path: "points", extraPositional: "ask", extraPositional2: "slice-tier", inputs: "in.json", response: "r.json", subject: "W-001", dryRun: true });
+    expect(resolveCommand(ask, commandRegistry)?.def.name).toBe("workspace points");
+    expect(parseArgs(["workspace", "points", "ask", "p", "--inputs", "-"]).inputs).toBe("-");
+    const answer = parseArgs(["workspace", "points", "answer", "slice-tier-0123456789ab", "--answer", "medium", "--by", "alice", "--by", "bob"]);
+    expect(answer).toMatchObject({ extraPositional: "answer", answer: "medium", bys: ["alice", "bob"] });
+    expect(parseArgs(["workspace", "points", "--open", "--json"])).toMatchObject({ open: true, json: true });
+    expect(() => parseArgs(["workspace", "points", "ask", "p", "--response", "--json"])).toThrow(/--response needs a JSON file/);
+  });
+});
+
 describe("workspace status (#2544)", () => {
   test("takes the environment as extra positional, a directory after it, and --compare-to", () => {
     const status = parseArgs(["workspace", "status", "staging", "apps", "--compare-to", "prod", "--json"]);