@intentius/chant 0.87.0 → 0.89.0

package/src/cli/main.ts

@@ -7,6 +7,8 @@ import { loadPlugins, resolveProjectLexicons } from "./plugins";
 import { resolveCommand, type CommandDef, type ParsedArgs } from "./registry";
 import { loadChantConfigUpward } from "../config";
 import { findProjectRoot, findWorkspaceRoot } from "../project-root";
+import { isNoLexiconDetected } from "../detectLexicon";
+import { CHANT_VERSION } from "./version";
 import { validateLexiconConfig, formatLexiconConfigProblems } from "../lexicon-config";
 import { armSandboxConfigEvaluation } from "../config-sandbox";
 import { armSandboxPolicyExecution } from "../lint/policy-import";
@@ -52,6 +54,7 @@ import type { LexiconPlugin } from "../lexicon";
  */
 const BOOLEAN_FLAGS = new Set([
   "--help",
+  "--version",
   "--agents",
   "--agent",
   "--all-projects",
@@ -167,6 +170,8 @@ export function parseArgs(args: string[]): ParsedArgs {
 
     if (arg === "--help" || arg === "-h") {
       result.help = true;
+    } else if (arg === "--version" || arg === "-V") {
+      result.version = true;
     } else if (arg === "--output" || arg === "-o") {
       result.output = args[++i];
     } else if (arg === "--format" || arg === "-f") {
@@ -389,6 +394,7 @@ export function parseArgs(args: string[]): ParsedArgs {
       if (!result.by || result.by.startsWith("-")) throw new Error("--by needs the reviewer: --by <principal>");
     } 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).
       // With no key file, git's user.signingkey, as `git commit -S` reads it.
       const next = args[i + 1];
       result.sign = next !== undefined && !next.startsWith("-") ? args[++i] : true;
@@ -757,34 +763,45 @@ Workspace (level 1, #2524):
                         --require attested exits 2 if any record is not
                         attested. A pinned file that changed is a warning,
                         asset-drift or asset-missing
-  workspace records [--kind <kind file>] --since <rev> [--at <rev>] [--json]
+  workspace records [--kind <kind file>] --since <rev|session id> [--at <rev>] [--json]
                         What changed in the records between <rev> and --at
                         (default: the working tree): new and removed records,
                         state transitions, new verdicts, new supersessions
-                        and changed pins
+                        and changed pins. A session id compares the commits
+                        the session opened and closed at
   workspace records pin <path>
                         Print the path from the workspace root and the
                         sha256 of a file, for a decision's evidence pin
-  workspace records new [<kind file>] --from <file|-> [--prefix <prefix>] [--dry-run]
+  workspace records new [<kind file>] --from <file|-> [--prefix <prefix>] [--sign [<key file>]] [--dry-run]
                         Write one new record in the kind's directory from
                         the JSON fields given, after validating them as
                         records would read them. Without a kind file, the one
                         kind the declaration names. Allocates the next id when
-                        the fields hold none. Prints {path, id} as JSON and
-                        never commits
-  workspace records amend <id> [--kind <kind file>] --set <file|-> [--dry-run]
+                        the fields hold none. --sign seals the record's author
+                        (decided_by for decisions) with an ssh key. Prints
+                        {path, id} as JSON and never commits
+  workspace records amend <id> [--kind <kind file>] --set <file|-> [--sign [<key file>]] [--dry-run]
                         Set top-level fields of one record. A closed record
                         never changes, and an approved one changes only its
                         state (upward), pins and reviews; anything else is
-                        refused with amend-supersede-instead. Prints
+                        refused with amend-supersede-instead. --sign seals
+                        the author again; without it an amendment removes
+                        the author seal and says so. Prints
                         {path, id, changed}
   workspace records review <id> [--kind <kind file>] --verdict agree|dissent|abstain --by <principal> [--note <text>] [--session <id>] [--sign [<key file>]] [--dry-run]
                         Append a review to one record, dated and bound to
                         the digest of the record text. A dissent needs
                         --note. --sign seals it with an ssh key (git's
                         user.signingkey without a file); under a signers
-                        file at base only a sealed verdict counts. Prints
+                        file at base only a sealed verdict counts. With
+                        --session, the session must be open, and the verdict
+                        is appended to its verdicts too. Prints
                         {path, id, review}
+  workspace records close <session id> [--kind <session kind file>] [--dry-run]
+                        Close an open review session: its state, close time,
+                        closing commit and seal, in one write. Without
+                        --kind, the one session kind the declaration names.
+                        Prints {path, id, changed, seal, closedRev}
   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
@@ -959,6 +976,7 @@ Options:
                         resolved build parameter and per-file fold decision
                         instead of the one-line summaries
   -h, --help            Show this help message
+  -V, --version         Print the installed chant's version
   --on <lexicon>        Which runtime hosts the run: a configured lexicon with
                         an opRuntime, or the built-in local runtime when
                         omitted (every run subcommand; #2121)
@@ -1171,6 +1189,28 @@ async function loadPluginsOrExit(path: string): Promise<import("../lexicon").Lex
   return plugins;
 }
 
+/**
+ * #2700 — whether `path` is the root of a declared workspace and holds no
+ * lexicon of its own: no `lexicons` in a root config, and no lexicon import in
+ * the root's source, which leaves the members' directories out (#2527). A
+ * generated chud repo is this shape: its lexicons are all in `delivery/`.
+ * `chant serve mcp` starts there instead of refusing with "No lexicon
+ * detected", and serves core with the chant members' lexicons.
+ *
+ * A directory with no workspace declaration costs only `findWorkspaceRoot`'s
+ * existence checks, so a level-0 project reaches `loadPluginsOrExit` as before.
+ */
+async function isLexiconlessWorkspaceRoot(path: string): Promise<boolean> {
+  const target = resolve(path);
+  if (findWorkspaceRoot(target)?.dir !== target) return false;
+  try {
+    await resolveProjectLexicons(target);
+    return false;
+  } catch (error) {
+    return isNoLexiconDetected(error);
+  }
+}
+
 /** Whether `def` must run without evaluating the project's `chant.config.ts` (chant#2591). */
 function commandRunsNoConfig(def: CommandDef, args: ParsedArgs): boolean {
   return typeof def.runsNoConfig === "function" ? def.runsNoConfig(args) : def.runsNoConfig === true;
@@ -1376,6 +1416,15 @@ async function main(): Promise<void> {
     throw err;
   }
 
+  // #2701 — `chant --version` / `-V` prints the installed chant's version, the
+  // one the MCP server reports (./version.ts). With a command word it answers
+  // only for one of core's own commands; a lexicon-mounted verb keeps the flag.
+  if (args.version && (!args.command || resolveCommand(args, commandRegistry))) {
+    console.log(CHANT_VERSION);
+    await flushAndExit(0);
+    return;
+  }
+
   if (args.help || !args.command) {
     const groups = await loadPluginsBestEffort().then(collectCommandGroups).catch(() => []);
     printHelp(groups);
@@ -1503,7 +1552,9 @@ async function main(): Promise<void> {
   const plugins = match.def.requiresPlugins
     ? isGenerateComponents || isComponentsStatus || isEmulator || isFanOutFromFile
       ? await loadPlugins(await resolveProjectLexicons(resolve(projectPath)).catch(() => [])).catch(() => [])
-      : await loadPluginsOrExit(projectPath)
+      : match.def.name === "serve mcp" && (await isLexiconlessWorkspaceRoot(projectPath))
+        ? [] // #2700 — runServeMcp loads the chant members' lexicons itself.
+        : await loadPluginsOrExit(projectPath)
     : [];
   const serializers = plugins.map((p) => p.serializer);
   const ctx = { args, plugins, serializers };

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

@@ -1,11 +1,15 @@
 import { describe, test, expect, beforeEach, afterEach } from "vitest";
 import { McpServer } from "./server";
+import { readFileSync } from "node:fs";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import type { LexiconPlugin } from "../../lexicon";
 import type { Serializer } from "../../serializer";
 
+/** The version in `packages/core/package.json`, read here apart from the code under test. */
+const CORE_VERSION: string = JSON.parse(readFileSync(join(import.meta.dirname, "..", "..", "..", "package.json"), "utf-8")).version;
+
 function createMockPlugin(overrides?: Partial<LexiconPlugin>): LexiconPlugin {
   return {
     name: "mock",
@@ -51,7 +55,16 @@ describe("McpServer", () => {
       expect(result.protocolVersion).toBe("2026-07-28");
       expect(result.capabilities).toBeDefined();
       expect((result.serverInfo as Record<string, unknown>).name).toBe("chant");
-      expect((result.serverInfo as Record<string, unknown>).version).toBe("0.1.0");
+      expect((result.serverInfo as Record<string, unknown>).version).toBe(CORE_VERSION);
+    });
+
+    test("server info names the installed chant's version, from core's package.json (#2689)", async () => {
+      expect(CORE_VERSION).toMatch(/^\d+\.\d+\.\d+/);
+      expect(CORE_VERSION).not.toBe("0.1.0");
+      for (const params of [{}, { protocolVersion: "2024-11-05" }]) {
+        const response = await server.handleRequest({ jsonrpc: "2.0", id: 1, method: "initialize", params });
+        expect(((response.result as Record<string, unknown>).serverInfo as Record<string, unknown>).version).toBe(CORE_VERSION);
+      }
     });
 
     test("capabilities include tools and resources", async () => {

package/src/cli/mcp/server.ts

@@ -13,6 +13,7 @@ import { createSnapshotTool, createDiffTool } from "./lifecycle-tools";
 import { setGateOrigin } from "../../lifecycle/gate-origin";
 import { createOpListTool, createOpRunTool, createOpStatusTool, createOpApproveTool, createOpReportTool } from "./op-tools";
 import { buildResourcesList, handleResourcesRead } from "./resource-handlers";
+import { CHANT_VERSION } from "../version";
 
 /**
  * Protocol versions this server understands, newest first. `initialize` and
@@ -92,9 +93,17 @@ export class McpServer {
   private toolHandlers: Map<string, ToolHandler> = new Map();
   private pluginResources: Map<string, { definition: ResourceDefinition; handler: () => Promise<string> }> = new Map();
   private plugins: LexiconPlugin[];
+  private instructions: string | undefined;
 
-  constructor(plugins?: LexiconPlugin[]) {
+  /**
+   * `options.instructions` is sent as the `initialize` result's
+   * `instructions`, the text a client may give its model about this server.
+   * Only a workspace root with no lexicon of its own sets it (#2700), to say
+   * which members' lexicons were loaded.
+   */
+  constructor(plugins?: LexiconPlugin[], options: { instructions?: string } = {}) {
     this.plugins = plugins ?? [];
+    this.instructions = options.instructions;
     // Register core tools
     this.registerTool(buildTool, handleBuild);
     this.registerTool(lintTool, handleLint);
@@ -223,7 +232,9 @@ export class McpServer {
     return {
       protocolVersion: negotiateProtocolVersion(protocolVersion),
       capabilities: { tools: {}, resources: {} },
-      serverInfo: { name: "chant", version: "0.1.0" },
+      // The installed chant's version, so a client can tell which chant it talks to (#2689).
+      serverInfo: { name: "chant", version: CHANT_VERSION },
+      ...(this.instructions ? { instructions: this.instructions } : {}),
     };
   }
 

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

@@ -0,0 +1,123 @@
+/**
+ * #2700 — the lexicons `chant serve mcp` loads at the root of a declared
+ * workspace that has no lexicon of its own.
+ *
+ * Such a root (a generated chud repo, say, whose lexicons are all in
+ * `delivery/`) used to refuse with "No lexicon detected", so an agent started
+ * there got none of chant's tools. The server now starts with core's tools and
+ * resources, and with the lexicons of the workspace's members of kind chant,
+ * each read from that member's own config the way `chant build` in the
+ * member's directory reads it.
+ *
+ * Loading is best effort, one member and one lexicon at a time: a member whose
+ * config does not load, or a lexicon this chant cannot import, is left out and
+ * named in the server's `instructions`, and the rest are served. Nothing here
+ * fails the server; with nothing loaded it serves core alone and says so.
+ */
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import type { LexiconPlugin } from "../../lexicon";
+
+/** One member of kind chant, and what came of reading its lexicons. */
+export interface MemberLexicons {
+  member: string;
+  dir: string;
+  /** The lexicon names its config declares or its source imports, or null when they could not be read. */
+  lexicons: string[] | null;
+  /** Why they could not be read. */
+  error?: string;
+}
+
+export interface WorkspacePlugins {
+  plugins: LexiconPlugin[];
+  members: MemberLexicons[];
+  /** Lexicons named by a member that did not load, with the reason. */
+  failed: { lexicon: string; error: string }[];
+  /** The text the MCP server gives as its `instructions`. */
+  instructions: string;
+}
+
+function message(error: unknown): string {
+  const text = error instanceof Error ? error.message : String(error);
+  return text.split("\n")[0];
+}
+
+/** Load the lexicons of the chant members of the workspace declared at `root`. */
+export async function loadWorkspacePlugins(root: string): Promise<WorkspacePlugins> {
+  const [{ readDeclaration }, { workingTree }, { resolveProjectLexicons, loadPlugins }] = await Promise.all([
+    import("../../workspace/declaration"),
+    import("../../workspace/tree"),
+    import("../plugins"),
+  ]);
+
+  const members: MemberLexicons[] = [];
+  let workspaceName: string | undefined;
+  let declarationError: string | undefined;
+  try {
+    const declaration = readDeclaration(workingTree(root));
+    workspaceName = declaration.name;
+    for (const m of declaration.members) {
+      // The root member is the directory this server already found no lexicon in.
+      if (m.kind !== "chant" || m.dir === ".") continue;
+      const abs = join(root, m.dir);
+      if (!existsSync(abs)) {
+        members.push({ member: m.name, dir: m.dir, lexicons: null, error: "its directory does not exist" });
+        continue;
+      }
+      try {
+        members.push({ member: m.name, dir: m.dir, lexicons: await resolveProjectLexicons(abs) });
+      } catch (error) {
+        members.push({ member: m.name, dir: m.dir, lexicons: null, error: message(error) });
+      }
+    }
+  } catch (error) {
+    declarationError = message(error);
+  }
+
+  const plugins: LexiconPlugin[] = [];
+  const failed: { lexicon: string; error: string }[] = [];
+  const seen = new Set<string>();
+  for (const m of members) {
+    for (const name of m.lexicons ?? []) {
+      if (seen.has(name)) continue;
+      seen.add(name);
+      try {
+        plugins.push(...(await loadPlugins([name])));
+      } catch (error) {
+        failed.push({ lexicon: name, error: message(error) });
+      }
+    }
+  }
+
+  return { plugins, members, failed, instructions: describe(workspaceName, members, plugins, failed, declarationError) };
+}
+
+function describe(
+  name: string | undefined,
+  members: MemberLexicons[],
+  plugins: LexiconPlugin[],
+  failed: { lexicon: string; error: string }[],
+  declarationError: string | undefined,
+): string {
+  const lines: string[] = [];
+  lines.push(
+    `This chant MCP server runs at the root of the workspace ${name ? `"${name}" ` : ""}(chant.workspace.json), which has no lexicon of its own. ` +
+      "Core tools and resources are served as in any project. The tools that take a path (build, lint, explain) work on a project directory, so pass a member's directory.",
+  );
+  if (declarationError) lines.push(`The workspace declaration could not be read: ${declarationError}.`);
+  for (const m of members) {
+    lines.push(
+      m.lexicons
+        ? `Member ${m.member} (${m.dir}/) declares ${m.lexicons.length ? m.lexicons.join(", ") : "no lexicon"}.`
+        : `Member ${m.member} (${m.dir}/) was not read: ${m.error}.`,
+    );
+  }
+  for (const f of failed) lines.push(`Lexicon ${f.lexicon} did not load: ${f.error}.`);
+  lines.push(
+    plugins.length > 0
+      ? `Lexicon tools and resources served: ${plugins.map((p) => p.name).join(", ")}.`
+      : "No member lexicon loaded, so only chant's core tools and resources are served.",
+  );
+  return lines.join("\n");
+}

package/src/cli/registry.ts

@@ -18,6 +18,8 @@ export interface ParsedArgs {
   watch: boolean;
   verbose: boolean;
   help: boolean;
+  /** `--version` / `-V` (#2701): print the installed chant's version. */
+  version?: boolean;
   report?: boolean;
   /** `chant run` — force the local in-process executor (the default). */
   local?: boolean;
@@ -297,7 +299,10 @@ export interface ParsedArgs {
   verdict?: string;
   /** `chant workspace records review <id> --by <principal>` (#2670): the reviewer, as the caller names them. */
   by?: string;
-  /** `chant workspace records review <id> --sign [<key file>]` (#2687): the key that seals the verdict, or true for git's user.signingkey. */
+  /**
+   * `chant workspace records review <id> --sign [<key file>]` (#2687): the key that seals the verdict, or true for git's user.signingkey.
+   * On `records new` and `records amend`, the key that seals the record's author (#2688).
+   */
   sign?: string | true;
   /** `chant workspace records review <id> --session <id>` (#2670): the review session the verdict was given in. */
   session?: string;

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

@@ -0,0 +1,142 @@
+import { describe, test, expect, beforeAll, afterAll } from "vitest";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { pathToFileURL } from "node:url";
+
+/**
+ * #2700 — `chant serve mcp` at a workspace root whose lexicons all live in
+ * members starts, with core's tools and the chant members' lexicons, instead
+ * of refusing with "No lexicon detected". A project with no workspace and no
+ * lexicon still refuses.
+ *
+ * #2701 — `chant --version` and `-V` print the installed version.
+ */
+
+const repoRoot = resolve(import.meta.dirname, "../../../..");
+const mainTs = join(repoRoot, "packages/core/src/cli/main.ts");
+const tsxLoader = pathToFileURL(join(repoRoot, "node_modules/tsx/dist/loader.mjs")).href;
+const TIMEOUT = 90_000;
+
+function chant(cwd: string, args: string[], input?: string) {
+  return spawnSync(process.execPath, ["--import", tsxLoader, mainTs, ...args], {
+    cwd,
+    input,
+    encoding: "utf-8",
+    timeout: 60_000,
+    env: { ...process.env, NO_COLOR: "1" },
+  });
+}
+
+interface InitializeResult {
+  serverInfo: { name: string; version: string };
+  instructions?: string;
+}
+
+/** Send initialize and tools/list over stdio; stdin closing ends the server. */
+function initializeAndList(cwd: string): { status: number | null; stderr: string; init: InitializeResult; tools: string[] } {
+  const input = [
+    { jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2024-11-05", clientInfo: { name: "test" } } },
+    { jsonrpc: "2.0", method: "notifications/initialized" },
+    { jsonrpc: "2.0", id: 2, method: "tools/list", params: {} },
+  ].map((m) => JSON.stringify(m)).join("\n") + "\n";
+  const run = chant(cwd, ["serve", "mcp"], input);
+  const responses = run.stdout.trim().split("\n").filter(Boolean).map((l) => JSON.parse(l));
+  const byId = (id: number) => responses.find((r) => r.id === id);
+  return {
+    status: run.status,
+    stderr: run.stderr,
+    init: byId(1)?.result,
+    tools: (byId(2)?.result?.tools ?? []).map((t: { name: string }) => t.name),
+  };
+}
+
+const CORE_TOOLS = ["composites", "search", "build", "lint", "explain", "op-list", "op-run", "op-status", "op-approve", "op-report"];
+
+describe("chant serve mcp at a workspace root with no lexicon of its own (#2700)", () => {
+  let scratch: string;
+
+  beforeAll(() => {
+    scratch = realpathSync(mkdtempSync(join(tmpdir(), "chant-serve-mcp-ws-")));
+  });
+  afterAll(() => {
+    rmSync(scratch, { recursive: true, force: true });
+  });
+
+  test("the reference workspace root answers initialize and lists core tools with the delivery member's lexicon", () => {
+    const { status, stderr, init, tools } = initializeAndList(join(repoRoot, "reference-workspace"));
+    expect(status, stderr).toBe(0);
+    expect(init.serverInfo.name).toBe("chant");
+    for (const name of CORE_TOOLS) expect(tools).toContain(name);
+    expect(tools).toContain("docker:diff");
+    expect(init.instructions).toContain("Member delivery (delivery/) declares docker.");
+  }, TIMEOUT);
+
+  test("a chud-shaped root, lexicons only in a member, serves core and the lexicons that load", () => {
+    const root = join(scratch, "chud-shaped");
+    mkdirSync(join(root, ".git"), { recursive: true });
+    mkdirSync(join(root, "delivery"), { recursive: true });
+    mkdirSync(join(root, "app"), { recursive: true });
+    writeFileSync(join(root, "chant.workspace.json"), JSON.stringify({
+      name: "t",
+      schema: 1,
+      members: [
+        { name: "app", dir: "app", kind: "other", because: "an app" },
+        { name: "delivery", dir: "delivery", kind: "chant" },
+      ],
+      pins: [],
+    }));
+    // `chud` is not installed here, as it would not be for a chant without
+    // @intentius/chud: it is named as not loaded and the rest is served.
+    writeFileSync(join(root, "delivery", "chant.config.ts"), 'export default { lexicons: ["docker", "chud"] };\n');
+    writeFileSync(join(root, "app", "server.js"), "// not chant\n");
+
+    const { status, stderr, init, tools } = initializeAndList(root);
+    expect(status, stderr).toBe(0);
+    for (const name of CORE_TOOLS) expect(tools).toContain(name);
+    expect(tools).toContain("docker:diff");
+    expect(init.instructions).toContain('workspace "t"');
+    expect(init.instructions).toContain("Lexicon chud did not load");
+    expect(init.instructions).toContain("Lexicon tools and resources served: docker.");
+  }, TIMEOUT);
+
+  test("a workspace root whose members' lexicons all fail to load serves core alone and says so", () => {
+    const root = join(scratch, "core-only");
+    mkdirSync(join(root, ".git"), { recursive: true });
+    mkdirSync(join(root, "delivery"), { recursive: true });
+    writeFileSync(join(root, "chant.workspace.json"), JSON.stringify({
+      name: "core-only",
+      schema: 1,
+      members: [{ name: "delivery", dir: "delivery", kind: "chant" }],
+      pins: [],
+    }));
+    writeFileSync(join(root, "delivery", "chant.config.ts"), 'export default { lexicons: ["no-such-lexicon"] };\n');
+
+    const { status, stderr, init, tools } = initializeAndList(root);
+    expect(status, stderr).toBe(0);
+    for (const name of CORE_TOOLS) expect(tools).toContain(name);
+    expect(tools.filter((t) => t.includes(":"))).toEqual([]);
+    expect(init.instructions).toContain("only chant's core tools and resources are served");
+  }, TIMEOUT);
+
+  test("a project with no workspace and no lexicon still refuses", () => {
+    const root = join(scratch, "plain");
+    mkdirSync(join(root, ".git"), { recursive: true });
+    writeFileSync(join(root, "index.ts"), "export const x = 1;\n");
+    const run = chant(root, ["serve", "mcp"], "");
+    expect(run.status).toBe(1);
+    expect(run.stderr).toContain("No lexicon detected");
+    expect(run.stdout).toBe("");
+  }, TIMEOUT);
+});
+
+describe("chant --version (#2701)", () => {
+  const version = (JSON.parse(readFileSync(join(repoRoot, "packages/core/package.json"), "utf-8")) as { version: string }).version;
+
+  test.each([["--version"], ["-V"]])("%s prints the package version and exits 0", (flag) => {
+    const run = chant(repoRoot, [flag]);
+    expect(run.status, run.stderr).toBe(0);
+    expect(run.stdout.trim()).toBe(version);
+  }, TIMEOUT);
+});

package/src/cli/version.ts

@@ -0,0 +1,15 @@
+import { createRequire } from "node:module";
+
+/**
+ * The installed chant's version, read from `@intentius/chant`'s own
+ * package.json, or "0.0.0" when it can't be read. The path is the same from
+ * `src/cli/` and `dist/cli/`, so it holds whether chant runs from source or
+ * from its build.
+ */
+export const CHANT_VERSION: string = (() => {
+  try {
+    return (createRequire(import.meta.url)("../../package.json") as { version?: string }).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+})();

package/src/workspace/__fixtures__/sessions.ts

@@ -64,3 +64,44 @@ export function reviewed(root: string, reviewers: string[], session: string, sta
       .replace(/^reviews: .*$/m, reviewers.length ? `reviews:\n${reviews}` : "reviews: []"),
   );
 }
+
+/**
+ * Declare the fixture's two kinds in a chant.workspace.json (#2693): the
+ * decisions at the root and the session kind in the design member, as the
+ * reference workspace declares them, so review --session, close and
+ * --since <session id> find the session kind.
+ */
+export function declareSessions(root: string): void {
+  writeFileSync(
+    join(root, "chant.workspace.json"),
+    `${JSON.stringify(
+      {
+        name: "sessions",
+        schema: 1,
+        members: [{ name: "design", dir: "design", kind: "other", because: "the session fixture", records: [{ kind: "sessions/session.kind.mjs" }] }],
+        records: [{ kind: DECISIONS_KIND }],
+        pins: [],
+      },
+      null,
+      2,
+    )}\n`,
+  );
+}
+
+/** The fields of a new open session, as a UI sends them to records new. */
+export function newSessionFields(over: Record<string, unknown> = {}): string {
+  return JSON.stringify({
+    schema: 1,
+    title: "Second walk",
+    state: "open",
+    agenda: [{ record: "ref-001" }, { record: "ref-002" }],
+    attendance: [
+      { principal: "lex00", class: "person" },
+      { principal: "alice", class: "person" },
+    ],
+    opened: "2026-09-25T09:00:00Z",
+    closed: null,
+    verdicts: [],
+    ...over,
+  });
+}