audit-tools 0.55.5 → 0.55.6

package/dist/audit/io/rollover.js

@@ -0,0 +1,152 @@
+// sites-pinned: tests/audit/artifacts-dir-rollover.test.ts
+/**
+ * The rollover of a finished audit's working dir into the next run (owner
+ * decision 2026-10-08, "keep the artifacts dir"; record
+ * docs/reviews/artifacts-dir-rollover-plan-2026-10-08.md).
+ *
+ * PROPERTY: the next run reuses every derived artifact whose inputs did not
+ * change — the staleness DAG decides which — and inherits NOTHING that belongs
+ * to the finished run. The carried set is an ALLOW-LIST: every entry not named
+ * here is deleted, so a run-scoped file added later can never leak into the
+ * next run by being forgotten.
+ *
+ * A run is FINISHED when its terminal step presented a promoted report: that
+ * step writes the run-ended marker (`markRunEnded`). The marker, not byte
+ * identity between the dir and the archive, is the gate: a host may still
+ * append diagnostics after promotion, and an operator may resynthesize the
+ * promoted deliverables, and neither may keep the next audit from starting.
+ * The appended diagnostics are archived again here before anything is deleted.
+ *
+ * Deliberately NOT carried, and why:
+ * - `audit_state.json`: a `complete` status short-circuits every derivation.
+ * - The intake set (`repo_manifest`, `file_disposition`, `scope`,
+ *   `scope_summary.json`): live-tree drift is never detected against a retained
+ *   manifest, and `--since` is not a DAG input. Re-intake of an unchanged tree
+ *   reproduces the same manifest content hash (`generated_at` is not semantic),
+ *   so nothing downstream re-stales.
+ * - Per-run choices (`intent_checkpoint`, consent and the analyzer results it
+ *   admitted, `auto_fixes_applied`, host fallbacks, and the analyzer install
+ *   settings in `analyzer-policy.json`): a per-run choice is never persisted
+ *   into the next run.
+ * - The finished run's deliverables in place (already promoted one level up)
+ *   and every run-scoped record: steps, dispatch, runs, submissions and their
+ *   ledger, staging, quarantine, lanes, scratch, friction, logs, handoff,
+ *   guidance, the snapshot record.
+ * - `tooling_manifest.json`: never read from disk; every bundle load rebuilds it.
+ *
+ * Measured (2026-10-08): over an UNCHANGED tree the next run re-derives only
+ * deterministic planning (`audit_tasks`, `audit_plan_metrics`,
+ * `task_affinity_graph`); the re-intaken manifest differs only in its
+ * non-semantic `generated_at`, so the analysis artifacts and the host-judged
+ * ones (charter, design assessment, systemic challenge) keep their revisions.
+ */
+import { existsSync } from "node:fs";
+import { readdir, rm, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { AUDIT_FINDINGS_FILENAME, auditFindingsPath, promotedAuditFindingsPath, SESSION_INTENT_RELATIVE_PATH, } from "audit-tools/shared";
+import { withArtifactTreeHold } from "../../shared/io/artifactTreeHold.js";
+import { ARTIFACT_DEFINITIONS, archiveRunDiagnostics } from "./artifacts.js";
+import { removeRunSnapshot } from "./runSnapshot.js";
+import { CHARTER_PACKET_ARCHIVE_DIRNAME } from "../orchestrator/charterPacketArchive.js";
+import { SNAPSHOT_DIRNAME } from "../orchestrator/designReviewSnapshot.js";
+import { graphEdgeCachePath } from "../orchestrator/graphEdgeCache.js";
+/** Registry artifacts derived from the run's inputs, each staleness-judged by the DAG. */
+const CARRIED_ARTIFACTS = [
+    "artifact_metadata",
+    "audit_results",
+    "unit_manifest",
+    "graph_bundle",
+    "surface_manifest",
+    "critical_flows",
+    "flow_coverage",
+    "risk_register",
+    "git_history",
+    "design_assessment",
+    "conceptual_review_adjudication",
+    "docs_digest",
+    "structure_decomposition",
+    "charter_register",
+    "charter_clarification",
+    "systemic_challenge",
+    "analyzer_capability",
+    "coverage_matrix",
+    "runtime_validation_tasks",
+    "runtime_validation_report",
+    "audit_tasks",
+    "audit_plan_metrics",
+    "task_affinity_graph",
+    "requeue_tasks",
+    "access_memory",
+    "synthesis_narrative",
+];
+/** Content-keyed stores outside the registry, each self-invalidating. */
+const CARRIED_STORES = [SNAPSHOT_DIRNAME, basename(graphEdgeCachePath("")), CHARTER_PACKET_ARCHIVE_DIRNAME];
+/**
+ * The operator's hand-authored repository intent (docs/audit-pkg/operator-guide.md).
+ * It grants nothing to a run on its own; the tool never writes it.
+ */
+const CARRIED_INTENT = [basename(SESSION_INTENT_RELATIVE_PATH)];
+const CARRIED = new Set([
+    ...CARRIED_ARTIFACTS.map((key) => ARTIFACT_DEFINITIONS[key].fileName),
+    ...CARRIED_STORES,
+    ...CARRIED_INTENT,
+]);
+const STATE_FILE = ARTIFACT_DEFINITIONS.audit_state.fileName;
+const runEndedPath = (artifactsDir) => join(artifactsDir, "run-ended.json");
+/**
+ * Record that the run ended: its terminal step presented a promoted report.
+ * Written by the terminal step only after the promotion succeeded.
+ */
+export async function markRunEnded(artifactsDir) {
+    await writeFile(runEndedPath(artifactsDir), "{}\n");
+}
+function warn(message) {
+    process.stderr.write(`[audit-code] ${message}\n`);
+}
+/**
+ * Roll an ENDED run over (see `markRunEnded`), under the artifact-tree hold:
+ * archive its diagnostics again, remove its snapshot, and delete every entry
+ * that is not carried. The state file and the marker go LAST, so a rollover
+ * that fails part-way is retried in full on the next call and never leaves a
+ * run-scoped record (consent above all) for the next run to adopt. When a
+ * diagnostic does not archive, or the snapshot cannot be removed, nothing is
+ * deleted: the dir then holds the only copy, or the record of what to clean.
+ * Returns whether it rolled the dir over.
+ */
+export async function rollOverFinishedRun(artifactsDir, runLogger) {
+    if (!existsSync(runEndedPath(artifactsDir)))
+        return false;
+    return await withArtifactTreeHold(artifactsDir, runLogger, async () => {
+        if (!existsSync(runEndedPath(artifactsDir)))
+            return false;
+        // The machine contract is promoted at the terminal step, never re-copied
+        // here (an operator may have resynthesized the promoted pair). An in-place
+        // contract with no promoted copy is the only copy: keep the dir.
+        if (existsSync(auditFindingsPath(artifactsDir)) && !existsSync(promotedAuditFindingsPath(artifactsDir))) {
+            warn(`the finished audit in ${artifactsDir} was not rolled over: ${AUDIT_FINDINGS_FILENAME} has no promoted copy ` +
+                `at ${promotedAuditFindingsPath(artifactsDir)}; copy it there, or run \`audit-code cleanup --force\` to discard it`);
+            return false;
+        }
+        const { lost } = await archiveRunDiagnostics({ artifactsDir });
+        if (lost.length > 0) {
+            warn(`the finished audit in ${artifactsDir} was not rolled over: could not archive ${lost.join("; ")}`);
+            return false;
+        }
+        const problems = await removeRunSnapshot(artifactsDir);
+        if (problems.length > 0) {
+            warn(`the finished audit in ${artifactsDir} was not rolled over: run snapshot cleanup: ${problems.join("; ")}`);
+            return false;
+        }
+        // Lock files are never deleted: the hold this runs under owns one of them.
+        const last = [STATE_FILE, basename(runEndedPath(artifactsDir))];
+        for (const entry of await readdir(artifactsDir)) {
+            if (CARRIED.has(entry) || entry.endsWith(".lock") || last.includes(entry))
+                continue;
+            await rm(join(artifactsDir, entry), { recursive: true, force: true });
+        }
+        for (const entry of last)
+            await rm(join(artifactsDir, entry), { force: true });
+        return true;
+    });
+}
+//# sourceMappingURL=rollover.js.map

package/dist/audit/io/rollover.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rollover.js","sourceRoot":"","sources":["../../../src/audit/io/rollover.ts"],"names":[],"mappings":"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"}

package/dist/audit/io/runSnapshot.d.ts

@@ -0,0 +1,149 @@
+import { z } from "zod";
+declare const RunSnapshotSchema: z.ZodObject<{
+    schema_version: z.ZodLiteral<"audit-run-snapshot/v1">;
+    repository_root: z.ZodString;
+    source_root: z.ZodString;
+    kind: z.ZodEnum<["git", "copy"]>;
+    /** Root repository first, then each submodule after its parent. Empty for `copy`. */
+    pins: z.ZodArray<z.ZodObject<{
+        /** realpath of the live repository directory that owns this pin's objects. */
+        repository: z.ZodString;
+        /** The checkout inside the snapshot. */
+        path: z.ZodString;
+        /** The live `HEAD` at run start — the checkout's `HEAD`; `null` when unborn. */
+        base: z.ZodNullable<z.ZodString>;
+        /** The tree of the live INDEX at run start — the checkout's index. */
+        index: z.ZodString;
+        /** The copied bytes as a commit, kept only to restore the checkout. */
+        commit: z.ZodString;
+        /** This run's own ref holding `commit`. */
+        ref: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        index: string;
+        path: string;
+        commit: string;
+        ref: string;
+        base: string | null;
+        repository: string;
+    }, {
+        index: string;
+        path: string;
+        commit: string;
+        ref: string;
+        base: string | null;
+        repository: string;
+    }>, "many">;
+    /** Snapshot-relative (POSIX) paths of the directory links the snapshot placed. */
+    linked: z.ZodArray<z.ZodString, "many">;
+    /** Each `--since` ref this run was given, resolved ONCE against the live root. */
+    since: z.ZodRecord<z.ZodString, z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    kind: "git" | "copy";
+    schema_version: "audit-run-snapshot/v1";
+    repository_root: string;
+    since: Record<string, string>;
+    source_root: string;
+    pins: {
+        index: string;
+        path: string;
+        commit: string;
+        ref: string;
+        base: string | null;
+        repository: string;
+    }[];
+    linked: string[];
+}, {
+    kind: "git" | "copy";
+    schema_version: "audit-run-snapshot/v1";
+    repository_root: string;
+    since: Record<string, string>;
+    source_root: string;
+    pins: {
+        index: string;
+        path: string;
+        commit: string;
+        ref: string;
+        base: string | null;
+        repository: string;
+    }[];
+    linked: string[];
+}>;
+export type RunSnapshot = z.infer<typeof RunSnapshotSchema>;
+export declare const runSnapshotPath: (artifactsDir: string) => string;
+/**
+ * The run's snapshot: created at run start, its checkouts restored when they
+ * went missing, refused when a copy went missing.
+ *
+ * The caller holds the artifact-tree lock (the snapshot is run state, created
+ * once per run). Callers on a run path go through {@link ensureRunSourceRoot},
+ * which owns the "a complete run reads nothing" rule.
+ */
+export declare function ensureRunSnapshot(root: string, artifactsDir: string): Promise<RunSnapshot>;
+/**
+ * The root a run's content reads use — THE one decision every run path shares
+ * (the next-step fold and every standalone step command). A COMPLETE run reads
+ * nothing more: it is given no snapshot (promotion removed it, and a new one
+ * would freeze a tree the run never read), and its terminal step needs only the
+ * live root. Any other run reads its frozen snapshot. The caller holds the
+ * artifact-tree lock.
+ */
+export declare function ensureRunSourceRoot(root: string, artifactsDir: string): Promise<string>;
+/**
+ * The commit a `--since` ref named when this run first saw it, resolved against
+ * the LIVE root (a pseudo-ref such as the branch upstream @{u} or ORIG_HEAD does
+ * not resolve in the detached snapshot) and persisted, so a moving HEAD cannot move the
+ * delta mid-run. An unresolvable ref is returned unchanged, for the scope
+ * resolver's own full-audit fallback. The caller holds the artifact-tree lock.
+ */
+export declare function resolveRunSince(root: string, artifactsDir: string, since: string): Promise<string>;
+/** The `--since` resolution this run recorded, without resolving anything (no lock). */
+export declare function lookupRunSince(artifactsDir: string, since: string): Promise<string>;
+/**
+ * The source root of the run in `artifactsDir`, WITHOUT creating a snapshot —
+ * for a read-only command that holds no lock. With no run started there is no
+ * frozen tree, and the live root is the only content there is.
+ */
+export declare function readRunSourceRoot(root: string, artifactsDir: string): Promise<string>;
+/** The directory links the run's snapshot placed — never audit input (see `readAuditReadState`). */
+export declare function readRunSnapshotLinks(artifactsDir: string): Promise<readonly string[]>;
+/**
+ * The one statement of where a host lane reads repository source during a run:
+ * the frozen snapshot, never its own working directory or the live repository,
+ * which may have moved since the run started. Single-sourced so the work-item
+ * prompts and every materialized lane prompt say it identically.
+ */
+export declare function sourceTreeInstruction(sourceRoot: string): string;
+/**
+ * Carry the tool's own edits of the snapshot (the opted-in auto-fix phase) back
+ * to the live tree. A file is written only when its live bytes still hash to
+ * `startHashes` — the content the run started from — so a user's concurrent
+ * edit is never overwritten; such a file is returned as skipped.
+ */
+export declare function writeBackSnapshotEdits(params: {
+    sourceRoot: string;
+    repositoryRoot: string;
+    paths: readonly string[];
+    startHashes: ReadonlyMap<string, string>;
+}): Promise<{
+    written: string[];
+    skipped: string[];
+}>;
+/**
+ * Re-pin the run's snapshot after the tool edited it (deepest checkout first),
+ * so a checkout restored later holds the edited bytes. The checkouts' `HEAD`
+ * and index are unchanged: the edit is the run's, not a commit's. The placed
+ * links are subtracted — on POSIX a dir-only ignore pattern does not match a
+ * symlink, and a pinned link would be restored as a file.
+ */
+export declare function repinRunSnapshot(artifactsDir: string): Promise<void>;
+/**
+ * Remove the run's snapshot: its links first (each points into the live tree),
+ * then the directory, then each checkout's own registration and ref (deepest
+ * first), then the record. Never throws — a cleanup must not fail on the
+ * scratch it is reclaiming; each problem is returned for the caller to report.
+ * The record goes last and only on a clean removal, so a failed one can be
+ * retried and a second call is a no-op.
+ */
+export declare function removeRunSnapshot(artifactsDir: string): Promise<string[]>;
+export {};
+//# sourceMappingURL=runSnapshot.d.ts.map

package/dist/audit/io/runSnapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runSnapshot.d.ts","sourceRoot":"","sources":["../../../src/audit/io/runSnapshot.ts"],"names":[],"mappings":"AAmDA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwBxB,QAAA,MAAM,iBAAiB;;;;;IAKrB,qFAAqF;;QApBrF,8EAA8E;;QAE9E,wCAAwC;;QAExC,gFAAgF;;QAEhF,sEAAsE;;QAEtE,uEAAuE;;QAEvE,2CAA2C;;;;;;;;;;;;;;;;;IAY3C,kFAAkF;;IAElF,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEzE,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,eAAe,GAAI,cAAc,MAAM,KAAG,MAAiD,CAAC;AAsezG;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAqBhG;AAED;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAI7F;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAexG;AAED,wFAAwF;AACxF,wBAAsB,cAAc,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAEzF;AAED;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAG3F;AAED,oGAAoG;AACpG,wBAAsB,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAE3F;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAGhE;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,MAAM,EAAE;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;IACzB,WAAW,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C,GAAG,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAA;CAAE,CAAC,CAoBpD;AAED;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkB1E;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CA4B/E"}