@dzhechkov/harness-core 0.8.30 → 0.8.31

package/src/book-kb.ts

@@ -16,7 +16,10 @@ import { existsSync, mkdirSync } from 'node:fs';
 import { pathToFileURL } from 'node:url';
 import { createRequire } from 'node:module';
 
+import { openSqliteReadOnly } from '@dzhechkov/memory';
+
 import { describeNativeDep, exerciseSqliteOpen, probeNativeDep } from './native-dep-probe.js';
+import { applyReadonlyPragmas } from './sqlite-read-helpers.js';
 
 /** A digitized Knowledge Unit as stored in the book KB. */
 export interface BookKU {
@@ -98,6 +101,66 @@ async function openDb(projectRoot: string, dbPath?: string): Promise<NativeDb |
   return db;
 }
 
+/**
+ * Open `books.sqlite` for READING ONLY (ADR-001, Решение 2) — no `mkdirSync`, no `exec(SCHEMA)`,
+ * no `pragma journal_mode`. Same native-dependency probe and resolution as {@link openDb} above
+ * (a silently different `better-sqlite3` module instance would be the class of bug
+ * `sqlite-readonly.ts`'s `OpenReadOnlyOptions` doc warns about), so `absent`/`unusable` still
+ * return `{error}` — the "instrument did not run" contract is unchanged.
+ *
+ * Critical for FR-6/Риск-4: any OTHER failure (a genuinely unreadable store) must still THROW,
+ * exactly like `openDb`. This function is called from `queryBookKnowledge` OUTSIDE its `try` —
+ * do not wrap the call in a `try` here or there; that would turn "store unreadable" (exit 1)
+ * into "instrument didn't run" (exit 3), which is the regression `books-recall-honesty.test.ts`
+ * pins against (measured 2026-08-27).
+ */
+async function openDbForRead(projectRoot: string, dbPath?: string): Promise<NativeDb | { error: string }> {
+  const verdict = probeNativeDep(projectRoot, 'better-sqlite3', exerciseSqliteOpen, 'sqlite-open');
+  if (verdict.state === 'absent') {
+    return { error: 'better-sqlite3 not installed in project (run: dz setup --memory agentdb)' };
+  }
+  if (verdict.state === 'unusable') return { error: describeNativeDep(verdict) };
+  let sqliteUrl: string;
+  try {
+    const req = createRequire(join(projectRoot, 'package.json'));
+    sqliteUrl = pathToFileURL(req.resolve('better-sqlite3')).href;
+  } catch {
+    return { error: 'better-sqlite3 not installed in project (run: dz setup --memory agentdb)' };
+  }
+  const path = dbPath ?? bookKbPath(projectRoot);
+  // NO mkdirSync, NO exec(SCHEMA), NO pragma journal_mode — this is the read path (FR-1); anything
+  // past this point that throws is meant to throw (see the doc comment above).
+  const { default: Database } = (await import(sqliteUrl)) as {
+    default: new (p: string, o?: { readonly?: boolean; fileMustExist?: boolean }) => unknown;
+  };
+  const handle = openSqliteReadOnly(path, { Database: Database as never });
+  const db = handle.db as {
+    pragma: (s: string) => void;
+    exec: (s: string) => void;
+    prepare: NativeDb['prepare'];
+    transaction: NativeDb['transaction'];
+    close: () => void;
+  };
+  // FR-1 (readonly-residuals): a throwing pragma must not leak the connection or a tmp-copy —
+  // applyReadonlyPragmas closes + cleans up before rethrowing.
+  applyReadonlyPragmas(handle, path);
+  return {
+    pragma: db.pragma.bind(db),
+    exec: db.exec.bind(db),
+    prepare: db.prepare.bind(db),
+    transaction: db.transaction.bind(db),
+    close: () => {
+      // `cleanup()` in `finally` — the tmp-copy must be removed even if `db.close()` throws
+      // (fix round 1, MEDIUM #3; matches `SqliteReadOnlyStore.close()` in `sqlite-readonly.ts`).
+      try {
+        db.close();
+      } finally {
+        handle.cleanup();
+      }
+    },
+  };
+}
+
 /**
  * Upsert a batch of KUs for a book. Idempotent per (book, kuId): existing rows for the same
  * kuId are replaced, and — since a re-ingest changes `corpusVersion` — every row for the book
@@ -164,7 +227,7 @@ export async function queryBookKnowledge(
 ): Promise<{ hits: BookKUHit[]; error?: string }> {
   const path = opts.dbPath ?? bookKbPath(projectRoot);
   if (!existsSync(path)) return { hits: [] };
-  const opened = await openDb(projectRoot, opts.dbPath);
+  const opened = await openDbForRead(projectRoot, opts.dbPath);
   if ('error' in opened) return { hits: [], error: opened.error };
   const db = opened;
   try {

package/src/brain.ts

@@ -23,6 +23,7 @@ import { createRequire } from 'node:module';
 import { spawn } from 'node:child_process';
 import { putBookKnowledge, queryBookKnowledge, bookKbPath, type BookKU, type BookKUHit } from './book-kb.js';
 import { indexPatternsToAgentdb, searchAgentdbPatterns, reindexAgentdbRows, type AgentdbRow } from './agentdb-index.js';
+import type { SnapshotRotationReport } from './agentdb-snapshot-rotation.js';
 import { resolveEmbedModel, type EmbedModelConfig } from './embedding-config.js';
 
 // ─────────────────────────────────────── Home & paths ───────────────────────────────────────
@@ -992,7 +993,7 @@ await emb.initialize();
 await emb.embed('warm embedding model cache');
 `;
     try {
-      const nodeBin = existsSync(process.execPath) ? process.execPath : (process.argv[0] ?? 'node');
+      const nodeBin = process.execPath;
       const child = spawn(nodeBin, ['--input-type=module', '-e', script], {
         cwd: depsRoot,
         detached: true,
@@ -1066,7 +1067,15 @@ export async function searchBrainVectors(opts: {
 export async function reindexBrainVectors(opts: {
   brainHome?: string;
   depsRoot?: string;
-}): Promise<{ reembedded: number; model?: string; version?: number; backupPath?: string; error?: string }> {
+}): Promise<{
+  reembedded: number;
+  model?: string;
+  version?: number;
+  backupPath?: string;
+  error?: string;
+  /** Pre-reindex snapshot rotation outcome — forwarded verbatim from `reindexAgentdbRows` (FR-4). */
+  snapshots?: SnapshotRotationReport;
+}> {
   const home = opts.brainHome ?? brainHome();
   const depsRoot = opts.depsRoot ?? process.cwd();
   const read = readBookKus({ storePath: brainBooksPath(home), depsRoot });

package/src/cadence.ts

@@ -4,7 +4,7 @@
  * caught a «year» digest standing on 174 days of data — scale forgery by aggregation; an
  * aggregator that silently computes any requested period repeats it mechanically.
  *
- * Four sources, every degradation NAMED in the report, never a silent zero:
+ * Five sources, every degradation NAMED in the report, never a silent zero:
  *  - graded shipments: features/<slug>/08_qe_report.md through the hardened readQeGrade
  *    (prefix-negation aware, all measured real-world grade forms); ungraded reports are a COLUMN;
  *  - npm publishes: the dz recap registry-time cache (third-party timestamps);
@@ -12,6 +12,8 @@
  *    start (the data-driven birth proxy — the no-stubs class of «zero repeats because the rule is
  *    young» is excluded by construction);
  *  - knowledge reuse: recall events per bucket from .dz/recall-usage.jsonl.
+ *  - focused round outcomes and execution receipts from the run-cost ledger; package commit counts
+ *    are injected by the CLI so this module never acquires a git/process dependency.
  */
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
@@ -76,6 +78,80 @@ export function weeklyBuckets(events: readonly CadenceEvent[], windowStartMs: nu
 
 export interface GuardDecayRow { readonly rule: string; readonly before: number; readonly inWindow: number }
 
+const ROUND_OUTCOMES = [
+  'shipped', 'refuted', 'blocked', 'abandoned',
+  'done', 'timeout', 'session-limit', 'model-refused', 'failed', 'empty',
+] as const;
+type RoundSummaryOutcome = typeof ROUND_OUTCOMES[number];
+
+export interface RoundsSummary {
+  readonly total: number;
+  readonly byStage: Readonly<Record<'round' | 'round-exec', number>>;
+  readonly byOutcome: Readonly<Record<RoundSummaryOutcome, number>>;
+  readonly unfinished: readonly {
+    readonly slug: string;
+    readonly round: number;
+    readonly stage: 'round' | 'round-exec';
+    readonly outcome: string;
+    readonly reason: string | null;
+    readonly date: string;
+  }[];
+  readonly minutes: number;
+  readonly tokens: number;
+  readonly tokensUnknown: number;
+  readonly malformed: number;
+}
+
+/** Pure round-ledger projection over a closed time window. Unknown outcomes stay visible. */
+export function summarizeRounds(
+  rows: readonly unknown[],
+  window: { readonly windowStartMs: number; readonly nowMs: number },
+): RoundsSummary {
+  const byStage: Record<'round' | 'round-exec', number> = { round: 0, 'round-exec': 0 };
+  const byOutcome = Object.fromEntries(ROUND_OUTCOMES.map((outcome) => [outcome, 0])) as Record<RoundSummaryOutcome, number>;
+  const unfinished: Array<RoundsSummary['unfinished'][number]> = [];
+  let total = 0;
+  let minutes = 0;
+  let tokens = 0;
+  let tokensUnknown = 0;
+  let malformed = 0;
+
+  for (const candidate of rows) {
+    if (candidate === null || typeof candidate !== 'object' || Array.isArray(candidate)) continue;
+    const row = candidate as Record<string, unknown>;
+    const stage = row['stage'];
+    if (stage !== 'round' && stage !== 'round-exec') continue;
+    const date = typeof row['date'] === 'string' ? row['date'] : '';
+    const ts = Date.parse(date);
+    if (!Number.isFinite(ts) || ts < window.windowStartMs || ts > window.nowMs) continue;
+
+    total += 1;
+    byStage[stage] += 1;
+    const rawOutcome = typeof row['outcome'] === 'string' ? row['outcome'].trim() : '';
+    if ((ROUND_OUTCOMES as readonly string[]).includes(rawOutcome)) {
+      byOutcome[rawOutcome as RoundSummaryOutcome] += 1;
+    } else {
+      malformed += 1;
+    }
+    if (typeof row['minutes'] === 'number' && Number.isFinite(row['minutes']) && row['minutes'] >= 0) minutes += row['minutes'];
+    if (typeof row['tokens'] === 'number' && Number.isFinite(row['tokens']) && row['tokens'] >= 0) tokens += row['tokens'];
+    else tokensUnknown += 1;
+
+    if (rawOutcome !== 'shipped' && rawOutcome !== 'done') {
+      const reason = typeof row['reason'] === 'string' && row['reason'].trim() !== '' ? row['reason'].trim() : null;
+      unfinished.push({
+        slug: typeof row['slug'] === 'string' && row['slug'].trim() !== '' ? row['slug'].trim() : 'unknown',
+        round: typeof row['round'] === 'number' && Number.isInteger(row['round']) ? row['round'] : 0,
+        stage,
+        outcome: rawOutcome === '' ? 'malformed' : rawOutcome,
+        reason,
+        date,
+      });
+    }
+  }
+  return { total, byStage, byOutcome, unfinished, minutes, tokens, tokensUnknown, malformed };
+}
+
 /**
  * Repeat decay over the FIXED set: only rules with at least one event BEFORE the window start
  * qualify (their existence predates the window); newborn rules are EXCLUDED by construction and
@@ -107,6 +183,7 @@ export interface CadenceReport {
   readonly npmPublishes: { weekly: Record<string, number>; degraded: string | null };
   readonly guard: { decay: GuardDecayRow[]; excludedNewborn: string[]; degraded: string | null };
   readonly recalls: { weekly: Record<string, number>; degraded: string | null };
+  readonly rounds: RoundsSummary & { readonly commitsInWindow: number | null; readonly degraded: string | null };
 }
 
 function safeJsonl(path: string): unknown[] {
@@ -121,7 +198,7 @@ function safeJsonl(path: string): unknown[] {
 }
 
 /** Build the full report. `now` injectable — the refusal decision must be testable. */
-export function buildCadenceReport(root: string, window: CadenceWindow, now?: number): CadenceReport {
+export function buildCadenceReport(root: string, window: CadenceWindow, now?: number, commitsInWindow?: number | null): CadenceReport {
   const nowMs = typeof now === 'number' && isFinite(now) ? now : Date.now();
 
   // Shipment events: graded 08 reports, dated by the run-cost ledger (fallback: report mtime is
@@ -216,6 +293,13 @@ export function buildCadenceReport(root: string, window: CadenceWindow, now?: nu
     recallWeekly[wk] = (recallWeekly[wk] ?? 0) + 1;
   }
   const recallDegraded = recallRows.length === 0 ? 'no recall-usage events — the reuse leg has nothing to stand on' : null;
+  const rounds = summarizeRounds(ledger, { windowStartMs: windowStart, nowMs });
+  const roundCommits = typeof commitsInWindow === 'number' && Number.isFinite(commitsInWindow) && commitsInWindow >= 0
+    ? commitsInWindow
+    : null;
+  const roundsDegraded = commitsInWindow === null
+    ? 'git unavailable — commits(packages/) not measured'
+    : null;
 
   return {
     window, decision, depthDays,
@@ -223,5 +307,6 @@ export function buildCadenceReport(root: string, window: CadenceWindow, now?: nu
     npmPublishes: { weekly: npmWeekly, degraded: npmDegraded },
     guard: { ...guard, degraded: guardDegraded },
     recalls: { weekly: recallWeekly, degraded: recallDegraded },
+    rounds: { ...rounds, commitsInWindow: roundCommits, degraded: roundsDegraded },
   };
 }

package/src/guard.ts

@@ -80,6 +80,20 @@ export interface GuardResult {
 /** Facts the CLI injects; each rule reads only the fields it needs. Missing evidence ⇒ that rule is skipped. */
 export interface GuardFacts {
   readonly op: GuardOp;
+  /** Package-code commits since the last round receipt; gathered by the CLI, never by core. */
+  readonly codeCommitsSinceLastRound?: {
+    readonly commits: number | null;
+    readonly since: string | null;
+    /** false is the explicit `.dz/config.json` `rounds.traced` waiver. */
+    readonly enabled?: boolean;
+  };
+  /** Open focused rounds are gathered from `.dz/rounds/` by the CLI; core receives facts only. */
+  readonly openRounds?: readonly {
+    readonly slug: string;
+    readonly round: number;
+    readonly ageMinutes: number;
+    readonly pidAlive: boolean | null;
+  }[];
   /** Signature evidence gathered by the CLI. The pure evaluator never reads manifests or keys. */
   readonly signedPacks?: readonly {
     readonly name: string;
@@ -458,6 +472,8 @@ function inspectSignatureFresh(
 
 /** The built-in rule set (works with no config). Ops are the mutating operations each rule guards. */
 export const DEFAULT_RULES: readonly GuardRule[] = [
+  { id: 'rounds-closed', severity: 'soft', ops: ['publish'], description: 'focused rounds older than 120 minutes are named before publish; a dead owner is reported as an abandoned round' },
+  { id: 'rounds-traced', severity: 'soft', ops: ['publish'], description: '10 or more package-code commits without a round ledger receipt are named; unavailable git evidence is not a pass' },
   { id: 'no-workspace-star', severity: 'hard', ops: ['publish'], description: 'a published package.json must carry no workspace:* dep (npm ships it verbatim → the install breaks)' },
   { id: 'plugin-manifest-audit', severity: 'hard', ops: ['publish'], description: 'every .claude-plugin/plugin.json parses and declares a non-empty name, description and a STRICT N.N.N version' },
   { id: 'sibling-dep-protocol', severity: 'hard', ops: ['publish'], description: 'a dependencies/devDependencies entry on a sibling @dzhechkov package must use the workspace: protocol on disk (peer/optional deps are deliberately exempt — a range is their point)' },
@@ -597,6 +613,25 @@ function mentionsSlug(haystackLower: string, slug: string): boolean {
 }
 
 const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[]> = {
+  'rounds-closed': (f, sev) => (f.openRounds ?? [])
+    .filter((round) => Number.isFinite(round.ageMinutes) && round.ageMinutes > 120)
+    .map((round) => ({
+      rule: 'rounds-closed',
+      severity: sev,
+      detail: round.pidAlive === false
+        ? `abandoned round ${round.slug}#${round.round}: ${round.ageMinutes} min, owner pid is dead`
+        : `${round.slug}#${round.round}: open round ${round.ageMinutes} min, owner pid ${round.pidAlive === true ? 'is alive' : 'liveness is unknown'}`,
+    })),
+  'rounds-traced': (f, sev) => {
+    const fact = f.codeCommitsSinceLastRound;
+    if (fact === undefined || fact.enabled === false || fact.commits === null || !Number.isFinite(fact.commits)) return [];
+    if (fact.commits < 10) return [];
+    return [{
+      rule: 'rounds-traced',
+      severity: sev,
+      detail: `${fact.commits} коммитов кода без единой строки круга с ${fact.since ?? 'неизвестной даты'}`,
+    }];
+  },
   'no-workspace-star': (f, sev) => {
     const out: Violation[] = [];
     for (const p of f.packages ?? []) {
@@ -1022,6 +1057,10 @@ const CHECKERS: Record<string, (f: GuardFacts, sev: GuardSeverity) => Violation[
 
 /** Per-rule evidence predicates. No entry preserves the rule's existing checked behaviour exactly. */
 const HAS_INPUT: Partial<Record<string, (f: GuardFacts) => boolean>> = {
+  'rounds-traced': (f) => {
+    const fact = f.codeCommitsSinceLastRound;
+    return fact !== undefined && fact.enabled !== false && typeof fact.commits === 'number' && Number.isFinite(fact.commits);
+  },
   // `!== undefined` пропускал `null`: правило объявлялось проверенным и возвращало чисто по
   // ветке «улик нет». Это буквально отсутствие улик, отчитанное как проверка (назвал независимый
   // ревьюер 2026-09-04).
@@ -1232,6 +1271,13 @@ export function evaluateGuard(facts: GuardFacts, rules: readonly GuardRule[] = D
   // (missing contents ⇒ nothing reported), but a skip nobody can see is fail-SILENT. One aggregate
   // note, computed AFTER the verdict so it can never block or warn: information, not a violation.
   const notes: string[] = [];
+  if (notEstablished.includes('rounds-traced')) {
+    const fact = facts.codeCommitsSinceLastRound;
+    if (fact?.enabled === false) notes.push('rounds-traced: skipped (.dz/config.json rounds.traced=false)');
+    else if (fact?.commits === null) notes.push(fact.since === null
+      ? 'rounds-traced: not measured (ledger has no dated rows)'
+      : 'rounds-traced: not measured (git unavailable)');
+  }
   if (checked.includes('no-stubs')) {
     const skipped = facts.change?.stubSkipped;
     if (typeof skipped === 'number' && Number.isFinite(skipped) && skipped > 0) {

package/src/index.ts

@@ -182,6 +182,8 @@ export {
   BANDIT_RRF_CAP,
   withVectorTimeout,
   isVectorNoise,
+  isMirrorableRecord,
+  mirrorQuarantineOf,
   patternVectorEntry,
   dreamVectorEntry,
   memoryRecordVectorEntry,
@@ -208,6 +210,7 @@ export type {
   VectorEngineKind,
   VectorEngineMode,
   VectorEntry,
+  MirrorQuarantineMetadata,
   VectorHit,
   ImportVectorRow,
   MirrorReceipt,
@@ -230,7 +233,30 @@ export type {
 } from './vector-tier.js';
 export { runSetup, generateHooksConfig, generateAgentdbWriter, writerVersionOf, AGENTDB_WRITER_VERSION,
   agentdbStorePath, agentdbMcpStorePath, agentdbStoreSeparationProblem } from './setup.js';
-export { countLearningStoreRowsReadonly } from './store-counts.js';
+// apply-leg (feature setup-installs-apply-leg, ADR-001): the third self-learning leg (APPLY) as a
+// versioned generator + the ONE measurement dz doctor/parity both read (Decision 3).
+export {
+  APPLY_LEG_VERSION,
+  applyLegVersionOf,
+  bakedCoreDistDirOf,
+  recallHookSource,
+  embedDaemonSource,
+  applyLegHookEntries,
+  applyLegStatus,
+  applyLegReasonMessage,
+  resolveIdleMs,
+  IDLE_MS_INT32_MAX,
+} from './apply-leg.js';
+export type {
+  ApplyLegHookEntry,
+  ApplyLegHelperStatus,
+  ApplyLegHookPresence,
+  ApplyLegStatus,
+  ApplyLegNotInstalledReason,
+  ResolvedIdleMs,
+} from './apply-leg.js';
+export { countLearningStoreRowsReadonly, quarantineTierParity } from './store-counts.js';
+export type { QuarantineTierRow, QuarantineTierParity } from './store-counts.js';
 export type { LearningStoreRowCounts } from './store-counts.js';
 export {
   STORE_GUARD_VERSION,
@@ -265,12 +291,14 @@ export {
   segmentRun,
 } from './eta.js';
 export type { CheckpointObservation, EtaEstimate, EtaInput, IncompleteCoverageSample, RunSegment, StageDurationSample, StageSample } from './eta.js';
-export { indexPatternsToAgentdb, resolveAgentdbPath, searchAgentdbPatterns, listAgentdbDzIds, resolveAgentdbEmbedder, cosineSimilarity, importVectorsToAgentdb, reindexAgentdbRows, bumpAgentdbUses, clearAgentdbQuarantine, deleteAgentdbByDzIds, readAgentdbRowsByTaskType, DZ_OWNED_TASK_TYPES } from './agentdb-index.js';
+export { indexPatternsToAgentdb, resolveAgentdbPath, searchAgentdbPatterns, listAgentdbDzIds, resolveAgentdbEmbedder, cosineSimilarity, importVectorsToAgentdb, reindexAgentdbRows, bumpAgentdbUses, clearAgentdbQuarantine, deleteAgentdbByDzIds, readAgentdbRowsByTaskType, DZ_OWNED_TASK_TYPES, ensureAgentdbSchema } from './agentdb-index.js';
 export type { AgentdbSearchHit, AgentdbSearchResult, AgentdbImportRow } from './agentdb-index.js';
 export { DEFAULT_EMBED_MODEL, LEGACY_EMBED_MODEL, DEFAULT_EMBED_DIM, KNOWN_EMBED_DIMS, resolveEmbedModel, readEmbedManifest, writeEmbedManifest, embedManifestPath, legacyEmbedManifest } from './embedding-config.js';
 export type { EmbedModelConfig, EmbedModelSource, EmbedManifest } from './embedding-config.js';
 export { putBookKnowledge, queryBookKnowledge, bookKbPath } from './book-kb.js';
 export type { BookKU, BookKUHit } from './book-kb.js';
+export { applyReadonlyPragmas, classifySqliteReadFailure, warnOnce } from './sqlite-read-helpers.js';
+export type { PragmaTarget, SqliteReadFailureKind } from './sqlite-read-helpers.js';
 export {
   brainHome,
   brainBooksPath,
@@ -296,6 +324,24 @@ export {
 } from './brain.js';
 export type { BrainQueryResult, BrainRegistry, BrainSource } from './brain.js';
 export type { AgentdbRow, AgentdbIndexResult } from './agentdb-index.js';
+// AM-5 (agentdb-snapshot-lock fix-round): `rotatePreReindexSnapshotsUnlocked` is package-internal
+// ONLY — the public API is `rotatePreReindexSnapshots`, which takes the snapshot lock. Exporting
+// the unlocked primitive from this barrel would hand callers outside the package a way to rotate
+// snapshots with NO mutual exclusion at all, defeating the whole point of this feature.
+export { listPreReindexSnapshots, planSnapshotRotation, rotatePreReindexSnapshots, scanSnapshotDir } from './agentdb-snapshot-rotation.js';
+export type { SnapshotFile, SnapshotFamily, SnapshotRotationPlan, SnapshotRotationReport, RotateSnapshotsOptions } from './agentdb-snapshot-rotation.js';
+export { snapshotSqliteDatabase, restoreSqliteSnapshot } from './agentdb-snapshot.js';
+export type { SnapshotMethod, SnapshotOutcome, SnapshotDbCtor } from './agentdb-snapshot.js';
+export {
+  withAgentdbSnapshotLock,
+  writeReindexMarker,
+  markReindexMarkerRecoveryRequired,
+  clearReindexMarker,
+  readLiveReindexMarkers,
+  reindexMarkerPath,
+  REINDEX_MARKER_TTL_MS,
+} from './agentdb-reindex-marker.js';
+export type { ReindexMarker } from './agentdb-reindex-marker.js';
 export { generatePlugin } from './plugin.js';
 export type { PluginManifest } from './plugin.js';
 export type { SetupOptions, SetupResult, SetupStep } from './setup.js';
@@ -905,6 +951,7 @@ export {
 export type { ParserSafeRegionVerdict, ParserSafeRegionRefusal } from './parser-safe-region.js';
 export {
   CLAUDE_USAGE_MODELS,
+  computeSpendReport,
   computeUsage,
   deriveUsageCalibration,
   fixedBlockWindowFor,
@@ -912,10 +959,12 @@ export {
   normalizeClaudeUsageModelKey,
   parseWeeklyResetAnchor,
   readUsageLimits,
+  spendReport,
+  spendInvariantViolations,
   weeklyWindowFor,
 } from './usage.js';
 export { claudeProjectsRoot, rawTokenMixOf, weightedTokensOf } from './usage.js';
-export type { RawTokenMix } from './usage.js';
+export type { RawTokenMix, SpendReport } from './usage.js';
 // Per-stage cost ledger + reconciliation invariant (feature cost-ledger, ADR-001/002/003).
 export {
   COST_LEDGER_SCOPE,
@@ -1073,8 +1122,8 @@ export * from './backlog.js';
 export * from './no-stubs.js';
 export { quiescenceProbeScript, decideWriterQuiescence, WQ_WINDOW_SECONDS, WQ_MAX_WINDOWS, WQ_REQUIRED_QUIET } from './writer-quiescence.js';
 export type { WriterQuiescenceDecision } from './writer-quiescence.js';
-export { decideCadenceWindow, isoWeekOf, weeklyBuckets, guardRepeatDecay, buildCadenceReport, CADENCE_WINDOW_DAYS } from './cadence.js';
-export type { CadenceWindow, CadenceReport, CadenceWindowDecision } from './cadence.js';
+export { decideCadenceWindow, isoWeekOf, weeklyBuckets, guardRepeatDecay, summarizeRounds, buildCadenceReport, CADENCE_WINDOW_DAYS } from './cadence.js';
+export type { CadenceWindow, CadenceReport, CadenceWindowDecision, RoundsSummary } from './cadence.js';
 export { readQeRounds, countQeRounds, QE_ROUNDS_DEFAULT_CEILING } from './qe-rounds.js';
 export type { QeRound, QeFailedAttempt, QeRoundsReport, QeRoundsStatus } from './qe-rounds.js';
 export {
@@ -1165,4 +1214,8 @@ export * from './run-registry.js';
 
 export { JOURNAL_KINDS, formatLine, parseLine, selectWindow, appendWitnessed } from './journal.js';
 export type { JournalKind, JournalEvent, JournalLine, JournalIo } from './journal.js';
+export { openRound, closeRound, listRounds } from './round.js';
+export type { RoundState, RoundExecState, RoundLedgerRow } from './round.js';
+export { parseCodexTokens, classifyRoundExecOutcome, buildRoundExecRow } from './round-exec.js';
+export type { RoundExecOutcome, RoundExecLedgerRow } from './round-exec.js';
 export * from './run-cleanup.js';

package/src/integration-probe-worker.ts

@@ -1,9 +1,6 @@
 /** Isolated bounded subprocess runner used by integration registration probes. */
 
 import { spawn, type ChildProcess } from 'node:child_process';
-import { realpathSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { resolve } from 'node:path';
 
 export const PROBE_REDACTION_MARKER = '[REDACTED]';
 export const PROBE_TRUNCATION_MARKER = '[TRUNCATED]';
@@ -214,7 +211,9 @@ export function runProbeWorker(request: ProbeWorkerRequest): Promise<ProbeWorker
     const child = spawn(request.command, [...request.args], {
       cwd: request.cwd,
       detached: process.platform !== 'win32',
-      env: process.env,
+      // Strip our own entry marker: a probed command (or its descendants) that imports this module must never
+      // run main() — review 2026-09-11 (Sonnet MEDIUM).
+      env: Object.fromEntries(Object.entries(process.env).filter(([key]) => key !== 'DZ_INTEGRATION_PROBE_WORKER')),
       stdio: ['ignore', 'pipe', 'pipe'],
       windowsHide: true,
     });
@@ -301,8 +300,7 @@ async function main(): Promise<void> {
   process.stdout.write(`${JSON.stringify(await runProbeWorker(request))}\n`);
 }
 
-const invokedPath = process.argv[1];
-if (invokedPath !== undefined && realpathSync(resolve(invokedPath)) === realpathSync(fileURLToPath(import.meta.url))) {
+if (process.env.DZ_INTEGRATION_PROBE_WORKER === '1') {
   main().catch((error) => {
     process.stderr.write(`integration probe worker failed: ${error instanceof Error ? error.message : String(error)}\n`);
     process.exitCode = 1;

package/src/integrations-verify.ts

@@ -74,7 +74,8 @@ export const defaultIntegrationProcessPort: IntegrationProcessPort = {
     if (!executable.ok) {
       return { status: null, signal: null, stdout: new Uint8Array(), stderr: new Uint8Array(), errorCode: executable.errorCode };
     }
-    const workerPath = fileURLToPath(new URL('./integration-probe-worker.js', import.meta.url));
+    // Source-importing tests and the compiled module both execute the built worker.
+    const workerPath = fileURLToPath(new URL('../dist/integration-probe-worker.js', import.meta.url));
     const result = spawnSync(process.execPath, [workerPath], {
       input: JSON.stringify({
         ...request,
@@ -83,6 +84,7 @@ export const defaultIntegrationProcessPort: IntegrationProcessPort = {
         aggregateMaxBytes: INTEGRATION_PROBE_AGGREGATE_MAX_BYTES,
       }),
       cwd: request.cwd,
+      env: { ...process.env, DZ_INTEGRATION_PROBE_WORKER: '1' },
       timeout: request.timeoutMs + 5_000,
       killSignal: 'SIGKILL',
       maxBuffer: 4 * 1024 * 1024,

package/src/managed-hooks.ts

@@ -86,8 +86,17 @@ export interface MergeManagedHookOptions {
  * - Events absent from `managed` are copied through untouched (including unknown ones), and their
  *   entries still count toward `foreignPreserved` — the number answers "how many of the user's
  *   entries did this registry hold and keep", not "how many survived the touched events".
- * - Within a touched event, non-ours entries keep their relative order and object identity, then
- *   the managed entries are appended.
+ * - Within a touched event, non-ours entries keep their relative order and object identity.
+ * - A CURRENT (non-legacy) managed entry that is already byte-identical to one of the fresh managed
+ *   targets stays IN PLACE rather than being dropped and re-appended at the tail (fix round 1,
+ *   feature `setup-installs-apply-leg`, review Codex C MEDIUM finding "идемпотентность Configure
+ *   hooks для чужой записи, добавленной ПОСЛЕ writer-а"). Before this, an already-installed managed
+ *   entry was unconditionally removed and the fresh target re-appended at the tail on EVERY run —
+ *   invisible while it was the only entry in its event, but a genuinely foreign entry a user added
+ *   AFTER it would get silently outrun to the front on the very next `dz setup` (MEASURED: `[writer,
+ *   foreign]` → next run → `[foreign, writer]`). Any managed entry that does NOT exactly match a
+ *   remaining target (stale content, a legacy shape, or a mixed matcher-group carrying a foreign
+ *   handler) still gets dropped/salvaged and the fresh target appended at the tail exactly as before.
  * - `merge(merge(x)) === merge(x)`.
  */
 export function mergeManagedHookEntries(
@@ -122,18 +131,34 @@ export function mergeManagedHookEntries(
   let replacedLegacy = false;
   for (const event of Object.keys(managed)) {
     const current = Array.isArray(hooks[event]) ? (hooks[event] as ManagedHookEntry[]) : [];
-    const kept: ManagedHookEntry[] = [];
+    const targets = [...(managed[event] ?? [])];
+    const usedTarget = new Array<boolean>(targets.length).fill(false);
+    const next: ManagedHookEntry[] = [];
     for (const entry of current) {
       const ours = options.isManaged(entry, event);
       if (!ours) {
-        kept.push(entry);
+        next.push(entry);
         continue;
       }
-      if (options.isLegacy?.(entry, event) === true) replacedLegacy = true;
+      const isLegacy = options.isLegacy?.(entry, event) === true;
+      if (isLegacy) replacedLegacy = true;
+      // A current-vintage managed entry already equal to one of the fresh targets is kept IN
+      // PLACE (see the doc comment above) — legacy entries always fall through to drop/salvage so
+      // they get migrated to the current shape rather than "matching" their own stale bytes.
+      if (!isLegacy) {
+        const matchIdx = targets.findIndex((t, i) => !usedTarget[i] && JSON.stringify(t) === JSON.stringify(entry));
+        if (matchIdx !== -1) {
+          usedTarget[matchIdx] = true;
+          next.push(entry);
+          continue;
+        }
+      }
       const salvaged = options.retainForeign?.(entry, event) ?? null;
-      if (salvaged !== null) kept.push(salvaged);
+      if (salvaged !== null) next.push(salvaged);
+    }
+    for (let i = 0; i < targets.length; i += 1) {
+      if (!usedTarget[i]) next.push(targets[i]);
     }
-    const next = [...kept, ...(managed[event] ?? [])];
     if (JSON.stringify(next) !== JSON.stringify(current)) changed = true;
     hooks[event] = next;
   }