agentic-qe 3.14.4 → 3.14.6

package/.claude/skills/skills-manifest.json

@@ -940,7 +940,7 @@
   },
   "metadata": {
     "generatedBy": "Agentic QE Fleet",
-    "fleetVersion": "3.14.4",
+    "fleetVersion": "3.14.6",
     "manifestVersion": "1.4.0",
     "lastUpdated": "2026-04-13T00:00:00.000Z",
     "contributors": [

package/CHANGELOG.md

@@ -5,6 +5,175 @@ All notable changes to the Agentic QE project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [3.14.6] - 2026-09-29
+
+This patch fixes an `aqe audit verify` crash on stores with no audit chain yet.
+It adds `aqe audit repair` for stores forked by concurrent writers before
+3.14.5, makes repeat `aqe init --auto` runs leave an unchanged project
+untouched, and makes GOAP planning work from the live fleet state. It also
+redacts secrets from AQE's logs and lets keyword matches improve pattern
+search.
+
+### Security
+
+- Secrets are redacted from AQE's structured logs and from logged errors. This
+  covers API keys (`sk-ant-`, `sk-`, `ghp_`, `github_pat_`, `AKIA…`),
+  Bearer/Basic credentials, credentials in URLs, JWTs, PEM private keys,
+  cookies, and values under sensitive keys (`password`, `token`, `apiKey`,
+  `access_token`, …) in objects, JSON text and query strings. Command output
+  such as `aqe memory get` is not changed ([#789]).
+
+### Added
+
+- `aqe audit verify --chain audit` now keeps checking past accidental forks
+  left by pre-3.14.5 concurrent writers, and reports them separately from
+  tampering (`status: "forked"`, `tampered: false`). The new
+  `aqe audit repair --chain audit [--dry-run]` acknowledges those forks with
+  one signed entry. It refuses if anything was tampered with, backs up the
+  database first, and never edits or deletes an existing row. Afterwards verify
+  passes again ([#784]).
+- `goap_status {type:"plans"}` lists saved GOAP plans ([#791]).
+
+### Changed
+
+- Running `aqe init --auto` again on an unchanged project no longer rewrites
+  generated files or creates `.claude/settings.json.backup`. Fresh and repeat
+  runs now produce the same settings: all 13 domains, and pattern promotion at
+  3 successes / 0.7 success rate, which is what the learning runtime actually
+  enforces ([#783]).
+- Keyword matches now contribute to pattern search alongside vector
+  similarity. A keyword-only hit is weighted by how many of the query's terms
+  it matches ([#779]).
+- `qe_coherence_consensus` rejects malformed votes with a clear error. Only a
+  unanimous vote is flagged as possible false consensus, and every
+  recommendation states the real tally ([#781]).
+- `goap_plan` rejects unknown constraint keys and supports
+  `constraints.maxSteps` ([#785]).
+
+### Fixed
+
+- `aqe audit verify --chain audit` and `aqe audit repair --dry-run` no longer
+  crash with `SQLITE_READONLY` on a store that has no audit chain yet (for
+  example after `aqe init --minimal`) or on older stores without the archive
+  table. A store whose live chain was deleted while archived rows remain is
+  now reported as tampered instead of valid ([#788]).
+- GOAP world state is read from the live fleet, and coverage from a coverage
+  report when one exists. Values it can't measure are reported as `null` with
+  `dataSource: "estimated"` instead of defaults labelled as real. Planning for
+  goals such as `achieve-90-percent-coverage` works again, and a plan can be
+  dry-run executed by its ID. A step whose domain call returns an error now
+  fails instead of being recorded as completed ([#785]).
+- A repeat `fleet_init` reports the fleet settings actually in effect instead
+  of echoing the requested ones ([#790]).
+- When another live process holds an RVF lock, AQE logs one clear warning and
+  falls back to SQLite, without a second, misleading `LockHeld` error ([#782]).
+- Updated `ip-address` to 10.7.2 ([#776]).
+
+[#776]: https://github.com/proffesor-for-testing/agentic-qe/pull/776
+[#779]: https://github.com/proffesor-for-testing/agentic-qe/pull/779
+[#781]: https://github.com/proffesor-for-testing/agentic-qe/pull/781
+[#782]: https://github.com/proffesor-for-testing/agentic-qe/pull/782
+[#783]: https://github.com/proffesor-for-testing/agentic-qe/pull/783
+[#784]: https://github.com/proffesor-for-testing/agentic-qe/pull/784
+[#785]: https://github.com/proffesor-for-testing/agentic-qe/pull/785
+[#788]: https://github.com/proffesor-for-testing/agentic-qe/pull/788
+[#789]: https://github.com/proffesor-for-testing/agentic-qe/pull/789
+[#790]: https://github.com/proffesor-for-testing/agentic-qe/pull/790
+[#791]: https://github.com/proffesor-for-testing/agentic-qe/pull/791
+
+## [3.14.5] - 2026-09-29
+
+This patch makes Agentic QE's results trustworthy for scripts and CI: failed
+commands now exit non-zero, `aqe platform setup` works again, and Codex setup
+through a globally installed `aqe` installs its hooks and skills. It also stops
+the audit chain from breaking when several AQE processes share a store or when
+stores are merged, lets the pattern search index bind when an embedder is
+configured, quiets the CLI's internal startup logging, and resolves plugin
+versions with npm SemVer. Ten of the issues fixed here were reported by
+[@pacphi](https://github.com/pacphi), and most of the fixes were contributed by
+[@rudycelekli](https://github.com/rudycelekli).
+
+### Security
+
+- Patched a high-severity undici advisory (GHSA-w293-vg96-wgc3) in the
+  vendored Ruflo skill tree; the published package was not affected ([#774]).
+
+### Changed
+
+- The CLI is much quieter by default. Internal startup diagnostics are filtered
+  by `AQE_LOG_LEVEL` / `LOG_LEVEL` (default `warn`) and always go to stderr, and
+  `aqe memory list|get|search|store|delete|usage` open the project store
+  directly instead of starting the whole fleet, so they no longer print ~99
+  lines of startup logging. A command's own `--verbose` flag still shows its
+  detail ([#763]).
+- Plugin versions and dependency ranges now follow npm SemVer. The newest
+  compatible cached version is selected, `minAqeVersion` and dependency ranges
+  are enforced at install and startup, and a rejected plugin is reported
+  without stopping independent plugins from loading. Noncanonical version
+  strings, `latest` ranges, and invalid `minAqeVersion` values are rejected
+  ([#750]).
+- `aqe task submit` without `--wait` now exits 1 and tells you to use `--wait`
+  or the MCP server. A task submitted from the CLI only ran inside that CLI
+  process and was lost when it exited, so the printed ID could never be looked
+  up ([#769]).
+- `aqe init --auto` in a project with a `.codex/` folder now applies the
+  selected Codex guidance mode (default `full`) to an existing `AGENTS.md`,
+  inside AQE's own marked block ([#767]).
+- `RUVECTOR_USE_*` environment overrides now take effect in the CLI and MCP
+  server. Any value other than `true` switches that feature off ([#768]).
+- Git submodules and worktrees inside a repository now use their own
+  `.agentic-qe` store instead of the parent repository's ([#741]).
+
+### Fixed
+
+- Commands that report failure now exit 1 instead of 0: `platform verify`,
+  `plugin install` / `remove` / `info`, invalid hook provenance, and every
+  command whose automatic initialization fails ([#760], [#770]).
+- `aqe platform setup <platform>` works again for Copilot, Cursor, Cline,
+  Kilo Code, Roo Code, Codex, Windsurf and Continue.dev; it failed for all of
+  them with "Module not found in bundle" ([#761]).
+- `aqe task submit --domain` and MCP `task_submit` reject unknown domains
+  instead of accepting a task nothing will run ([#769]).
+- `aqe init --with-codex` through a globally installed `aqe`, a project-local
+  install, or `npx` now installs the Codex hooks and QE skills, and warns when
+  packaged assets cannot be found ([#765]).
+- `--codex-guidance full` is applied to an existing `AGENTS.md`, the `--json`
+  summary reports the bytes actually written, and switching modes no longer
+  piles `---` separators into your part of the file ([#767]).
+- The audit chain no longer forks when two AQE processes (for example an MCP
+  server and hooks) append at once, so `aqe audit verify --chain audit` stays
+  valid ([#764]).
+- `brain import` no longer copies the source store's audit rows into the
+  target chain; it records one `BRAIN_IMPORT` entry instead, so the target
+  chain still verifies after a merge ([#766], [#771]).
+- With an embedder endpoint configured, the pattern search index (and
+  `brain.rvf`) now binds in every process instead of leaving patterns
+  `COMMITTED_PENDING_INDEX`. The provenance guard still refuses when no
+  embedder or a mismatched one is configured ([#768], [#773]).
+- Running `aqe`, the hook runner or the MCP server from a subfolder no longer
+  creates a separate `.agentic-qe` store there; relative `AQE_MEMORY_PATH` /
+  `AQE_STORAGE_PATH` and MCP session journals resolve from the project root, a
+  stray `~/.agentic-qe` no longer claims non-git folders below your home
+  directory, and `status` / `health` exit 1 when they refuse to run
+  ([#741], [#772]).
+
+[#750]: https://github.com/proffesor-for-testing/agentic-qe/pull/750
+[#763]: https://github.com/proffesor-for-testing/agentic-qe/pull/763
+[#774]: https://github.com/proffesor-for-testing/agentic-qe/pull/774
+[#741]: https://github.com/proffesor-for-testing/agentic-qe/pull/741
+[#760]: https://github.com/proffesor-for-testing/agentic-qe/pull/760
+[#761]: https://github.com/proffesor-for-testing/agentic-qe/pull/761
+[#764]: https://github.com/proffesor-for-testing/agentic-qe/pull/764
+[#765]: https://github.com/proffesor-for-testing/agentic-qe/pull/765
+[#766]: https://github.com/proffesor-for-testing/agentic-qe/pull/766
+[#767]: https://github.com/proffesor-for-testing/agentic-qe/pull/767
+[#768]: https://github.com/proffesor-for-testing/agentic-qe/pull/768
+[#769]: https://github.com/proffesor-for-testing/agentic-qe/pull/769
+[#770]: https://github.com/proffesor-for-testing/agentic-qe/pull/770
+[#771]: https://github.com/proffesor-for-testing/agentic-qe/pull/771
+[#772]: https://github.com/proffesor-for-testing/agentic-qe/pull/772
+[#773]: https://github.com/proffesor-for-testing/agentic-qe/pull/773
+
 ## [3.14.4] - 2026-09-27
 
 This patch moves Agentic QE to the current AI model generation and fixes live

package/assets/skills/skills-manifest.json

@@ -940,7 +940,7 @@
   },
   "metadata": {
     "generatedBy": "Agentic QE Fleet",
-    "fleetVersion": "3.14.4",
+    "fleetVersion": "3.14.6",
     "manifestVersion": "1.4.0",
     "lastUpdated": "2026-04-13T00:00:00.000Z",
     "contributors": [

package/dist/adapters/ag-ui/event-types.d.ts

@@ -366,7 +366,7 @@ export interface AQEToolResult<T = unknown> {
         readonly domain?: string;
         readonly taskId?: string;
         readonly toolName?: string;
-        readonly dataSource?: 'real' | 'demo' | 'fallback';
+        readonly dataSource?: 'real' | 'demo' | 'fallback' | 'estimated';
     };
 }
 /**

package/dist/audit/witness-chain-hash.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Witness Chain hash primitives (ADR-070).
+ *
+ * Shared by the chain itself, its verifier and the brain-import audit writer
+ * so the link format can never drift between the code that writes a link and
+ * the code that checks it.
+ */
+import type { WitnessEntry } from './witness-chain.js';
+export declare const GENESIS_PREV_HASH: string;
+export declare function sha256(data: string): string;
+/** SHAKE-256 (32-byte output) with SHA-256 fallback for older Node.js runtimes. */
+export declare function shake256(data: string): string;
+export declare function hashWith(algo: string, data: string): string;
+/** Serialize a WitnessEntry to a deterministic string (original 7-field format). */
+export declare function serializeEntry(entry: WitnessEntry): string;
+/** The bytes an Ed25519 witness signature covers (unchanged since ADR-070 Phase 6.2). */
+export declare function signaturePayload(entry: Pick<WitnessEntry, 'prev_hash' | 'action_hash' | 'action_type' | 'timestamp' | 'actor'>): Buffer;
+//# sourceMappingURL=witness-chain-hash.d.ts.map

package/dist/audit/witness-chain-hash.js

@@ -0,0 +1,37 @@
+/**
+ * Witness Chain hash primitives (ADR-070).
+ *
+ * Shared by the chain itself, its verifier and the brain-import audit writer
+ * so the link format can never drift between the code that writes a link and
+ * the code that checks it.
+ */
+import { createHash } from 'crypto';
+export const GENESIS_PREV_HASH = '0'.repeat(64);
+export function sha256(data) {
+    return createHash('sha256').update(data, 'utf-8').digest('hex');
+}
+/** SHAKE-256 (32-byte output) with SHA-256 fallback for older Node.js runtimes. */
+export function shake256(data) {
+    try {
+        return createHash('shake256', { outputLength: 32 }).update(data, 'utf-8').digest('hex');
+    }
+    catch {
+        return sha256(data);
+    }
+}
+export function hashWith(algo, data) {
+    return algo === 'shake256' ? shake256(data) : sha256(data);
+}
+/** Serialize a WitnessEntry to a deterministic string (original 7-field format). */
+export function serializeEntry(entry) {
+    return JSON.stringify({
+        id: entry.id, prev_hash: entry.prev_hash, action_hash: entry.action_hash,
+        action_type: entry.action_type, action_data: entry.action_data,
+        timestamp: entry.timestamp, actor: entry.actor,
+    });
+}
+/** The bytes an Ed25519 witness signature covers (unchanged since ADR-070 Phase 6.2). */
+export function signaturePayload(entry) {
+    return Buffer.from(entry.prev_hash + entry.action_hash + entry.action_type + entry.timestamp + entry.actor, 'utf-8');
+}
+//# sourceMappingURL=witness-chain-hash.js.map

package/dist/audit/witness-chain-repair.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Witness Chain fork repair (re-anchor) — ADR-070, issue #753.
+ *
+ * Stores written before v3.14.5 can contain accidental forks from concurrent
+ * `append()` calls. `verify()` classifies them (witness-chain-verifier.ts) but
+ * keeps `valid: false` until they are acknowledged, so an existing consumer
+ * never sees a previously-broken store silently turn valid.
+ *
+ * Repair acknowledges them by appending ONE signed (when a key is available)
+ * `CHAIN_REANCHOR` entry that lists each unacknowledged fork row (id, parent
+ * id, prev_hash, action_hash), pins the hash of every dead-end row (the
+ * losing race siblings nothing else links to) and records the tip it verified.
+ * It:
+ *
+ * - refuses when any tamper-class break or signature failure exists;
+ * - backs up the database first (`VACUUM INTO <db>.bak-<epoch>`, taken while
+ *   holding the write lock so it is exactly the state being modified) and
+ *   checks the backup (integrity_check, witness row counts) before writing;
+ * - never deletes, moves or rewrites an existing row — history stays as-is
+ *   and `verify()` still lists every fork (`status: 'valid-with-forks'`);
+ * - re-verifies, backs up and appends inside ONE `BEGIN IMMEDIATE`
+ *   transaction, so no writer can slip a row in between;
+ * - checks row counts before/after (live +1, archive unchanged);
+ * - is idempotent: a second run finds nothing unacknowledged and writes nothing.
+ */
+import { type Database as DatabaseType } from 'better-sqlite3';
+import type { WitnessKeyManager } from './witness-key-manager.js';
+import { type ChainStatus, type TamperReason } from './witness-chain-verifier.js';
+export interface WitnessRowCounts {
+    live: number;
+    archive: number;
+}
+export interface VerifySummary {
+    status: ChainStatus;
+    entriesChecked: number;
+    forks: number;
+    unacknowledgedForks: number;
+    tamperedAt?: number;
+    tamperReason?: TamperReason;
+}
+export type RepairAction = 'none' | 'would-reanchor' | 'reanchored' | 'refused';
+export interface RepairResult {
+    action: RepairAction;
+    dryRun: boolean;
+    message: string;
+    before: VerifySummary;
+    after?: VerifySummary;
+    rowsBefore: WitnessRowCounts;
+    rowsAfter: WitnessRowCounts;
+    /** Fork row ids this run acknowledged (or would, on a dry run). */
+    forksAcknowledged: number[];
+    reanchorId?: number;
+    backupPath?: string;
+}
+export interface RepairOptions {
+    /** Path of the database file `db` is opened on — the backup is written next to it. */
+    dbPath: string;
+    dryRun?: boolean;
+    /**
+     * Signs the CHAIN_REANCHOR row and verifies fork/re-anchor signatures.
+     * Pass a read-only (autoGenerate: false) manager for a dry run.
+     */
+    keyManager?: WitnessKeyManager | null;
+    actor?: string;
+}
+/**
+ * Re-anchor a witness chain whose only breaks are accidental forks.
+ * `db` must be a writable connection on `options.dbPath`.
+ */
+export declare function repairWitnessChainForks(db: DatabaseType, options: RepairOptions): Promise<RepairResult>;
+//# sourceMappingURL=witness-chain-repair.d.ts.map

package/dist/audit/witness-chain-repair.js

@@ -0,0 +1,203 @@
+/**
+ * Witness Chain fork repair (re-anchor) — ADR-070, issue #753.
+ *
+ * Stores written before v3.14.5 can contain accidental forks from concurrent
+ * `append()` calls. `verify()` classifies them (witness-chain-verifier.ts) but
+ * keeps `valid: false` until they are acknowledged, so an existing consumer
+ * never sees a previously-broken store silently turn valid.
+ *
+ * Repair acknowledges them by appending ONE signed (when a key is available)
+ * `CHAIN_REANCHOR` entry that lists each unacknowledged fork row (id, parent
+ * id, prev_hash, action_hash), pins the hash of every dead-end row (the
+ * losing race siblings nothing else links to) and records the tip it verified.
+ * It:
+ *
+ * - refuses when any tamper-class break or signature failure exists;
+ * - backs up the database first (`VACUUM INTO <db>.bak-<epoch>`, taken while
+ *   holding the write lock so it is exactly the state being modified) and
+ *   checks the backup (integrity_check, witness row counts) before writing;
+ * - never deletes, moves or rewrites an existing row — history stays as-is
+ *   and `verify()` still lists every fork (`status: 'valid-with-forks'`);
+ * - re-verifies, backs up and appends inside ONE `BEGIN IMMEDIATE`
+ *   transaction, so no writer can slip a row in between;
+ * - checks row counts before/after (live +1, archive unchanged);
+ * - is idempotent: a second run finds nothing unacknowledged and writes nothing.
+ */
+import { existsSync } from 'node:fs';
+import { basename } from 'node:path';
+import { openDatabase } from '../shared/safe-db.js';
+import { WitnessChain } from './witness-chain.js';
+import { sha256, shake256, serializeEntry } from './witness-chain-hash.js';
+import { ownHash, tableExists, } from './witness-chain-verifier.js';
+const VERIFY_OPTIONS = { includeArchive: true };
+function countRows(db) {
+    const n = (table) => (tableExists(db, table)
+        ? db.prepare(`SELECT COUNT(*) AS n FROM ${table}`).get().n
+        : 0);
+    return { live: n('witness_chain'), archive: n('witness_chain_archive') };
+}
+function summarize(r) {
+    return {
+        status: r.status,
+        entriesChecked: r.entriesChecked,
+        forks: r.forks.length,
+        unacknowledgedForks: r.forks.length - r.acknowledgedForks.length,
+        ...(r.tamperedAt !== undefined ? { tamperedAt: r.tamperedAt } : {}),
+        ...(r.tamperReason ? { tamperReason: r.tamperReason } : {}),
+    };
+}
+function unacknowledged(r) {
+    return r.forkDetails.filter((f) => !f.acknowledged)
+        .map(({ id, parentId, prevHash, actionHash }) => ({ id, parentId, prevHash, actionHash }));
+}
+/**
+ * Dead-end rows: every row except the tip whose hash no row's prev_hash
+ * references — the losing sibling of each race. Nothing else vouches for
+ * their content, so the re-anchor pins it. (Checked under both hash algos,
+ * since a child hashes its parent with the CHILD's algorithm.)
+ */
+function deadEndPins(db, tipId) {
+    const referenced = new Set();
+    const prevs = db.prepare('SELECT prev_hash FROM witness_chain UNION ALL SELECT prev_hash FROM witness_chain_archive').pluck().iterate();
+    for (const h of prevs)
+        referenced.add(h);
+    const pins = [];
+    const seen = new Set();
+    for (const table of ['witness_chain', 'witness_chain_archive']) {
+        const rows = db.prepare(`SELECT * FROM ${table} ORDER BY id ASC`).iterate();
+        for (const row of rows) {
+            if (row.id === tipId || seen.has(row.id))
+                continue;
+            seen.add(row.id);
+            const ser = serializeEntry(row);
+            if (!referenced.has(shake256(ser)) && !referenced.has(sha256(ser)))
+                pins.push({ id: row.id, hash: ownHash(row) });
+        }
+    }
+    return pins.sort((a, b) => a.id - b.id);
+}
+function refusal(r) {
+    return `Refusing to repair: tampering detected at id=${r.tamperedAt} (${r.tamperReason}). ` +
+        'Only accidental forks can be re-anchored; restore from a backup and investigate.';
+}
+function nextBackupPath(dbPath) {
+    const base = `${dbPath}.bak-${Math.floor(Date.now() / 1000)}`;
+    if (!existsSync(base))
+        return base;
+    let i = 1;
+    while (existsSync(`${base}-${i}`))
+        i++;
+    return `${base}-${i}`;
+}
+/**
+ * Snapshot the database with VACUUM INTO from a SECOND, read-only connection.
+ * Called while the repairing connection holds the write lock (BEGIN IMMEDIATE)
+ * and before it writes anything, so the snapshot is exactly the state about to
+ * be modified: no other process can commit in between (issue found in review).
+ * The backup must then open clean and hold exactly `expected` witness rows.
+ */
+function backupDatabase(dbPath, expected) {
+    const backupPath = nextBackupPath(dbPath);
+    const reader = openDatabase(dbPath, { readonly: true, fileMustExist: true });
+    try {
+        reader.prepare('VACUUM INTO ?').run(backupPath);
+    }
+    finally {
+        reader.close();
+    }
+    const copy = openDatabase(backupPath, { readonly: true, fileMustExist: true });
+    try {
+        const check = copy.pragma('integrity_check', { simple: true });
+        if (check !== 'ok')
+            throw new Error(`backup integrity_check failed: ${String(check)}`);
+        const counts = countRows(copy);
+        if (counts.live !== expected.live || counts.archive !== expected.archive) {
+            throw new Error(`backup holds ${JSON.stringify(counts)} witness rows, expected ${JSON.stringify(expected)}`);
+        }
+    }
+    finally {
+        copy.close();
+    }
+    return backupPath;
+}
+/**
+ * Re-anchor a witness chain whose only breaks are accidental forks.
+ * `db` must be a writable connection on `options.dbPath`.
+ */
+export async function repairWitnessChainForks(db, options) {
+    const dryRun = options.dryRun === true;
+    const chain = new WitnessChain(db, options.keyManager ?? undefined);
+    await chain.initialize();
+    const rowsBefore = countRows(db);
+    const before = chain.verify(VERIFY_OPTIONS);
+    const base = { dryRun, before: summarize(before), rowsBefore, rowsAfter: rowsBefore };
+    if (before.tampered) {
+        return { ...base, action: 'refused', message: refusal(before), forksAcknowledged: [] };
+    }
+    const pending = unacknowledged(before);
+    if (pending.length === 0) {
+        const message = before.forks.length > 0
+            ? `Nothing to repair: all ${before.forks.length} fork(s) are already re-anchored.`
+            : 'Nothing to repair: the audit chain has no forks.';
+        return { ...base, action: 'none', message, forksAcknowledged: [] };
+    }
+    if (dryRun) {
+        return {
+            ...base, action: 'would-reanchor', forksAcknowledged: pending.map((f) => f.id),
+            message: `Dry run: would back up the database and append a CHAIN_REANCHOR entry acknowledging ${pending.length} fork(s). Nothing was written.`,
+        };
+    }
+    // Re-verify, back up and append under ONE write lock: nothing can land
+    // between the check, the snapshot and the write.
+    let backupPath;
+    const reanchor = db.transaction(() => {
+        const txBefore = countRows(db);
+        const check = chain.verify(VERIFY_OPTIONS);
+        if (check.tampered)
+            return { kind: 'refused', check };
+        const forks = unacknowledged(check);
+        if (forks.length === 0)
+            return { kind: 'noop' };
+        backupPath = backupDatabase(options.dbPath, txBefore);
+        const tip = db.prepare('SELECT * FROM witness_chain ORDER BY id DESC LIMIT 1').get();
+        const entry = chain.append('CHAIN_REANCHOR', {
+            reason: 'fork-repair',
+            issue: 'https://github.com/proffesor-for-testing/agentic-qe/issues/753',
+            note: 'Acknowledges accidental forks from pre-3.14.5 concurrent appends; no rows were changed.',
+            forkCount: forks.length,
+            forks,
+            pins: deadEndPins(db, tip.id),
+            verifiedTipId: tip.id,
+            verifiedTipHash: ownHash(tip),
+            entriesChecked: check.entriesChecked,
+            rows: txBefore,
+            backup: basename(backupPath),
+        }, options.actor ?? 'aqe-audit-repair');
+        const txAfter = countRows(db);
+        if (txAfter.live !== txBefore.live + 1 || txAfter.archive !== txBefore.archive) {
+            throw new Error(`row-count check failed: before ${JSON.stringify(txBefore)}, after ${JSON.stringify(txAfter)}`);
+        }
+        return { kind: 'reanchored', entry, forks, txAfter };
+    }).immediate();
+    if (reanchor.kind === 'refused') {
+        return { ...base, action: 'refused', message: refusal(reanchor.check), forksAcknowledged: [] };
+    }
+    if (reanchor.kind === 'noop') {
+        return { ...base, action: 'none', message: 'Nothing to repair (another process re-anchored first).', forksAcknowledged: [] };
+    }
+    const after = chain.verify(VERIFY_OPTIONS);
+    const ok = after.valid && !after.tampered;
+    return {
+        ...base,
+        action: 'reanchored',
+        after: summarize(after),
+        rowsAfter: reanchor.txAfter,
+        forksAcknowledged: reanchor.forks.map((f) => f.id),
+        reanchorId: reanchor.entry.id,
+        backupPath,
+        message: ok
+            ? `Re-anchored ${reanchor.forks.length} fork(s) with CHAIN_REANCHOR id=${reanchor.entry.id}; chain now ${after.status}. Backup: ${backupPath}`
+            : `Appended CHAIN_REANCHOR id=${reanchor.entry.id}, but the chain still verifies as ${after.status}. Backup: ${backupPath}`,
+    };
+}
+//# sourceMappingURL=witness-chain-repair.js.map