@intentius/chant 0.101.0 → 0.104.0

package/src/lifecycle/work-lease.test.ts

@@ -107,7 +107,7 @@ describe("a work lease in one clone", () => {
 
     const again = await claimWorkLease("W-003", "carol", { cwd, ttlMs: 1_000, now: at(t0) });
     if (!again.ok) throw new Error(again.message);
-    const closed = await releaseWorkLease("W-003", "dispatcher", { cwd, outcome: "expired", now: at("2026-09-25T11:00:00.000Z") });
+    const closed = await releaseWorkLease("W-003", "dispatcher", { cwd, outcome: "abandoned", now: at("2026-09-25T11:00:00.000Z") });
     expect(closed).toMatchObject({ ok: true, lease: { holder: "carol" } });
   });
 

package/src/lifecycle/work-lease.ts

@@ -100,6 +100,93 @@ export interface WorkLeaseState extends WorkLease {
   ref: string;
 }
 
+/**
+ * How a work lease can end (#3147): the closed list of outcomes a release
+ * records. A new outcome is a contract change. Readers of an older history
+ * may still find free text from before the list was closed, which counts as
+ * an attempt (see {@link outcomeCountsAsAttempt}).
+ */
+export const WORK_LEASE_OUTCOMES = [
+  /** The work was finished: built, checked and recorded. */
+  "done",
+  /** A build ran and did not finish, or the run failed. Counts as an attempt. */
+  "not_done",
+  /** An expired lease closed out by someone other than its holder: the worker went away. Counts as an attempt. */
+  "abandoned",
+  /** The run stopped at a gate, waiting for an approval. */
+  "gated",
+  /** The run stopped on a decision point's open question, waiting for a person. */
+  "waiting",
+  /** The item was dropped, such as by a refuse at the understand point. Nothing was built. */
+  "dropped",
+  /** The understand point answered redraft: the item goes back to its author. Nothing was built. */
+  "redraft",
+  /** The understand point answered ask: the item waits on a question to its author. Nothing was built. */
+  "ask",
+] as const;
+export type WorkLeaseOutcome = (typeof WORK_LEASE_OUTCOMES)[number];
+
+/** The outcomes that count toward an item's attempt limit. */
+export const ATTEMPT_OUTCOMES: readonly WorkLeaseOutcome[] = ["not_done", "abandoned"];
+
+/** Whether `value` is one of {@link WORK_LEASE_OUTCOMES}. */
+export function isWorkLeaseOutcome(value: unknown): value is WorkLeaseOutcome {
+  return typeof value === "string" && (WORK_LEASE_OUTCOMES as readonly string[]).includes(value);
+}
+
+/**
+ * Whether a release with `outcome` counts toward the item's attempt limit:
+ * `not_done` and `abandoned` do, and so does a release that gave no outcome
+ * or one outside the closed list (free text written before #3147), since
+ * nothing says the work got anywhere.
+ */
+export function outcomeCountsAsAttempt(outcome: string | null | undefined): boolean {
+  if (!isWorkLeaseOutcome(outcome)) return true;
+  return ATTEMPT_OUTCOMES.includes(outcome);
+}
+
+/** The ref prefix that keeps an unfinished attempt's work (#3147). */
+export const KEPT_REF_PREFIX = "refs/chant/kept/";
+
+/**
+ * Where the work of an attempt that ended `not_done` is kept: one ref per
+ * lease token, `refs/chant/kept/[<member>/...]<item>/<token>`, scoped by the
+ * members the way the work branch `chant/work/[<member>/]<item>` is.
+ */
+export function keptAttemptRef(id: string, token: string, members: readonly string[] = []): string {
+  return `${keptAttemptPrefix(id, members)}${token}`;
+}
+
+/** The prefix under which every kept attempt of item `id` sits. */
+export function keptAttemptPrefix(id: string, members: readonly string[] = []): string {
+  return `${KEPT_REF_PREFIX}${members.length ? `${members.join("/")}/` : ""}${id}/`;
+}
+
+/** One kept attempt, as `work history` lists it. */
+export interface KeptAttempt {
+  /** The lease token the attempt ran under. */
+  token: string;
+  ref: string;
+  /** The commit the ref points at. */
+  commit: string;
+}
+
+/** Every kept attempt of item `id`, from the local refs, sorted by ref. Empty outside git. */
+export async function listKeptAttempts(id: string, opts: { cwd: string; members?: readonly string[] }): Promise<KeptAttempt[]> {
+  const prefix = keptAttemptPrefix(id, opts.members ?? []);
+  const out = await getRuntime().spawn(["git", "for-each-ref", "--format=%(refname) %(objectname)", prefix], { cwd: opts.cwd });
+  if (out.exitCode !== 0) return [];
+  return out.stdout
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      const [ref, commit] = line.split(" ");
+      return { token: ref.slice(prefix.length), ref, commit };
+    })
+    .filter((k) => k.token !== "" && !k.token.includes("/"))
+    .sort((a, b) => (a.ref < b.ref ? -1 : a.ref > b.ref ? 1 : 0));
+}
+
 /** One line of `_leases/<id>.jsonl`. */
 export interface LeaseHistoryRecord {
   version: 1;
@@ -115,7 +202,7 @@ export interface LeaseHistoryRecord {
   expiresAt: string;
   /** When the event happened. */
   timestamp: string;
-  /** How the work ended, on a release. Free text such as done, not_done or skipped. */
+  /** How the work ended, on a release: one of {@link WORK_LEASE_OUTCOMES}, or free text in a line written before #3147. */
   outcome?: string;
   note?: string;
 }
@@ -257,7 +344,8 @@ async function finish(
 /**
  * Give the lease on `id` back. The holder releases a live lease (with
  * `token`, only that one); anyone may release an expired one, which is how an
- * abandoned claim is closed out. `outcome` says how the work ended. Refused
+ * abandoned claim is closed out. `outcome` says how the work ended, from the
+ * closed list {@link WORK_LEASE_OUTCOMES}; any other value throws. Refused
  * with `lease-not-held` when there is no lease, and `lease-held` when someone
  * else holds it live.
  */
@@ -267,6 +355,9 @@ export async function releaseWorkLease(
   opts: WorkLeaseOptions & { token?: string; outcome?: string; note?: string },
 ): Promise<WorkLeaseResult> {
   checkId(id);
+  if (opts.outcome !== undefined && !isWorkLeaseOutcome(opts.outcome)) {
+    throw new Error(`${JSON.stringify(opts.outcome)} is not a work lease outcome: use one of ${WORK_LEASE_OUTCOMES.join(", ")}`);
+  }
   const key = workLeaseKey(id);
   const now = opts.now?.() ?? new Date();
   const { record } = await readLease(key, { cwd: opts.cwd });

package/src/lint/engine.test.ts

@@ -6,6 +6,61 @@ import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
 describe("runLint", () => {
+  // #2511
+  test("a rule that throws is an error for that file, and the other rules still run", async () => {
+    await withTestDir(async (testDir) => {
+      const testFile = join(testDir, "test.ts");
+      await writeFile(testFile, "const x = 1;");
+
+      const throwing: LintRule = {
+        id: "throws",
+        severity: "warning",
+        category: "correctness",
+        check: () => {
+          throw new Error("bad input");
+        },
+      };
+      const after: LintRule = {
+        id: "after",
+        severity: "warning",
+        category: "correctness",
+        check: (context: LintContext): LintDiagnostic[] => [
+          { file: context.filePath, line: 1, column: 1, ruleId: "after", severity: "warning", message: "ran" },
+        ],
+      };
+
+      const { diagnostics } = await runLint([testFile], [throwing, after]);
+
+      expect(diagnostics.map((d) => d.ruleId).sort()).toEqual(["after", "throws"]);
+      const threw = diagnostics.find((d) => d.ruleId === "throws")!;
+      expect(threw.severity).toBe("error");
+      expect(threw.file).toBe(testFile);
+      expect(threw.message).toBe(`Rule throws threw while checking ${testFile}: bad input`);
+    });
+  });
+
+  test("a disable comment does not suppress a rule's failure", async () => {
+    await withTestDir(async (testDir) => {
+      const testFile = join(testDir, "test.ts");
+      await writeFile(testFile, "// chant-disable\nconst x = 1;");
+
+      const throwing: LintRule = {
+        id: "throws",
+        severity: "warning",
+        category: "correctness",
+        check: () => {
+          throw "not an Error";
+        },
+      };
+
+      const { diagnostics, suppressed } = await runLint([testFile], [throwing]);
+
+      expect(suppressed).toHaveLength(0);
+      expect(diagnostics).toHaveLength(1);
+      expect(diagnostics[0].message).toContain("not an Error");
+    });
+  });
+
   test("executes rules and returns diagnostics", async () => {
     await withTestDir(async (testDir) => {
       const testFile = join(testDir, "test.ts");

package/src/lint/engine.ts

@@ -189,6 +189,23 @@ function isDiagnosticDisabled(
   return { suppressed: false };
 }
 
+/**
+ * The error reported when a rule throws while checking a file (#2511). It
+ * names the rule, the file and the thrown message, at error severity so
+ * `chant lint` exits non-zero.
+ */
+export function ruleThrewDiagnostic(ruleId: string, filePath: string, error: unknown): LintDiagnostic {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    file: filePath,
+    line: 1,
+    column: 1,
+    ruleId,
+    severity: "error",
+    message: `Rule ${ruleId} threw while checking ${filePath}: ${message}`,
+  };
+}
+
 /**
  * Execute lint rules on a set of files
  * @param files - Array of file paths to lint
@@ -246,11 +263,17 @@ export async function runLint(
         propertyClasses,
       };
 
-      // Execute each rule
+      // Execute each rule. A rule that throws is reported as an error for
+      // this file (#2511) and the remaining rules still run.
+      const ruleErrors: LintDiagnostic[] = [];
       for (const rule of rules) {
         const options = ruleOptions?.get(rule.id);
-        const diagnostics = rule.check(context, options);
-        allDiagnostics.push(...diagnostics);
+        try {
+          const diagnostics = rule.check(context, options);
+          allDiagnostics.push(...diagnostics);
+        } catch (error) {
+          ruleErrors.push(ruleThrewDiagnostic(rule.id, filePath, error));
+        }
       }
 
       // Partition file diagnostics into active and suppressed
@@ -269,7 +292,10 @@ export async function runLint(
 
       // Replace file diagnostics with filtered ones
       allDiagnostics.length = 0;
-      allDiagnostics.push(...otherFileDiags, ...keptDiags);
+      // A rule's own failure is never suppressed by a disable comment: the
+      // comment is aimed at the rule's findings, and hiding the failure would
+      // make a rule that did not run look like a clean lint.
+      allDiagnostics.push(...otherFileDiags, ...keptDiags, ...ruleErrors);
     } catch (error) {
       // If parsing fails, skip this file and continue with others
       continue;

package/src/lint/output-docs.test.ts

@@ -1,6 +1,7 @@
 import { describe, test, expect } from "vitest";
 import { parseOutputDocs, pick, get } from "./output-docs";
 import type { SerializerResult } from "../serializer";
+import { load as jsYamlLoad } from "js-yaml";
 
 describe("parseOutputDocs", () => {
   test("parses a single JSON output as one document", () => {
@@ -156,65 +157,67 @@ describe("parseOutputDocs", () => {
       expect(bad.value).toBeUndefined();
     });
   });
-});
-
-describe("pick", () => {
-  interface Widget {
-    kind: string;
-    name: string;
-    extra: unknown;
-  }
-
-  test("returns only the named keys that are present", () => {
-    const value = { kind: "Deployment", name: "web", other: "ignored" };
-    expect(pick<Widget>(value, ["kind", "name"])).toEqual({ kind: "Deployment", name: "web" });
-  });
-
-  test("omits a named key that is absent — no invented default", () => {
-    const value = { kind: "Deployment" };
-    expect(pick<Widget>(value, ["kind", "name"])).toEqual({ kind: "Deployment" });
-  });
-
-  test("returns an empty object for a non-object value", () => {
-    expect(pick<Widget>(null, ["kind"])).toEqual({});
-    expect(pick<Widget>("a string", ["kind"])).toEqual({});
-    expect(pick<Widget>(undefined, ["kind"])).toEqual({});
-  });
-
-  test("copies values through unvalidated, whatever their actual shape", () => {
-    const value = { kind: 42 }; // wrong runtime type for `kind: string`
-    expect(pick<Widget>(value, ["kind"])).toEqual({ kind: 42 });
-  });
-});
-
-describe("get", () => {
-  test("walks a dotted path through nested objects", () => {
-    const value = { spec: { template: { spec: { containers: [] } } } };
-    expect(get(value, "spec.template.spec")).toEqual({ containers: [] });
-  });
-
-  test("returns undefined as soon as a segment is missing", () => {
-    const value = { spec: {} };
-    expect(get(value, "spec.template.spec")).toBeUndefined();
-  });
 
-  test("returns undefined when an intermediate value is not indexable", () => {
-    const value = { spec: "not-an-object" };
-    expect(get(value, "spec.template")).toBeUndefined();
-  });
+  // #2925: hand-written and third-party YAML (`chant audit`, test fixtures)
+  // uses flow collections and folded scalars. Each case is checked against
+  // js-yaml, so the expected value is what a full parser reads.
+  describe("YAML a hand-written manifest uses (#2925)", () => {
+    const docOf = (yaml: string): unknown => {
+      const docs = parseOutputDocs(new Map<string, string | SerializerResult>([["k8s", yaml]]));
+      expect(docs).toHaveLength(1);
+      expect(docs[0].error).toBeUndefined();
+      return docs[0].value;
+    };
 
-  test("indexes into arrays with a numeric path segment", () => {
-    const value = { items: [{ name: "first" }, { name: "second" }] };
-    expect(get(value, "items.1.name")).toBe("second");
-  });
+    test("flow mappings read as mappings, not strings", () => {
+      const yaml = [
+        "apiVersion: apps/v1",
+        "kind: Deployment",
+        "metadata: { name: gw, namespace: obs }",
+        "spec:",
+        "  template:",
+        "    spec:",
+        "      volumes:",
+        "        - name: conf",
+        "          configMap: { name: gw-config }",
+      ].join("\n");
+      const value = docOf(yaml);
+      expect(value).toEqual(jsYamlLoad(yaml));
+      expect(get(value, "metadata.namespace")).toBe("obs");
+      expect(get(value, "spec.template.spec.volumes.0.configMap.name")).toBe("gw-config");
+    });
 
-  test("returns the value itself for an empty path", () => {
-    const value = { a: 1 };
-    expect(get(value, "")).toBe(value);
-  });
+    test("a flow sequence of flow mappings reads as a list of mappings", () => {
+      const yaml = [
+        "kind: Pod",
+        "spec:",
+        "  containers:",
+        "    - name: gw",
+        "      volumeMounts: [{ name: conf, mountPath: /conf }, { name: data, mountPath: /data, readOnly: true }]",
+        "      args: [--config, /conf/config.yaml]",
+      ].join("\n");
+      const value = docOf(yaml);
+      expect(value).toEqual(jsYamlLoad(yaml));
+      expect(get(value, "spec.containers.0.volumeMounts.1.readOnly")).toBe(true);
+      expect(get(value, "spec.containers.0.args")).toEqual(["--config", "/conf/config.yaml"]);
+    });
 
-  test("does not throw on null/undefined input", () => {
-    expect(get(null, "a.b")).toBeUndefined();
-    expect(get(undefined, "a.b")).toBeUndefined();
+    test("a folded scalar keeps the line breaks of its more-indented lines", () => {
+      // js-yaml dumps a long ConfigMap value this way.
+      const yaml = [
+        "kind: ConfigMap",
+        "data:",
+        "  config.yaml: >",
+        "    receivers:",
+        "      k8s_cluster:",
+        "        auth_type: serviceAccount",
+        "    exporters: {}",
+      ].join("\n");
+      const value = docOf(yaml);
+      expect(value).toEqual(jsYamlLoad(yaml));
+      expect((value as { data: Record<string, string> }).data["config.yaml"]).toBe(
+        "receivers:\n  k8s_cluster:\n    auth_type: serviceAccount\nexporters: {}\n",
+      );
+    });
   });
 });

package/src/lint/post-synth.test.ts

@@ -162,6 +162,25 @@ describe("cross-lexicon activity contracts (#2101)", () => {
   });
 });
 
+describe("telemetry attribution (#3375)", () => {
+  const readsTelemetry: PostSynthCheck = {
+    id: "TELEMETRY",
+    description: "reports the attribution the context carries",
+    check(ctx) {
+      return [{ checkId: "TELEMETRY", severity: "warning", message: JSON.stringify(ctx.telemetry ?? null) }];
+    },
+  };
+
+  test("the build's attribution is threaded into the context", () => {
+    const diags = runPostSynthChecks([readsTelemetry], createBuildResult(), undefined, { telemetry: { workspace: "acme" } });
+    expect(diags[0].message).toBe('{"workspace":"acme"}');
+  });
+
+  test("a level-0 run leaves the field undefined", () => {
+    expect(runPostSynthChecks([readsTelemetry], createBuildResult())[0].message).toBe("null");
+  });
+});
+
 describe("isPostSynthCheck", () => {
   test("accepts a well-formed check and rejects others", async () => {
     const { isPostSynthCheck } = await import("./post-synth");

package/src/lint/post-synth.ts

@@ -1,6 +1,7 @@
 import type { Declarable } from "../declarable";
 import type { ActivityContract } from "../op/activity-contract";
 import type { SerializerResult } from "../serializer";
+import type { TelemetryAttribution } from "../telemetry-attribution";
 import type { Severity } from "./rule";
 import { parseOutputDocs, type OutputDoc } from "./output-docs";
 
@@ -55,6 +56,13 @@ export interface PostSynthContext {
    * when it is `undefined`.
    */
   readonly activityContracts?: ReadonlyMap<string, ActivityContract>;
+  /**
+   * The telemetry attribution the build stamped (#2558), from
+   * `resolveTelemetryAttribution`. Set when the project is inside a workspace
+   * or sets `telemetry.attribution: true`, and absent at level 0 and from a
+   * hand-built context. OTEL118 runs only when it is set.
+   */
+  readonly telemetry?: TelemetryAttribution;
   /** Raw build result object */
   buildResult: {
     outputs: Map<string, string | SerializerResult>;
@@ -183,6 +191,14 @@ export interface PostSynthCheck {
   description: string;
   /** Execute the check and return diagnostics */
   check(ctx: PostSynthContext): PostSynthDiagnostic[];
+  /**
+   * `chant audit` skips this check unless the project enables it with a
+   * `lint.rules` entry for its id (chant #3190). Builds are not affected: they
+   * already filter by the lexicon's `lintPresets()`. It exists because the
+   * audit runs every check a lexicon ships, report-only ones included, so a
+   * new check would otherwise change the audit output of every project.
+   */
+  auditOptIn?: boolean;
 }
 
 /** Structural type guard — used to collect project-authored policy checks. */
@@ -201,12 +217,13 @@ export function isPostSynthCheck(value: unknown): value is PostSynthCheck {
  * into the context so a check can branch on the current environment/stack, and
  * `opts.activityContracts` (chant #2101) carries the build's cross-lexicon
  * activity-contract map to the checks that validate Op steps against it.
+ * `opts.telemetry` is the build's resolved telemetry attribution.
  */
 export function runPostSynthChecks(
   checks: PostSynthCheck[],
   buildResult: PostSynthContext["buildResult"],
   env?: string,
-  opts?: { activityContracts?: ReadonlyMap<string, ActivityContract> },
+  opts?: { activityContracts?: ReadonlyMap<string, ActivityContract>; telemetry?: TelemetryAttribution },
 ): PostSynthDiagnostic[] {
   const getDocs = createDocsAccessor(buildResult.outputs);
   const ctx: PostSynthContext = {
@@ -215,6 +232,7 @@ export function runPostSynthChecks(
     env,
     buildResult,
     ...(opts?.activityContracts ? { activityContracts: opts.activityContracts } : {}),
+    ...(opts?.telemetry ? { telemetry: opts.telemetry } : {}),
     get docs(): OutputDoc[] {
       return getDocs();
     },

package/src/meta/declared-imports.test.ts

@@ -43,7 +43,7 @@ const DELIBERATELY_UNDECLARED = new Map<string, string>([
   [
     "@cdktn/hcl2json",
     "carries a ~1.8 MB wasm blob and is only needed by `chant carve`; " +
-      "`terraform/parse.ts` catches the failed import and prints the install line",
+      "`terraform/hcl2json.ts` catches the failed import and prints the install line",
   ],
   [
     "@intentius/chant-lexicon-gitlab",

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

@@ -252,6 +252,29 @@ export const sourceArchiveContract = activityContract(
   z.object({ digest: z.string(), archive: z.string(), commit: z.string(), dir: z.string(), files: z.number(), bytes: z.number() }),
 );
 
+const changeSetPart = z.object({
+  member: z.object({ member: z.string(), planDigest: z.string().nullable() }).passthrough(),
+  entries: z.array(z.unknown()),
+});
+
+export const composeChangeSetContract = activityContract(
+  "composeChangeSet",
+  z.strictObject({ parts: z.array(changeSetPart) }),
+  z.object({ document: z.record(z.string(), z.unknown()), digest: z.string(), summary: z.record(z.string(), z.unknown()) }),
+);
+
+export const lifecyclePlanChangeSetContract = activityContract(
+  "lifecyclePlanChangeSet",
+  z.strictObject({ member: z.string(), env: z.string(), cwd: z.string().optional(), owned: z.boolean().optional() }),
+  z.object({ part: changeSetPart }),
+);
+
+export const readChangeSetPartContract = activityContract(
+  "readChangeSetPart",
+  z.strictObject({ member: z.string(), planner: z.enum(["chant", "warden"]), file: z.string(), lexicon: z.string().optional() }),
+  z.object({ part: changeSetPart }),
+);
+
 export const releasePlanContract = activityContract(
   "releasePlan",
   z.strictObject({
@@ -356,3 +379,64 @@ export const releaseRollbackRecordContract = activityContract(
   }),
   z.object({ recorded: z.boolean(), digest: z.string(), env: z.string(), component: z.string(), approver: z.string().nullable() }),
 );
+
+/**
+ * The factory reference Op's activities (#3406, ws-087, ./factory.ts).
+ * OPS013 checks a later step's reference into each result, so `factoryOp`'s
+ * wiring (ask into build, build into check, all three into record) is
+ * validated at `chant build`.
+ */
+const factoryLease = z.unknown();
+const factoryBackends = z.record(z.string(), backendSchema).optional();
+
+export const factoryPickContract = activityContract(
+  "factoryPick",
+  z.strictObject({ cwd: z.string().optional(), kind: z.string().optional() }),
+  z.strictObject({
+    candidates: z.array(z.string()),
+    held: z.array(z.object({ item: z.string(), hold: z.string(), message: z.string() })),
+    keys: z.array(z.string()),
+  }),
+);
+
+export const factoryReadyContract = activityContract(
+  "factoryReady",
+  z.strictObject({ cwd: z.string().optional(), kind: z.string().optional(), also: z.string().optional() }),
+  z.array(z.string()),
+);
+
+export const factoryAskContract = activityContract(
+  "factoryAsk",
+  z.strictObject({ lease: factoryLease, cwd: z.string().optional(), kind: z.string().optional(), backends: factoryBackends }),
+  z.strictObject({
+    item: z.string(),
+    ask: z.boolean(),
+    tier: z.string(),
+    understand: z.string().nullable(),
+    outcome: z.enum(["dropped", "redraft", "ask"]).nullable(),
+  }),
+);
+
+export const factoryBuildContract = activityContract(
+  "factoryBuild",
+  z.strictObject({ lease: factoryLease, ask: z.unknown(), builder: z.string().min(1), context: z.string().optional(), cwd: z.string().optional() }),
+  z.strictObject({ ran: z.boolean(), finished: z.boolean(), exitCode: z.number().nullable(), reverted: z.array(z.string()), note: z.string(), report: z.record(z.string(), z.unknown()).nullable() }),
+);
+
+export const factoryCheckContract = activityContract(
+  "factoryCheck",
+  z.strictObject({ lease: factoryLease, build: z.unknown(), check: z.string().optional(), cwd: z.string().optional() }),
+  z.strictObject({ ran: z.boolean(), ok: z.boolean(), command: z.string().nullable(), evidence: z.array(z.string()), log: z.string().nullable(), report: z.record(z.string(), z.unknown()).nullable() }),
+);
+
+export const factoryRecordContract = activityContract(
+  "factoryRecord",
+  z.strictObject({ lease: factoryLease, ask: z.unknown(), build: z.unknown(), check: z.unknown(), after: z.string().optional(), cwd: z.string().optional() }),
+  z.strictObject({
+    outcome: z.enum(["done", "not_done", "dropped", "redraft", "ask"]),
+    reason: z.string().nullable(),
+    commit: z.string().nullable(),
+    implementsProposed: z.array(z.object({ decision: z.string(), paths: z.array(z.string()) })),
+  }),
+);
+