akm-cli 0.9.7 → 0.9.8-beta.2

package/CHANGELOG.md

@@ -4,6 +4,316 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [0.9.8-beta.2] - 2026-09-02
+
+> **Adds state migration `026-proposals-strip-legacy-fragment-refs`.** The
+> one-way caveat below applies to it as well: once this build opens
+> `state.db`, 0.9.8-beta.1 and earlier refuse it with `unknown migration ID
+> 026-proposals-strip-legacy-fragment-refs`.
+
+### Added
+
+- **`akm health` reports data-dir disk usage** (#896). A `data-dir-usage`
+  advisory sums the data directory with a stat-only walk and warns when it is
+  more than 3× the three live databases (state.db, index.db, logs.db) or when
+  one top-level subdirectory holds more than half of it, naming that
+  subdirectory with its size and share (for example `backups/ is 70G (94% of
+  data dir)`). The walk stops after 100,000 entries and says so. Silent when
+  nothing looks wrong.
+
+### Fixed
+
+- **`akm task sync` no longer spawns `npm root --global` on every call** (#901).
+  The npm-global-root probe behind `resolveAkmInvocation` is memoized for the
+  process, so a `task sync --rebind` cycle spawns npm at most once instead of
+  twice, and an installation that loops it every minute stops accumulating an
+  npm debug log per spawn.
+- **A blocked v2 task now says how to convert it** (#902, #899). The
+  `argv-array-has-no-portable-shell-string` blocker printed by `akm migrate`
+  and the `TASK_SCHEMA_VERSION_UNSUPPORTED` read error now state that manual
+  conversion is required and name the rewrite (`command:` argv array →
+  `run:` string plus `shell:`). The full v2 → v4 field mapping is documented in
+  `docs/migration/v0.9.1-to-v0.9.2.md`.
+- **Legacy `#fragment` proposal rows are repaired instead of warned about
+  forever** (#898). State migration 026 strips the retired export-fragment
+  selector from `proposals.ref` in place so the rows parse again, and an
+  unparseable proposal row now warns once per process instead of once per
+  read (`akm health --report` read the table seven times).
+
+- **A no-op incremental `akm index` no longer costs minutes of CPU** (#900).
+  Two causes: the per-directory freshness check ran two full scans of the
+  `entries` table for every directory (O(directories × entries)), and every
+  file was read, hashed, and parsed before the freshness check decided the
+  directory was unchanged. The directory lookup now uses the existing
+  `file_path` index, and a stat-based gate over each directory's walked file
+  set skips unchanged directories before any file is read. On a synthetic
+  800-directory, 4,000-entry corpus a no-op pass fell from ~37 s to under 1 s
+  of CPU with identical entries and search results. The persisted directory
+  fingerprint now covers every walked file and `index_dir_state` gains a
+  `row_count` column; an existing index.db drains each directory once more
+  after upgrading, then takes the fast path.
+
+- **Task-migration snapshots are capped at the five most recent** (#897).
+  `akm migrate apply` writes one snapshot directory per run under
+  `backups/task-v3` and `backups/task-v4` and never pruned them; each apply
+  now keeps the five newest and removes the rest, the same policy config
+  backups already use. Nothing in the current code writes the legacy
+  `backups/migrations`, `manual`, `releases`, or `operations` directories,
+  so they are left alone; the new health advisory is what surfaces them.
+
+## [0.9.8-beta.1] - 2026-09-01
+
+A cleanup and stabilization release: deletion of machinery that policed the
+codebase's shape rather than its behaviour, and — because auditing for that
+machinery meant reading the code closely — a run of real defects it had been
+sitting on top of.
+
+> **Upgrading is one-way for `state.db`.** This release adds migration
+> `025-task-history-vocabulary-backfill`. Once any 0.9.8 command opens
+> `state.db`, the ledger contains an ID that 0.9.7 does not know, and 0.9.7
+> refuses to open it: `Refusing to open a database with a newer migration
+> ledger: unknown migration ID 025-task-history-vocabulary-backfill`.
+>
+> The refusal is deliberate — an older binary must not write a database whose
+> schema it cannot reason about — but the practical effect is that
+> **downgrading to 0.9.7 requires restoring a `state.db` backup.** Commands
+> that only read the derived index (`akm info`, `akm search`) keep working on
+> 0.9.7; everything that touches `state.db` (`akm health`, `akm task`,
+> `akm improve`, proposals) does not.
+>
+> Snapshot `state.db` before upgrading if you may need to go back:
+>
+> ```sh
+> akm info --format json    # confirm your data dir
+> sqlite3 "$DATA_DIR/state.db" "VACUUM INTO '''state.db.pre-0.9.8.bak'''"
+> ```
+
+Two security holes, two search-correctness bugs, a locale-dependent hash, a
+deletion shield that failed open, and sixteen places that answered a failure
+with a confident wrong answer instead of an error.
+
+### Changed
+
+- **`akm workflow plan` returns JSON by default**, like every other command
+  (#903). It was the one verb whose unmarked default was a human summary. That
+  exception cost a bespoke branch which could not reliably distinguish "no
+  format named" from "`--format json` named globally before the subcommand" —
+  citty parses each command level against its own argv, so the leaf read
+  `undefined` in both cases. Working around that meant reading the invocation
+  singleton, folding in a persisted `output.format`, and finally leaving a
+  resolved `"json"` on the text branch because it was indistinguishable from
+  "nothing configured" — which meant an explicit `--format json` silently did
+  nothing for anyone whose config already resolved to json. Deleted, along with
+  ~60 lines of comment justifying it. `--format text` still renders the same
+  summary through the same formatter; it is simply no longer the default.
+
+### Fixed
+
+- **Historical state migrations are reachable where akm cannot reinstall
+  itself** (#895). A migration flagged `historical-destructive` is refused
+  during an ordinary open — it needs a verified safety copy, taken under the
+  migration writer lock, so an unattended `akm index` can never quietly drop
+  operator state. That guard is correct and unchanged. Its *remedy* was not:
+  the only code path that admitted the migration ran as a post-install step of
+  `akm upgrade`, behind an npm install. Where akm is installed globally by a
+  container image and the runtime user is unprivileged, that install fails
+  `EACCES` and throws long before the migration is reached, so `akm index
+  --full` was blocked with no supported way out — and the two obvious
+  workarounds are both wrong (upgrading as root installs a *newer* akm than the
+  image ships, which `config-version-shim` then fails closed against; deleting
+  `state.db` destroys task history, proposals, and lessons metadata, none of
+  which is derived). New `akm upgrade --state-only` applies pending state
+  migrations and installs nothing. Nothing about the migration needed the
+  network, root, or a new binary; coupling it to one was the bug. The safety
+  copy is still taken — this changes who may request the migration, not what it
+  does.
+
+- **Two security holes closed.** A failed `git ls-remote` made
+  `verifyClonedRevision` a no-op, silently skipping the R-011 post-clone
+  revision-integrity check — the guard against a compromised mirror — so any
+  network blip disabled it without a word. And `scanExtractedFiles`, the
+  post-extraction TOCTOU path-traversal rescan, returned silently when a
+  directory could not be read: it passed clean in exactly the race it exists
+  to catch. Both now fail loudly.
+
+- **`akm curate --type` ignored the type filter.** A set `--type` bypassed
+  `selectCuratedStashHits` entirely and did a raw slice of the hits as
+  received, which neither filtered by type nor ranked by score — so
+  `--type command` could return a skill, in arbitrary order. It now narrows
+  the candidate pool and runs the full curation pipeline over it. The test
+  that should have caught this passed by accident, because the off-type hit
+  happened to sit past the result limit.
+
+- **Curate silently dropped relevant results.** An undocumented floor excluded
+  any hit scoring below `max(0.35, leader * 0.7)`. Measured against a real
+  3,265-memory bundle, one query went from one result to four once it was
+  removed — the suppressed hits were the ones actually matching. Ordering is
+  unchanged: results were already sorted before the floor ran, so it could
+  only ever hide the tail.
+
+- **A bundle-audit hash depended on the machine's locale.** `canonicalJson`
+  in `installed-stashes.ts` sorted keys with `localeCompare` — ICU-dependent —
+  and fed the result to `sha256Hex`, so the same object could hash differently
+  on two machines. Now codepoint order, matching the other implementations.
+
+- **A deletion shield failed open.** `isHotCapturedMemory` returned false when
+  it could not read or parse a memory, marking exactly the memories it failed
+  to inspect as fair game for consolidate to merge or delete. It now fails
+  closed.
+
+- **Sixteen places returned a confident wrong answer instead of an error.**
+  The pattern (#791) recurred across search, graph, indexing, and scheduling:
+  a corrupt or locked index reported "no matches"; a failed inline rebuild
+  surfaced as "Index is empty. Run 'akm index'" at exit 0; `akm show` reported
+  "0 related files" for an unreadable index; a DB failure in
+  `listProposalsReadOnly` returned `[]`, so dedup could not tell "no prior
+  proposal" from "database unreadable" and could re-mint an already-rejected
+  one; a permission fault on the bundle directory told the user to run
+  `akm bundle create`; and `launchd`'s `list()` returned `[]` when the
+  LaunchAgents directory could not be read, so task reconciliation concluded
+  there was nothing to manage. In each case the failure now surfaces.
+
+- **Drifted copies of shared helpers.** `asNonEmptyString` trimmed in two
+  places and not in four others, so a whitespace-only session id decoded to
+  `" "` in some subsystems and `undefined` in others. `isPlainObject` had two
+  incompatible definitions under one name; the loose form would accept a
+  `Date` or class instance as a plain record. Both consolidated, along with
+  `toPosix` (15 copies, whose "avoid an import cycle" justification was false
+  in every case), `isRecord` (11), `compareCodePoints` (8), and five more
+  families.
+
+- **Pruning a memory no longer leaves dangling belief edges (#885).**
+  `writeContradictEdge` — the hardened, test-covered `contradictedBy` writer —
+  had no production caller; its docstring named three that did not exist. The
+  live pass used a private near-copy that had drifted on exactly the two
+  behaviours the original was hardened for: it read the key with
+  `Array.isArray` only, so a SCALAR edge (live data the indexer accepts and
+  lint never flags) read as "no edges" and was overwritten out of existence;
+  and it set `beliefState: "contradicted"` unconditionally, promoting an
+  `archived` memory back up the ranking. The tests for both behaviours were
+  guarding dead code. The copy is gone.
+
+  `persistBeliefStateTransition` is deliberately NOT routed through the shared
+  primitive: it is a state-transition writer that replaces the edge list
+  wholesale and can clear it, which an append-only, never-weaken primitive
+  cannot express.
+
+- **`git worktree` operations no longer fail on a busy machine (#891).** The
+  module's internal `GIT_TIMEOUT_MS` was a flat 30s with no margin, so a
+  healthy `git worktree remove` on a loaded host returned
+  `{ removed: false, error: "timed out after 30000ms" }`. Anyone running a
+  workflow with `isolation: worktree` alongside other git activity could hit
+  spurious create failures, or have a clean worktree wrongly retained as
+  unremovable. Raised to 120s, matching the existing `GIT_PUSH_TIMEOUT_MS`
+  precedent. Note `scripts/test-integration.sh` had already raised *bun's*
+  per-test timeout for this reason, but that never touched the production
+  subprocess timeout, which fires first.
+
+- **`akm health`'s dead-link check no longer reports an unearned all-clear
+  (#892).** `checkDeadUrls` capped at 20 URLs across the whole bundle, plus an
+  undocumented `slice(0, 3)` per entry, then the caller logged "URL check
+  complete (0 dead)". A bundle with thousands of links got a clean bill of
+  health after twenty were examined. Both caps removed; every URL is checked
+  and a failed request surfaces instead of being swallowed.
+
+- **`akm lint --fix` no longer breaks on gitignored drafts (#887).** The doc
+  linter walked `docs/` with no gitignore awareness, so unpublished drafts
+  under `docs/.pending/` were held to the published-docs contract —
+  `bun run lint` failed locally while CI, which never has those files, stayed
+  green.
+
+### Changed
+
+- **Search no longer truncates long queries (#892).** `MAX_LEXICAL_QUERY_TOKENS
+  = 16` silently dropped every token past the sixteenth, and tokens are
+  collected in order, so the discarded half was the tail — for
+  natural-language input, usually where the discriminating words are. It also
+  fed ranking, so token-overlap scoring ran on the truncated set too. It was
+  unexplained in the code and in the commit that introduced it, and unreachable
+  from any flag, config key, or environment variable. Removed: the planner
+  handles 10,000 tokens in 9ms, so no performance cliff was being protected.
+
+- **Content and memory bodies are no longer silently truncated.**
+  `MAX_CONTENT_CHARS` (100k, duplicated across 8 adapters) cut indexed content
+  so the tail of a long document was unsearchable; `MAX_BODY_CHARS` (4000) cut
+  the text sent for memory inference, so on a large-context engine the model
+  saw a fraction of the input while the derived memory looked complete. Both
+  removed.
+
+- **GitHub Actions are pinned to commit SHAs (#768).** All 29 `uses:` steps
+  across every workflow, with the tag preserved in a trailing comment.
+
+- **Gated CI runs on schedule, dispatch, and candidate tags only.** The
+  `detect-changes` job that selected suites by regex-matching a PR diff is
+  gone — its path patterns had gone stale and still named test files this
+  release moved or deleted, so it was silently under-selecting suites. Release
+  evidence is unchanged; the checklist always required an exact-SHA dispatch.
+
+- **`akm-eval` in CI is now a determinism check only.** Its score gates are
+  removed. Measured before cutting: the baseline scored a perfect 1.0 against
+  a 0.75 gate, and seven of nine case types never ran — CI has no LLM and no
+  run history, so everything the eval exists to measure was skipped while the
+  job reported green. The harness itself is unchanged and remains a genuine
+  quality signal when run against a real bundle.
+
+### Removed
+
+- **`akm health --clean-dead-residue` and every other compensating shim.**
+  A special-purpose flag on `health` that deleted files existed because
+  migrations had not finished their own job. Removing a superseded layout IS
+  migration, so `akm migrate status` now reports it and `akm migrate apply`
+  removes it. Four more of the same class went the same way: the D8
+  `task_history` vocabulary is rewritten once by a state migration instead of
+  re-decided at three read sites; the legacy `extraParams` config lift happens
+  once in `migrate apply` instead of silently on every load forever (an
+  unmigrated config now fails closed, naming the command to run); retired
+  `type:slug` xrefs are rewritten by `lint --fix`; and stale transaction
+  journals are recovered by `migrate apply` rather than reported by an
+  advisory that pointed at documentation while the recovery function it needed
+  sat with zero callers.
+
+- **Dead code with no consumers.** An empty `{}` type threaded through two
+  functions as a parameter neither read, with a `{}` placeholder at the call
+  site; unused helpers, imports, and parameters throughout.
+
+- **14 architecture ratchets, 15 golden/snapshot suites, 12 characterization
+  suites.** Function-size and import-cycle ratchets that failed on refactors
+  harming nothing; byte-for-byte snapshots "fixed" by regenerating; tests that
+  pinned "what the code does today" by definition.
+- **11 of 14 lint scripts (-3,988 lines).** `lint-tests-isolation` alone was
+  717 lines standing in front of `src/core/paths.ts`, which already throws
+  `TEST_ISOLATION_MISSING` at runtime. Also removed: the `gen-config-schema
+  --check` gate (`build` regenerates the schema anyway, so what ships is always
+  current), and `lint-devto-posts` (322 lines that were wired to nothing and
+  duplicated checks `devto-cli` performs itself). The three kept catch
+  user-visible problems: secrets must route through the resolver, no dead refs
+  in shipped assets, no docs teaching commands that do not exist.
+- **Both `MIN_TESTS` floors** — arbitrary numbers whose only job was to fail
+  the suite when test count dropped.
+- **`release-workflow-syntax.yml`** — a workflow that ran actionlint over the
+  other workflows. A broken workflow file already fails at GitHub.
+- **Dead `$STASH/.akm` residue is now reportable (#889).** `akm health` gains a
+  read-only `stash-dead-residue` advisory naming each stale path and its size;
+  deletion is gated behind an explicit `akm health --clean-dead-residue`. On a
+  real bundle 82% of `.akm` (135 MB) was pre-0.9.0 leftovers no code reads.
+
+### Testing
+
+- Test isolation grandfather list drained 58 -> 2 (#785); the two retained
+  entries are the helper-definitions file and a meta-test of the guard itself.
+- The test tree now has a stated unit/integration rule and ~250 files were
+  reclassified by evidence — real DB, network, or process spawn — rather than
+  by filename (#786).
+- 31 status-only `not.toBe(0)` assertions replaced with exact exit codes and
+  machine-readable error codes, every value observed rather than inferred
+  (#787).
+- Near-duplicate clusters drained (#788); real-server timing flakes removed or
+  made deterministic (#789).
+- Kept deliberately: `registry-network-boundary.test.ts`, which enforces that
+  only `pinned-transport.ts` may import `node:http`/`node:https` — the control
+  that stops a raw request bypassing address-pinned fetching. No lint script
+  covers that boundary.
+
 ## [0.9.7] - 2026-08-31
 
 ### Added

package/dist/commands/env/env.js

@@ -48,28 +48,9 @@
 import fs from "node:fs";
 import path from "node:path";
 import dotenv from "dotenv";
-import { writeFileAtomic } from "../../core/common.js";
+import { scanEnvKeyNames, writeFileAtomic } from "../../core/common.js";
 import { sensitiveMarkerPath } from "./marker-path.js";
-/** Matches a KEY=value assignment line, capturing only the key. */
-const ASSIGN_RE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/;
-/** Scan lines and return KEY names in file order, without duplicates. */
-export function scanEnvKeyNames(text) {
-    const keys = [];
-    const seen = new Set();
-    for (const line of text.split(/\r?\n/)) {
-        const m = line.match(ASSIGN_RE);
-        if (!m)
-            continue;
-        const key = m[1];
-        if (!key)
-            continue;
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        keys.push(key);
-    }
-    return keys;
-}
+export { scanEnvKeyNames };
 /**
  * Read and return ONLY non-secret metadata: key names.
  *

package/dist/commands/health/checks.js

@@ -706,29 +706,4 @@ export const HEALTH_CHECKS = [
             };
         },
     },
-    {
-        // Item 4: stale durable-transaction journals under $DATA/txn (stranded
-        // recovery state seen twice in a real 0.9 migration) had zero health
-        // visibility. `count`/`unreadable` already exclude journals younger than
-        // the sweeper's grace period (a currently-running operation), so any
-        // nonzero count here is a real leftover.
-        name: "stale-txn-journals",
-        channel: "advisory",
-        run: (ctx) => {
-            const s = ctx.staleTxnJournals;
-            const warn = s.count > 0;
-            const unreadablePart = s.unreadable > 0 ? `, ${s.unreadable} unreadable` : "";
-            const agePart = s.oldestAgeMs !== null ? `, oldest ${Math.round(s.oldestAgeMs / 60000)}m old` : "";
-            return {
-                name: "stale-txn-journals",
-                kind: "deterministic",
-                status: warn ? "warn" : "pass",
-                confidence: "high",
-                message: warn
-                    ? `${s.count} stale transaction journal(s) found under ${s.dir}${unreadablePart}${agePart} — see docs/migration/v0.9.0-troubleshooting.md for journal reconciliation steps.`
-                    : "No stale transaction journals found.",
-                evidence: { dir: s.dir, count: s.count, unreadable: s.unreadable, oldestAgeMs: s.oldestAgeMs },
-            };
-        },
-    },
 ];

package/dist/commands/health/data-dir-usage.js

@@ -0,0 +1,165 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * `data-dir-usage` advisory for `akm health` (#896).
+ *
+ * A real environment's `$XDG_DATA_HOME/akm` grew to 74 GB with none of the
+ * ~20 health checks saying a word about disk. 70 of the 74 GB turned out to
+ * be `backups/` (unpruned migration snapshots, see #897); the live working
+ * set (state.db + index.db + logs.db) was ~4.2 GB. Naming the largest
+ * top-level contributor and its share of the total is most of the value —
+ * `backups/ is 70G (94% of data dir)` is self-diagnosing where "akm health
+ * says nothing" is not.
+ *
+ * Best-effort and read-only: a plain recursive `fs` stat walk over the data
+ * dir, no `du` shell-out. Silent (returns `undefined`) whenever nothing
+ * looks wrong, matching the stash-exposure/type-directory-check house
+ * pattern — this is not a "always show a pass line" check.
+ */
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * Warn when the data dir's total size is more than this many times the
+ * combined size of the three live databases (state.db + index.db +
+ * logs.db). Chosen so a healthy install (backups roughly comparable to the
+ * live working set) stays quiet, while an order-of-magnitude blowup like
+ * the 74 GB/4.2 GB (~17x) incident trips it.
+ */
+const DATA_DIR_BLOAT_RATIO_THRESHOLD = 3;
+/**
+ * Warn when a single top-level subdirectory accounts for more than this
+ * percentage of the data dir's total size — the "one thing ate the disk"
+ * signal (94% for `backups/` in the incident).
+ */
+const DOMINANT_SUBDIR_PERCENT_THRESHOLD = 50;
+/**
+ * Cap on the number of filesystem entries the recursive size walk will
+ * `stat`. A 70 GB tree of a few thousand backup copies is cheap to walk
+ * (stat-only), but a data dir polluted with hundreds of thousands of small
+ * files (task logs, npm logs) must not make `akm health` slow. Past this
+ * cap the walk stops descending further and the advisory says its size
+ * figures are a lower bound.
+ */
+const MAX_WALK_ENTRIES = 100_000;
+const LIVE_DB_FILES = ["state.db", "index.db", "logs.db"];
+/**
+ * Recursively sum file sizes under `root` (stat-only, symlinks not
+ * followed so a cyclic or huge-target symlink can't blow up the walk).
+ * `budget` is a shared mutable counter across the whole tree so the
+ * `MAX_WALK_ENTRIES` cap applies to the walk as a whole, not per-branch.
+ */
+function sizeOfPath(root, budget) {
+    let stat;
+    try {
+        stat = fs.lstatSync(root);
+    }
+    catch {
+        return { bytes: 0, truncated: false };
+    }
+    if (stat.isSymbolicLink())
+        return { bytes: 0, truncated: false };
+    if (!stat.isDirectory())
+        return { bytes: stat.size, truncated: false };
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return { bytes: 0, truncated: false };
+    }
+    let bytes = 0;
+    let truncated = false;
+    for (const entry of entries) {
+        if (budget.remaining <= 0) {
+            truncated = true;
+            break;
+        }
+        budget.remaining--;
+        const sub = sizeOfPath(path.join(root, entry.name), budget);
+        bytes += sub.bytes;
+        if (sub.truncated)
+            truncated = true;
+    }
+    return { bytes, truncated };
+}
+/** `1610612736` -> `"1.5G"`. Values under 10 in a unit keep one decimal; 10+ round to an integer. */
+function formatBytes(bytes) {
+    const units = ["B", "K", "M", "G", "T"];
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit++;
+    }
+    const rendered = unit === 0 ? String(Math.round(value)) : value < 10 ? value.toFixed(1) : String(Math.round(value));
+    return `${rendered}${units[unit]}`;
+}
+/**
+ * Build the `data-dir-usage` advisory, or `undefined` when the data dir is
+ * missing/empty/unreadable or its size looks unremarkable (neither
+ * threshold trips). `dataDir` is the caller-resolved `getDataDir()` path —
+ * this module never resolves paths or reads env itself.
+ */
+export function collectDataDirUsageAdvisory(dataDir) {
+    let topEntries;
+    try {
+        topEntries = fs.readdirSync(dataDir, { withFileTypes: true });
+    }
+    catch {
+        return undefined; // no data dir yet — nothing to report.
+    }
+    const budget = { remaining: MAX_WALK_ENTRIES };
+    let totalBytes = 0;
+    let truncated = false;
+    const sizes = new Map();
+    for (const entry of topEntries) {
+        const size = sizeOfPath(path.join(dataDir, entry.name), budget);
+        totalBytes += size.bytes;
+        if (size.truncated)
+            truncated = true;
+        sizes.set(entry.name, { bytes: size.bytes, isDirectory: entry.isDirectory() });
+    }
+    if (totalBytes === 0)
+        return undefined;
+    const subdirs = [...sizes]
+        .filter(([, size]) => size.isDirectory)
+        .map(([name, size]) => ({ name, bytes: size.bytes, percent: (size.bytes / totalBytes) * 100 }))
+        .sort((a, b) => b.bytes - a.bytes);
+    const largest = subdirs[0];
+    const liveDbBreakdown = Object.fromEntries(LIVE_DB_FILES.map((f) => [f, sizes.get(f)?.bytes ?? 0]));
+    const liveDbBytes = Object.values(liveDbBreakdown).reduce((a, b) => a + b, 0);
+    const ratio = liveDbBytes > 0 ? totalBytes / liveDbBytes : undefined;
+    const bloatWarn = ratio !== undefined && ratio > DATA_DIR_BLOAT_RATIO_THRESHOLD;
+    const dominantWarn = largest !== undefined && largest.percent > DOMINANT_SUBDIR_PERCENT_THRESHOLD;
+    if (!bloatWarn && !dominantWarn)
+        return undefined;
+    const parts = [`data dir is ${formatBytes(totalBytes)} at ${dataDir}`];
+    if (largest) {
+        parts.push(`${largest.name}/ is ${formatBytes(largest.bytes)} (${Math.round(largest.percent)}% of data dir)`);
+    }
+    if (ratio !== undefined) {
+        parts.push(`live databases (${LIVE_DB_FILES.join("+")}) total ${formatBytes(liveDbBytes)}, ~${ratio.toFixed(1)}x smaller`);
+    }
+    if (truncated) {
+        parts.push(`size figures are a lower bound — the walk stopped after ${MAX_WALK_ENTRIES} entries`);
+    }
+    const message = `${parts.join("; ")}.`;
+    return {
+        name: "data-dir-usage",
+        kind: "deterministic",
+        status: "warn",
+        confidence: "medium",
+        message,
+        evidence: {
+            dataDir,
+            totalBytes,
+            liveDbBytes,
+            liveDbBreakdown,
+            largestSubdir: largest,
+            ratio,
+            walkBounded: truncated,
+            maxWalkEntries: MAX_WALK_ENTRIES,
+        },
+    };
+}

package/dist/commands/health/improve-metrics.js

@@ -33,42 +33,16 @@ export function taskFailureDetail(row) {
     }
 }
 /**
- * D8 read-boundary predicate (spec docs/plans/specs/p1b-model-extraction.md
- * §5.3) for `akm health`'s `agentFailureRate`: true for a `task_history` row
- * that represents a prepared command (agent/LLM) result, across both
- * vocabularies. Mirrors src/tasks/run/task-history.ts's
- * `taskHistoryRowToResult` read mapping:
- *   - NEW rows mark themselves with metadata `targetVocab: 2` and store
- *     `target_kind: "command"` for the agent/LLM arm.
- *   - LEGACY rows (no marker, written before P1b's F-2 re-code) stored
- *     `target_kind: "prompt"` for the same arm — and `"command"` for the
- *     UNRELATED native shell/script arm, which must NOT be counted here.
- * So an unmarked `"command"` row is a legacy shell/script run, not an
- * agent/LLM one; a marked `"command"` row (or an unmarked `"prompt"` row) is.
+ * `akm health`'s `agentFailureRate` predicate: true for a `task_history` row
+ * that represents a prepared command (agent/LLM) result. `target_kind` is
+ * read in the current (post-D8) vocabulary — the
+ * `025-task-history-vocabulary-backfill` state migration rewrites every
+ * legacy-vocabulary row (which stored the agent/LLM arm as `"prompt"` and
+ * the native shell/script arm as `"command"`) before this ever runs against
+ * it, so a `"command"` row here is unambiguously the agent/LLM arm.
  */
 export function isAgentTaskHistoryRow(row) {
-    // Check target_kind BEFORE decoding metadata: some rows in the wild
-    // (e.g. improve-pipeline task_history rows, target_kind "improve") carry
-    // metadata_json that predates the metadataVersion:2 shape entirely, and
-    // decodeTaskHistoryMetadata throws on that — exactly like the pre-fix
-    // `target_kind === "prompt"` filter, which never called it for a row this
-    // function isn't going to count anyway. Only decode for the two target
-    // kinds this predicate can return true for.
-    if (row.target_kind !== "command" && row.target_kind !== "prompt")
-        return false;
-    // An undecodable metadata_json is by definition unmarked: pre-P1b rows can
-    // carry shapes decodeTaskHistoryMetadata rejects, and `akm health` must
-    // classify them as legacy rather than throw (round-3 review advisory).
-    let marked = false;
-    try {
-        marked = decodeTaskHistoryMetadata(row.metadata_json).targetVocab === 2;
-    }
-    catch {
-        marked = false;
-    }
-    if (row.target_kind === "command")
-        return marked;
-    return !marked;
+    return row.target_kind === "command";
 }
 function createUnknownImproveMetrics() {
     return {

package/dist/commands/health/windows.js

@@ -148,10 +148,6 @@ export function buildWindowMetrics(db, stateDbPath, since, until, now = () => Da
     const failedTaskRows = taskRows.filter((row) => row.status === "failed");
     const activeRows = taskRows.filter((row) => row.status === "active" && row.completed_at === null);
     const stuckActiveRuns = activeRows.filter((row) => now() - new Date(row.started_at).getTime() > ACTIVE_RUN_WARN_MS).length;
-    // D8 (spec §5.3): a marked "command" row or a legacy (unmarked) "prompt"
-    // row is the agent/LLM arm; an unmarked "command" row is the legacy
-    // native shell/script arm and must not be counted here (see
-    // isAgentTaskHistoryRow's header comment for the full mapping).
     const agentRows = taskRows.filter((row) => isAgentTaskHistoryRow(row));
     const agentFailures = agentRows.filter((row) => {
         const detail = taskFailureDetail(row);