@intentius/chant 0.89.0 → 0.91.0

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

@@ -49,6 +49,16 @@ vi.mock("../../lifecycle/build-ledger-store", () => ({
   readBuildManifest: (...args: unknown[]) => readBuildManifestMock(...args),
 }));
 
+const persistReleasePlanMock = vi.fn();
+
+vi.mock("../../lifecycle/plan-ledger", async () => {
+  const actual = await vi.importActual<typeof import("../../lifecycle/plan-ledger")>("../../lifecycle/plan-ledger");
+  return {
+    ...actual,
+    persistReleasePlan: (...args: unknown[]) => persistReleasePlanMock(...args),
+  };
+});
+
 vi.mock("../../lifecycle/release-ledger", async () => {
   const actual = await vi.importActual<typeof import("../../lifecycle/release-ledger")>("../../lifecycle/release-ledger");
   return {
@@ -137,6 +147,7 @@ describe("components handlers", () => {
     discoverComponentsMock.mockReset().mockResolvedValue({ components: new Map(), sourceFiles: [], errors: [] });
     findBuildManifestByArtifactDigestMock.mockReset().mockResolvedValue(undefined);
     readBuildManifestMock.mockReset().mockResolvedValue(null);
+    persistReleasePlanMock.mockReset().mockResolvedValue({ commit: "a".repeat(40), written: true });
 
     delete process.env.GITHUB_RUN_ID;
     delete process.env.CI_PIPELINE_ID;
@@ -222,6 +233,88 @@ describe("components handlers", () => {
       await runComponentsReleaseRecord(ctx);
       expect(JSON.parse(stdoutBuf.join(""))).toMatchObject(record);
     });
+
+    describe("--plan (ws-055, #2733)", () => {
+      let planDir: string;
+
+      beforeEach(async () => {
+        planDir = await mkdtemp(join(tmpdir(), "chant-plan-"));
+      });
+
+      afterEach(async () => {
+        await rm(planDir, { recursive: true, force: true });
+      });
+
+      test("persists the plan and records its own digest, when --digest is omitted", async () => {
+        const planPath = join(planDir, "plan.json");
+        await writeFile(planPath, JSON.stringify({ digest: "sha256:fromplan", release: "r-1", units: [] }));
+        appendReleaseRecordMock.mockResolvedValue({
+          commit: "a".repeat(40),
+          record: { version: 1, component: "svc", env: "prod", digest: "sha256:fromplan", gitSha: "abc123headsha", runId: "local-123", timestamp: "2026-01-01T00:00:00.000Z", actor: "alice" },
+        });
+
+        const ctx = { args: makeArgs({ extraPositional: "prod", component: "svc", releasePlanFile: planPath, actor: "alice" }), plugins: [], serializers: [] };
+        const exit = await runComponentsReleaseRecord(ctx);
+
+        expect(exit).toBe(0);
+        expect(persistReleasePlanMock).toHaveBeenCalledTimes(1);
+        expect(persistReleasePlanMock.mock.calls[0][0]).toEqual({ digest: "sha256:fromplan", release: "r-1", units: [] });
+        const [input] = appendReleaseRecordMock.mock.calls[0];
+        expect(input).toMatchObject({ digest: "sha256:fromplan" });
+        // The plan is persisted before the release record is appended, so the
+        // record's digest always names a plan this checkout can resolve.
+        expect(persistReleasePlanMock.mock.invocationCallOrder[0]).toBeLessThan(appendReleaseRecordMock.mock.invocationCallOrder[0]);
+      });
+
+      test("--digest agreeing with the plan's own digest is accepted", async () => {
+        const planPath = join(planDir, "plan.json");
+        await writeFile(planPath, JSON.stringify({ digest: "sha256:agree", release: "r-1" }));
+        appendReleaseRecordMock.mockResolvedValue({ commit: "a".repeat(40), record: { version: 1, component: "svc", env: "prod", digest: "sha256:agree", gitSha: "x", runId: "y", timestamp: "z", actor: "alice" } });
+
+        const ctx = { args: makeArgs({ extraPositional: "prod", component: "svc", digest: "sha256:agree", releasePlanFile: planPath, actor: "alice" }), plugins: [], serializers: [] };
+        const exit = await runComponentsReleaseRecord(ctx);
+        expect(exit).toBe(0);
+      });
+
+      test("--digest disagreeing with the plan's own digest is refused", async () => {
+        const planPath = join(planDir, "plan.json");
+        await writeFile(planPath, JSON.stringify({ digest: "sha256:plandigest" }));
+
+        const ctx = { args: makeArgs({ extraPositional: "prod", component: "svc", digest: "sha256:other", releasePlanFile: planPath, actor: "alice" }), plugins: [], serializers: [] };
+        const exit = await runComponentsReleaseRecord(ctx);
+        expect(exit).toBe(1);
+        expect(stderrBuf.join("\n")).toContain("does not match --release-plan");
+        expect(persistReleasePlanMock).not.toHaveBeenCalled();
+        expect(appendReleaseRecordMock).not.toHaveBeenCalled();
+      });
+
+      test("a plan file with no digest field is refused", async () => {
+        const planPath = join(planDir, "plan.json");
+        await writeFile(planPath, JSON.stringify({ release: "r-1" }));
+
+        const ctx = { args: makeArgs({ extraPositional: "prod", component: "svc", releasePlanFile: planPath, actor: "alice" }), plugins: [], serializers: [] };
+        const exit = await runComponentsReleaseRecord(ctx);
+        expect(exit).toBe(1);
+        expect(stderrBuf.join("\n")).toContain("missing its own \"digest\" field");
+      });
+
+      test("a plan file that is not valid JSON is refused", async () => {
+        const planPath = join(planDir, "plan.json");
+        await writeFile(planPath, "{not json");
+
+        const ctx = { args: makeArgs({ extraPositional: "prod", component: "svc", releasePlanFile: planPath, actor: "alice" }), plugins: [], serializers: [] };
+        const exit = await runComponentsReleaseRecord(ctx);
+        expect(exit).toBe(1);
+        expect(stderrBuf.join("\n")).toContain("is not valid JSON");
+      });
+
+      test("a --plan path that can't be read is refused", async () => {
+        const ctx = { args: makeArgs({ extraPositional: "prod", component: "svc", releasePlanFile: join(planDir, "missing.json"), actor: "alice" }), plugins: [], serializers: [] };
+        const exit = await runComponentsReleaseRecord(ctx);
+        expect(exit).toBe(1);
+        expect(stderrBuf.join("\n")).toContain("Could not read --release-plan");
+      });
+    });
   });
 
   describe("runComponentsStatus", () => {

package/src/cli/handlers/components.ts

@@ -38,6 +38,7 @@ import {
   resolveRunId,
   InvalidReleaseRecordError,
 } from "../../lifecycle/release-ledger";
+import { persistReleasePlan, InvalidReleasePlanError, type ReleasePlan } from "../../lifecycle/plan-ledger";
 import { reconcileStatus, liveEvidenceFromChangeSet, compareAcrossEnvironments, mergeLiveEvidence, type LiveComponentEvidence, type EntityLiveRead } from "../../lifecycle/status";
 import { commandBuildParams } from "../build-params-cli";
 import { buildChangeSet } from "../../lifecycle/change-set";
@@ -75,6 +76,14 @@ import { withoutReadFlags } from "../../lifecycle/legacy-digest";
  * never threaded in from elsewhere and never mocked in production code, per
  * #568: "the session cannot call Date.now() in some contexts; take the
  * timestamp from the environment/CLI at record time."
+ *
+ * `--release-plan <file>` (ws-055, #2733) takes `--digest`'s place: the file is a
+ * release plan JSON object naming its own `digest` field, persisted
+ * content-addressed to `_plans/<digest>.json` (../../lifecycle/plan-
+ * ledger.ts) before the release record is appended, so the record's digest
+ * always names a plan this checkout can resolve. Passing both requires them
+ * to agree — a plan is content-addressed by its own digest, so a caller
+ * naming a different one is a mistake, not an override.
  */
 export async function runComponentsReleaseRecord(ctx: CommandContext): Promise<number> {
   const { args } = ctx;
@@ -87,11 +96,42 @@ export async function runComponentsReleaseRecord(ctx: CommandContext): Promise<n
   }
 
   const component = args.component;
-  const digest = args.digest;
+  let digest = args.digest;
+  let plan: ReleasePlan | undefined;
+  if (args.releasePlanFile) {
+    let raw: string;
+    try {
+      raw = await readFile(args.releasePlanFile, "utf-8");
+    } catch (err) {
+      console.error(formatError({ message: `Could not read --release-plan ${args.releasePlanFile}: ${err instanceof Error ? err.message : String(err)}` }));
+      return 1;
+    }
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      console.error(formatError({ message: `--release-plan ${args.releasePlanFile} is not valid JSON: ${err instanceof Error ? err.message : String(err)}` }));
+      return 1;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      console.error(formatError({ message: `--release-plan ${args.releasePlanFile} must be a JSON object` }));
+      return 1;
+    }
+    plan = parsed as ReleasePlan;
+    if (typeof plan.digest !== "string" || plan.digest.length === 0) {
+      console.error(formatError({ message: `--release-plan ${args.releasePlanFile} is missing its own "digest" field — a release plan is content-addressed by its own digest` }));
+      return 1;
+    }
+    if (digest !== undefined && digest !== plan.digest) {
+      console.error(formatError({ message: `--digest ${digest} does not match --release-plan ${args.releasePlanFile}'s own digest ${plan.digest}` }));
+      return 1;
+    }
+    digest = plan.digest;
+  }
   if (!component || !digest) {
     console.error(formatError({
       message: "--component and --digest are required",
-      hint: "chant components release <env> --component <name> --digest <sha256:...> [--git-sha <sha>] [--run-id <id>] [--actor <name>] [--approver <name>]",
+      hint: "chant components release <env> --component <name> --digest <sha256:...> [--release-plan <file>] [--git-sha <sha>] [--run-id <id>] [--actor <name>] [--approver <name>]",
     }));
     return 1;
   }
@@ -121,6 +161,7 @@ export async function runComponentsReleaseRecord(ctx: CommandContext): Promise<n
   const timestamp = new Date().toISOString();
 
   try {
+    if (plan) await persistReleasePlan(plan);
     const { commit, record } = await appendReleaseRecord({
       component,
       env: environment,
@@ -142,7 +183,7 @@ export async function runComponentsReleaseRecord(ctx: CommandContext): Promise<n
     }
     return 0;
   } catch (err) {
-    if (err instanceof InvalidReleaseRecordError) {
+    if (err instanceof InvalidReleaseRecordError || err instanceof InvalidReleasePlanError) {
       console.error(formatError({ message: err.message }));
       return 1;
     }

package/src/cli/handlers/operator.ts

@@ -11,7 +11,8 @@ import { loadChantConfig } from "../../config";
 import { build } from "../../build";
 import { isResourceDeclarable } from "../../declarable";
 import { collectBuildRootContributors, collectChangeSubscribers } from "../plugins";
-import { discoverOps } from "../../op/discover";
+import { discoverOps, discoverStewards } from "../../op/discover";
+import { pickSteward, stewardFormFor, stewardLeaseName, DEFAULT_STEWARD_ENV } from "../../op/steward";
 import { loadActivities, loadProfiles } from "../../op/activity-registry";
 import { parseDuration } from "../../op/local-executor";
 import {
@@ -21,11 +22,12 @@ import {
   formatRoundLine,
   formatSignalLine,
   DEFAULT_OPERATOR_INTERVAL_MS,
+  acquireStewardLease,
   type ChangeSubscriber,
   type OperatorSignalEvent,
   type OperatorTickEvent,
 } from "../../op/operator";
-import { readLease, DEFAULT_LEASE_TTL_MS } from "../../lifecycle/lease";
+import { readLease, releaseLease, currentHolderId, DEFAULT_LEASE_TTL_MS } from "../../lifecycle/lease";
 import { readConvergeLedger, type ConvergeTickRecord } from "../../lifecycle/converge-ledger";
 import { readRunLedger } from "../../lifecycle/run-ledger";
 import type { OpRunRecord } from "../../op/runtime";
@@ -141,6 +143,7 @@ async function collectOperatorSubscribers(
  * leaving the daemon running); omitted, the daemon loops until Ctrl-C.
  */
 export async function runOperator(ctx: CommandContext): Promise<number> {
+  if (ctx.args.steward !== undefined) return runStewardOperator(ctx);
   const { ops, errors } = await discoverConvergeOps({ env: ctx.args.env });
   for (const err of errors) console.error(formatWarning({ message: err }));
 
@@ -205,6 +208,108 @@ export async function runOperator(ctx: CommandContext): Promise<number> {
   }
 }
 
+// ── chant operator --steward ────────────────────────────────────────────────
+
+/**
+ * `chant operator --steward [<name>] [--env <env>] [--interval] [--lease-ttl]
+ * [--once]` (#2731) — a steward's local form. The same Ops the steward runs on
+ * Fountain, on the same crons, one at a time, each under its operator lease,
+ * and the whole process under the steward's own lease.
+ *
+ * Refuses, before ticking anything:
+ * - an environment whose form is `fountain`, because there the composite's
+ *   Agent and Teammate are the steward and this process would be a second
+ *   writer beside them;
+ * - a steward whose lease another live process holds (a second local
+ *   operator for it).
+ */
+export async function runStewardOperator(ctx: CommandContext): Promise<number> {
+  const { stewards, errors, conflicts } = await discoverStewards();
+  for (const err of errors) console.error(formatWarning({ message: err }));
+  for (const conflict of conflicts) console.error(formatError({ message: conflict }));
+
+  const picked = pickSteward(stewards, ctx.args.steward ?? "");
+  if (typeof picked === "string") {
+    console.error(formatError({ message: picked }));
+    return 1;
+  }
+  const steward = picked;
+  const env = ctx.args.env ?? DEFAULT_STEWARD_ENV;
+  const form = stewardFormFor(steward, env);
+  if (form !== "local") {
+    console.error(formatError({
+      message: `steward "${steward.name}" runs on ${form} in environment "${env}", so a local operator for it would be a second writer`,
+      hint: `Its turns run on the fountain teammate "${steward.name}". Run this in an environment the declaration's form makes local, or change the form.`,
+    }));
+    return 1;
+  }
+
+  let activities, profiles;
+  try {
+    [activities, profiles] = await loadOperatorActivities();
+  } catch (err) {
+    console.error(formatError({ message: err instanceof Error ? err.message : String(err) }));
+    return 1;
+  }
+
+  const intervalMs = ctx.args.interval ? parseDuration(ctx.args.interval) : DEFAULT_OPERATOR_INTERVAL_MS;
+  const leaseTtlMs = ctx.args.leaseTtl ? parseDuration(ctx.args.leaseTtl) : DEFAULT_LEASE_TTL_MS;
+  const holder = currentHolderId();
+
+  // Refuse a second local operator up front rather than letting it loop on
+  // `steward-busy` rounds: one steward is one writer.
+  const first = await acquireStewardLease(steward.name, holder, { ttlMs: leaseTtlMs });
+  if (!first.acquired) {
+    console.error(formatError({
+      message: `steward "${steward.name}" is already running (lease held by ${first.heldBy?.holder ?? "another process"} until ${first.heldBy?.expiresAt ?? "?"})`,
+      hint: "One steward is one writer. Stop the other operator, or wait for its lease to expire.",
+    }));
+    return 1;
+  }
+
+  const controller = new AbortController();
+  const onSigint = () => {
+    console.error(formatWarning({ message: "interrupted — stopping steward" }));
+    controller.abort();
+  };
+  process.once("SIGINT", onSigint);
+  process.once("SIGTERM", onSigint);
+
+  const printRound = (events: OperatorTickEvent[]) => {
+    for (const event of events) console.error(formatInfo(formatRoundLine(event)));
+  };
+
+  const scheduled = steward.ops.filter((op) => op.schedule !== undefined);
+  try {
+    if (ctx.args.once) {
+      const events = await runOperatorRound({ steward, holder, leaseTtlMs, activities, profiles, signal: controller.signal });
+      printRound(events);
+      return events.some((e) => e.kind === "tick-failed" || e.kind === "steward-busy") ? 1 : 0;
+    }
+    console.error(formatInfo(
+      `chant operator: steward ${steward.name} (local) runs ${scheduled.length} scheduled Op(s) of ${steward.ops.length}, ` +
+        `checking every ${intervalMs}ms (Ctrl-C to stop)`,
+    ));
+    await runOperatorForever({
+      steward,
+      holder,
+      intervalMs,
+      leaseTtlMs,
+      activities,
+      profiles,
+      signal: controller.signal,
+      onRound: printRound,
+    });
+    return 0;
+  } finally {
+    process.removeListener("SIGINT", onSigint);
+    process.removeListener("SIGTERM", onSigint);
+    // A courtesy: the lease expires on its own if this never runs.
+    const { record } = await readLease(stewardLeaseName(steward.name)).catch(() => ({ record: undefined }));
+    if (record?.holder === holder) await releaseLease(stewardLeaseName(steward.name), holder, record.token).catch(() => false);
+  }
+}
+
 // ── chant operator status ───────────────────────────────────────────────────
 
 interface OpStatusLine {

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

@@ -199,6 +199,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();

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";
@@ -866,6 +867,12 @@ export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
   const runtime = await resolveOpRuntime(ctx);
   if (!runtime) 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`.
   const progress = ctx.args.progressJson ? ndjsonProgressSink<StepRecord>() : undefined;
@@ -885,6 +892,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();
 
@@ -945,6 +953,50 @@ export async function runOpOnRuntime(ctx: CommandContext): Promise<number> {
   }
 }
 
+/**
+ * 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 ────────────────────────────────────────────────────────────────���─
 
 export function runOpUnknown(ctx: CommandContext): Promise<number> {

package/src/cli/handlers/serve.ts

@@ -20,7 +20,8 @@ export async function runServeMcp(ctx: CommandContext): Promise<number> {
     const { loadWorkspacePlugins } = await import("../mcp/workspace-plugins");
     ({ plugins, instructions } = await loadWorkspacePlugins(process.cwd()));
   }
-  const server = new McpServer(plugins, { instructions });
+  // #2707 — at or inside a declared workspace, the workspace tools are served too.
+  const server = new McpServer(plugins, { instructions, workspace: { cwd: process.cwd() } });
   await server.start();
   await new Promise(() => {});
   return 0; // unreachable

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",
@@ -734,13 +746,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 +775,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"]);