vouchington-tooling 0.44.0 → 0.46.0

package/README.md

@@ -315,7 +315,6 @@ import {
 } from 'vouchington-tooling/vitest-diagnostics'
 import { runRetrospectiveTranscript } from 'vouchington-tooling/retrospective-transcript'
 import { appendJournal, probeBlackboard } from 'vouchington-tooling/agent-blackboard'
-import { buildSessionFrictionReport, recordFriction } from 'vouchington-tooling/session-friction'
 import { GITHUB_BODY_MAX_CHARACTERS, validateGitHubBodyLength } from 'vouchington-tooling'
 import { createPullRequest, processDiffCommand, runGh, runGit } from 'vouchington-tooling/gh-cli'
 import {
@@ -475,41 +474,6 @@ audit finishes, when the process receives SIGINT, SIGTERM, or SIGHUP, and on the
 previous process died first, including SIGKILL. Each workspace records its owner's PID so a later
 audit can delete directories whose owner is gone.
 
-`session-friction` is an opt-in capture and reporting library. Callers supply the session id,
-absolute log directory, host-independent observation, and journal loader; it does not inspect host
-environment variables, install hooks, or connect to a journal service by itself. Invoking
-`recordFriction` touches the session log even when no event is classified, preserving the
-difference between an observed clean session and missing evidence. Report markdown keeps backend
-diagnostics separate from its paste-safe output. Capture stores at most 500 events per session and counts rejected captures in a fixed-size atomic
-sidecar under the same session lock for either the event or byte limit, with visible `truncated`/`droppedCount` metadata. Saturated
-capture reads only the bounded counter; reports also preserve historical overflow markers.
-Interrupted or inconsistent counter updates make coverage unavailable. Malformed records also make the scan partial. It
-truncates event detail to 1,000 characters, and consumes up to 500 entries from the journal loader
-when building a report, stopping earlier when its aggregate 1 MB inspected-byte budget is reached.
-Bounded journal scans that stop before exhaustion are reported as incomplete rather than clean.
-Report liveness inherits the caller-supplied journal loader, which must bound its own I/O and yields.
-Log reads are capped at 2 MB, journal Markdown at 10,000 bytes per entry,
-and rendered audit fields are kept whole: composition loads the journal and friction log once, redacts each field from its raw text before Markdown escaping (a caller-supplied redactor runs first, then the built-in one), then renders the CI and sandbox sections, measures the real envelope against its 12,000-byte markdown and 16,384-byte envelope limits, and shrinks them in a few bounded attempts. A block shrinks Root diagnostic first and Evidence last, cutting only at token boundaries (never inside a URL or SHA) with a trailing `…`; groups that still cannot fit are omitted and counted in an explicit conforming group that points at the journal. The final attempt keeps only that omission note (about 300 bytes), so an input within roughly 300 bytes of the limit can still fail to compose. A caller-supplied `budgets` cap limits rendered groups only; the omission note is exempt from it. Permission requests record requested outcomes; explicit result observations may record approved
-or denied outcomes. A decision and simultaneous tool failure are both retained and counted in
-the report. Escalation detail without a decision remains unknown. Localhost connection
-refusal is an ambiguous failure and does not establish a sandbox cause. The supplied log directory must be dedicated
-to session-friction; existing directories must already be owner-only, while newly created
-directories and log files are enforced as owner-only when recording. Reads use a fixed bounded
-buffer that can detect growth one byte beyond the documented 2 MB cap.
-Ownership checks require POSIX effective-user IDs (Linux and macOS); session-friction throws on
-Windows and other platforms where those IDs are unavailable.
-Root-owned system symlink ancestors are supported for paths such as macOS `/var`; callers must not
-allow the directory chain to be mutated while it is being validated.
-Command-prefix normalization recognizes simple shell
-segments with single or double quotes; it does not evaluate substitutions or implement a full shell
-grammar. Normalization attempts limited redaction of obvious credential patterns but is not a secret
-scrubber; callers must ensure credentials are never included in captured commands.
-Failure classification inspects at most 100,000 structured-stderr characters, split evenly between
-the beginning and end when input exceeds that bound.
-Cooperating log readers and writers are serialized, including the initial clean-session
-touch. Recording and report log reads are synchronous: on contention they block the caller's
-event loop for up to one second before failing explicitly. Avoid these APIs on hot request paths.
-
 The artifact, review-payload, HTTP body, and pagination APIs validate untrusted inputs at their
 boundaries. Neutral review posting lives in `gha-post-review` and requires a caller-supplied GitHub
 token. Claude App OIDC is an explicitly selected `gha-claude-post-review` adapter; the legacy
@@ -669,31 +633,25 @@ replay the identical envelope and source ID to verify its actual persistence.
 generates required sections and markers. Tool and architectural assessments preserve observation,
 evidence, disposition and tracking reference. None-observed and unassessed states need a scoped
 reason. Complete coverage is rejected when required sources are unavailable or capture is partial.
-Typed collector reports expose availability independently of rendered text. Composition rejects
-aggregate dropped counts below observed friction drops and retains larger caller aggregates without
-double counting. Generated frontmatter carries validated `work_outcome` and `feedback_coverage`
+Typed collector reports expose availability independently of rendered text. Generated frontmatter carries validated `work_outcome` and `feedback_coverage`
 for consumers to preserve or reject conflicting explicit overrides; trusted mode stays external.
 Human top-five summaries do not authorize dropping additional durable findings.
 
 The `## CI Failures` and `## Sandbox & Permission Audit` sections come from one optional audit
-source; the two inputs are mutually exclusive and supplying both throws before any collector runs.
-`friction: {directory, journalLoader, ...}` keeps reading the session-friction log together with the
-journal and is unchanged. `journal: {journalLoader}` needs no friction directory or log: both
-sections are assessed from the session's journal entries alone, and the report carries
-`coverage.frictionStatus: 'journal-only'` (in place of `empty` or `events`) so the text states that
-no log was observed. `feedbackCoverage.status: 'complete'` accepts either source. It is rejected
-when neither is supplied (the error names the missing source), and a journal-only audit does not
-count as assessed when the loader reports `not-found` (there is no log to establish that the session
-was observed), throws, or is truncated by the scan bounds.
+source, `journal: {journalLoader}`: both sections are assessed from the session's journal entries
+alone, with the text stating `journal entries only`. `feedbackCoverage.status: 'complete'` is
+rejected when no journal source is supplied (the error names the missing source), and a journal
+audit does not count as assessed when the loader reports `not-found` (nothing else establishes that
+the session was observed), throws, or is truncated by the scan bounds.
 
 ```ts
 await composeRetrospective({ ...input, journal: { journalLoader } })
 ```
 
-`journalLoader` is the session-friction `JournalLoader`; `JournalLoader`, `JournalLoadResult`,
+`journalLoader` is a `JournalLoader`; `JournalLoader`, `JournalLoadResult`,
 `JournalEntry`, and `JournalAuditOptions` are exported as types from
-`vouchington-tooling/agent-blackboard`. The `## CI Failures` block grammar and its three status
-lines (`failures observed`, `none observed`, `unavailable (<reason>)`) are the same for both sources.
+`vouchington-tooling/agent-blackboard`. The `## CI Failures` block grammar has three status
+lines (`failures observed`, `none observed`, `unavailable (<reason>)`).
 Journal-only sandbox and permission entries are journal Markdown entries that hold exactly one
 block, escaped and length-bounded like CI failures, and other entries are ignored:
 
@@ -709,7 +667,7 @@ block, escaped and length-bounded like CI failures, and other entries are ignore
 
 `ambiguous-failure` takes the same shape as `sandbox-failure`. The section reports
 `Status: none observed` or `Status: events observed`, each followed by
-`(journal entries only; no friction log observed)`; a truncated scan reports
+`(journal entries only)`; a truncated scan reports
 `unavailable (journal scan incomplete)` with the entries read so far.
 
 ## Basic Auth exemption facts

package/dist/agent-blackboard/client.d.mts

@@ -32,6 +32,12 @@ export type BlackboardClientModule = {
     Snapshots?: new (connection: BlackboardConnection) => {
         export(options?: unknown): Promise<unknown>;
     };
+    /** Newer clients own the ownership markers of their exports and clean them with a capability. */
+    cleanupSnapshotPartitions?: (options: {
+        path?: string;
+        directory?: string;
+        cleanupToken?: string;
+    }) => Promise<void>;
 };
 type BlackboardClientLoader = () => Promise<BlackboardClientModule>;
 export type BlackboardClientDependencies = {

package/dist/agent-blackboard/feedback-audit-source.d.mts

@@ -1,17 +1,11 @@
-import { type FrictionReportInputs, type SessionFrictionReport, type SessionFrictionReportOptions } from '../session-friction/index.mts';
-import type { JournalScan } from '../session-friction/journal.mts';
+import type { JournalScan } from '../audit-journal/journal.mts';
 import { type JournalAuditOptions, type JournalAuditReport } from './feedback-journal-audit.mts';
 export type AuditSourceInput = {
-    friction?: SessionFrictionReportOptions;
     journal?: JournalAuditOptions;
 };
-export type AuditReport = SessionFrictionReport | JournalAuditReport;
-export declare function assertSingleAuditSource(input: AuditSourceInput): void;
+export type AuditReport = JournalAuditReport;
 /** What the audit sections read from outside, loaded once and rendered as often as needed. */
 export type AuditInputs = {
-    kind: 'friction';
-    loaded: FrictionReportInputs;
-} | {
     kind: 'journal';
     scanned: JournalScan;
 } | {
@@ -19,7 +13,7 @@ export type AuditInputs = {
 };
 export declare function loadAuditInputs(sessionId: string, input: AuditSourceInput): Promise<AuditInputs>;
 /** Builds the CI-failure and sandbox sections from loaded inputs, with no further I/O. */
-export declare function renderAuditReport(sessionId: string, input: AuditSourceInput, inputs: AuditInputs): AuditReport;
-/** Only a real log status or an explicit journal-only scan counts as assessed. */
+export declare function renderAuditReport(input: AuditSourceInput, inputs: AuditInputs): AuditReport;
+/** Only a complete, untruncated journal scan counts as assessed. */
 export declare function auditAssessed({ coverage }: AuditReport): boolean;
 export declare function completeCoverageError(input: AuditSourceInput): Error;

package/dist/agent-blackboard/feedback-audit-source.mjs

@@ -1,37 +1,26 @@
-import { loadFrictionReportInputs, renderFrictionReport, } from "../session-friction/index.mjs";
 import { loadJournalAuditInput, renderJournalAuditReport, } from "./feedback-journal-audit.mjs";
 const ASSESSED_SOURCE_ERROR = 'complete feedback coverage requires assessed available factual and finding sources';
 const NOT_ASSESSED_MARKDOWN = '## CI Failures\nStatus: unavailable (not assessed)\n\n## Sandbox & Permission Audit\nStatus: unavailable (not assessed)';
-export function assertSingleAuditSource(input) {
-    if (input.friction && input.journal)
-        throw new Error('composition accepts either a friction or a journal audit source, not both');
-}
 export async function loadAuditInputs(sessionId, input) {
-    if (input.friction)
-        return { kind: 'friction', loaded: await loadFrictionReportInputs(sessionId, input.friction) };
     if (input.journal)
         return { kind: 'journal', scanned: await loadJournalAuditInput(sessionId, input.journal) };
     return { kind: 'none' };
 }
 /** Builds the CI-failure and sandbox sections from loaded inputs, with no further I/O. */
-export function renderAuditReport(sessionId, input, inputs) {
-    if (inputs.kind === 'friction')
-        return renderFrictionReport(sessionId, input.friction, inputs.loaded);
+export function renderAuditReport(input, inputs) {
     if (inputs.kind === 'journal')
-        return renderJournalAuditReport(sessionId, input.journal, inputs.scanned);
+        return renderJournalAuditReport(input.journal, inputs.scanned);
     return {
-        coverage: { journalStatus: 'unavailable', frictionStatus: 'absent', truncated: false },
+        coverage: { journalStatus: 'unavailable', truncated: false },
         markdown: NOT_ASSESSED_MARKDOWN,
     };
 }
-/** Only a real log status or an explicit journal-only scan counts as assessed. */
+/** Only a complete, untruncated journal scan counts as assessed. */
 export function auditAssessed({ coverage }) {
-    return (coverage.journalStatus === 'complete' &&
-        ['empty', 'events', 'journal-only'].includes(coverage.frictionStatus) &&
-        !coverage.truncated);
+    return coverage.journalStatus === 'complete' && !coverage.truncated;
 }
 export function completeCoverageError(input) {
-    return new Error(input.friction || input.journal
+    return new Error(input.journal
         ? ASSESSED_SOURCE_ERROR
-        : `${ASSESSED_SOURCE_ERROR} (no friction or journal source supplied for CI failures and sandbox audit)`);
+        : `${ASSESSED_SOURCE_ERROR} (no journal source supplied for CI failures and sandbox audit)`);
 }

package/dist/agent-blackboard/feedback-compose-audit.mjs

@@ -25,21 +25,13 @@ export function boundedAuditSource(input, caps) {
         ciBytes: Math.min(caller?.ciBytes ?? Infinity, caps.ciBytes),
         sandboxBytes: Math.min(caller?.sandboxBytes ?? Infinity, caps.sandboxBytes),
     });
-    return input.friction
+    return input.journal
         ? {
-            friction: {
-                ...input.friction,
-                redact: redactionFor(input.friction.redact),
-                budgets: clamp(input.friction.budgets),
+            journal: {
+                ...input.journal,
+                redact: redactionFor(input.journal.redact),
+                budgets: clamp(input.journal.budgets),
             },
         }
-        : input.journal
-            ? {
-                journal: {
-                    ...input.journal,
-                    redact: redactionFor(input.journal.redact),
-                    budgets: clamp(input.journal.budgets),
-                },
-            }
-            : {};
+        : {};
 }

package/dist/agent-blackboard/feedback-compose.d.mts

@@ -1,6 +1,5 @@
 import { type RetrospectiveFactsOptions } from '../retrospective-facts/index.mts';
 import { type ResolveOptions } from '../retrospective-transcript/index.mts';
-import type { SessionFrictionReportOptions } from '../session-friction/index.mts';
 import type { JournalAuditOptions } from './feedback-journal-audit.mts';
 import type { FeedbackCoverage, FeedbackReference, WorkOutcome } from './feedback-types.mts';
 export type FeedbackAssessment = {
@@ -29,9 +28,7 @@ export type RetrospectiveCompositionInput = {
     narrative: string;
     facts: Omit<RetrospectiveFactsOptions, 'raw'> | Unassessed;
     transcript: ResolveOptions | Unassessed;
-    /** CI failures and sandbox audit from a friction log plus journal. Exclusive with `journal`. */
-    friction?: SessionFrictionReportOptions;
-    /** CI failures and sandbox audit from journal entries alone (`frictionStatus: 'journal-only'`). */
+    /** CI failures and sandbox audit from the session journal's entries. */
     journal?: JournalAuditOptions;
     tools: FeedbackAssessment;
     architecture: FeedbackAssessment;

package/dist/agent-blackboard/feedback-compose.mjs

@@ -1,6 +1,6 @@
 import { runRetrospectiveFactsReport, } from "../retrospective-facts/index.mjs";
 import { runRetrospectiveTranscriptReport, } from "../retrospective-transcript/index.mjs";
-import { assertSingleAuditSource, auditAssessed, loadAuditInputs, renderAuditReport, completeCoverageError, } from "./feedback-audit-source.mjs";
+import { auditAssessed, loadAuditInputs, renderAuditReport, completeCoverageError, } from "./feedback-audit-source.mjs";
 import { AUDIT_ATTEMPTS, boundedAuditSource, shrinkCaps, UNBOUNDED_CAPS, } from "./feedback-compose-audit.mjs";
 import { createFeedbackEnvelope, feedbackOverflowBytes, redactFeedbackText, } from "./feedback-codec.mjs";
 import { validateFeedbackText } from "./feedback-fields.mjs";
@@ -33,7 +33,6 @@ function unavailable(marker, input) {
     return `${marker}\nStatus: ${input.status.replaceAll('-', ' ')} (${input.reason})`;
 }
 export async function composeRetrospective(input) {
-    assertSingleAuditSource(input);
     const unavailableFacts = 'status' in input.facts
         ? {
             markdown: unavailable('=== Retrospective Facts ===', input.facts),
@@ -93,7 +92,7 @@ export async function composeRetrospective(input) {
     let audit;
     let markdown;
     for (let attempt = 1;; attempt++) {
-        audit = renderAuditReport(input.sessionId, boundedAuditSource(input, caps), loaded);
+        audit = renderAuditReport(boundedAuditSource(input, caps), loaded);
         markdown = assemble(audit.markdown);
         const overflow = feedbackOverflowBytes(envelopeFor(markdown));
         if (!overflow || attempt === AUDIT_ATTEMPTS)
@@ -107,7 +106,5 @@ export async function composeRetrospective(input) {
             ['not-assessed', 'unavailable'].includes(input.architecture.status) ||
             !auditAssessed(audit)))
         throw completeCoverageError(input);
-    if ((audit.coverage.droppedCount ?? 0) > input.feedbackCoverage.droppedCount)
-        throw new Error('feedback coverage dropped count must include observed friction drops');
     return createFeedbackEnvelope(envelopeFor(markdown)).markdown;
 }

package/dist/agent-blackboard/feedback-fields.mjs

@@ -1,4 +1,4 @@
-import { isWellFormedUnicode } from "../session-friction/text.mjs";
+import { isWellFormedUnicode } from "../audit-journal/text.mjs";
 export function validateFeedbackText(value, label, maximum) {
     if (typeof value !== 'string' ||
         !value.trim() ||

package/dist/agent-blackboard/feedback-identity.mjs

@@ -1,4 +1,4 @@
-import { isWellFormedUnicode } from "../session-friction/text.mjs";
+import { isWellFormedUnicode } from "../audit-journal/text.mjs";
 import { assertSessionId } from "./session-id.mjs";
 import { isObject } from "./snapshot-partition-guards.mjs";
 export function validateFeedbackIdentity(identity) {

package/dist/agent-blackboard/feedback-journal-audit.d.mts

@@ -1,5 +1,5 @@
-import { type JournalScan } from '../session-friction/journal.mts';
-import type { JournalLoader, SessionFrictionCoverage } from '../session-friction/types.mts';
+import { type JournalScan } from '../audit-journal/journal.mts';
+import type { AuditCoverage, JournalLoader } from '../audit-journal/types.mts';
 export type JournalAuditOptions = {
     journalLoader: JournalLoader;
     /** Redacts raw field text before Markdown escaping, which would otherwise break matching. */
@@ -13,19 +13,17 @@ export type JournalAuditOptions = {
 /** `journal-only` says both sections were assessed from journal entries, with no log observed. */
 export type JournalAuditReport = {
     coverage: {
-        journalStatus: SessionFrictionCoverage['journalStatus'];
-        frictionStatus: 'journal-only';
+        journalStatus: AuditCoverage['journalStatus'];
         truncated: false;
-        droppedCount?: never;
     };
     markdown: string;
 };
 /**
  * Builds `## CI Failures` and `## Sandbox & Permission Audit` from the session's journal entries
- * alone. Unlike `buildSessionFrictionReport`, a session with no journal is unavailable rather than
- * empty: without a log, nothing else establishes that the session was observed.
+ * alone. A session with no journal is unavailable rather than empty: nothing else establishes
+ * that the session was observed.
  */
 export declare function loadJournalAuditInput(sessionId: string, options: JournalAuditOptions): Promise<JournalScan>;
 /** Pure render of a loaded journal scan, so it can be repeated without reloading. */
-export declare function renderJournalAuditReport(sessionId: string, options: JournalAuditOptions, scanned: JournalScan): JournalAuditReport;
+export declare function renderJournalAuditReport(options: JournalAuditOptions, scanned: JournalScan): JournalAuditReport;
 export declare function buildJournalAuditReport(sessionId: string, options: JournalAuditOptions): Promise<JournalAuditReport>;

package/dist/agent-blackboard/feedback-journal-audit.mjs

@@ -1,24 +1,24 @@
-import { buildCiFailuresSection, getConformingGroups, incompleteCiSection, } from "../session-friction/ci-failures.mjs";
-import { scanJournal } from "../session-friction/journal.mjs";
-import { validateSessionId } from "../session-friction/session-id.mjs";
+import { buildCiFailuresSection, getConformingGroups, incompleteCiSection, } from "../audit-journal/ci-failures.mjs";
+import { scanJournal } from "../audit-journal/journal.mjs";
+import { validateSessionId } from "../audit-journal/session-id.mjs";
 import { getConformingSandboxBlocks, journalSandboxSection, unavailableSandboxSection, } from "./feedback-journal-sandbox.mjs";
 function report(journalStatus, markdown) {
-    return { coverage: { journalStatus, frictionStatus: 'journal-only', truncated: false }, markdown };
+    return { coverage: { journalStatus, truncated: false }, markdown };
 }
 function unavailable(reason) {
     return report('unavailable', `## CI Failures\nStatus: unavailable (${reason})\n\n${unavailableSandboxSection(reason)}`);
 }
 /**
  * Builds `## CI Failures` and `## Sandbox & Permission Audit` from the session's journal entries
- * alone. Unlike `buildSessionFrictionReport`, a session with no journal is unavailable rather than
- * empty: without a log, nothing else establishes that the session was observed.
+ * alone. A session with no journal is unavailable rather than empty: nothing else establishes
+ * that the session was observed.
  */
 export async function loadJournalAuditInput(sessionId, options) {
     validateSessionId(sessionId);
     return scanJournal(sessionId, options.journalLoader);
 }
 /** Pure render of a loaded journal scan, so it can be repeated without reloading. */
-export function renderJournalAuditReport(sessionId, options, scanned) {
+export function renderJournalAuditReport(options, scanned) {
     if (scanned.status === 'unreachable')
         return unavailable('blackboard unreachable');
     if (scanned.status === 'not-found')
@@ -27,9 +27,8 @@ export function renderJournalAuditReport(sessionId, options, scanned) {
     const sandbox = getConformingSandboxBlocks(scanned.entries, options.redact, options.budgets?.sandboxBytes);
     if (scanned.truncated)
         return report('partial', `${incompleteCiSection(ci)}\n\n${unavailableSandboxSection('journal scan incomplete', sandbox)}`);
-    const journal = { status: 'ok', markdownBlocks: ci, truncated: false };
-    return report('complete', `${buildCiFailuresSection(sessionId, journal, 'journal-only')}\n\n${journalSandboxSection(sandbox)}`);
+    return report('complete', `${buildCiFailuresSection(ci)}\n\n${journalSandboxSection(sandbox)}`);
 }
 export async function buildJournalAuditReport(sessionId, options) {
-    return renderJournalAuditReport(sessionId, options, await loadJournalAuditInput(sessionId, options));
+    return renderJournalAuditReport(options, await loadJournalAuditInput(sessionId, options));
 }

package/dist/agent-blackboard/feedback-journal-sandbox.d.mts

@@ -1,5 +1,5 @@
-import type { AuditRedactor } from '../session-friction/text.mts';
-import type { JournalEntry } from '../session-friction/types.mts';
+import type { AuditRedactor } from '../audit-journal/text.mts';
+import type { JournalEntry } from '../audit-journal/types.mts';
 /** Journal entries that hold exactly one sandbox or permission block, made paste-safe. */
 export declare function getConformingSandboxBlocks(entries: Iterable<JournalEntry>, redact?: AuditRedactor, maxBytes?: number): string[];
 export declare function unavailableSandboxSection(reason: string, blocks?: string[]): string;

package/dist/agent-blackboard/feedback-journal-sandbox.mjs

@@ -1,6 +1,6 @@
-import { conformingBlocks, matchAuditBlock } from "../session-friction/audit-block.mjs";
+import { conformingBlocks, matchAuditBlock } from "../audit-journal/audit-block.mjs";
 const SANDBOX_SECTION_HEADER = '## Sandbox & Permission Audit';
-const SOURCE = 'journal entries only; no friction log observed';
+const SOURCE = 'journal entries only';
 const EVIDENCE = /^ {2}- Evidence: .*[^\s]$/;
 const DISPOSITION = /^ {2}- Disposition: .*[^\s]$/;
 const ESCALATION = [

package/dist/agent-blackboard/feedback-outbox-rejected.mjs

@@ -1,6 +1,6 @@
 import { readdirSync, renameSync } from 'node:fs';
 import { join } from 'node:path';
-import { withFileLock } from "../session-friction/lock.mjs";
+import { withFileLock } from "../private-files/lock.mjs";
 import { canonicalFeedback } from "./feedback-canonical.mjs";
 import { ensureOutboxDirectory } from "./feedback-outbox-directory.mjs";
 import { filename, outboxDirectory, readRecord, records, syncDirectory, } from "./feedback-outbox.mjs";

package/dist/agent-blackboard/feedback-outbox.mjs

@@ -3,8 +3,8 @@ import { createHash, randomUUID } from 'node:crypto';
 import { closeSync, constants, fsyncSync, fstatSync, openSync, readdirSync, renameSync, unlinkSync, } from 'node:fs';
 import { isAbsolute, join, resolve } from 'node:path';
 import { ensureOutboxDirectory } from "./feedback-outbox-directory.mjs";
-import { withFileLock } from "../session-friction/lock.mjs";
-import { openLogFile, readLogContent, writeAll } from "../session-friction/log-file.mjs";
+import { withFileLock } from "../private-files/lock.mjs";
+import { openLogFile, readLogContent, writeAll } from "../private-files/log-file.mjs";
 import { validateFeedbackEnvelope } from "./feedback-codec.mjs";
 import { validateFeedbackIdentity } from "./feedback-identity.mjs";
 import { isObject } from "./snapshot-partition-guards.mjs";

package/dist/agent-blackboard/index.d.mts

@@ -23,5 +23,5 @@ export { feedbackOutboxStatus, readFeedbackOutbox } from './feedback-outbox.mts'
 export { composeRetrospective } from './feedback-compose.mts';
 export type { RetrospectiveCompositionInput, FeedbackAssessment } from './feedback-compose.mts';
 export type { JournalAuditOptions } from './feedback-journal-audit.mts';
-export type { JournalEntry, JournalLoader, JournalLoadResult } from '../session-friction/types.mts';
+export type { JournalEntry, JournalLoader, JournalLoadResult } from '../audit-journal/types.mts';
 export { feedbackOutboxCounts } from './feedback-outbox-counts.mts';

package/dist/audit-journal/ci-failures.d.mts

@@ -0,0 +1,6 @@
+import type { JournalEntry } from './types.mts';
+import type { AuditRedactor } from './text.mts';
+export declare function isConformingCiFailureBlock(markdown: string): boolean;
+export declare function getConformingGroups(entries: Iterable<JournalEntry>, redact?: AuditRedactor, maxBytes?: number): string[];
+export declare function incompleteCiSection(markdownBlocks: string[]): string;
+export declare function buildCiFailuresSection(markdownBlocks: string[]): string;

package/dist/{session-friction → audit-journal}/ci-failures.mjs

@@ -1,5 +1,4 @@
 import { conformingBlocks, matchAuditBlock } from "./audit-block.mjs";
-import { markdownAuditText } from "./text.mjs";
 const GROUP_HEADER = /^- `(recurring|one-off)` — `GitHub Actions` — .*[^\s]$/;
 const EVIDENCE = /^ {2}- Evidence: .*[^\s]$/;
 const ROOT_DIAGNOSTIC = /^ {2}- Root diagnostic: .*[^\s]$/;
@@ -17,7 +16,6 @@ const CI_SECTION_MAX_BYTES = 4_000;
 // Field order: header, Evidence, Root diagnostic, Disposition. Cut Root diagnostic first and
 // Evidence last, so the run URL and commit SHA survive longest.
 const SHRINK_ORDER = [2, 3, 0, 1];
-const SESSION_ID_MAX_BYTES = 120;
 function matchBlock(markdown, render = {}) {
     return matchAuditBlock(markdown, [GROUP_HEADER, EVIDENCE, ROOT_DIAGNOSTIC, DISPOSITION], FIELD_PREFIXES, { ...render, shrinkOrder: SHRINK_ORDER });
 }
@@ -45,12 +43,8 @@ export function incompleteCiSection(markdownBlocks) {
         ...markdownBlocks,
     ].join('\n\n');
 }
-export function buildCiFailuresSection(sessionId, journal, frictionStatus) {
-    if (journal.status === 'unreachable')
-        return `${CI_FAILURES_HEADER}\nStatus: unavailable (blackboard unreachable)`;
-    if (journal.markdownBlocks.length === 0 && frictionStatus === 'absent')
-        return `${CI_FAILURES_HEADER}\nStatus: unavailable (no friction log for session ${markdownAuditText(sessionId, undefined, SESSION_ID_MAX_BYTES)})`;
-    if (journal.markdownBlocks.length === 0)
+export function buildCiFailuresSection(markdownBlocks) {
+    if (markdownBlocks.length === 0)
         return `${CI_FAILURES_HEADER}\nStatus: none observed`;
-    return `${CI_FAILURES_HEADER}\nStatus: failures observed\n\n${journal.markdownBlocks.join('\n\n')}`;
+    return `${CI_FAILURES_HEADER}\nStatus: failures observed\n\n${markdownBlocks.join('\n\n')}`;
 }

package/dist/{session-friction → audit-journal}/journal.d.mts

@@ -9,6 +9,5 @@ export type JournalScan = {
     status: 'unreachable';
     diagnostic: string;
 };
-export declare function errorMessage(error: unknown): string;
 /** Loads the session journal through the caller's loader within the shared bounded scan. */
 export declare function scanJournal(sessionId: string, loader: JournalLoader): Promise<JournalScan>;

package/dist/{session-friction → audit-journal}/journal.mjs

@@ -44,7 +44,7 @@ async function collectEntries(entries) {
     }
     return { entries: result, truncated };
 }
-export function errorMessage(error) {
+function errorMessage(error) {
     try {
         return error instanceof Error ? error.message : String(error);
     }

package/dist/audit-journal/session-id.d.mts

@@ -0,0 +1 @@
+export declare function validateSessionId(sessionId: string): void;

package/dist/{session-friction → audit-journal}/session-id.mjs

@@ -1,4 +1,3 @@
-import { createHash } from 'node:crypto';
 import { isWellFormedUnicode, normalizeAuditText } from "./text.mjs";
 const SESSION_ID_MAX_LENGTH = 4096;
 export function validateSessionId(sessionId) {
@@ -11,7 +10,3 @@ export function validateSessionId(sessionId) {
     if (normalizeAuditText(sessionId) === '')
         throw new Error('sessionId must be non-empty');
 }
-export function sanitizeSessionId(sessionId) {
-    validateSessionId(sessionId);
-    return createHash('sha256').update(sessionId).digest('hex');
-}

package/dist/{session-friction → audit-journal}/text.d.mts

@@ -1,7 +1,5 @@
 export declare function normalizeAuditText(value: string): string;
-export declare function boundedText(value: string, maximum: number): string;
 export declare function isWellFormedUnicode(value: string): boolean;
-export declare function isSafeAuditText(value: unknown): value is string;
 export type AuditRedactor = (value: string) => string;
 /**
  * Splits a field into atomic Markdown-escaped units (one code point, plus its backslash when
@@ -14,5 +12,4 @@ export declare function markdownAuditUnits(value: string, redact?: AuditRedactor
  * Joins escaped units whole, or, when over `maxBytes`, keeps only complete whitespace-separated
  * tokens (so URLs and SHAs are never split) and marks the cut. Never ends in whitespace.
  */
-export declare function fitUnits(units: string[], maxBytes: number, atTokens?: boolean): string;
-export declare function markdownAuditText(value: string, redact?: AuditRedactor, maxBytes?: number): string;
+export declare function fitUnits(units: string[], maxBytes: number): string;

package/dist/{session-friction → audit-journal}/text.mjs

@@ -3,14 +3,6 @@ const MARKDOWN_CHARACTER = /\\|`|\*|_|~|\[|\]|<|>|#|-|\+|!|\||&/;
 export function normalizeAuditText(value) {
     return value.replace(CONTROL_CHARACTERS, ' ').trim();
 }
-export function boundedText(value, maximum) {
-    let end = Math.min(value.length, maximum);
-    if (end < value.length &&
-        /[\uD800-\uDBFF]/.test(value[end - 1]) &&
-        /[\uDC00-\uDFFF]/.test(value[end]))
-        end--;
-    return value.slice(0, end);
-}
 export function isWellFormedUnicode(value) {
     for (let index = 0; index < value.length; index++) {
         const code = value.charCodeAt(index);
@@ -25,12 +17,6 @@ export function isWellFormedUnicode(value) {
     }
     return true;
 }
-export function isSafeAuditText(value) {
-    return (typeof value === 'string' &&
-        value !== '' &&
-        isWellFormedUnicode(value) &&
-        value === normalizeAuditText(value));
-}
 /**
  * Splits a field into atomic Markdown-escaped units (one code point, plus its backslash when
  * escaped), so a later cut can never land inside an escape sequence. Redaction runs on the raw
@@ -47,7 +33,7 @@ const WHITESPACE = /^\s$/u;
  * Joins escaped units whole, or, when over `maxBytes`, keeps only complete whitespace-separated
  * tokens (so URLs and SHAs are never split) and marks the cut. Never ends in whitespace.
  */
-export function fitUnits(units, maxBytes, atTokens = true) {
+export function fitUnits(units, maxBytes) {
     const whole = units.join('');
     if (Buffer.byteLength(whole) <= maxBytes)
         return whole;
@@ -58,13 +44,9 @@ export function fitUnits(units, maxBytes, atTokens = true) {
         used += Buffer.byteLength(unit);
         if (used > room)
             break;
-        if (!atTokens || WHITESPACE.test(unit))
-            boundary = atTokens ? index : index + 1;
+        if (WHITESPACE.test(unit))
+            boundary = index;
     }
     const kept = units.slice(0, boundary).join('').trimEnd();
-    return kept ? `${kept}${atTokens ? ' ' : ''}${CUT_MARKER}` : CUT_MARKER;
-}
-export function markdownAuditText(value, redact, maxBytes = Infinity) {
-    // Used for identifiers, which have no token boundaries to cut at.
-    return fitUnits(markdownAuditUnits(value, redact), maxBytes, false);
+    return kept ? `${kept} ${CUT_MARKER}` : CUT_MARKER;
 }

package/dist/audit-journal/types.d.mts

@@ -0,0 +1,17 @@
+export type JournalEntry = {
+    data?: {
+        type?: unknown;
+        markdown?: unknown;
+    };
+};
+export type JournalLoadResult = {
+    status: 'ok';
+    entries: Iterable<JournalEntry> | AsyncIterable<JournalEntry>;
+} | {
+    status: 'not-found';
+};
+export type JournalLoader = (sessionId: string) => JournalLoadResult | Promise<JournalLoadResult>;
+export type AuditCoverage = {
+    journalStatus: 'complete' | 'partial' | 'unavailable';
+    truncated: boolean;
+};

package/dist/cli/commands/gha-runtime-audit.mjs

@@ -1,9 +1,11 @@
 import { execFileSync } from 'node:child_process';
+import { ghSpawnEnv } from "../../gh-cli/env.mjs";
 import { auditCiJobRuntime } from "../../gha-runtime-audit/index.mjs";
 /* v8 ignore next 10 -- live `gh api` adapter */
 function defaultGhApiExecutor() {
     return async (request) => JSON.parse(execFileSync('gh', ['api', request.endpoint, '--jq', request.jq], {
         encoding: 'utf8',
+        env: ghSpawnEnv(),
         maxBuffer: 16 * 1024 * 1024,
     }));
 }