rea-agents 6.4.0 → 6.7.0

package/dist/application/ReconstructionObligationLedgerProjection.js

@@ -1,50 +1,8 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
-import { canonicalJson } from "../domain/comparisonSemantics.js";
+import { reconstructionObligationEvidenceIds } from "../domain/reconstructionObligationLedgerIntegrity.js";
 import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
-export const obligationLedgerCoverage = (incomplete) => ({
-    status: incomplete ? "partial" : "complete",
-});
-export const summarizeObligations = (obligations) => ({
-    total: obligations.length,
-    required: obligations.filter(({ required }) => required).length,
-    verified: obligations.filter(({ status }) => status === "verified").length,
-    required_open: obligations.filter(({ required, status }) => required && status !== "verified").length,
-    by_status: countBy(obligations, [
-        "unowned",
-        "characterized",
-        "implemented",
-        "verified",
-        "contradicted",
-        "blocked",
-        "out-of-scope",
-        "unknown",
-    ], ({ status }) => status),
-    by_application_layer: countBy(obligations, [
-        "cli",
-        "protocol",
-        "electron",
-        "persistence",
-        "process",
-        "runtime",
-        "packaging",
-        "native-abi",
-        "application",
-        "other",
-    ], ({ application_layer: layer }) => layer),
-    by_evidence_authority: countBy(obligations, ["candidate", "observed", "reviewed", "unknown"], ({ source_state: state }) => state),
-});
-export const obligationReports = (obligations) => ({
-    missing_owner_obligation_ids: obligationIdsWith(obligations, "missing-owner"),
-    missing_verifier_obligation_ids: obligationIdsWith(obligations, "missing-verifier"),
-    contradicted_obligation_ids: obligationIdsWith(obligations, "contradiction"),
-    residual_unknown_ids: [
-        ...new Set(obligations.flatMap(({ residual_unknown_ids: ids }) => ids)),
-    ].sort(),
-});
 export const obligationLedgerEvidenceLinks = (obligations, manifest) => [
     ...new Set([
-        ...obligations.flatMap(({ authority_references: references }) => references.map(({ evidence_id: id }) => id)),
+        ...reconstructionObligationEvidenceIds(obligations),
         ...manifest.bindings.flatMap((binding) => [
             ...binding.original_cases.map(({ evidence_id: id }) => id),
             ...binding.fixtures.flatMap(({ evidence_ids: ids }) => ids),
@@ -54,31 +12,4 @@ export const obligationLedgerEvidenceLinks = (obligations, manifest) => [
         ]),
         ...manifest.contradictions.flatMap(({ evidence_ids: ids }) => ids),
     ]),
-].sort();
-export const obligationLedgerStatus = (obligations) => {
-    if (obligations.length === 0)
-        return "unknown";
-    const requiredOpen = obligations.filter(({ required, status }) => required && status !== "verified");
-    if (requiredOpen.some(({ status, diagnostics }) => status === "contradicted" ||
-        hasDiagnostic(diagnostics, "verifier-failed")))
-        return "failed";
-    if (requiredOpen.some(({ status }) => status === "unknown"))
-        return "unknown";
-    return requiredOpen.length === 0 ? "ready" : "open";
-};
-export const obligationEdgeOrder = (left, right) => compareUnicodeCodePoints(canonicalJson(left), canonicalJson(right));
-export const digestObligationLedgerValue = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Reconstruction obligation ledger is not canonical JSON");
-    return createHash("sha256").update(encoded).digest("hex");
-};
-const countBy = (items, values, valueFor) => values.map((value) => ({
-    key: value,
-    count: items.filter((item) => valueFor(item) === value).length,
-}));
-const obligationIdsWith = (obligations, code) => obligations
-    .filter(({ diagnostics }) => hasDiagnostic(diagnostics, code))
-    .map(({ obligation_id: id }) => id)
-    .sort();
-const hasDiagnostic = (diagnostics, code) => diagnostics.some((diagnostic) => diagnostic.code === code);
+].sort(compareUnicodeCodePoints);

package/dist/application/ReconstructionObligationLedgerService.js

@@ -1,13 +1,13 @@
 import { z } from "zod";
 import { AnalysisProtocolError } from "../domain/analysisErrorCore.js";
-import {} from "../domain/analysisErrorBase.js";
+import { DuplicateEvidenceRecordError, NonCanonicalEvidenceBundleError, } from "../domain/evidenceBundle.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonObjectSchema, jsonValueSchema } from "../domain/jsonValue.js";
 import { reconstructionObligationLedgerInputSchema, reconstructionObligationLedgerSchema, } from "../domain/reconstructionObligationLedgerSchemas.js";
 import { err, ok } from "../domain/result.js";
 import { requestInputError, workflowInputError } from "./workflowInputError.js";
 import { JAVASCRIPT_APPLICATION_WORKFLOW_PROVIDER } from "./InvestigationProviders.js";
-import { deriveReconstructionObligationCandidates } from "./ReconstructionObligationCandidates.js";
+import { deriveReconstructionObligationCandidates, MissingReviewEvidenceError, } from "./ReconstructionObligationCandidates.js";
 import { evaluateReconstructionObligationLedger } from "./ReconstructionObligationLedgerEvaluation.js";
 const OPERATION = "build_reconstruction_obligation_ledger";
 /** Parse one portable ledger request for both CLI and MCP adapters. */
@@ -30,6 +30,10 @@ export const buildReconstructionObligationLedgerEvidenceValidated = (input) => {
         return ok(createLedgerEvidence(input, ledger));
     }
     catch (cause) {
+        if (cause instanceof NonCanonicalEvidenceBundleError ||
+            cause instanceof DuplicateEvidenceRecordError ||
+            cause instanceof MissingReviewEvidenceError)
+            return err(workflowInputError(OPERATION, cause));
         if (cause instanceof z.ZodError)
             return err(workflowInputError(OPERATION, cause));
         return err(new AnalysisProtocolError("Reconstruction obligation ledger generation failed", { cause }));

package/dist/application/ReconstructionObligationOriginalCases.js

@@ -1,11 +1,12 @@
 import { evidenceSupportsOriginalAuthority } from "./ReconstructionObligationAuthority.js";
+import { compareUnicodeCodePoints } from "../domain/unicodeCodePointOrder.js";
 /** Merge generated and manifest-supplied original observations canonically. */
 export const originalCasesFor = (candidate, binding) => [
     ...new Map([...candidate.observed_cases, ...(binding?.original_cases ?? [])].map((observed) => [
         `${observed.kind}:${observed.evidence_id}:${observed.location}`,
         observed,
     ])).values(),
-].sort((left, right) => `${left.kind}:${left.evidence_id}:${left.location}`.localeCompare(`${right.kind}:${right.evidence_id}:${right.location}`));
+].sort((left, right) => compareUnicodeCodePoints(`${left.kind}:${left.evidence_id}:${left.location}`, `${right.kind}:${right.evidence_id}:${right.location}`));
 /** Report original cases that are absent or lack comparable Evidence authority. */
 export const originalCaseDiagnostics = (candidate, binding, evidenceById) => {
     const diagnostics = [];
@@ -19,6 +20,14 @@ export const originalCaseDiagnostics = (candidate, binding, evidenceById) => {
             });
             continue;
         }
+        // A valid entry for this case kind does not resolve another entry's
+        // reference; every referenced Evidence ID must be in the bundle.
+        for (const { evidence_id: evidenceId } of cases)
+            if (!evidenceById.has(evidenceId))
+                diagnostics.push({
+                    code: "missing-original-case",
+                    detail: `Original ${caseKind} case references Evidence ${evidenceId}, which is absent from the bundle.`,
+                });
         if (!cases.some(({ evidence_id: evidenceId }) => {
             const evidence = evidenceById.get(evidenceId);
             return (evidence !== undefined &&

package/dist/application/ReferenceSourceImport.js

@@ -4,7 +4,6 @@ import { err, ok } from "../domain/result.js";
 import { readReferenceSource } from "../reference/ReferenceSourceReader.js";
 import { parseReferenceSourceEntries } from "./ReferenceSourceImportEntries.js";
 import { readReferenceSourceVcs } from "./ReferenceSourceVcsAdapter.js";
-import {} from "./ReferenceSourceImportTypes.js";
 import { prepareReferenceSourceImport, } from "./ReferenceSourceImportPolicy.js";
 const failure = (code, message) => ({
     tag: "reference-source-import",
@@ -55,7 +54,8 @@ const deriveInventoryState = (input) => {
     const partialEntry = input.entries.some((entry) => entry.limitations.length > 0 ||
         (entry.kind === "file" && entry.content_state !== "hashed") ||
         (entry.kind === "directory" && entry.tree_state !== "enumerated") ||
-        (entry.kind === "symlink" && entry.target_state !== "internal"));
+        (entry.kind === "symlink" && entry.target_state !== "internal") ||
+        entry.kind === "unknown");
     if (partialEntry)
         return "partial";
     const partialRelationship = input.relationships.some(({ parse_state, resolution }) => parse_state !== "parsed" ||
@@ -74,20 +74,31 @@ const sortExclusions = (exclusions) => [...exclusions].sort((left, right) => {
     return compareUnicodeCodePoints("pattern" in left ? left.pattern : "", "pattern" in right ? right.pattern : "");
 });
 const createShouldExclude = (exclusions, secrets, ignored) => (path, kind) => {
-    const patternPath = kind === "directory" ? `${path}/` : path;
-    const secretMatch = secrets.test(patternPath);
-    if (secretMatch.ignored) {
+    // An entry of unknown kind may be a directory, so directory-only rules
+    // must still exclude it; this fails closed for caller-marked secrets.
+    const patternPaths = kind === "directory"
+        ? [`${path}/`]
+        : kind === "unknown"
+            ? [path, `${path}/`]
+            : [path];
+    const firstMatch = (matcher) => {
+        const results = patternPaths.map((patternPath) => matcher.test(patternPath));
+        return results.find(({ ignored }) => ignored) ?? results[0];
+    };
+    const secretMatch = firstMatch(secrets);
+    if (secretMatch?.ignored === true) {
         if (!secretMatch.rule)
             throw new Error(`Ignored secret path has no matching rule: ${path}`);
         exclusions.push({
             path,
+            entry_kind: kind,
             reason: "configured-secret",
             pattern: secretMatch.rule.pattern,
         });
         return true;
     }
-    const match = ignored.test(patternPath);
-    if (!match.ignored)
+    const match = firstMatch(ignored);
+    if (match?.ignored !== true)
         return false;
     if (!match.rule)
         throw new Error(`Ignored path has no matching rule: ${path}`);
@@ -96,7 +107,12 @@ const createShouldExclude = (exclusions, secrets, ignored) => (path, kind) => {
         reason !== "default-ignored" &&
         reason !== "caller-excluded")
         throw new Error(`Ignored path has unknown rule origin: ${path}`);
-    exclusions.push({ path, reason, pattern: match.rule.pattern });
+    exclusions.push({
+        path,
+        entry_kind: kind,
+        reason,
+        pattern: match.rule.pattern,
+    });
     return true;
 };
 /**

package/dist/application/ReferenceSourceImportEntries.js

@@ -3,8 +3,8 @@ import { posix } from "node:path";
 import { logicalPathEscapesRoot } from "../domain/artifactIdentity.js";
 import { createReferenceSourcePathLookup, isPortableAbsoluteReferenceTarget, } from "../domain/referenceSourcePathIdentity.js";
 import { classifyReferenceSourcePath, detectReferenceSourceLanguage, } from "../domain/referenceSourceClassification.js";
-import { parseReferenceSourceImports } from "../domain/referenceSourceImportParsing.js";
-import { PARSEABLE_REFERENCE_SOURCE_LANGUAGES } from "./ReferenceSourceImportTypes.js";
+import { parseReferenceSourceImports, PARSEABLE_REFERENCE_SOURCE_LANGUAGES, } from "../domain/referenceSourceImportParsing.js";
+import { typescriptEmittedSourceCandidates } from "./TypeScriptEmittedSourceCandidates.js";
 /** Preserve the observed reader failure and add entry-specific recovery guidance. */
 export const projectReferenceSourceEntryFailure = (entry) => `${entry.message} ${entryRecoveryGuidance(entry)}`;
 const entryRecoveryGuidance = (entry) => {
@@ -16,6 +16,8 @@ const entryRecoveryGuidance = (entry) => {
         return "This directory could not be read. Check its permissions, then try again.";
     if (entry.kind === "symlink")
         return "This symbolic link could not be read safely. Check the link and its permissions, then try again.";
+    if (entry.kind === "unknown")
+        return "This entry's type could not be determined. Check the parent directory and try again.";
     return "This file could not be read. Check its permissions, then try again.";
 };
 const hashBytes = (bytes) => createHash("sha256").update(bytes).digest("hex");
@@ -39,6 +41,13 @@ const failedEntry = (entry) => {
             classifications,
             limitations: [limitation],
         };
+    if (entry.kind === "unknown" || entry.kind === "other")
+        return {
+            path: entry.path,
+            kind: "unknown",
+            classifications: ["unknown"],
+            limitations: [limitation],
+        };
     return {
         path: entry.path,
         kind: "file",
@@ -50,40 +59,164 @@ const failedEntry = (entry) => {
         limitations: [limitation],
     };
 };
-const resolveInternalSpecifier = (fromPath, specifier, lookupPath) => {
+/**
+ * Read each inventoried `package.json` once. Node selects a non-empty string
+ * `main` before a directory index; an unreadable or invalid manifest leaves
+ * that selection unknown.
+ */
+const readPackageMains = (read) => {
+    const mains = new Map();
+    const manifestPaths = [];
+    for (const entry of read.entries) {
+        if (posix.basename(entry.path) !== "package.json")
+            continue;
+        manifestPaths.push(entry.path);
+        const directory = posix.dirname(entry.path);
+        if (mains.has(directory)) {
+            mains.set(directory, { state: "unknown" });
+            continue;
+        }
+        if (entry.status !== "read" || entry.kind !== "file") {
+            mains.set(directory, { state: "unknown" });
+            continue;
+        }
+        try {
+            const manifest = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(entry.bytes));
+            const main = typeof manifest === "object" && manifest !== null
+                ? Reflect.get(manifest, "main")
+                : undefined;
+            mains.set(directory, typeof main === "string" && main !== ""
+                ? { state: "declared", main }
+                : { state: "none" });
+        }
+        catch {
+            mains.set(directory, { state: "unknown" });
+        }
+    }
+    return {
+        mains,
+        pathLookup: createReferenceSourcePathLookup(manifestPaths),
+    };
+};
+/**
+ * Extension slots in probe order. Within a slot, files precede directory
+ * indexes. The CommonJS loader tries `X.json` after `X.js` and before any
+ * directory index; ESM and TypeScript require an explicit `.json`.
+ */
+const RESOLUTION_SUFFIXES = [
+    [""],
+    [".ts"],
+    [".mts"],
+    [".cts"],
+    [".js"],
+    [".mjs"],
+    [".cjs"],
+    [".tsx"],
+    [".jsx"],
+];
+const REQUIRE_RESOLUTION_SUFFIXES = RESOLUTION_SUFFIXES.map((slot) => slot.includes(".js") ? [...slot, ".json"] : slot);
+const NODE_REQUIRE_SUFFIXES = ["", ".js", ".json", ".node"];
+const resolutionSuffixes = (mode) => mode === "source-require" ? REQUIRE_RESOLUTION_SUFFIXES : RESOLUTION_SUFFIXES;
+const nodeRequireFileCandidates = (path) => NODE_REQUIRE_SUFFIXES.map((suffix) => `${path}${suffix}`);
+const nodeRequireIndexCandidates = (directory) => NODE_REQUIRE_SUFFIXES.filter((suffix) => suffix !== "").map((suffix) => posix.join(directory, `index${suffix}`));
+const packageMainForDirectory = (directory, context) => {
+    const manifestPath = context.packageManifestPathLookup.resolve(posix.join(directory, "package.json"));
+    if (manifestPath !== undefined) {
+        const manifestDirectory = posix.dirname(manifestPath);
+        const main = context.packageMains.get(manifestDirectory);
+        return main === undefined
+            ? undefined
+            : { directory: manifestDirectory, main };
+    }
+    return context.packageManifestPathLookup.has(posix.join(directory, "package.json"))
+        ? { directory, main: { state: "unknown" } }
+        : undefined;
+};
+/** Apply a package main, retaining an existing index as the fallback target. */
+const selectPackageMain = (directory, indexFallback, context, mode) => {
+    const packageSelection = packageMainForDirectory(directory, context);
+    const packageDirectory = packageSelection?.directory ?? directory;
+    const manifest = packageSelection?.main;
+    if (manifest === undefined || manifest.state === "none")
+        return indexFallback === undefined
+            ? { to: directory, resolution: "unresolved" }
+            : { to: indexFallback, resolution: "internal" };
+    if (manifest.state === "unknown")
+        return { to: packageDirectory, resolution: "unresolved" };
+    // Node resolves `main` with path.resolve: an absolute main leaves the
+    // package, and a trailing separator does not make the entry a directory.
+    if (posix.isAbsolute(manifest.main))
+        return { to: posix.normalize(manifest.main), resolution: "unresolved" };
+    const target = posix
+        .normalize(posix.join(packageDirectory, manifest.main))
+        .replace(/(?<=.)\/+$/u, "");
+    // Node would load a declared entry outside the imported root.
+    if (logicalPathEscapesRoot(target))
+        return { to: target, resolution: "unresolved" };
+    const slots = resolutionSuffixes(mode);
+    const candidates = mode === "runtime-require"
+        ? [
+            ...nodeRequireFileCandidates(target),
+            ...nodeRequireIndexCandidates(target),
+        ]
+        : [
+            ...slots.flatMap((slot) => slot.map((suffix) => `${target}${suffix}`)),
+            ...slots
+                .flat()
+                .filter((suffix) => suffix !== "")
+                .map((suffix) => posix.join(target, `index${suffix}`)),
+        ];
+    const selected = context.lookupPath.resolveCandidates(candidates);
+    return selected === undefined
+        ? indexFallback === undefined
+            ? { to: packageDirectory, resolution: "unresolved" }
+            : { to: indexFallback, resolution: "internal" }
+        : { to: selected, resolution: "internal" };
+};
+const resolveInternalSpecifier = (fromPath, specifier, context, mode) => {
     if (posix.isAbsolute(specifier))
         return { to: specifier, resolution: "unresolved" };
     const normalized = posix.normalize(posix.join(posix.dirname(fromPath), specifier));
     if (logicalPathEscapesRoot(normalized))
         return { to: normalized, resolution: "unresolved" };
-    const suffixes = ["", ".ts", ".js", ".mjs", ".cjs", ".tsx", ".jsx"];
-    const candidates = suffixes.flatMap((suffix) => [
-        `${normalized}${suffix}`,
-        `${normalized}/index${suffix}`,
-    ]);
-    // TypeScript source commonly names the extension emitted for NodeNext.
+    // Preserve directory intent before normalization removes terminal dot segments.
+    const directoryReference = specifier.endsWith("/") || [".", ".."].includes(posix.basename(specifier));
+    // A directory resolves only to an index with an extension; neither Node nor
+    // TypeScript selects an extensionless `index` file.
+    const slots = resolutionSuffixes(mode);
+    const candidates = mode === "runtime-require"
+        ? [
+            ...(directoryReference ? [] : nodeRequireFileCandidates(normalized)),
+            ...nodeRequireIndexCandidates(normalized),
+        ]
+        : slots.flatMap((slot) => [
+            ...(directoryReference
+                ? []
+                : slot.map((suffix) => `${normalized}${suffix}`)),
+            ...slot
+                .filter((suffix) => suffix !== "")
+                .map((suffix) => posix.join(normalized, `index${suffix}`)),
+        ]);
     // Retain present runtime files first; substitute only a missing counterpart.
     // Counterparts cover explicit filenames, not directory/index resolution.
-    if (/\.(?:ts|tsx|mts|cts)$/u.test(fromPath)) {
-        const sourceSuffixes = normalized.endsWith(".js")
-            ? [".ts", ".tsx", ".d.ts"]
-            : normalized.endsWith(".mjs")
-                ? [".mts", ".d.mts"]
-                : normalized.endsWith(".cjs")
-                    ? [".cts", ".d.cts"]
-                    : normalized.endsWith(".jsx")
-                        ? [".tsx", ".d.ts"]
-                        : [];
-        const stem = normalized.slice(0, -posix.extname(normalized).length);
-        candidates.push(...sourceSuffixes.map((suffix) => `${stem}${suffix}`));
-    }
-    const match = lookupPath.resolveCandidates(candidates);
-    return match === undefined
-        ? { to: normalized, resolution: "unresolved" }
+    if (!directoryReference)
+        candidates.push(...typescriptEmittedSourceCandidates(fromPath, normalized).map(({ path }) => path));
+    const match = context.lookupPath.resolveCandidates(candidates);
+    if (match === undefined)
+        return packageMainForDirectory(normalized, context) !== undefined
+            ? selectPackageMain(normalized, undefined, context, mode)
+            : { to: normalized, resolution: "unresolved" };
+    const resolvedThroughIndex = posix.basename(match).startsWith("index.") &&
+        posix.dirname(match).normalize("NFC") === normalized.normalize("NFC");
+    return resolvedThroughIndex
+        ? selectPackageMain(posix.dirname(match), match, context, mode)
         : { to: match, resolution: "internal" };
 };
-const appendFile = (entry, lookupPath, output) => {
+const appendFile = (entry, context, output) => {
     const language = detectReferenceSourceLanguage(entry.path);
+    const parsed = language === null || !PARSEABLE_REFERENCE_SOURCE_LANGUAGES.has(language)
+        ? undefined
+        : parseReferenceSourceImports(entry.path, entry.bytes, language);
     output.entries.push({
         path: entry.path,
         kind: "file",
@@ -92,28 +225,33 @@ const appendFile = (entry, lookupPath, output) => {
         language,
         classifications: classifyReferenceSourcePath(entry.path),
         content_state: "hashed",
-        limitations: [],
+        limitations: [...(parsed?.limitations ?? [])],
     });
-    if (language === null || !PARSEABLE_REFERENCE_SOURCE_LANGUAGES.has(language))
+    if (parsed === undefined)
         return;
-    const parsed = parseReferenceSourceImports(entry.path, entry.bytes, language);
     for (const relationship of parsed.relationships) {
-        if (relationship.resolution !== "internal") {
-            output.relationships.push(relationship);
+        const { resolutionStrategy, ...graphRelationship } = relationship;
+        if (graphRelationship.resolution !== "internal") {
+            output.relationships.push(graphRelationship);
             continue;
         }
-        const resolved = resolveInternalSpecifier(relationship.from_path, relationship.to, lookupPath);
+        const mode = resolutionStrategy === "runtime-require"
+            ? "runtime-require"
+            : graphRelationship.kind === "requires"
+                ? "source-require"
+                : "source-import";
+        const resolved = resolveInternalSpecifier(graphRelationship.from_path, graphRelationship.to, context, mode);
         output.relationships.push({
-            ...relationship,
+            ...graphRelationship,
             to: resolved.to,
             resolution: resolved.resolution,
         });
     }
     output.parseFailures.push(...parsed.parse_failures);
 };
-const appendReadEntry = (entry, lookupPath, output) => {
+const appendReadEntry = (entry, context, output) => {
     if (entry.kind === "file") {
-        appendFile(entry, lookupPath, output);
+        appendFile(entry, context, output);
         return;
     }
     const classifications = classifyReferenceSourcePath(entry.path);
@@ -150,14 +288,19 @@ export const parseReferenceSourceEntries = (read, filePaths, signal) => {
         parseFailures: [],
         limitations: [...read.limitations],
     };
-    const lookupPath = createReferenceSourcePathLookup(filePaths);
+    const packageMainInventory = readPackageMains(read);
+    const context = {
+        lookupPath: createReferenceSourcePathLookup(filePaths),
+        packageMains: packageMainInventory.mains,
+        packageManifestPathLookup: packageMainInventory.pathLookup,
+    };
     for (const entry of read.entries) {
         if (signal?.aborted === true)
             break;
         if (entry.status === "failed")
             output.entries.push(failedEntry(entry));
         else
-            appendReadEntry(entry, lookupPath, output);
+            appendReadEntry(entry, context, output);
     }
     return output;
 };

package/dist/application/ReferenceSourceImportPolicy.js

@@ -62,12 +62,14 @@ const buildIgnored = async (root, excludePaths, resources, signal) => {
             text = await readRegularFileText(policyPath, { signal });
         }
         catch (cause) {
+            if (signal?.aborted === true && cause === signal.reason)
+                throw cause;
             if (!(cause instanceof RegularFileCleanupFailure))
                 throw cause;
-            const retry = await retryRegularFileCleanup(cause, resources);
+            const retry = await retryRegularFileCleanup(cause, resources, signal);
             if (retry.cleanup !== undefined) {
-                const primary = cause.outcome.kind === "failed"
-                    ? cause.outcome.cause
+                const primary = retry.outcome.kind === "failed"
+                    ? retry.outcome.cause
                     : cause.cleanupCause;
                 return err({
                     ...failure(signal?.aborted === true ? "cancelled" : "io", `Reference source ignore policy could not be read at ${policyPath}: ${errorMessage(primary)}`),

package/dist/application/ReferenceSourceImportTypes.js

@@ -44,4 +44,3 @@ export const DEFAULT_REFERENCE_SOURCE_IGNORE_PATTERNS = [
     ".coverage",
     "*.log",
 ];
-export const PARSEABLE_REFERENCE_SOURCE_LANGUAGES = new Set(["JavaScript", "TypeScript", "JSX", "TSX"]);

package/dist/application/ReferenceSourceVcsAdapter.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import { lstat } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { err, ok } from "../domain/result.js";
 import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
 import { readRegularFile, RegularFileCleanupFailure, retryRegularFileCleanup, } from "./RegularFileRead.js";
@@ -12,18 +12,27 @@ import { readRegularFile, RegularFileCleanupFailure, retryRegularFileCleanup, }
 export const readReferenceSourceVcs = async (root, resources, signal) => {
     try {
         return await resources.run(async () => {
-            if (isAborted(signal))
-                return ok(unknownVcs());
-            try {
-                await lstat(join(root, ".git"));
-            }
-            catch (cause) {
-                return ok(errorCode(cause) === "ENOENT"
-                    ? { kind: "none", head: null, dirty: null }
-                    : unknownVcs());
+            // Like Git, a subdirectory belongs to its nearest enclosing repository;
+            // only a missing `.git` at every ancestor means no version control.
+            let repository = resolve(root);
+            for (;;) {
+                if (isAborted(signal))
+                    return ok(unknownVcs());
+                try {
+                    await lstat(join(repository, ".git"));
+                    break;
+                }
+                catch (cause) {
+                    if (errorCode(cause) !== "ENOENT")
+                        return ok(unknownVcs());
+                }
+                const parent = dirname(repository);
+                if (parent === repository)
+                    return ok({ kind: "none", head: null, dirty: null });
+                repository = parent;
             }
             try {
-                const head = await resolveSourceHead(root, resources, signal);
+                const head = await resolveSourceHead(repository, resources, signal);
                 if (isAborted(signal))
                     return ok(unknownVcs());
                 return ok({ kind: "git", head, dirty: null });
@@ -62,9 +71,11 @@ const resolveSourceHead = async (root, resources, signal) => {
             return await readRegularFile(path, { signal });
         }
         catch (cause) {
+            if (signal?.aborted === true && cause === signal.reason)
+                throw cause;
             if (!(cause instanceof RegularFileCleanupFailure))
                 throw cause;
-            const retry = await retryRegularFileCleanup(cause, resources);
+            const retry = await retryRegularFileCleanup(cause, resources, signal);
             if (retry.outcome.kind === "failed" &&
                 errorCode(retry.outcome.cause) !== "ENOENT")
                 failedRead ??= { cause: retry.outcome.cause };
@@ -109,13 +120,21 @@ const resolveSourceHead = async (root, resources, signal) => {
                 // The library probes readFile() without a path to detect promise APIs.
                 // Reject that invocation without attributing it to a source read.
                 if (path === undefined)
-                    throw new TypeError("Git filesystem read requires a path");
+                    throw new TypeError("Git metadata path is required");
                 try {
                     const bytes = await readMetadataBytes(path);
-                    const encoding = typeof options === "string" ? options : options?.encoding;
-                    return encoding === undefined || encoding === null
-                        ? bytes
-                        : bytes.toString(encoding);
+                    const encoding = typeof options === "string"
+                        ? options
+                        : typeof options === "object" &&
+                            options !== null &&
+                            "encoding" in options
+                            ? options.encoding
+                            : undefined;
+                    if (encoding === undefined || encoding === null)
+                        return bytes;
+                    if (typeof encoding !== "string" || !Buffer.isEncoding(encoding))
+                        throw new TypeError("Unsupported Git metadata text encoding");
+                    return bytes.toString(encoding);
                 }
                 catch (cause) {
                     if (cause instanceof ArtifactReaderFailure) {