@intentius/chant 0.124.22 → 0.124.24

package/src/workspace/links.ts

@@ -15,7 +15,11 @@
  * that parameter give way to the declared one, which is how an inferred edge
  * is promoted.
  *
- * Every row says how it was found (`declared` or `inferred:joinKey`), where it
+ * A member whose kind has a link reader (#3932, `./kind-link-readers.ts`) also
+ * states links in its own files, such as a dbt project's sources. Those rows
+ * have origin `kind-reader` and carry the file and line that state them.
+ *
+ * Every row says how it was found (`declared`, `kind-reader` or `inferred:joinKey`), where it
  * resolved (`source`, or `live` for the rows of `check --live`, #2549) and its status. A link that
  * can't be resolved is kept, with the reason.
  *
@@ -30,6 +34,7 @@ import { joinKey, joinLabel, type JoinLabel } from "../join-key";
 import type { Declaration, LinkDeclaration, Member } from "./declaration";
 import type { KindRegistry, MemberKind } from "./kinds";
 import type { MemberCollector } from "./compose-graph";
+import type { KindLinkRead, KindReadLink } from "./kind-link-readers";
 
 /**
  * The link kinds chant knows. Closed: a link of any other kind fails closed.
@@ -46,14 +51,20 @@ export const TELEMETRY_LINK_KIND = "telemetry";
 /** The OTLP protocols a telemetry link may state, as `OTEL_EXPORTER_OTLP_PROTOCOL` names them. */
 export const TELEMETRY_PROTOCOLS = ["grpc", "http/protobuf", "http/json"] as const;
 
-/** How a row was found: written down, or inferred by the named rule. */
-export type LinkOrigin = "declared" | "inferred:joinKey";
+/**
+ * How a row was found: written down in the declaration, read from the
+ * member's own files by its kind's link reader (#3932), or inferred by the
+ * named rule.
+ */
+export type LinkOrigin = "declared" | "kind-reader" | "inferred:joinKey";
 
 /** One output or parameter of a member, as a join sees it. */
 export interface JoinHandle {
   name: string;
   /** The node that holds it, when the reader knows one (a graph IR id). */
   node?: string;
+  /** Names it had before, from a rename hint in the producer's source (#3931). */
+  previously?: readonly string[];
 }
 
 /** What a member offers links, and what it reads. */
@@ -80,6 +91,10 @@ interface RowBase {
   resolves: "source" | "live";
   /** Why the row is not `resolved`, or null. */
   reason: string | null;
+  /** A `kind-reader` row (#3932): the reader, and the file (from the workspace root) and line that state the link. */
+  reader?: string;
+  file?: string;
+  line?: number;
 }
 
 /** A declared link, or an inferred join with one producer. */
@@ -113,7 +128,11 @@ export interface TelemetryTargets {
   composed: ReadonlySet<string>;
 }
 
-/** A parameter that joins outputs of two or more producers (or two outputs of one). */
+/**
+ * A parameter that joins outputs of two or more producers (or two outputs of
+ * one). For a `kind-reader` row whose file names no producer, `input` is the
+ * output it reads, and the candidates are the members that could produce it.
+ */
 export interface AmbiguousRow extends RowBase {
   status: "ambiguous";
   input: string;
@@ -170,9 +189,16 @@ function nearNames(name: string, outputs: JoinHandle[]): string[] {
  * Resolve every declared link and infer the joins nobody wrote down.
  * `handles` holds one entry per member whose handles were read; a member
  * missing from it is unresolved. Declared rows come first, in declaration
- * order; inferred and ambiguous rows follow, sorted by consumer and parameter.
+ * order; then the rows each member's kind reader found (`readLinks`, #3932),
+ * in member and file order; inferred and ambiguous rows follow, sorted by
+ * consumer and parameter.
  */
-export function resolveLinks(declaration: Declaration, handles: ReadonlyMap<string, MemberHandles>, telemetry?: TelemetryTargets): LinkTableRow[] {
+export function resolveLinks(
+  declaration: Declaration,
+  handles: ReadonlyMap<string, MemberHandles>,
+  telemetry?: TelemetryTargets,
+  readLinks?: ReadonlyMap<string, KindLinkRead>,
+): LinkTableRow[] {
   const rows: LinkTableRow[] = [];
   const declaredTargets = new Map<string, Set<string>>();
 
@@ -215,30 +241,18 @@ export function resolveLinks(declaration: Declaration, handles: ReadonlyMap<stri
         row.reason = `protocol applies to telemetry links; this link has kind ${kind}`;
         continue;
       }
-      const producer = handles.get(link.member);
-      const found = producer?.outputs.find((o) => o.name === link.output);
-      if (found) {
-        if (found.node) row.to = found.node;
-        continue;
-      }
-      if (!producer) {
-        row.status = "unresolved";
-        row.reason = `the outputs of ${link.member} were not read`;
-      } else if (producer.exposesNone) {
-        row.status = "missing";
-        row.reason = producer.why ?? `${link.member} exposes no outputs`;
-      } else if (!producer.complete) {
-        row.status = "unresolved";
-        row.reason = `${link.output} was not found in ${link.member}, whose outputs could not all be read in source${producer.why ? ` (${producer.why})` : ""}`;
-      } else {
-        const near = nearNames(link.output, producer.outputs);
-        const known = producer.outputs.map((o) => o.name);
-        row.status = "missing";
-        row.reason =
-          `${link.member} has no output ${link.output}` +
-          (near.length ? `; did you mean ${near.join(" or ")}? Links match exactly` : "") +
-          (known.length ? `; its outputs: ${[...new Set(known)].sort(cmp).join(", ")}` : "; it exposes no outputs");
-      }
+      resolveOutput(row, handles);
+    }
+  }
+
+  // Links a kind's reader found in the member's own files (#3932).
+  for (const consumer of declaration.members) {
+    const read = readLinks?.get(consumer.name);
+    if (!read) continue;
+    for (const link of read.links) {
+      const row = readerRow(declaration, consumer, read, link, handles);
+      rows.push(row);
+      if (row.status !== "ambiguous") (declaredTargets.get(consumer.name) ?? declaredTargets.set(consumer.name, new Set()).get(consumer.name)!).add(`${row.producer}\0${row.output}`);
     }
   }
 
@@ -297,6 +311,85 @@ export function resolveLinks(declaration: Declaration, handles: ReadonlyMap<stri
   return [...rows, ...inferred];
 }
 
+/** Match a declared or reader's output row against its producer's handles, setting its status and reason. */
+function resolveOutput(row: LinkRow, handles: ReadonlyMap<string, MemberHandles>): void {
+  const producer = handles.get(row.producer);
+  const found = producer?.outputs.find((o) => o.name === row.output);
+  if (found) {
+    if (found.node) row.to = found.node;
+    return;
+  }
+  if (!producer) {
+    row.status = "unresolved";
+    row.reason = `the outputs of ${row.producer} were not read`;
+  } else if (producer.exposesNone) {
+    row.status = "missing";
+    row.reason = producer.why ?? `${row.producer} exposes no outputs`;
+  } else if (!producer.complete) {
+    row.status = "unresolved";
+    row.reason = `${row.output} was not found in ${row.producer}, whose outputs could not all be read in source${producer.why ? ` (${producer.why})` : ""}`;
+  } else {
+    const renamed = [...new Set(producer.outputs.filter((o) => o.previously?.includes(row.output)).map((o) => o.name))].sort(cmp);
+    const near = renamed.length ? [] : nearNames(row.output, producer.outputs);
+    const known = producer.outputs.map((o) => o.name);
+    row.status = "missing";
+    row.reason =
+      `${row.producer} has no output ${row.output}` +
+      (renamed.length ? `; it was renamed to ${renamed.join(" or ")}, so link to that instead` : "") +
+      (near.length ? `; did you mean ${near.join(" or ")}? Links match exactly` : "") +
+      (known.length ? `; its outputs: ${[...new Set(known)].sort(cmp).join(", ")}` : "; it exposes no outputs");
+  }
+}
+
+/**
+ * The row for one link a kind's reader found (#3932). A link whose file names
+ * its producer resolves like a declared one. One that doesn't is given the
+ * producer that exposes its anchor (a dbt column's table); when none does,
+ * and exactly one other member exposes outputs at all, that member, so a
+ * dropped table is missing from the only place it could be. Otherwise the
+ * row is ambiguous, and the message names the field that settles it.
+ */
+function readerRow(declaration: Declaration, consumer: Member, read: KindLinkRead, link: KindReadLink, handles: ReadonlyMap<string, MemberHandles>): LinkTableRow {
+  const base = { consumer: consumer.name, kind: DEFAULT_LINK_KIND, origin: "kind-reader" as const, resolves: "source" as const, reader: read.reader, file: link.file, line: link.line };
+  let producer = link.member;
+  if (producer === null) {
+    const anchor = link.anchor ?? link.output;
+    const others = declaration.members.filter((m) => m.name !== consumer.name);
+    const exposing = others.filter((m) => handles.get(m.name)?.outputs.some((o) => o.name === anchor));
+    const possible = others.filter((m) => {
+      const h = handles.get(m.name);
+      return h !== undefined && !h.exposesNone;
+    });
+    if (exposing.length === 1) producer = exposing[0].name;
+    else if (exposing.length === 0 && possible.length === 1) producer = possible[0].name;
+    else {
+      const candidates = (exposing.length > 0 ? exposing : possible).map((m) => ({ producer: m.name, output: link.output, label: "exact" as const }));
+      const field = read.producerField ? `; set fields.${read.producerField} on ${consumer.name} to name it` : "";
+      return {
+        ...base,
+        status: "ambiguous",
+        input: link.output,
+        candidates,
+        reason:
+          exposing.length > 1
+            ? `${link.file}:${link.line} reads ${anchor}, which ${exposing.map((m) => m.name).join(" and ")} all expose${field}`
+            : candidates.length > 0
+              ? `${link.file}:${link.line} reads ${anchor}, which no member exposes, and ${consumer.name} does not say which of ${candidates.map((c) => c.producer).join(", ")} produces it${field}`
+              : `${link.file}:${link.line} reads ${anchor}, and no other member exposes outputs`,
+      };
+    }
+  }
+  const row: LinkRow = { ...base, producer, output: link.output, label: "exact", input: null, status: "resolved", reason: null };
+  const problem = linkTargetProblem(declaration, consumer, { member: producer } as LinkDeclaration);
+  if (problem) {
+    row.status = "invalid";
+    row.reason = read.producerField ? `fields.${read.producerField}: ${problem}` : problem;
+    return row;
+  }
+  resolveOutput(row, handles);
+  return row;
+}
+
 /**
  * Resolve a telemetry link against the producer's collector (#2558): the
  * target exists (presence), and when the link states a protocol, the target
@@ -369,7 +462,7 @@ export interface ComposedHandles {
   composed: readonly string[];
   /** The collectors those members report (#2558); a telemetry link resolves against them. */
   collectors?: readonly MemberCollector[];
-  exports: readonly { member: string; name: string; node?: string }[];
+  exports: readonly { member: string; name: string; node?: string; previously?: readonly string[] }[];
   imports: readonly { member: string; name: string; node: string }[];
 }
 
@@ -384,7 +477,9 @@ export function irMemberHandles(graph: ComposedHandles): Map<string, MemberHandl
   for (const member of graph.composed) {
     out.set(member, {
       member,
-      outputs: graph.exports.filter((e) => e.member === member).map((e) => ({ name: e.name, ...(e.node ? { node: e.node } : {}) })),
+      outputs: graph.exports
+        .filter((e) => e.member === member)
+        .map((e) => ({ name: e.name, ...(e.node ? { node: e.node } : {}), ...(e.previously?.length ? { previously: e.previously } : {}) })),
       inputs: graph.imports.filter((i) => i.member === member).map((i) => ({ name: i.name, node: i.node })),
       complete: true,
       why: null,
@@ -401,7 +496,7 @@ export function irMemberHandles(graph: ComposedHandles): Map<string, MemberHandl
  * With `kinds`, a member that isn't composed but whose kind lists its outputs
  * (`other`, kinds from a package) is a link target too.
  */
-export function graphLinks(declaration: Declaration, graph: ComposedHandles, kinds?: KindRegistry): LinkTableRow[] {
+export function graphLinks(declaration: Declaration, graph: ComposedHandles, kinds?: KindRegistry, readLinks?: ReadonlyMap<string, KindLinkRead>): LinkTableRow[] {
   const handles = irMemberHandles(graph);
   for (const m of declaration.members) {
     const kind = kinds?.get(m.kind);
@@ -413,7 +508,7 @@ export function graphLinks(declaration: Declaration, graph: ComposedHandles, kin
     collectors: new Map((graph.collectors ?? []).map((c) => [c.member, c])),
     composed: new Set(graph.composed),
   };
-  return resolveLinks(declaration, handles, telemetry).map((row) => {
+  return resolveLinks(declaration, handles, telemetry, readLinks).map((row) => {
     if (row.status === "ambiguous" || row.origin !== "declared") return row;
     // The declaration's pointer means nothing to a graph reader.
     const { pointer: _pointer, ...rest } = row;

package/src/workspace/member-handles.ts

@@ -25,6 +25,7 @@ import { isInside, type Declaration, type ResolvedGroup } from "./declaration";
 import type { KindRegistry } from "./kinds";
 import { kindHandles, type MemberHandles } from "./links";
 import { joinPath, skippedDir, type WorkspaceTree } from "./tree";
+import type { MemberLexiconOutputs } from "./lexicon-outputs";
 
 const memberDir = (dir: string) => (dir === "." ? "" : dir);
 
@@ -60,7 +61,7 @@ function isSourceFile(name: string): boolean {
  * directories (other members, group matches), `node_modules`, dot
  * directories and build output.
  */
-function sourceFiles(tree: WorkspaceTree, dir: string, exclude: ReadonlySet<string>): string[] {
+export function sourceFiles(tree: WorkspaceTree, dir: string, exclude: ReadonlySet<string>): string[] {
   const out: string[] = [];
   const walk = (at: string) => {
     for (const e of tree.list(at) ?? []) {
@@ -188,18 +189,35 @@ export function readSourceHandles(tree: WorkspaceTree, dir: string, exclude: Rea
   return out;
 }
 
+/**
+ * The directories inside member `m` that are not its source: other members'
+ * directories and example-group matches nested in it.
+ */
+export function memberExcludes(declaration: Declaration, groups: readonly ResolvedGroup[], m: Declaration["members"][number]): Set<string> {
+  const exclude = new Set<string>();
+  for (const o of declaration.members) if (o !== m && o.dir !== "." && isInside(o.dir, m.dir)) exclude.add(o.dir);
+  for (const g of groups) for (const dir of g.matches) if (isInside(dir, m.dir)) exclude.add(dir);
+  return exclude;
+}
+
 /**
  * Every member's handles, read in source for `chant workspace check`. A
  * `chant` member's outputs and parameters are parsed from its TypeScript
  * without running it; other kinds expose what the kind and the entry list.
  * A member whose directory is missing or whose kind is unknown is left out,
  * so links to it are unresolved.
+ *
+ * `lexiconOutputs` adds what the member's lexicons report about their own
+ * declarations (#3931, `./lexicon-outputs.ts`), gathered beforehand because
+ * reading them folds the member's files, which is asynchronous. Its gaps
+ * count as the member's.
  */
 export function sourceMemberHandles(
   declaration: Declaration,
   tree: WorkspaceTree,
   groups: readonly ResolvedGroup[],
   kinds: KindRegistry,
+  lexiconOutputs?: ReadonlyMap<string, MemberLexiconOutputs>,
 ): Map<string, MemberHandles> {
   const out = new Map<string, MemberHandles>();
   for (const m of declaration.members) {
@@ -210,16 +228,18 @@ export function sourceMemberHandles(
       out.set(m.name, listed);
     } else {
       // Other members' directories and group matches inside this one are not its source.
-      const exclude = new Set<string>();
-      for (const o of declaration.members) if (o !== m && o.dir !== "." && isInside(o.dir, m.dir)) exclude.add(o.dir);
-      for (const g of groups) for (const dir of g.matches) if (isInside(dir, m.dir)) exclude.add(dir);
-      const read = readSourceHandles(tree, memberDir(m.dir), exclude);
+      const read = readSourceHandles(tree, memberDir(m.dir), memberExcludes(declaration, groups, m));
+      const lexicon = lexiconOutputs?.get(m.name);
+      const gaps = [...read.gaps, ...(lexicon?.gaps ?? [])];
       out.set(m.name, {
         member: m.name,
-        outputs: read.outputs.map((o) => ({ name: o.name })),
+        outputs: [
+          ...read.outputs.map((o) => ({ name: o.name })),
+          ...(lexicon?.outputs ?? []).map((o) => ({ name: o.name, ...(o.previously?.length ? { previously: o.previously } : {}) })),
+        ],
         inputs: read.inputs.map((i) => ({ name: i.name })),
-        complete: read.gaps.length === 0,
-        why: read.gaps.length === 0 ? null : read.gaps.length === 1 ? read.gaps[0] : `${read.gaps[0]}, and ${read.gaps.length - 1} more`,
+        complete: gaps.length === 0,
+        why: gaps.length === 0 ? null : gaps.length === 1 ? gaps[0] : `${gaps[0]}, and ${gaps.length - 1} more`,
         exposesNone: false,
       });
     }

package/src/workspace/nested-graph.test.ts

@@ -97,6 +97,20 @@ describe("foldNested", () => {
   });
 });
 
+describe("foldNested with CI pipelines and dangling references (#3922)", () => {
+  test("prefixes byPipeline and dangling with the outer member, and keeps the nested member on each reference", () => {
+    const outer = composeWorkspaceGraph({ name: "outer", root: "." }, [
+      { member: member("platform", { kind: "workspace", status: "skipped", reason: { code: "kind-not-run", message: "nested" }, chant: null, irVersion: null }) },
+    ]);
+    const inner = innerGraph();
+    inner.groups.byPipeline = { "api/ci": ["api/Queue"] };
+    inner.dangling = [{ from: "api/Queue", kind: "needs", path: "needs", value: "lint", member: "api" }];
+    foldNested(outer, outer.members[0], inner);
+    expect(outer.groups.byPipeline).toEqual({ "platform/api/ci": ["platform/api/Queue"] });
+    expect(outer.dangling).toEqual([{ from: "platform/api/Queue", kind: "needs", path: "needs", value: "lint", member: "platform", nested: "api" }]);
+  });
+});
+
 describe("the outer workspace never writes inside a nested one", () => {
   let root: string;
   afterEach(() => rmSync(root, { recursive: true, force: true }));

package/src/workspace/nested-graph.ts

@@ -22,7 +22,7 @@
 
 import { spawn } from "node:child_process";
 import type { ParsedArgs } from "../cli/registry";
-import type { ComposedMember, ComposedNode, WorkspaceGraph } from "./compose-graph";
+import { danglingKey, SCOPED_GROUPS, type ComposedMember, type ComposedNode, type WorkspaceGraph } from "./compose-graph";
 
 export type { NestedWorkspace } from "./compose-graph";
 import { readerToolchain, type Toolchain } from "./member-commands";
@@ -148,12 +148,17 @@ export function foldNested(graph: WorkspaceGraph, member: ComposedMember, inner:
       into[k] = [...(into[k] ?? []), ...v.map((id) => prefixed(outer, id))].sort();
     }
   }
-  for (const key of ["byStack", "byContainer", "byWave"] as const) {
+  for (const key of SCOPED_GROUPS) {
     for (const [k, v] of Object.entries(innerGroups[key] ?? {})) {
       const into = (groups[key] ??= {});
       into[prefixed(outer, k)] = v.map((id) => prefixed(outer, id)).sort();
     }
   }
+  if (inner.dangling?.length) {
+    graph.dangling = [...(graph.dangling ?? []), ...inner.dangling.map((d) => ({ ...d, from: prefixed(outer, d.from), member: outer, nested: d.member }))].sort((a, b) =>
+      danglingKey(a).localeCompare(danglingKey(b)),
+    );
+  }
   for (const c of inner.collectors ?? []) graph.collectors.push({ ...c, member: prefixed(outer, c.member) });
   for (const [kind, attrs] of Object.entries(inner.derivedAttrs ?? {})) {
     const all = new Set([...(graph.derivedAttrs?.[kind] ?? []), ...attrs]);

package/src/workspace/records-checkout.ts

@@ -11,10 +11,15 @@
  *
  * Every git call here reads. None takes the index lock or refreshes the
  * index (`--no-optional-locks`), so a read leaves the checkout as it was,
- * `.git` included, which the reader conformance suite checks.
+ * `.git` included, which the reader conformance suite checks. A diff against
+ * the working tree is the exception git makes: it refreshes the index even
+ * then, so {@link worktreeChanges} runs it on a private copy.
  */
 
 import { execFileSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { isAbsolute, join } from "node:path";
 import { resolveBase, type BaseSource } from "./trust/provenance";
 
 /** Where a record's file stands against `HEAD`. */
@@ -55,6 +60,35 @@ function tryGit(top: string, args: string[]): string | undefined {
   }
 }
 
+/**
+ * The paths under `spec` whose working-tree content differs from `rev`, or
+ * undefined when git can't say. `git diff <rev>` refreshes the index's stat
+ * data for a file touched without a change, and writes the index even under
+ * `--no-optional-locks` (git 2.54), so it runs against a copy of the index
+ * (`GIT_INDEX_FILE`) and the checkout's own index is never written.
+ */
+export function worktreeChanges(top: string, rev: string, spec: string): string[] | undefined {
+  const scratch = mkdtempSync(join(tmpdir(), "chant-index-"));
+  try {
+    const at = tryGit(top, ["rev-parse", "--git-path", "index"])?.trim();
+    const index = at ? (isAbsolute(at) ? at : join(top, at)) : undefined;
+    const copy = join(scratch, "index");
+    if (index && existsSync(index)) copyFileSync(index, copy);
+    const out = execFileSync("git", ["--no-optional-locks", "--literal-pathspecs", "diff", "--name-only", "-z", "--no-renames", rev, "--", spec], {
+      cwd: top,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 256 * 1024 * 1024,
+      env: { ...process.env, GIT_INDEX_FILE: copy },
+    });
+    return out.split("\0").filter(Boolean);
+  } catch {
+    return undefined;
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+
 /**
  * The branch, head and base of the checkout at `top`. `explicitBase` is
  * `--base`, as the trust policy takes it; otherwise the target branch is the
@@ -98,7 +132,7 @@ export function worktreeStates(
   const direct = (p: string) => p.startsWith(prefix) && !p.slice(prefix.length).includes("/");
   const spec = dir === "." ? "." : dir;
   const atHead = new Set(zList(tryGit(top, ["ls-tree", "-r", "-z", "--name-only", head, "--", spec])).filter(direct));
-  const changed = new Set(zList(tryGit(top, ["diff", "--name-only", "-z", "--no-renames", head, "--", spec])));
+  const changed = new Set(worktreeChanges(top, head, spec) ?? []);
   for (const p of paths) states.set(p, !atHead.has(p) ? "new" : changed.has(p) ? "modified" : "committed");
   const present = new Set(paths);
   const deleted = [...atHead].filter((p) => !present.has(p) && match.test(p.slice(prefix.length))).sort();

package/src/workspace/records-uncommitted.test.ts

@@ -6,7 +6,7 @@
  */
 
 import { execFileSync } from "node:child_process";
-import { cpSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { cpSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, unlinkSync, utimesSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import Ajv2020 from "ajv/dist/2020";
@@ -101,6 +101,10 @@ describe("records in the working tree (#3160)", () => {
     const { root } = repository();
     const path = join(root, file("001"));
     writeFileSync(path, decided("001"));
+    // Its stat data no longer matches the index on any clock, so a read that
+    // refreshes the index would write it (a CI runner was slow enough to).
+    const later = new Date(Date.now() + 5_000);
+    utimesSync(path, later, later);
     const index = join(root, ".git", "index");
     const before = { bytes: readFileSync(index), mtime: statSync(index).mtimeMs };
     const doc = result(await queryRecords({ kind: KIND, cwd: root, uncommitted: true }));

package/src/workspace/runs.ts

@@ -55,7 +55,7 @@ import { createHash, randomBytes } from "node:crypto";
 import { readFileSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 import { z } from "zod";
-import { describeLifecyclePush, fetchLifecycleStatus, type LifecyclePushStatus, pushLifecycleStatus, readBlobBySha, RefCASConflictError, writeLedgerFiles } from "../lifecycle/git";
+import { describeLifecyclePush, fetchLifecycleStatus, ledgerRevision, type LifecyclePushStatus, pushLifecycleStatus, readBlobBySha, RefCASConflictError, writeLedgerFiles } from "../lifecycle/git";
 import { resolveMemberLedger } from "../lifecycle/member-ledger";
 import { sortedJsonReplacer } from "../utils";
 import { followSquashes, type SquashFollow } from "./squash";
@@ -509,7 +509,9 @@ async function appendRun(top: string, rootOnDisk: string, id: string, make: (exi
   let written: RunLine[] = [];
   let lastErr: unknown;
   for (let attempt = 1; attempt <= APPEND_RETRY_ATTEMPTS && commit === undefined; attempt++) {
-    const prior = git(top, ["rev-parse", "--verify", "--quiet", `refs/heads/${LEDGER_BRANCH}:${path}`])?.trim() || null;
+    // #3955: in a run that records nothing, the run's own unrecorded tip.
+    const rev = await ledgerRevision(top);
+    const prior = git(top, ["rev-parse", "--verify", "--quiet", `${rev === LEDGER_BRANCH ? `refs/heads/${LEDGER_BRANCH}` : rev}:${path}`])?.trim() || null;
     const text = prior ? ((await readBlobBySha(prior, { cwd: top })) ?? "") : "";
     const existing = parseRunFile(text, id).lines;
     const lines = make(existing);

package/src/workspace/status.ts

@@ -41,7 +41,7 @@ import { readPathSha } from "../lifecycle/git";
 import { latestPerComponent, readReleaseLedger, type ReleaseRecord } from "../lifecycle/release-ledger";
 import { readReleasePlan, type ReleasePlan } from "../lifecycle/plan-ledger";
 import { listWorkLeases, type WorkLeaseState } from "../lifecycle/work-lease";
-import { readCheckoutHead, type CheckoutHead } from "./records-checkout";
+import { readCheckoutHead, worktreeChanges, type CheckoutHead } from "./records-checkout";
 import { policyView, replicationState, type ReplicationState } from "./wip";
 import { findWorkspaceRoot } from "../project-root";
 import { resolveBoxes, type ResolvedIsolation } from "./box-isolation";
@@ -400,7 +400,8 @@ async function shipView(member: Member, cwd: string, read: LedgerReader): Promis
   };
   // The commit must be here: a release from a commit this checkout never had says nothing about it.
   if (lines(["cat-file", "-e", `${last.gitSha}^{commit}`]) === null) return view;
-  const changed = lines(["diff", "--name-only", "-z", "--no-renames", last.gitSha, "--"]);
+  // A diff against the working tree writes the index; run it on a copy.
+  const changed = worktreeChanges(top, last.gitSha, ".") ?? null;
   const untracked = lines(["ls-files", "--others", "--exclude-standard", "-z"]);
   if (changed === null || untracked === null) return view;
   const bookkeeping = (path: string) => ship.bookkeeping.some((prefix) => path === prefix || path.startsWith(`${prefix}/`));

package/src/workspace/workspace-kinds.schema.json

@@ -78,6 +78,11 @@
         },
         "fields": {
           "$ref": "#/$defs/fields"
+        },
+        "reader": {
+          "type": "string",
+          "pattern": "^[a-z][a-z0-9-]{0,39}$",
+          "description": "A link reader chant ships, by name, that derives a member's links from the member's own files (#3932): dbt-project reads a dbt project's sources. The reader is chant's code and runs offline, parsing files as data; the package supplies only the name. A name this chant doesn't have keeps the kind without a reader, and the load reports it. A chant older than this field fails a kinds file that uses it."
         }
       },
       "patternProperties": {