fix(harness): sanitize nested baseline errors

Fixes #104 using docs/specs/2026-08-24-104-deepseek-harness-shared-analysis-evidence-bundle.md AC-11 and AC-12. Serialized Bundle regressions and focused Node 22/24 suites validate nested Baseline stage-error path redaction.

Co-authored-by: Codex (GPT 5.6 Sol) <codex@openai.com>

Author: Cobb04

scripts/coding-agent-practices/asset-baseline.mjs

@@ -145,10 +145,10 @@ function text(value, limit = 320) {
   return String(value ?? "").replace(/[\u0000-\u001f\u007f]/gu, " ").replace(/\s+/gu, " ").trim().slice(0, limit);
 }
 
-function compactError(error, stage) {
+function compactError(error, stage, context) {
   return {
     code: `${stage.toUpperCase().replace(/[^A-Z0-9]+/gu, "_")}_UNAVAILABLE`,
-    message: text(error instanceof Error ? error.message : error),
+    message: boundedText(error instanceof Error ? error.message : error, context),
   };
 }
 
@@ -169,6 +169,7 @@ function pathLocator(filePath, context) {
   if (filePath === "<path>" || filePath.startsWith("<workspace>") || filePath.startsWith("<git-root>") || filePath.startsWith("~/")) {
     return filePath.split(/[\\/]/u).includes("..") ? "<path>" : filePath;
   }
+  if (process.platform !== "win32" && /^(?:[A-Za-z]:[\\/]|\\\\)/u.test(filePath)) return "<path>";
   const absolute = path.resolve(context.workspace, filePath);
   const resolved = canonicalIfPresent(absolute);
   const workspace = canonicalIfPresent(context.workspace);
@@ -214,6 +215,10 @@ function boundedText(value, context, knownPath) {
   const locator = knownPath ? pathLocator(knownPath, context) ?? "<path>" : undefined;
   if (knownPath) result = result.replaceAll(String(knownPath), marker);
   return result
+    .replace(
+      /(["'])((?:[A-Za-z]:[\\/]|\\\\|\/)[^"']+)\1/gu,
+      (_candidate, quote, candidate) => `${quote}${pathLocator(candidate, context) ?? "<path>"}${quote}`,
+    )
     .replace(/\\\\[^\s,;)'"\]]+\\[^\s,;)'"\]]+/gu, (candidate) => pathLocator(candidate, context) ?? "<path>")
     .replace(/[A-Za-z]:[\\/][^\s,;)'"\]]+/gu, (candidate) => pathLocator(candidate, context) ?? "<path>")
     .replace(/\/(?:[^\s,;)'"\]]+\/?)+/gu, (candidate) => pathLocator(candidate, context) ?? "<path>")
@@ -400,8 +405,8 @@ function compactIntegrity(integrity, context) {
   };
 }
 
-function unavailable(error, stage) {
-  return { status: "unavailable", error: compactError(error, stage) };
+function unavailable(error, stage, context) {
+  return { status: "unavailable", error: compactError(error, stage, context) };
 }
 
 function available(data) {
@@ -547,6 +552,14 @@ export async function collectAssetBaseline(options = {}, dependencies = {}) {
     includeGlobalHooks: includeUserHome,
     includeMemories,
   };
+  const pathContext = {
+    workspace,
+    workspaceInput: normalizeWorkspace(options.workspace ?? "."),
+    gitRoot: topology?.gitRoot,
+    gitRootInput: options.topology?.gitRoot,
+    home: dependencies.homeDirectory?.() ?? os.homedir(),
+    includeUserHome,
+  };
   const collectRawInventory = dependencies.collectRawInventory ?? collectAgentCustomizeInventory;
   let rawInventory;
   try {
@@ -566,7 +579,7 @@ export async function collectAssetBaseline(options = {}, dependencies = {}) {
       rawInventory = mergeInheritedInventories(rawInventory, inheritedInventories, topology);
     }
   } catch (error) {
-    const failed = unavailable(error, "inventory");
+    const failed = unavailable(error, "inventory", pathContext);
     return {
       kind: ASSET_BASELINE_KIND,
       schemaVersion: ASSET_BASELINE_SCHEMA_VERSION,
@@ -580,28 +593,20 @@ export async function collectAssetBaseline(options = {}, dependencies = {}) {
   const lintRunner = dependencies.runLint ?? runAgentLint;
   const inventoryRunner = dependencies.collectPublicInventory
     ?? (provider === "qoder" ? collectQoderInventory : collectProviderInventory);
-  const pathContext = {
-    workspace,
-    workspaceInput: normalizeWorkspace(options.workspace ?? "."),
-    gitRoot: topology?.gitRoot,
-    gitRootInput: options.topology?.gitRoot,
-    home: dependencies.homeDirectory?.() ?? os.homedir(),
-    includeUserHome,
-  };
   const [lintResult, inventoryResult] = await Promise.allSettled([
     lintRunner({ ...common, profile: "agent-assets-review", inventory: rawInventory }),
     inventoryRunner({ ...common, inventory: rawInventory }),
   ]);
   const lintEnvelope = lintResult.status === "fulfilled"
     ? available(compactLint(lintResult.value, pathContext))
-    : unavailable(lintResult.reason, "lint");
+    : unavailable(lintResult.reason, "lint", pathContext);
   const inventoryEnvelope = inventoryResult.status === "fulfilled"
     ? available(await compactInventory(inventoryResult.value, workspace, {
       stat: dependencies.stat,
       now: dependencies.now,
       pathContext,
     }))
-    : unavailable(inventoryResult.reason, "inventory");
+    : unavailable(inventoryResult.reason, "inventory", pathContext);
   let integrityEnvelope;
   if (inventoryResult.status === "fulfilled") {
     try {
@@ -611,10 +616,10 @@ export async function collectAssetBaseline(options = {}, dependencies = {}) {
         pathContext,
       ));
     } catch (error) {
-      integrityEnvelope = unavailable(error, "integrity");
+      integrityEnvelope = unavailable(error, "integrity", pathContext);
     }
   } else {
-    integrityEnvelope = unavailable(new Error("The shared public inventory is unavailable."), "integrity");
+    integrityEnvelope = unavailable(new Error("The shared public inventory is unavailable."), "integrity", pathContext);
   }
   const envelopes = { lint: lintEnvelope, inventory: inventoryEnvelope, integrity: integrityEnvelope };
   const availableCount = Object.values(envelopes).filter((envelope) => envelope.status === "available").length;

test/reporting/better-harness-evidence-bundle.test.mjs

@@ -18,6 +18,7 @@ import { workspaceToClaudeSlugVariants } from "../../scripts/session-analysis/pl
 import { collectAgentCustomize } from "../../scripts/harness-analysis/evidence-bundle/agent-customize.mjs";
 import { collectProjectHarness } from "../../scripts/harness-analysis/evidence-bundle/project-harness.mjs";
 import { EVIDENCE_BUNDLE_HELP } from "../../scripts/harness-analysis/evidence-bundle/cli.mjs";
+import { collectAssetBaseline } from "../../scripts/coding-agent-practices/asset-baseline.mjs";
 
 const NOW = new Date("2026-07-24T08:00:00.000Z");
 
@@ -525,6 +526,120 @@ test("agentCustomize preserves valid partial and failed Baseline v2 semantics",
   assert.equal(failedLane.error.code, "AGENT_CUSTOMIZE_BASELINE_FAILED");
 });
 
+function dshRawInventory() {
+  return {
+    provider: "dsh",
+    generatedAt: "2026-07-24T07:00:00.000Z",
+    diagnostics: {
+      evidenceKind: "configured-not-observed",
+      configurationSource: "qualified-defaults",
+      userHomeCollection: "not-authorized",
+      instructionCollection: "enabled",
+      qualifiedDshVersion: "0.1.1-rc.2",
+      qualifiedDshSourceSha: "b150a551b8d465e31e418e1b2eaf5e79bbb7d28e",
+    },
+  };
+}
+
+function healthyBaselineStages() {
+  return {
+    collectRawInventory: async () => dshRawInventory(),
+    runLint: async () => ({
+      kind: "agent-lint",
+      profile: "agent-assets-review",
+      summary: {},
+      findings: [],
+    }),
+    collectPublicInventory: async () => ({
+      scope: { platform: "dsh" },
+      summary: {},
+      surfaces: [],
+      memories: { included: false, categories: [] },
+      warnings: [],
+    }),
+    reviewIntegrity: () => ({
+      kind: "agent-asset-integrity",
+      profile: "agent-assets-review",
+      status: "reviewed",
+      contentPolicy: "metadata-only",
+      summary: {},
+      findings: [],
+    }),
+  };
+}
+
+const NESTED_BASELINE_ERROR_CASES = [
+  {
+    name: "failed raw inventory with a spaced POSIX path",
+    privatePath: "/Users/example/private project/raw inventory.json",
+    stages: ["lint", "inventory", "integrity"],
+    configure: (message) => ({
+      ...healthyBaselineStages(),
+      collectRawInventory: async () => { throw new Error(message); },
+    }),
+  },
+  {
+    name: "partial lint with a Windows drive path",
+    privatePath: "C:\\Users\\example\\private folder\\lint.json",
+    stages: ["lint"],
+    configure: (message) => ({
+      ...healthyBaselineStages(),
+      runLint: async () => { throw new Error(message); },
+    }),
+  },
+  {
+    name: "partial inventory with a spaced POSIX path",
+    privatePath: "/Users/example/private project/inventory.json",
+    stages: ["inventory"],
+    configure: (message) => ({
+      ...healthyBaselineStages(),
+      collectPublicInventory: async () => { throw new Error(message); },
+    }),
+  },
+  {
+    name: "partial integrity with a UNC path",
+    privatePath: "\\\\server\\private share\\integrity.json",
+    stages: ["integrity"],
+    configure: (message) => ({
+      ...healthyBaselineStages(),
+      reviewIntegrity: () => { throw new Error(message); },
+    }),
+  },
+];
+
+for (const current of NESTED_BASELINE_ERROR_CASES) {
+  test(`serialized Bundle sanitizes ${current.name}`, async () => {
+    const safeContext = "stage context remains available";
+    const message = `collector could not inspect '${current.privatePath}' while ${safeContext}`;
+    const result = await collectEvidenceBundle({
+      workspace: ".",
+      cwd: ".",
+      platform: "dsh",
+      depth: "quick",
+    }, dependencies({
+      collectAgentCustomize: undefined,
+      collectAssetBaseline: (options) => collectAssetBaseline(options, current.configure(message)),
+    }));
+    const serialized = JSON.stringify(result);
+
+    assert.equal(serialized.includes(current.privatePath), false);
+    assert.match(serialized, /<path>/u);
+    assert.match(serialized, /stage context remains available/u);
+    for (const stage of current.stages) {
+      assert.equal(result.lanes.agentCustomize.data.envelopes[stage].status, "unavailable");
+      assert.match(result.lanes.agentCustomize.data.envelopes[stage].error.code, /_UNAVAILABLE$/u);
+    }
+    assert.doesNotMatch(
+      serialized,
+      /PRIVATE_SKILL_SECRET_X|PRIVATE_INSTRUCTION_SECRET_Y|sk-test-secret-credential|configuredDigest|symlinkTargetRealpath/u,
+    );
+    assert.doesNotMatch(
+      serialized,
+      /existedAtSessionTime|usedInSession|influencedSession|sameHistoricalAsset|historicalAbsence/u,
+    );
+  });
+}
+
 test("lead receives configured cwd while Project Harness remains on its generic Git scope", async () => {
   const canonicalCwd = await realpath(".");
   let leadOptions;