@intentius/chant 0.90.0 → 0.93.0

package/src/cli/main.ts

@@ -54,6 +54,7 @@ import type { LexiconPlugin } from "../lexicon";
  */
 const BOOLEAN_FLAGS = new Set([
   "--help",
+  "--open",
   "--version",
   "--agents",
   "--agent",
@@ -378,6 +379,14 @@ export function parseArgs(args: string[]): ParsedArgs {
       // `chant workspace graph --intent <path[:start-end]>` (#2651)
       result.intent = args[++i];
       if (!result.intent || result.intent.startsWith("-")) throw new Error("--intent needs a region: --intent <path[:start-end]>");
+    } else if (arg === "--changes") {
+      // `chant workspace check --changes <base>..<head>` (#2773)
+      result.changes = args[++i];
+      if (!result.changes || result.changes.startsWith("-")) throw new Error("--changes needs a range: --changes <base>..<head>");
+    } else if (arg === "--severity") {
+      // `chant workspace check --changes <range> --severity off|warn|fail` (#2773)
+      result.severity = args[++i];
+      if (!result.severity || result.severity.startsWith("-")) throw new Error("--severity needs off, warn or fail");
     } else if (arg === "--current") {
       result.current = true;
     } else if (arg === "--set") {
@@ -392,6 +401,27 @@ export function parseArgs(args: string[]): ParsedArgs {
       // `chant workspace records review <id> --by <principal>` (#2670): whoever the caller says.
       result.by = args[++i];
       if (!result.by || result.by.startsWith("-")) throw new Error("--by needs the reviewer: --by <principal>");
+      // Repeatable for `workspace points answer` (#2739): each person who answered.
+      (result.bys ??= []).push(result.by);
+    } else if (arg === "--open") {
+      // `chant workspace points --open` (#2739): only the questions still open.
+      result.open = true;
+    } else if (arg === "--inputs") {
+      // `chant workspace points ask <point> --inputs <file|->` (#2739)
+      result.inputs = args[++i];
+      if (!result.inputs || (result.inputs.startsWith("-") && result.inputs !== "-")) throw new Error("--inputs needs a JSON file, or - for standard input: --inputs <file|->");
+    } else if (arg === "--response") {
+      // `chant workspace points ask <point> --response <file>` (#2739): a POST /v1/systemone response the caller got.
+      result.response = args[++i];
+      if (!result.response || result.response.startsWith("-")) throw new Error("--response needs a JSON file: --response <file>");
+    } else if (arg === "--subject") {
+      // `chant workspace points ask <point> --subject <id>` (#2739): what the question is about.
+      result.subject = args[++i];
+      if (!result.subject || result.subject.startsWith("-")) throw new Error("--subject needs what the question is about, such as a work item id: --subject <id>");
+    } else if (arg === "--answer") {
+      // `chant workspace points answer <id> --answer <value>` (#2739)
+      result.answer = args[++i];
+      if (result.answer === undefined || result.answer === "") throw new Error("--answer needs one of the question's candidates: --answer <value>");
     } else if (arg === "--sign") {
       // `chant workspace records review <id> --sign [<key file>]` (#2687): seal the verdict.
       // `records new` and `records amend` take it too, to seal the record's author (#2688).
@@ -431,6 +461,8 @@ export function parseArgs(args: string[]): ParsedArgs {
     } else if (arg === "--digest") {
       result.digest = args[++i];
       if (result.digest !== undefined) (result.digests ??= []).push(result.digest);
+    } else if (arg === "--release-plan") {
+      result.releasePlanFile = args[++i];
     } else if (arg === "--git-sha") {
       result.gitSha = args[++i];
     } else if (arg === "--run-id") {
@@ -483,8 +515,28 @@ export function parseArgs(args: string[]): ParsedArgs {
       result.interval = args[++i];
     } else if (arg === "--lease-ttl") {
       result.leaseTtl = args[++i];
+    } else if (arg === "--steward") {
+      // #2731 — the name is optional: a project with one steward runs it
+      // with a bare `--steward`.
+      const next = args[i + 1];
+      if (next !== undefined && !next.startsWith("-")) {
+        result.steward = next;
+        i++;
+      } else {
+        result.steward = "";
+      }
     } else if (arg === "--once") {
       result.once = true;
+    } else if (arg === "--work") {
+      // `chant run <op> --work <id>` (#2748)
+      const value = args[++i];
+      if (!value || value.startsWith("-")) throw new Error("--work needs a work item id: --work <id>");
+      result.work = value;
+    } else if (arg === "--holder" || arg === "--ttl" || arg === "--token" || arg === "--outcome") {
+      // `chant workspace work claim|renew|release <id>` (#2732)
+      const value = args[++i];
+      if (!value || value.startsWith("-")) throw new Error(`${arg} needs a value: ${arg} <${arg.slice(2)}>`);
+      result[arg.slice(2) as "holder" | "ttl" | "token" | "outcome"] = value;
     } else if (arg === "--note") {
       result.note = args[++i];
     } else if (arg === "--expire") {
@@ -664,6 +716,8 @@ Commands:
 
 Ops:
   run <name>            Run an Op on the resolved runtime (--on; local by default)
+                        [--work <id>] [--holder <name>]: the work item an Op
+                        with a work lease runs under, and who holds it
   run list              List all Ops with the runtime's state for each
   run status <name>     Show the runtime's state for one Op's latest run
   run approve <op> <gate>  Record a gate's resolution and wake the runtime
@@ -691,7 +745,10 @@ Ops:
                         environment; --interval <dur> (default 60s) and
                         --lease-ttl <dur> (default 5m) tune cadence; --once
                         runs a single round and exits (cron/systemd-timer/
-                        CronJob invokers use this instead of the daemon)
+                        CronJob invokers use this instead of the daemon).
+                        --steward [<name>] runs a declared steward's local
+                        form instead (#2731): its scheduled Ops on their
+                        crons, under the steward's own lease
   operator status        Last tick, outcomes, and pending gates per
                         ConvergeOp, read from the chant/lifecycle orphan
                         branch alone — no daemon needs to be running
@@ -802,6 +859,29 @@ Workspace (level 1, #2524):
                         closing commit and seal, in one write. Without
                         --kind, the one session kind the declaration names.
                         Prints {path, id, changed, seal, closedRev}
+  workspace work claim|renew|release <id> --holder <name> [--kind <kind file>] [--ttl <seconds|duration>] [--token <token>] [--outcome <text>] [--note <text>] [--json]
+                        Take, heartbeat or give back the lease on a work item:
+                        refs/chant/lease/work/<id>, a compare-and-set ref with a
+                        fencing token and an expiry, pushed to the remote so
+                        separate clones coordinate. A claim is refused, exit 2,
+                        while anyone holds it live. Each change appends to
+                        _leases/<id>.jsonl on chant/lifecycle
+  workspace work history <id> [--kind <kind file>] [--json]
+                        A work item's lease history: each claim with its token
+                        and holder, and how it ended, released with an outcome
+                        or never released (expired or lost). Read-only
+  workspace points [--open] [--kind <kind file>] [--at <rev>] [--json]
+                        List the decision points the declared answer kinds'
+                        points files declare, and the questions asked of them;
+                        --open keeps the escalated and proposed ones (ws-058)
+  workspace points ask <point> --inputs <file|-> [--response <file>] [--subject <id>] [--kind <kind file>] [--dry-run]
+                        Ask a point's table, model and quorum deciders and
+                        record the answer: proposed from a model, escalated to
+                        people below its threshold. --response is a POST
+                        /v1/systemone response the caller got; chant calls no model
+  workspace points answer <id> --answer <value> --by <name>... [--kind <kind file>] [--dry-run]
+                        Record people's answer to an open question, or confirm
+                        a model's proposal, once the point's quorum is met
   workspace verify [--base <rev>] [--head <rev>] [--require attested]
                         Check the commits in base..head against the signers
                         and roles read from base. A change to the signers file
@@ -828,6 +908,13 @@ Workspace (level 1, #2524):
                         whose pinned files changed. Needs no workspace file.
                         --at reads a commit's git objects; --format json
                         prints the read-contract document
+  workspace check --changes <base>..<head> [--work <id>] [--severity off|warn|fail] [--kind <kind file>...] [--json]
+                        Map each path the diff changes to the current records
+                        whose constrains cover it: change-uncovered when none
+                        does, change-out-of-scope when a record in hand (the
+                        --work item and its decisions) lists it in
+                        out_of_scope. The declaration's changes block sets
+                        the severity (warn by default) and ignore globs
   workspace build [dir] [--member <name>] [-o <dir>] [--dry-run]
                         Build every chant member and example project, each with
                         its own chant, one process per toolchain. -o <dir>
@@ -904,7 +991,11 @@ Component release ledger + status:
                              <file> finishes an attempt that stopped)
   components release <env> Append one immutable release record
                             (--component <name> --digest <sha256:...>
-                             [--git-sha <sha>] [--run-id <id>] [--actor <name>])
+                             [--git-sha <sha>] [--run-id <id>] [--actor <name>]);
+                            --release-plan <file> takes --digest's place,
+                            persisting the release plan the file holds to
+                            _plans/<digest>.json (ws-055) and recording its
+                            own digest
   components export <env>  Materialize a persisted build archive manifest to
                             a portable directory (--component <name>
                             [--digest <manifestDigest>] -o <dir> [--json]);
@@ -1328,8 +1419,12 @@ export const commandRegistry: CommandDef[] = [
   // Workspace reads (#2524). Imported on first use, so a level-0 command never
   // loads anything under workspace/ (#2525 rule 5, pinned by #2526's goldens).
   { name: "workspace records", handler: async (ctx) => (await import("../workspace/records-cli")).runWorkspaceRecords(ctx) },
+  // ws-058 (#2739) — decision points and the questions asked of them; never calls a model.
+  { name: "workspace points", handler: async (ctx) => (await import("../workspace/points-cli")).runWorkspacePoints(ctx) },
   { name: "workspace init", handler: async (ctx) => (await import("../workspace/init")).runWorkspaceInit(ctx) },
   { name: "workspace ls", handler: async (ctx) => (await import("../workspace/ls")).runWorkspaceLs(ctx) },
+  // #2732 — the work lease: claim, renew and release a work item.
+  { name: "workspace work", runsNoConfig: true, handler: async (ctx) => (await import("../workspace/work-cli")).runWorkspaceWork(ctx) },
   { name: "workspace status", handler: async (ctx) => (await import("../workspace/status")).runWorkspaceStatus(ctx) },
   { name: "workspace lineage", handler: async (ctx) => (await import("../workspace/lineage-cli")).runWorkspaceLineage(ctx) },
   { name: "workspace upgrade", handler: async (ctx) => (await import("../workspace/lineage-upgrade-cli")).runWorkspaceUpgrade(ctx) },

package/src/cli/mcp/workspace-tools.test.ts

@@ -85,7 +85,7 @@ describe("which servers have the workspace tools", () => {
       const { tools } = (await rpc(server(cwd), "tools/list")) as { tools: { name: string }[] };
       expect(tools.map((t) => t.name)).toEqual(expect.arrayContaining(names));
     }
-    expect(names).toEqual(["workspace-ls", "workspace-status", "workspace-graph", "workspace-records", "records-new", "records-amend", "records-review", "records-close"]);
+    expect(names).toEqual(["workspace-ls", "workspace-status", "workspace-graph", "workspace-changes", "workspace-records", "workspace-points", "workspace-work-history", "records-new", "records-amend", "records-review", "records-close", "points-answer"]);
   });
 
   test("a server outside any workspace, or given none, does not", async () => {
@@ -100,8 +100,8 @@ describe("which servers have the workspace tools", () => {
     }
   });
 
-  test("the descriptions say records are proposals and by names who decided", () => {
-    for (const t of workspaceWriteTools) expect(t.description).toMatch(/proposals until they are reviewed.*by must name the person or agent that actually decided/s);
+  test("the descriptions say records are proposals and by names who proposed or decided", () => {
+    for (const t of workspaceWriteTools) expect(t.description).toMatch(/proposals until they are reviewed.*by must name the person or agent that actually proposed or decided it/s);
   });
 });
 
@@ -115,6 +115,41 @@ describe("reads", () => {
     expect(recordsOf(only.structuredContent).map((r) => r.id)).toEqual(["fix-001"]);
   }, 120_000);
 
+  test("workspace-points returns the document chant workspace points --json prints, and points-answer the write's (ws-058)", async () => {
+    const s = server();
+    const res = await call(s, "workspace-points", { open: true });
+    expect(res.isError).toBeUndefined();
+    expect(res.structuredContent).toEqual(cli(["workspace", "points", "--open", "--json"]));
+    expect(res.structuredContent).toMatchObject({ open: true, sources: [], points: [], questions: [] });
+    // The generated workspace declares no answer kind, so there is nothing to answer.
+    const answered = await call(s, "points-answer", { id: "slice-tier-000000000000", answer: "small", by: ["alice"] });
+    expect(answered.structuredContent).toMatchObject({ verb: "answer", error: { code: "points-undeclared" } });
+    const bad = await call(s, "points-answer", { id: "slice-tier-000000000000", answer: "small", by: [] });
+    expect(bad.isError).toBe(true);
+  }, 120_000);
+
+  test("workspace-work-history returns the document chant workspace work history --json prints (#2785)", async () => {
+    const s = server();
+    const res = await call(s, "workspace-work-history", { item: "W-1" });
+    expect(res.isError).toBeUndefined();
+    expect(res.structuredContent).toEqual(cli(["workspace", "work", "history", "W-1", "--json"]));
+    expect(res.structuredContent).toMatchObject({ contract: 1, error: { code: expect.any(String) } });
+    const bad = await call(s, "workspace-work-history", {});
+    expect(bad.isError).toBe(true);
+  }, 120_000);
+
+  test("workspace-changes returns the document chant workspace check --changes --json prints (#2773)", async () => {
+    const s = server();
+    const res = await call(s, "workspace-changes", { range: "HEAD", severity: "fail" });
+    expect(res.isError).toBeUndefined();
+    expect(res.structuredContent).toEqual(cli(["workspace", "check", "--changes", "HEAD", "--severity", "fail", "--json"]));
+    expect(res.structuredContent).toMatchObject({ severity: "fail", paths: [], findings: [], ok: true });
+    const unknown = await call(s, "workspace-changes", { range: "HEAD", work: "W-999" });
+    expect(unknown.structuredContent).toMatchObject({ error: { code: "work-item-unknown" } });
+    const bad = await call(s, "workspace-changes", { range: "HEAD", severity: "loud" });
+    expect(bad.isError).toBe(true);
+  }, 120_000);
+
   test("an error document is returned as a document, and a flag-shaped value is refused before chant runs", async () => {
     const s = server();
     const missing = await call(s, "workspace-records", { kind: "nowhere/none.kind.mjs" });
@@ -130,6 +165,7 @@ describe("reads", () => {
     expect(mcpToolCall(["workspace", "graph", "--intent", "a.mjs:1", "--kind", KIND, "--json"])).toEqual({ name: "workspace-graph", arguments: { intent: "a.mjs:1", kind: [KIND] } });
     expect(mcpToolCall(["workspace", "graph", "--composites", "--json"])).toEqual({ name: "workspace-graph", arguments: { composites: true } });
     expect(mcpToolCall(["workspace", "check", "--format", "json"])).toBeUndefined();
+    expect(mcpToolCall(["workspace", "check", "--changes", "main..HEAD", "--work", "W-001", "--json"])).toEqual({ name: "workspace-changes", arguments: { range: "main..HEAD", work: "W-001" } });
   });
 });
 
@@ -173,25 +209,18 @@ describe("writes", () => {
     const reasoning = await call(s, "records-amend", { kind: KIND, id: "fix-001", fields: { question: "Something else?" } });
     expect(reasoning.structuredContent).toMatchObject({ error: { code: "amend-supersede-instead" } });
 
-    const both = await call(s, "records-new", { kind: KIND, record: { ...proposal("Two authors"), decided_by: "alice" }, by: "bob", dryRun: true });
+    // A new record opens proposed (MCP forces it), so by names the proposer, in proposedBy's field, not the decider (#2756).
+    const both = await call(s, "records-new", { kind: KIND, record: { ...proposal("Two proposers"), proposed_by: "alice" }, by: "bob", dryRun: true });
     expect(both.structuredContent).toMatchObject({ error: { code: "write-input-invalid" } });
-    const by = await call(s, "records-new", { kind: KIND, record: proposal("One author"), by: "alice", dryRun: true });
+    const by = await call(s, "records-new", { kind: KIND, record: proposal("One proposer"), by: "alice", dryRun: true });
     expect(by.structuredContent, JSON.stringify(by.structuredContent)).toHaveProperty("text");
-    expect((by.structuredContent as { text: string }).text).toContain('decided_by: "alice"');
+    expect((by.structuredContent as { text: string }).text).toContain('proposed_by: "alice"');
+    expect((by.structuredContent as { text: string }).text).toContain("decided_by: null");
+
+    // --sign seals the decider, and a record by names as proposed carries no decided_by yet.
+    const signed = await call(s, "records-new", { kind: KIND, record: proposal("Signed"), by: "alice", sign: true, dryRun: true });
+    expect(signed.structuredContent).toMatchObject({ error: { code: "record-sign-failed", message: expect.stringContaining("names no decided_by") } });
 
-    // No key configured on this host: the CLI's refusal and remedy.
-    const home = { GIT_CONFIG_GLOBAL: "/dev/null", GIT_CONFIG_NOSYSTEM: "1" };
-    const saved = { ...process.env };
-    Object.assign(process.env, home);
-    try {
-      const signed = await call(s, "records-new", { kind: KIND, record: proposal("Signed"), by: "alice", sign: true, dryRun: true });
-      expect(signed.structuredContent).toMatchObject({ error: { code: "record-sign-failed", message: expect.stringContaining("pass --sign <key file>") } });
-    } finally {
-      for (const k of Object.keys(home)) {
-        if (saved[k] === undefined) delete process.env[k];
-        else process.env[k] = saved[k];
-      }
-    }
     // Nothing above wrote a file.
     expect(readFileSync(join(ws.dir, "decisions", "fix-001-how-the-app-is-deployed.md"), "utf-8")).toContain('question: "What declares the app\'s deployment?"');
   }, 180_000);

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

@@ -6,15 +6,18 @@
  * is a thin call into the code the CLI runs:
  *
  * - The reads (`workspace-ls`, `workspace-status`, `workspace-graph`,
- *   `workspace-records`) run `chant workspace <command> ... --json` with the
- *   chant this server runs as, in the server's directory, and return the
+ *   `workspace-changes`, `workspace-records`, `workspace-points`,
+ *   `workspace-work-history`) run `chant workspace <command>
+ *   ... --json` with the chant this server runs as, in the server's
+ *   directory, and return the
  *   document it printed, unchanged, with its reason codes (#2536). Running the
  *   command, rather than calling into it, keeps every rule it has, handing the
  *   read to the workspace root's pinned chant included (ws-021), and keeps
  *   anything a command prints away from the protocol on stdout.
  * - The writes (`records-new`, `records-amend`, `records-review`,
- *   `records-close`) call the functions `chant workspace records new|amend|
- *   review|close` call, and return the same JSON result. They keep every rule
+ *   `records-close`, `points-answer`) call the functions `chant workspace
+ *   records new|amend|review|close` and `points answer` call, and return the
+ *   same JSON result. They keep every rule
  *   the CLI keeps: the kind's schema, a closed record never changing, an
  *   approved one changing only as its approval rule allows, a dissent needing
  *   a note, and `sign` using this host's configured key or refusing with the
@@ -50,7 +53,7 @@ export interface WorkspaceToolsOptions {
 
 const PROTOCOL =
   "Records are proposals until they are reviewed: a new record opens proposed, and people decide it through reviews and amendments. " +
-  "by must name the person or agent that actually decided, as it is recorded as given.";
+  "by must name the person or agent that actually proposed or decided it, as it is recorded as given.";
 
 const kindProp = {
   type: "string",
@@ -75,7 +78,7 @@ export const workspaceReadTools: ToolDefinition[] = [
   {
     name: "workspace-status",
     description:
-      "What each member has released to an environment, from the lifecycle ledgers: chant workspace status <env> --json. Returns that document unchanged (status.schema.json).",
+      "What each member has released to an environment, its gates, and the steward that runs it with each Op's last run, from the declaration and the lifecycle ledgers: chant workspace status <env> --json. Returns that document unchanged (status.schema.json).",
     inputSchema: {
       type: "object",
       properties: {
@@ -103,10 +106,29 @@ export const workspaceReadTools: ToolDefinition[] = [
       },
     },
   },
+  {
+    name: "workspace-changes",
+    description:
+      "The forward coverage check over a diff: chant workspace check --changes <range> --json (changes.schema.json, #2773). Each changed path with the current records whose constrains cover it, and a change-uncovered or change-out-of-scope finding for each gap, at the severity the declaration's changes block sets. Returns the document unchanged.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        range: { type: "string", description: "The diff: <base>..<head>, <base>...<head> (from their merge base), or <base> alone, to HEAD (--changes)." },
+        work: { type: "string", description: "The id of the work item in hand, whose out_of_scope and whose decisions' out_of_scope apply (--work)." },
+        severity: { type: "string", enum: ["off", "warn", "fail"], description: "In place of the declaration's changes.severity (--severity)." },
+        kind: {
+          type: "array",
+          items: { type: "string" },
+          description: "Record kind files to read in place of the declared ones (--kind).",
+        },
+      },
+      required: ["range"],
+    },
+  },
   {
     name: "workspace-records",
     description:
-      "The records of a kind, validated, with supersession, provenance, quorum and warnings: chant workspace records --json (records.schema.json). With since, what changed since a revision or a review session (records-since.schema.json). Returns the document unchanged; with id, only that record is kept in records. " +
+      "The records of a kind, validated, with supersession, remediation, provenance, quorum and warnings: chant workspace records --json (records.schema.json). With since, what changed since a revision or a review session (records-since.schema.json). Returns the document unchanged; with id, only that record is kept in records. " +
       PROTOCOL,
     inputSchema: {
       type: "object",
@@ -119,6 +141,32 @@ export const workspaceReadTools: ToolDefinition[] = [
       },
     },
   },
+  {
+    name: "workspace-points",
+    description:
+      "The workspace's decision points and the questions asked of them: chant workspace points --json (points.schema.json, ws-058). A question is open while it is escalated to people, or proposed by a model and not yet confirmed; each lists any model's answer with its confidence and threshold. Returns the document unchanged. chant calls no model to answer this.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        open: { type: "boolean", description: "Only the open questions (--open)." },
+        kind: { type: "string", description: "One answer kind file, in place of the declared ones (--kind)." },
+        at: atProp,
+      },
+    },
+  },
+  {
+    name: "workspace-work-history",
+    description:
+      "One work item's lease history, from the lifecycle ledger of the member that owns its work kind: chant workspace work history <item> --json (work-history.schema.json, #2785). Each claim has its fencing token and holder and how it ended: released with an outcome, still held, or never released (expired, or lost to a later claim). Returns the document unchanged.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        item: { type: "string", description: "The work item's id." },
+        kind: { type: "string", description: "The work kind file, when more than one declared work kind has the id (--kind)." },
+      },
+      required: ["item"],
+    },
+  },
 ];
 
 export const workspaceWriteTools: ToolDefinition[] = [
@@ -133,7 +181,11 @@ export const workspaceWriteTools: ToolDefinition[] = [
         kind: kindProp,
         record: { type: "object", description: "The record's fields, as the kind's schema describes them. The id is allocated when left out." },
         prefix: { type: "string", description: "The id prefix to allocate under, when the records use several (--prefix)." },
-        by: { type: "string", description: "Who decided: written to the kind's decider field, such as decided_by. Required to sign." },
+        by: {
+          type: "string",
+          description:
+            "Who proposed it: written to the kind's proposedBy field, such as proposed_by, since a record opens proposed. Written to its decider field, such as decided_by, only when the record's fields open it straight into a later state. Required to sign.",
+        },
         sign: signProp,
         dryRun: dryRunProp,
       },
@@ -191,6 +243,23 @@ export const workspaceWriteTools: ToolDefinition[] = [
       required: ["id"],
     },
   },
+  {
+    name: "points-answer",
+    description:
+      "Record people's answer to an open decision point question, or confirm a model's proposal: chant workspace points answer. Refused unless the point's quorum is met: distinct people, none holding the agent role, each holding one of the quorum's roles when it names any. An answered question never changes. " +
+      PROTOCOL,
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "The question's id, as workspace-points lists it." },
+        answer: { type: ["string", "boolean"], description: "One of the question's candidates; for a noul, true or false." },
+        by: { type: "array", items: { type: "string" }, description: "Each person who answered (--by)." },
+        kind: { type: "string", description: "The answer kind file. Without it, the declared answer kinds." },
+        dryRun: dryRunProp,
+      },
+      required: ["id", "answer", "by"],
+    },
+  },
 ];
 
 /** A tool call that can't be made as given: the client gets it as an error result, and nothing runs. */
@@ -249,6 +318,31 @@ export function readArgv(tool: string, params: Record<string, unknown>): string[
       if (intent !== undefined) return ["workspace", "graph", "--intent", intent, ...kindArgs, ...atArgs, "--json"];
       return ["workspace", "graph", ...kindArgs, ...atArgs, "--json"];
     }
+    case "workspace-changes": {
+      const range = str(params, "range", true)!;
+      const work = str(params, "work");
+      const severity = str(params, "severity");
+      if (severity !== undefined && !["off", "warn", "fail"].includes(severity)) throw new ToolInputError("severity must be off, warn or fail");
+      return [
+        "workspace",
+        "check",
+        "--changes",
+        range,
+        ...(work !== undefined ? ["--work", work] : []),
+        ...(severity !== undefined ? ["--severity", severity] : []),
+        ...kinds(params).flatMap((k) => ["--kind", k]),
+        "--json",
+      ];
+    }
+    case "workspace-work-history": {
+      const item = str(params, "item", true)!;
+      const kind = str(params, "kind");
+      return ["workspace", "work", "history", item, ...(kind !== undefined ? ["--kind", kind] : []), "--json"];
+    }
+    case "workspace-points": {
+      const kind = str(params, "kind");
+      return ["workspace", "points", ...(bool(params, "open") ? ["--open"] : []), ...(kind !== undefined ? ["--kind", kind] : []), ...atArgs, "--json"];
+    }
     case "workspace-records": {
       const kind = str(params, "kind");
       const since = str(params, "since");
@@ -389,6 +483,14 @@ export function createWorkspaceTools(options: WorkspaceToolsOptions): WorkspaceT
         cwd,
       });
     },
+    "points-answer": async (params) => {
+      const { answerPoint } = await import("../../workspace/decide");
+      const answer = params.answer;
+      if (typeof answer !== "string" && typeof answer !== "boolean") throw new ToolInputError("answer must be a string, or true or false");
+      const by = params.by;
+      if (!Array.isArray(by) || by.length === 0 || !by.every((b) => typeof b === "string" && b.trim() !== "")) throw new ToolInputError("by must list each person who answered");
+      return answerPoint({ cwd, id: str(params, "id", true)!, answer, by: by as string[], kind: str(params, "kind"), dryRun: bool(params, "dryRun") });
+    },
     "records-close": async (params) => {
       const w = await write();
       const { closeRecord, RECORDS_CLOSE_SCHEMA_ID } = await import("../../workspace/records-close");

package/src/cli/plugins.ts

@@ -1,4 +1,4 @@
-import { importLexiconModule, lexiconModulePath, lexiconNames, registerLexiconDeclarations } from "../lexicon-module";
+import { importLexiconModule, importLexiconPackage, lexiconModulePath, lexiconNames, registerLexiconDeclarations, resolveFromProject } from "../lexicon-module";
 import { readLexiconDeclarationsStatically, type StaticLexiconRead } from "../config-static";
 export { unknownPathLexiconsNotice } from "../config-static";
 import { createRequire } from "node:module";
@@ -51,7 +51,7 @@ export async function loadPlugin(lexiconName: string): Promise<LexiconPlugin> {
   }
 
   const packageName = `@intentius/chant-lexicon-${lexiconName}`;
-  const mod = await import(packageName);
+  const mod = (await importLexiconPackage(packageName)) as Record<string, any>;
 
   // Look for an explicit LexiconPlugin export
   for (const value of Object.values(mod)) {
@@ -109,7 +109,15 @@ export function resolveLexiconVersions(lexiconNames: readonly string[]): Record<
     if (lexiconModulePath(name) !== undefined) continue;
     const packageName = `@intentius/chant-lexicon-${name}`;
     try {
-      let dir = dirname(require_.resolve(packageName));
+      // chant#2845 — a lexicon chant's own install can't reach is resolved from the project.
+      let entry: string | undefined;
+      try {
+        entry = require_.resolve(packageName);
+      } catch (err) {
+        entry = resolveFromProject(packageName);
+        if (entry === undefined) throw err;
+      }
+      let dir = dirname(entry);
       // Bounded walk — a resolved entry point is never deeply nested inside
       // its own package, and an unbounded loop here would climb to `/`.
       for (let depth = 0; depth < 10; depth++) {

package/src/cli/registry.ts

@@ -287,17 +287,39 @@ export interface ParsedArgs {
   kind?: string;
   /** Every `--kind` given, in order: `chant workspace graph --intent` reads each (#2651). */
   kinds?: string[];
+  /** Every `--by` given, in order: `chant workspace points answer` counts each person toward the quorum (#2739). */
+  bys?: string[];
+  /** `chant workspace points --open` (#2739): only the questions still open. */
+  open?: boolean;
+  /** `chant workspace points ask <point> --inputs <file|->` (#2739): the inputs, as a JSON object. */
+  inputs?: string;
+  /** `chant workspace points ask <point> --response <file>` (#2739): a POST /v1/systemone response the caller got from a backend. */
+  response?: string;
+  /** `chant workspace points ask <point> --subject <id>` (#2739): what the question is about. */
+  subject?: string;
+  /** `chant workspace points answer <id> --answer <value>` (#2739): the people's answer. */
+  answer?: string;
   /** `chant workspace graph --composites` (#2662): print each composite instance with the components that can deploy it. */
   composites?: boolean;
   /** `chant workspace graph --intent <path[:start-end]>` (#2651): the region the intent graph is over. */
   intent?: string;
+  /** `chant workspace check --changes <base>..<head>` (#2773): the diff the forward coverage check maps to records. */
+  changes?: string;
+  /** `chant workspace check --changes ... --severity off|warn|fail` (#2773): in place of the declaration's `changes.severity`. */
+  severity?: string;
   /** `chant workspace records --current` (#2546): leave out records a closed record supersedes. */
   current?: boolean;
   /** `chant workspace records amend <id> --set <file|->` (#2670): the JSON fields to set. */
   set?: string;
   /** `chant workspace records review <id> --verdict <v>` (#2670): agree, dissent or abstain. */
   verdict?: string;
-  /** `chant workspace records review <id> --by <principal>` (#2670): the reviewer, as the caller names them. */
+  /**
+   * `chant workspace records review <id> --by <principal>` (#2670): the
+   * reviewer, as the caller names them. Also `chant workspace records new
+   * --by <name>` (#2756): the record's proposer, or its decider when it
+   * opens straight into a later state; see {@link ChannelOptions.by} in
+   * `records-write.ts`.
+   */
   by?: string;
   /**
    * `chant workspace records review <id> --sign [<key file>]` (#2687): the key that seals the verdict, or true for git's user.signingkey.
@@ -369,6 +391,8 @@ export interface ParsedArgs {
   component?: string;
   /** `chant components release record --digest <sha256:...>` (#568) — artifact digest to record, joining this release to the build archive/ledger. Also `chant components export --digest <manifestDigest>` (#929) — a build archive manifest digest to export directly, bypassing env/component resolution. */
   digest?: string;
+  /** `chant components release record --release-plan <file>` (ws-055, #2733) — path to a release plan JSON file, persisted content-addressed to `_plans/<digest>.json` on chant/lifecycle and read back through the read contract (`chant workspace status --json`). The plan's own `digest` field supplies `--digest` when it is omitted, and must match it when both are given. Distinct from `--plan` (#2300, below), the Op gate-approval plan digest. */
+  releasePlanFile?: string;
   /** Every `--digest` value, in order (#2602). `chant components promote --digest <component>=<sha256:...>` is repeatable, one per component; the other commands read the single {@link digest}. */
   digests?: string[];
   /** `chant components release record --git-sha <sha>` (#568) — git commit the deploy was built from. */
@@ -413,6 +437,23 @@ export interface ParsedArgs {
   interval?: string;
   /** `chant operator --lease-ttl <duration>` (#1485) — how long an acquired lease is valid before it's reclaimable by another operator. Default: 5m. */
   leaseTtl?: string;
+  /**
+   * `chant operator --steward [<name>]` (#2731) — run a declared steward's
+   * local form: its scheduled Ops on their crons, under the steward's own
+   * lease. `""` when the flag is given without a name, which picks the
+   * project's only steward.
+   */
+  steward?: string;
+  /** `chant workspace work claim|renew|release <id> --holder <name>` (#2732): who holds, or releases, the work lease. */
+  holder?: string;
+  /** `chant run <op> --work <id>` (#2748): the work item an Op with a work lease runs under. `chant workspace check --changes --work <id>` (#2773): the work item in hand. */
+  work?: string;
+  /** `chant workspace work claim|renew <id> --ttl <seconds|duration>` (#2732): how long the lease lasts unless renewed. */
+  ttl?: string;
+  /** `chant workspace work renew|release <id> --token <token>` (#2732): the fencing token the caller holds. */
+  token?: string;
+  /** `chant workspace work release <id> --outcome <text>` (#2732): how the work ended, such as done or not_done. */
+  outcome?: string;
   /** `chant operator --once` (#1485) — run a single round and exit, instead of looping until Ctrl-C. Also the offline test/cron-invoker story. */
   once?: boolean;
   /** `chant approve <op> <gate> --note <text>` (#1485) — optional free-text prose recorded on the gate-resolution fact. The PR link belongs in `--url` since #2028; this is for everything that isn't the link. */

package/src/codegen/pinned-upgrade.ts

@@ -26,6 +26,7 @@ import { join } from "path";
 import { regenLexicon, type RegenResult } from "./lexicon-regen";
 import { fetchWithRetry } from "./fetch";
 import { isLexiconPlugin, type UpstreamPin } from "../lexicon";
+import { importLexiconPackage } from "../lexicon-module";
 
 // ── Public types ──────────────────────────────────────────────────────
 
@@ -200,7 +201,7 @@ export function revertVersionBump(filePath: string, original: string): void {
 export async function loadUpstreamPin(lexicon: LexiconId): Promise<UpstreamPin | null> {
   let mod: Record<string, unknown>;
   try {
-    mod = (await import(`@intentius/chant-lexicon-${lexicon}`)) as Record<string, unknown>;
+    mod = (await importLexiconPackage(`@intentius/chant-lexicon-${lexicon}`)) as Record<string, unknown>;
   } catch {
     return null;
   }