@dailephd/my-dev-kit-lab 0.9.4 → 0.9.5

package/dist/src/securityValidation/cliAdversarial/tempWorkspace.js

@@ -1,18 +1,28 @@
 import { createHash } from "node:crypto";
-import { mkdirSync, mkdtempSync, readdirSync, readFileSync, statSync, writeFileSync, } from "node:fs";
+import { lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, statSync, writeFileSync, } from "node:fs";
 import { rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-// ---------------------------------------------------------------------------
-// Workspace creation
-// ---------------------------------------------------------------------------
-export function createTempWorkspace(prefix = "adv-cli-") {
-    const root = mkdtempSync(path.join(os.tmpdir(), prefix));
+export function createTempWorkspace(prefix = "adv-cli-", options = {}) {
+    let enclosureDir;
+    let root;
+    let outsideDir;
+    if (options.nestDepth === undefined) {
+        root = mkdtempSync(path.join(os.tmpdir(), prefix));
+        // Create outside dir as a sibling of root (not inside it).
+        outsideDir = mkdtempSync(path.join(os.tmpdir(), `${prefix}outside-`));
+    }
+    else {
+        enclosureDir = mkdtempSync(path.join(os.tmpdir(), `${prefix}encl-`));
+        const nest = Array.from({ length: options.nestDepth }, (_, i) => `d${i + 1}`);
+        root = path.join(enclosureDir, ...nest, "ws");
+        outsideDir = path.join(enclosureDir, "outside");
+        mkdirSync(root, { recursive: true });
+        mkdirSync(outsideDir, { recursive: true });
+    }
     const sourceDir = path.join(root, "source");
     const outputDir = path.join(root, "output");
     const indexDir = path.join(root, "index");
-    // Create outside dir as a sibling of root (not inside it).
-    const outsideDir = mkdtempSync(path.join(os.tmpdir(), `${prefix}outside-`));
     mkdirSync(sourceDir, { recursive: true });
     mkdirSync(outputDir, { recursive: true });
     mkdirSync(indexDir, { recursive: true });
@@ -28,7 +38,12 @@ export function createTempWorkspace(prefix = "adv-cli-") {
         outputDir,
         indexDir,
         outsideDir,
+        enclosureDir,
         cleanup: async () => {
+            if (enclosureDir) {
+                await rm(enclosureDir, { recursive: true, force: true });
+                return;
+            }
             await Promise.all([
                 rm(root, { recursive: true, force: true }),
                 rm(outsideDir, { recursive: true, force: true }),
@@ -82,6 +97,40 @@ function collectSnapshots(baseDir, currentDir, out) {
         }
     }
 }
+/**
+ * Strict snapshot of a whole tree: records directories and links as well as
+ * files, never follows links, and THROWS when any entry cannot be inspected.
+ * Used where an unreadable tree must not be mistaken for an unchanged one.
+ */
+export function snapshotTreeStrict(dir) {
+    const snapshots = [];
+    collectStrict(dir, dir, snapshots);
+    return snapshots.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+function collectStrict(baseDir, currentDir, out) {
+    for (const entry of readdirSync(currentDir)) {
+        const abs = path.join(currentDir, entry);
+        const stat = lstatSync(abs);
+        const relativePath = path.relative(baseDir, abs);
+        if (stat.isSymbolicLink()) {
+            out.push({ relativePath, absolutePath: abs, contentHash: `<link:${readlinkSync(abs)}>` });
+        }
+        else if (stat.isDirectory()) {
+            out.push({ relativePath, absolutePath: abs, contentHash: "<dir>" });
+            collectStrict(baseDir, abs, out);
+        }
+        else if (stat.isFile()) {
+            out.push({
+                relativePath,
+                absolutePath: abs,
+                contentHash: createHash("sha256").update(readFileSync(abs)).digest("hex"),
+            });
+        }
+        else {
+            out.push({ relativePath, absolutePath: abs, contentHash: "<special>" });
+        }
+    }
+}
 export function diffSnapshots(before, after) {
     const beforeMap = new Map(before.map((s) => [s.relativePath, s.contentHash]));
     const afterMap = new Map(after.map((s) => [s.relativePath, s.contentHash]));

package/dist/src/securityValidation/cliAdversarial/traversalContainment.js

@@ -0,0 +1,161 @@
+import { lstatSync, realpathSync } from "node:fs";
+import path from "node:path";
+// ---------------------------------------------------------------------------
+// Containment policy for deliberately traversing --out / --index values.
+//
+// A traversing value may only be handed to a CLI when its full destination is
+// proven to stay inside a NEW task-owned disposable enclosure. The enclosure is
+// not the declared output directory: the value may leave the declared
+// directory, but never the enclosure. Anything that cannot be proven is refused
+// before launch.
+// ---------------------------------------------------------------------------
+/** Largest number of net parent components the harness will accommodate. */
+export const MAX_TRAVERSAL_DEPTH = 10;
+/** Longest destination (excluding the file a CLI adds) allowed on Windows. */
+const MAX_WINDOWS_DESTINATION_LENGTH = 200;
+const MAX_POSIX_DESTINATION_LENGTH = 3000;
+function pathFor(platform) {
+    return platform === "win32" ? path.win32 : path.posix;
+}
+/**
+ * Pure classification of a traversal value according to how the given host
+ * platform resolves it. Reports how many parent components the value needs
+ * room for, or refuses values that are absolute or ambiguous on that host.
+ */
+export function classifyTraversalValue(value, platform = process.platform) {
+    if (value.length === 0) {
+        return { kind: "refused", reason: "empty path value" };
+    }
+    if (value.includes("\0")) {
+        return { kind: "refused", reason: "path value contains a NUL character" };
+    }
+    const host = pathFor(platform);
+    if (host.isAbsolute(value)) {
+        return { kind: "refused", reason: `absolute path on ${platform}: destination is not confined to the enclosure` };
+    }
+    if (platform === "win32") {
+        if (/^[A-Za-z]:/.test(value)) {
+            return { kind: "refused", reason: "drive-qualified path on win32: drive-relative resolution is ambiguous" };
+        }
+        if (/[<>:"|?*]/.test(value)) {
+            return { kind: "refused", reason: "win32 path contains reserved characters (stream or device ambiguity)" };
+        }
+    }
+    const segments = value.split(platform === "win32" ? /[\\/]+/ : /\/+/);
+    let depth = 0;
+    let lowest = 0;
+    for (const segment of segments) {
+        if (segment === "" || segment === ".")
+            continue;
+        if (segment === "..") {
+            depth -= 1;
+            lowest = Math.min(lowest, depth);
+        }
+        else {
+            if (platform === "win32" && /[. ]$/.test(segment)) {
+                return { kind: "refused", reason: "win32 path component ends in a dot or space and would be rewritten by the OS" };
+            }
+            depth += 1;
+        }
+    }
+    const nestDepth = lowest === 0 ? 0 : -lowest;
+    if (nestDepth > MAX_TRAVERSAL_DEPTH) {
+        return {
+            kind: "refused",
+            reason: `traversal depth ${nestDepth} exceeds the supported maximum of ${MAX_TRAVERSAL_DEPTH}`,
+        };
+    }
+    return { kind: "relative", nestDepth };
+}
+/** True when `candidate` equals or is below `parent` under the host's path semantics. */
+export function isPathInside(parent, candidate, platform = process.platform) {
+    const host = pathFor(platform);
+    const relative = host.relative(parent, candidate);
+    if (relative === "")
+        return true;
+    return !relative.startsWith("..") && !host.isAbsolute(relative);
+}
+/**
+ * Resolves `value` against `baseDir` and proves, using the real filesystem,
+ * that the destination, its nearest existing parent and every not-yet-created
+ * descendant stay inside `enclosureDir`. Never creates anything.
+ */
+export function proveContainment(options) {
+    const { value, baseDir, enclosureDir, declaredDir } = options;
+    const platform = process.platform;
+    const host = pathFor(platform);
+    const plan = classifyTraversalValue(value, platform);
+    if (plan.kind === "refused")
+        return { ok: false, reason: plan.reason };
+    let enclosure;
+    let realBase;
+    let realDeclared;
+    try {
+        enclosure = realpathSync.native(enclosureDir);
+        realBase = realpathSync.native(baseDir);
+        realDeclared = realpathSync.native(declaredDir);
+    }
+    catch (error) {
+        return { ok: false, reason: `enclosure, base or declared directory is not inspectable: ${errorMessage(error)}` };
+    }
+    if (!isPathInside(enclosure, realBase, platform) || !isPathInside(enclosure, realDeclared, platform)) {
+        return { ok: false, reason: "base or declared directory is not inside the enclosure" };
+    }
+    const destination = host.resolve(realBase, value);
+    if (!isPathInside(enclosure, destination, platform)) {
+        return { ok: false, reason: `destination ${destination} resolves outside the enclosure ${enclosure}` };
+    }
+    const limit = platform === "win32" ? MAX_WINDOWS_DESTINATION_LENGTH : MAX_POSIX_DESTINATION_LENGTH;
+    if (destination.length > limit) {
+        return { ok: false, reason: `destination length ${destination.length} exceeds the supported ${limit}` };
+    }
+    // Find the nearest existing physical ancestor; anything else is inspectable
+    // only if lstat answers either "exists" or "does not exist".
+    let nearest = destination;
+    for (;;) {
+        try {
+            lstatSync(nearest);
+            break;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                return { ok: false, reason: `cannot inspect ${nearest}: ${errorMessage(error)}` };
+            }
+            const parent = host.dirname(nearest);
+            if (parent === nearest || !isPathInside(enclosure, parent, platform)) {
+                return { ok: false, reason: "no existing ancestor found inside the enclosure" };
+            }
+            nearest = parent;
+        }
+    }
+    // Existing part must be a plain directory chain: no links, junctions or
+    // case/short-name aliases (the real path must equal the lexical path).
+    let nearestReal;
+    try {
+        if (lstatSync(nearest).isSymbolicLink()) {
+            return { ok: false, reason: `${nearest} is a symbolic link or junction` };
+        }
+        nearestReal = realpathSync.native(nearest);
+    }
+    catch (error) {
+        return { ok: false, reason: `cannot resolve ${nearest}: ${errorMessage(error)}` };
+    }
+    if (nearestReal !== nearest) {
+        return { ok: false, reason: `${nearest} is an alias of ${nearestReal} (link, junction, case or short-name ambiguity)` };
+    }
+    if (!isPathInside(enclosure, nearestReal, platform)) {
+        return { ok: false, reason: `${nearest} resolves outside the enclosure` };
+    }
+    return {
+        ok: true,
+        destination,
+        enclosure,
+        nearestExisting: nearest,
+        relativeToEnclosure: host.relative(enclosure, destination).split(host.sep).join("/"),
+        declared: realDeclared,
+        insideDeclared: isPathInside(realDeclared, destination, platform),
+    };
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/src/securityValidation/commandRunner.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { resolveCommand } from "../core/resolveCommand.js";
+import { terminateProcessTree } from "../core/processTree.js";
 // Prefer the unqualified npm command and let the shared resolver locate
 // npm.cmd/.ps1 shims or direct executables per platform.
 export function resolveNpmCommand() {
@@ -13,6 +14,8 @@ export function buildSecurityCommandSpawnOptions(options) {
     return {
         cwd: options.cwd,
         shell: false,
+        windowsHide: true,
+        detached: process.platform !== "win32",
         stdio: ["ignore", "pipe", "pipe"],
         env: options.env,
     };
@@ -53,6 +56,8 @@ export async function runSecurityCommand(options) {
             stdout: "",
             stderr: resolved.warnings.join("\n"),
             timedOut: false,
+            resolutionKind: resolved.resolutionKind,
+            timeoutMs: options.timeoutMs,
             skipped: false,
         };
     }
@@ -62,6 +67,12 @@ export async function runSecurityCommand(options) {
         let timedOut = false;
         let settled = false;
         let timeout;
+        let closeGrace;
+        let termination;
+        let treeTerminated;
+        let signal;
+        let exitCode = null;
+        let spawnError;
         let child;
         try {
             child = spawn(command, args, buildSecurityCommandSpawnOptions({ cwd: options.cwd, env }));
@@ -76,6 +87,9 @@ export async function runSecurityCommand(options) {
                 stdout: "",
                 stderr: spawnErr instanceof Error ? spawnErr.message : String(spawnErr),
                 timedOut: false,
+                spawnError: spawnErr instanceof Error ? spawnErr.message : String(spawnErr),
+                resolutionKind: resolved.resolutionKind,
+                timeoutMs: options.timeoutMs,
                 skipped: false,
             });
             return;
@@ -86,52 +100,64 @@ export async function runSecurityCommand(options) {
         child.stderr.on("data", (chunk) => {
             stderr += chunk.toString("utf8");
         });
-        child.on("error", (error) => {
+        const finish = async () => {
             if (settled)
                 return;
             settled = true;
             if (timeout)
                 clearTimeout(timeout);
+            if (termination)
+                await termination;
+            if (closeGrace)
+                clearTimeout(closeGrace);
             resolve({
                 command,
                 args,
                 cwd: options.cwd,
-                exitCode: null,
+                exitCode,
                 durationMs: Date.now() - started,
                 stdout,
-                stderr: error.message,
+                stderr,
                 timedOut,
+                signal,
+                spawnError,
+                resolutionKind: resolved.resolutionKind,
+                timeoutMs: options.timeoutMs,
+                treeTerminated,
                 skipped: false,
             });
+        };
+        child.on("error", (error) => {
+            spawnError = error.message;
+            stderr += `${stderr ? "\n" : ""}${error.message}`;
+            void finish();
         });
         if (options.timeoutMs > 0) {
             timeout = setTimeout(() => {
                 timedOut = true;
-                try {
-                    child.kill("SIGTERM");
-                }
-                catch {
-                    // Process may have already exited.
-                }
+                // Keep the parent alive until its entire owned tree is addressed.
+                // Killing only npm's cmd parent can strand its children and their pipes.
+                termination = terminateProcessTree(child.pid, { waitTimeoutMs: 5000 }).then((terminated) => {
+                    treeTerminated = terminated;
+                    return terminated;
+                });
+                void termination.then(() => {
+                    if (settled)
+                        return;
+                    // A failed tree operation or a pipe that never closes must not make
+                    // the command wait indefinitely beyond its deadline and kill grace.
+                    closeGrace = setTimeout(() => {
+                        child.stdout.destroy();
+                        child.stderr.destroy();
+                        void finish();
+                    }, 1000);
+                });
             }, options.timeoutMs);
         }
-        child.on("close", (exitCode) => {
-            if (settled)
-                return;
-            settled = true;
-            if (timeout)
-                clearTimeout(timeout);
-            resolve({
-                command,
-                args,
-                cwd: options.cwd,
-                exitCode,
-                durationMs: Date.now() - started,
-                stdout,
-                stderr,
-                timedOut,
-                skipped: false,
-            });
+        child.on("close", (code, exitSignal) => {
+            exitCode = code;
+            signal = exitSignal;
+            void finish();
         });
     });
 }

package/dist/src/securityValidation/config.js

@@ -37,3 +37,13 @@ export const DEFAULT_SECURITY_CONFIG = {
     commandTimeoutMs: 60_000,
     requireOsvScanner: false,
 };
+// Windows native Semgrep startup can exceed the shared one-minute deadline.
+// Keep this allowance local to Semgrep, bounded, and independently cancellable.
+export function resolveSemgrepCommandTimeoutMs(config, platform = process.platform) {
+    const timeoutMs = config.semgrepCommandTimeoutMs ??
+        (platform === "win32" ? 300_000 : config.commandTimeoutMs);
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+        throw new Error("Semgrep process timeout must be a positive finite duration.");
+    }
+    return platform === "win32" ? Math.min(timeoutMs, 300_000) : timeoutMs;
+}

package/dist/src/securityValidation/validate/runCliSecuritySuiteCheck.js

@@ -65,10 +65,17 @@ export async function runCliSecuritySuiteCheck(options) {
         timeoutMs: Math.min(options.timeoutMs * 3, 180_000),
     });
     const finishedAt = new Date().toISOString();
-    const passed = cmd.exitCode === 0;
+    const passed = cmd.exitCode === 0 && !cmd.timedOut && !cmd.spawnError && cmd.treeTerminated !== false;
     const name = isSelf
         ? "CLI adversarial test suite (tool self-tests)"
         : "Target security test suite";
+    const outcome = cmd.timedOut
+        ? `exceeded its ${cmd.timeoutMs ?? "configured"} ms deadline (exit code ${String(cmd.exitCode)}).`
+        : cmd.spawnError
+            ? "could not be started; see process error evidence."
+            : cmd.treeTerminated === false
+                ? "did not confirm process-tree cleanup."
+                : `exited with code ${String(cmd.exitCode)}.`;
     return {
         id: "cli-adversarial-suite",
         name,
@@ -87,8 +94,8 @@ export async function runCliSecuritySuiteCheck(options) {
                     severity: "major",
                     category: "cli-adversarial",
                     description: isSelf
-                        ? `Tool-root test:security exited with code ${String(cmd.exitCode)}.`
-                        : `Target-root test:security exited with code ${String(cmd.exitCode)}.`,
+                        ? `Tool-root test:security ${outcome}`
+                        : `Target-root test:security ${outcome}`,
                     evidence: buildEvidence(cmd),
                     recommendation: isSelf
                         ? "Fix failing tool security tests before release."
@@ -104,14 +111,23 @@ export async function runCliSecuritySuiteCheck(options) {
     };
 }
 function summarizeOutput(value) {
-    const normalized = value.replace(/\r\n/g, "\n").trim();
+    const normalized = value.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "")
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "")
+        .replace(/\r\n/g, "\n").trim();
     if (!normalized) {
         return undefined;
     }
     return normalized.slice(0, 500);
 }
 function buildEvidence(cmd) {
-    const parts = [`cwd=${cmd.cwd}`, `exitCode=${String(cmd.exitCode)}`];
+    const parts = [
+        `cwd=${cmd.cwd}`, `exitCode=${String(cmd.exitCode)}`,
+        `timedOut=${cmd.timedOut}`, `signal=${cmd.signal === undefined ? "unknown" : String(cmd.signal)}`,
+        `timeoutMs=${cmd.timeoutMs ?? "unknown"}`, `durationMs=${cmd.durationMs}`,
+        `resolutionKind=${cmd.resolutionKind ?? "unknown"}`, `treeTerminated=${cmd.treeTerminated ?? "not-requested"}`,
+    ];
+    if (cmd.spawnError)
+        parts.push(`spawnError=${summarizeOutput(cmd.spawnError)}`);
     const stdoutSummary = summarizeOutput(cmd.stdout);
     const stderrSummary = summarizeOutput(cmd.stderr);
     if (stdoutSummary) {

package/dist/src/securityValidation/validate/runSecurityValidation.js

@@ -8,7 +8,7 @@ import { runAllFuzzTargets } from "../fuzz/fuzzHarness.js";
 import { ALL_FUZZ_TARGETS } from "../fuzz/fuzzTargets.js";
 import { calculateVerdict, summarizeVerdictReasoning } from "./verdict.js";
 import { resolveValidationTarget, targetDescription as describeTarget } from "./resolveTarget.js";
-import { DEFAULT_SECURITY_CONFIG } from "../config.js";
+import { DEFAULT_SECURITY_CONFIG, resolveSemgrepCommandTimeoutMs } from "../config.js";
 import { runCliSecuritySuiteCheck } from "./runCliSecuritySuiteCheck.js";
 import { DEFAULT_SECURITY_CHECKS, DEFAULT_SECURITY_PROFILE, IMPLEMENTED_SECURITY_CHECK_IDS, PLANNED_SECURITY_CHECK_IDS, } from "./cliOptions.js";
 import { runAttackScenarios } from "../attackScenarios/attackRunner.js";
@@ -102,7 +102,7 @@ export async function runSecurityValidation(options) {
             collect(await runSemgrepCheck({
                 targetRoot: target.targetRoot,
                 toolRoot,
-                timeoutMs: config.commandTimeoutMs,
+                timeoutMs: resolveSemgrepCommandTimeoutMs(config),
             }));
         }
         catch (err) {

package/dist/src/tutorial/tutorialAssertions.js

@@ -66,6 +66,13 @@ export function resolveAssertionRequestUrl(applicationUrl, suppliedPath) {
         throw new Error(`HTTP assertion path must be a root-relative path beginning with "/" and must not be protocol-relative; received ${JSON.stringify(suppliedPath)}.`);
     }
     const base = new URL(applicationUrl);
+    // Defend the exported assertion boundary as well as the validated tutorial
+    // caller: same-origin alone does not make an unchecked remote origin local.
+    const hostname = base.hostname.replace(/^\[/, "").replace(/\]$/, "").toLowerCase();
+    if ((base.protocol !== "http:" && base.protocol !== "https:") ||
+        !["localhost", "127.0.0.1", "::1"].includes(hostname)) {
+        throw new Error("HTTP assertion application origin must use HTTP(S) on loopback.");
+    }
     const resolved = new URL(suppliedPath, base);
     if (resolved.protocol !== base.protocol || resolved.hostname !== base.hostname || resolved.port !== base.port) {
         throw new Error(`HTTP assertion path ${JSON.stringify(suppliedPath)} resolves to ${resolved.origin}, which leaves the application origin ${base.origin}.`);

package/docs/METRICS.md

@@ -646,7 +646,7 @@ The `incremental-change-staleness` plugin reuses the six existing v0.6.1 affecte
 **Required-file relation** (per scenario, comparing the two treatments' required-file status):
 
 - `stale-worse`: `stale-index` is `missing` while `full-refresh` is `present`.
-- `same`: both treatments have the same status (including `missing`/`missing`).
+- `same`: both treatments have the same status, except that `missing`/`missing` is `unknown` (see the reference-adequacy gate below).
 - `stale-better`: `stale-index` is `present` while `full-refresh` is `missing`.
 - `unknown`: either treatment's status is `unknown`.
 
@@ -690,6 +690,16 @@ Availability: the first three are always present for a validated incremental tre
 
 `no-observed-regression-relative-to-full` means only that the executed scenario showed no regression under those two evidence dimensions. It does not establish equivalence or safety and does not show that full refresh is unnecessary. `not-comparable-as-partial-refresh` says the run gives no evidence about the requested partial behavior. There is no winner, ranking, composite score, safety score, safe-to-skip-refresh flag, or stale-risk percentage. Ordinary per-treatment correctness `score` remains the existing deterministic fake-agent evidence.
 
+**Evidence families and the reference-adequacy gate (v0.9.5).** The staleness experiment keeps five kinds of evidence distinct and never converts one into another:
+
+- *Source read*: a file whose own `source` command succeeded under the bounded multi-source retrieval protocol (`bounded-multi-source-v1`: one `search` with an explicit limit, then at most 8 distinct candidate files in search rank order, each with one `source` command). `retrieval.filesRead` and `requiredFileEvidence.observedFiles` carry only these. Candidates come only from the actual search output; the answer key never selects them.
+- *Surfaced*: a file or symbol that search, lookup or slice merely returned. It is not credited as read.
+- *Expected but not observed*: `requiredFileEvidence.missingFiles`. `missing` is relative to the fixed candidate budget and is not an exhaustive source-set assessment; its reason states the budget and truncation flags. Unsourced required files are `unknown` (not `missing`) when the protocol cannot source as many files as are required, a bounded source command failed, or candidate identities were rejected.
+- *Synthetic agent correctness*: the deterministic fake agent reports only two expected facts, so scenarios requiring three or more facts score 0.75 (0.70 for T1) and never pass. This is not measured my-dev-kit answer correctness, is identical across treatments, and cannot discriminate between them.
+- *Candidate relative to full refresh*: the relation and classification fields. Full refresh is the reference, not an automatically adequate treatment: an equal required-file status supports `same` only when the full-refresh reference itself is `present`. `missing`/`missing` is reported as `unknown`, so an all-equal but insufficient experiment is `inconclusive`, never `no-observed-regression`.
+
+Fact-context-target coverage from `retrievalQuality` is not used here: five of the six frozen scenario answer keys carry no `factIds` mappings, so that metric would be unavailable.
+
 **Report presentation.** `report.incrementalChangeStaleness` (schema `my-dev-kit-lab-incremental-change-staleness-report-v2`) holds the summary counts (including per-treatment applied-partial, fallback, and classification counts), per-scenario lifecycle, four treatments and three comparisons identified by explicit treatment IDs, and fixed limitations text. Unavailable evidence is written as `unavailable` or `not applicable`, never zero. Historical V1 reports keep their original two-treatment presentation.
 
 ## Retrieval precision/recall evidence (v0.8.0)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dailephd/my-dev-kit-lab",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "type": "module",
   "description": "Evidence, benchmark, and evaluation companion for my-dev-kit.",
   "bin": {