11 Commits

Include renames

Author	SHA1	Message	Date
3 people	9bf96db807	v0.42.51.0 fix(sync): contention-free clock + checkpoint integrity + honest sync freshness (#2255) ... * fix(sync): contention-free page-generation clock — sequence swap The page-generation clock backed the query-cache Layer-1 bookmark via a FOR EACH STATEMENT trigger running `UPDATE page_generation_clock SET value=value+1 WHERE id=1`. That took a transaction-length RowExclusiveLock on one tuple, so every concurrent page writer serialized on the prior writer's COMMIT — sync ran at ~0.8 cores regardless of worker count. Swap to a SEQUENCE bumped by nextval() (a microsecond LWLock, never a row lock). The clock's only contract is monotonic advancement on any page INSERT/UPDATE/DELETE; last_value is non-transactional, so rolled-back or concurrent-uncommitted writers only OVER-invalidate the cache (lose a hit), never serve stale. - migration v118: CREATE SEQUENCE + load-bearing 2-arg setval (is_called= true, floor 1, seeded >= old clock and MAX(generation)) + repoint the trigger function body + DELETE query_cache so no old-clock bookmark survives the swap. v107 left immutable. - query-cache-gate.ts: 3 readers -> SELECT last_value FROM page_generation_clock_seq. - schema.sql + pglite-schema.ts (+ regenerated schema-embedded.ts) ship the sequence on fresh install; table + trigger names retained. - tests: clockValue reads last_value; mechanism proof (trigger fn uses nextval not the row UPDATE); rollback-advances-clock safety pin; real PGLite sequence round-trip (is_called gotcha); shape test requires _seq. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(sync): op_checkpoints array-shape guard — CHECK + repair + defensive loader completed_keys is JSONB and the checkpoint loader runs jsonb_array_elements_text over it. A non-array (scalar) value makes that throw "cannot extract elements from a scalar", which takes down the whole UNION load — including the valid op_checkpoint_paths child rows — and loses all checkpoint progress for that key. No current writer produces a scalar, but an older binary / external script / future bug could. Make the corruption class structurally impossible and self-healing: - migration v119: LOCK TABLE (so an out-of-band scalar can't land between repair and constrain; no-op on single-connection PGLite), repair any pre-existing scalar to '[]' (op_checkpoint_paths child rows are the append-only source of truth, so the reset loses nothing), then add the named CHECK (jsonb_typeof(completed_keys) = 'array') via a pg_constraint IF NOT EXISTS guard. A DB-enforced always-on guard — the correct pattern vs a migration verify-hook, which never runs on already-stamped brains. - schema.sql + pglite-schema.ts (+ regenerated schema-embedded.ts) ship the same NAMED inline CHECK so fresh installs match migrated brains and v119 skips the duplicate. - op-checkpoint.ts loader: gate the legacy arm on jsonb_typeof = 'array' so a scalar parent is skipped (children still load) instead of throwing the whole union, and log a specific corruption warning when one is seen. - tests: CHECK rejects a scalar (exactly one constraint, no blob+migration dupe); loader survives a scalar parent and returns the children; v119 repair converts a scalar to '[]'. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(doctor): report actively-running sync via live lock, not stale freshness A slow source that makes partial progress every cycle but never fully completes used to read as permanently "stale" / "never synced" because last_sync_at only advances on a full successful sync. The naive fix (treat recent checkpoint banking as "in progress") is unsafe: a blocked sync banks the good files then writes no anchor, so banking can't tell in-progress from wedged. Use the only honest signal: a LIVE, non-expired per-source sync lock (inspectLock + syncLockId against gbrain_cycle_locks). Every non-skipLock sync holds it and refreshes it; a blocked/failed sync's process has exited (no lock row) and a wedged holder stops refreshing (TTL lapses), so either correctly falls through to the stale path and is NEVER masked. An actively-syncing source (including a never-synced source doing its first sync) counts as synced_recently, preserving the pinned 3-bucket invariant. The lock lookup reuses doctor's existing dynamic db-lock import and swallows any throw (stub engine, pre-lock-table brain) to false, so it can only ADD an in-progress verdict, never suppress a real stale one. Tests (real PGLiteEngine + real lock rows): stale+no-lock -> fail; stale+live-lock -> ok; never-synced+live-lock -> ok; never-synced+no-lock -> fail; expired-TTL lock -> fail (wedged not masked); blocked source with banked checkpoint rows but no lock -> still fail. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(sync): honest --force-break-lock diagnostic when no lock is held --force-break-lock used to emit the same terse "Lock ... is not held (nothing to break)" line and exit 0 even when a sync was genuinely wedged, sending the operator down a dead end — the wedge was not a held lock. Keep rc=0 (breaking a non-existent lock is idempotently successful; flipping the exit code would break automation), but under --force say plainly that nothing was broken and point at the real next step (gbrain sync / gbrain doctor) plus a `wedge_hint` field in --json output. The non-force path is byte-for-byte unchanged. runBreakLock is exported for the test. Tests: force+no-lock -> wedge_hint JSON + human hint, rc 0; non-force+no-lock -> unchanged terse line, no hint. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(doctor): surface the in-progress sync holder in the freshness message Plan-completion follow-up to the BUG 4 live-lock signal: when a source is actively syncing, name the holder (pid + host) in the check message instead of silently folding it into synced_recently. The note is appended only when something is in progress, so steady-state messages stay byte-for-byte unchanged (the pinned exact-message + 3-bucket-invariant tests still pass). Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(sync): pre-landing review fixes — monotonic clock seed, scoped CHECK guard Adversarial (codex) review of the implementation diff caught three: - P1 (correctness): the fresh-schema setval was not monotonic. initSchema replays the schema blob, and the unconditional setval(MAX(generation)) could move page_generation_clock_seq.last_value BACKWARD on an already-upgraded brain, letting a stored query_cache bookmark serve stale rows. Seed via GREATEST over the sequence's OWN last_value (+ old table value + MAX(generation)) in all 3 fresh schemas and migration v118, so a replay is idempotent — mirrors the old table's ON CONFLICT DO NOTHING. Pinned by a new monotonic regression test. - P2: v119's CHECK-exists guard keyed on conname only (not globally unique). Scope it to conrelid = 'op_checkpoints'::regclass. - P3: in-progress note ran into the prior sentence in fail/warn doctor messages; separate it with '. '. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * test: make Anthropic/ZE no-key tests hermetic against a dev config key These "no key" tests cleared only ANTHROPIC_API_KEY / ZEROENTROPY_API_KEY from the env, but hasAnthropicKey() and checkZeEmbeddingHealth() also read the key from ~/.gbrain/config.json. On a dev machine whose real config holds a key, the no-key assertions flipped and the tests failed locally (they passed only in key-less CI). Add a shared with-env emptyHome() helper and point GBRAIN_HOME at an empty dir in every no-key path so loadConfig finds nothing — matching the already-hermetic anthropic-key / gateway-probe tests. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * chore: bump version and changelog (v0.44.1.0) Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * docs(key-files): sync doctor + op-checkpoint entries to v0.44.1.0 truth checkSyncFreshness now reports an actively-running sync via the live per-source lock (names holder pid+host, counts as synced_recently) instead of flagging it stale; loadOpCheckpoint gates the legacy union arm on jsonb_typeof = 'array' so a scalar parent can't take down the whole load, and migration v119's CHECK constraint makes the corruption class structurally impossible. Reference docs describe current behavior only — both entries updated in place, no release-clause appends. Guard + llms freshness test green. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * chore: re-version to v0.42.51.0 (natural next-off-master) Maintainer override of the queue allocator's leap to 0.44.1.0 (it jumped past in-flight sibling PR claims at 0.42.50/0.43.0/0.44.0). Take the natural next slot in the 0.42.x line above the immediate sibling claim (0.42.50.0); a merge re-bump resolves any collision if a cathedral PR lands first. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * ci(e2e): bound + retry the OpenClaw install so a transient npm hang can't burn the Tier 2 budget The Tier 2 (LLM Skills) job failed at 30m16s — the `npm install -g openclaw@2026.4.9` step hung on a transient npm/registry stall (orphan `npm install openclaw` was still running at cancel time) and consumed the entire 30m job budget that v0.42.50.0 (#2254) introduced. The install normally finishes in under a minute (Tier 2 is ~4m end to end on master), so this is flaky-install infra, not a test failure. Wrap the install in `timeout 120` + a 3-attempt retry loop with an 8-minute step backstop: a hung attempt is killed in 2 min and retried instead of eating the whole job. Same bound-the-hang philosophy as #2254's job timeouts. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-17 14:02:47 -07:00
3 people	f7f8512b14	v0.42.28.0 fix(engine): batch inserts use jsonb_to_recordset, not text[] array literals (#1861) (#1927) ... * fix(engine): batch inserts use jsonb_to_recordset, not text[] array literals (#1861) addLinksBatch/addTimelineEntriesBatch/addTakesBatch passed free text through unnest(${arr}::text[]); postgres.js serialized it to a Postgres text[] literal that array_in rejected ("malformed array literal") on calendar/Zoom context, aborting the whole `extract links --stale` sweep. Bind the batch as one JSONB doc via jsonb_to_recordset(($1::jsonb)->'rows') through the audited executeRawJsonb contract instead. Shared row builders (src/core/batch-rows.ts) keep both engines byte-identical; NUL is stripped only from free-text body fields (context/summary/detail/claim), while identity/security fields (slugs/source_ids/holder/kind/dates) still reject NUL. addTakesBatch is now batchRetry-wrapped ('addTakesBatch' audit site) and its BrainEngine signature takes BatchOpts. Scalar addLink context is NUL-stripped too. Regression tests on both engines: PGLite always-on poison/NUL/parity suite + DATABASE_URL-gated Postgres lane (the engine that actually crashed). * test: make "no Anthropic key" tests hermetic via withoutAnthropicKey hasAnthropicKey() reads both ANTHROPIC_API_KEY and ~/.gbrain config; tests that only deleted the env var fired a real LLM call on configured machines (warning flipped NO_ANTHROPIC_API_KEY -> LLM_OUTPUT_NOT_JSON). New test/helpers/no-anthropic-key.ts neutralizes both sources (env + GBRAIN_HOME temp dir) for the duration of the call. Refactors the five no-key tests in think-pipeline + takes-mcp-allowlist to use it, including two that previously passed only by luck of the live LLM output. * chore: docs + version bump (v0.42.28.0) KEY_FILES.md/RETRIEVAL.md describe the jsonb_to_recordset batch path; TODOS.md files the #1861 follow-ups (element-isolation, remaining ::text[] sites, shared SQL-string hoist, batch-insert edge-case tests). CHANGELOG + VERSION + package.json to 0.42.28.0. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * docs: sync TESTING.md batch-insert references for v0.42.28.0 The #1861 fix migrated links/timeline/takes batch inserts from unnest(::text[]) to jsonb_to_recordset. Update the stale "postgres-js unnest() binding" note and add the two new poison-regression test files (test/links-timeline-jsonb-poison.test.ts PGLite half, test/e2e/jsonb-batch-poison-postgres.test.ts Postgres lane) to the inventory. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> * fix(sql-query): reject top-level array jsonb params in executeRawJsonb (#1861 P2a) The "no top-level array" rule was only a comment. A bare JS array bound to a $N::jsonb position can serialize as a Postgres array literal (not jsonb) through postgres.js, silently re-entering the "malformed array literal" class #1861 just escaped. executeRawJsonb now throws a clear error steering callers to the { rows: [...] } object wrapper. Verified breaks zero call sites (all pass objects or null). Codex adversarial P2a; batch-size enforcement (P2b) filed as a TODO. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-07 08:05:34 -07:00
3 people	ff32fcaa78	v0.41.25.0 perf(sync): batched deletes + global page-generation clock (supersedes #1538) (#1566) ... * feat(engine): add deletePages + resolveSlugsByPaths to BrainEngine (v0.41.21.0 T1) Two new REQUIRED methods on the BrainEngine interface, implemented on both Postgres and PGLite engines. Closes the per-file N+1 query pattern that PR #1538 batched on Postgres only. deletePages(slugs: string[], opts: { sourceId: string }): Promise<string[]> — Single SQL round-trip: DELETE FROM pages WHERE slug = ANY($1::text[]) AND source_id = $2 RETURNING slug — Returns slugs ACTUALLY DELETED (D6, codex CDX-8) so callers can filter pagesAffected to exclude phantom slugs (paths in the deletion list but with no DB row). — Single-batch primitive: caller chunks input to DELETE_BATCH_SIZE. Throws if input exceeds the cap. — sourceId is REQUIRED at the type level (D5, codex CDX-10). Asymmetric with single-row deletePage which keeps the optional 'default' fallback for back-compat. v0.42+ TODO to tighten. resolveSlugsByPaths(paths, opts): Promise<Map<path, slug>> — Batch path → slug lookup. Single SQL round-trip: SELECT slug, source_path FROM pages WHERE source_path = ANY($1::text[]) AND source_id = $2 — Missing paths absent from the Map (caller falls back to path-derived slug, same contract as resolveSlugByPathOrSourcePath). — Empty input short-circuits to empty Map (no SQL). src/core/engine-constants.ts (NEW) — Single source of truth for DELETE_BATCH_SIZE = 500. — Both engines import; no engine-from-engine coupling. — Lives outside engine.ts (the interface module) to avoid circular imports. Also updates the deletePage JSDoc (CDX-11): drops the misleading "hard delete is admin-only" framing. `gbrain sync` hard-deletes on every run that sees a deleted file; not admin-only. Co-Authored-By: garrytan-agents <noreply@anthropic.com> Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * perf(sync): batched delete + rename + DRY refactor (v0.41.21.0 T2/T3/T4) Replaces the per-file delete loop (sync.ts:1241-1257) and per-file rename slug-resolve (sync.ts:1263-1295) with interleaved per-batch flows using engine.resolveSlugsByPaths + engine.deletePages. Also refactors resolveSlugByPathOrSourcePath (sync.ts:267) to delegate to the new batch helper when sourceId is set — one owner of the SQL + fallback semantics (D8). ROUND-TRIP COUNTS (73K-delete commit): pre-fix: 73,000 SELECTs + 73,000 DELETEs = 146,000 (~5 hours) post-fix: 146 SELECTs + 146 DELETEs = 292 (~2 minutes) Headline win: a single commit deleting 73K files no longer jams the sync pipeline for hours, no longer cascades staleness across every other source on the brain. Shape (T2 delete loop, per the plan's ASCII diagram): filtered.deleted (73K paths) │ ▼ slice into batches of DELETE_BATCH_SIZE (500) │ ▼ for each batch: abort-check ──► partial('timeout') │ ▼ engine.resolveSlugsByPaths(batch, {sourceId}) ◀── 1 SQL round-trip │ ▼ slugs = batch.map(path => map.get(path) ?? resolveSlugForPath(path)) ◀── pure-JS fallback │ for frontmatter- ▼ fallback slugs try { deleted = engine.deletePages(slugs, opts) ◀── 1 SQL round-trip pagesAffected.push(...deleted) ◀── D6 confirmed only } catch { // D7 decompose: per-slug deletePage, // unrecoverable failures → failedFiles } Per-batch try-catch (D7) decomposes batch DELETE failures to per-slug deletePage so a transient blip on batch 73 doesn't lose 500 deletes — it self-heals to one-at-a-time for that batch only. Unrecoverable per-slug failures land in failedFiles (matching the existing import-loop pattern at sync.ts:~1350). failedFiles declaration hoisted above the delete loop so both delete decompose and import loops feed the same sync-bookmark gate. T4 rename loop: pre-resolves all `from` slugs in batches via resolveSlugsByPaths BEFORE iterating. Per-file updateSlug + importFile calls stay (those are inherently per-file). The try/catch around updateSlug for slug-doesn't-exist preserves verbatim. T3 DRY refactor: resolveSlugByPathOrSourcePath delegates to resolveSlugsByPaths via a single-element array when sourceId is set. When sourceId is undefined (legacy unscoped callers), falls back to the original executeRaw shape — the batch engine surface requires sourceId per D5 (multi-source-bug-class defense). Atomicity coarsening (D3): each batch is one transaction. A mid-batch abort or connection failure rolls back up to DELETE_BATCH_SIZE - 1 successful deletes from the in-flight batch. Sync is idempotent so the next run picks them up via git diff regenerating the deletion list. Documented at the call site + in the deletePages JSDoc. Co-Authored-By: garrytan-agents <noreply@anthropic.com> Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(schema): global page-generation clock + statement-level trigger (v0.41.21.0 T5) Migration v104: page_generation_clock_and_statement_trigger. The pre-v0.41.21.0 query-cache Layer 1 bookmark read MAX(generation) FROM pages to detect "writes happened since cache-store". Two bugs in that contract — independent of any sync work, surfaced by codex outside-voice on the /plan-eng-review pass: 1. The row-level bump_page_generation_trg (migration v91) sets NEW.generation = OLD.generation + 1 on UPDATE. Updating a NON-MAX page didn't advance MAX(generation). Cache silently served stale for any UPDATE-to-non-max page. (CDX-2) 2. The trigger is BEFORE INSERT OR UPDATE — DELETE doesn't fire it at all. Even an AFTER DELETE wouldn't move MAX (surviving rows are untouched). (CDX-1) Fix: single-row page_generation_clock counter, bumped per-statement (FOR EACH STATEMENT — per-row would turn a 73K-row batch DELETE into 73K UPDATEs on the same counter, recreating the bottleneck this PR fixes elsewhere — codex CDX-4). Layer 1 reads the clock value directly (T6, separate commit). Per-row pages.generation stays for Layer 2 (per-page snapshot via jsonb_each + LEFT JOIN pages) which doesn't care about MAX, only per-page advancement. Seeded with COALESCE(MAX(pages.generation), 0) so existing query_cache rows stored under the old MAX semantics aren't all instantly invalidated on upgrade. Their max_generation_at_store stamp compares cleanly against the seeded clock; future writes bump the clock and the bookmark fires correctly. CREATE TABLE page_generation_clock ( id INTEGER PRIMARY KEY CHECK (id = 1), value BIGINT NOT NULL DEFAULT 0 ); CREATE TRIGGER bump_page_generation_clock_trg AFTER INSERT OR UPDATE OR DELETE ON pages FOR EACH STATEMENT EXECUTE FUNCTION bump_page_generation_clock_fn(); Mirror in src/core/pglite-schema.ts so fresh PGLite installs get the table + trigger via SCHEMA_SQL replay. The forward-reference bootstrap probe doesn't need an entry: page_generation_clock is created directly by SCHEMA_SQL (no separate index or FK references it), so the schema-bootstrap-coverage gate is satisfied as-is. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(cache): move Layer 1 to global clock + invalidate empty snapshots (v0.41.21.0 T6) Closes the silent stale-cache bug class that's been live in master since the bookmark feature shipped. Pre-fix, gbrain search would silently serve stale cached results in three independent scenarios: 1. UPDATE to a non-max-generation page (CDX-2) — the row-level trigger advanced per-page generation but didn't move MAX(generation), so the bookmark passed. 2. DELETE of any page (CDX-1) — the trigger didn't fire at all, and even an AFTER DELETE wouldn't move MAX. 3. Empty-result cache row + subsequent matching INSERT (CDX-6 / D20) — page_generations = '{}'::jsonb was "vacuously valid" via Layer 2, surviving any clock bump. Fix: buildPageGenerationsSnapshot (store path) — Replaces the SELECT MAX(generation) FROM pages reads at cache-write time with SELECT value FROM page_generation_clock WHERE id = 1. — Empty pageIds path: only need the clock value (D20 contract). — Combined non-empty path: per-page generation (Layer 2 substrate) + clock value, both folded in one round trip via UNION ALL. CACHE_GATE_WHERE_CLAUSE (lookup path) — Layer 1 reads page_generation_clock.value (single-row O(1) lookup, faster than the pre-fix MAX(generation) backward index scan). — Layer 2 stricter: requires page_generations <> '{}'::jsonb AND the per-page check (not OR with the vacuously-valid `= '{}'` shortcut). Empty snapshots can no longer survive a Layer 1 miss. validateCacheRowAgainstPages (pure validator) — Layer 2 returns false for empty snapshots when Layer 1 fails. — Documented contract change. Backward compat: pre-v0.40.3.0 cache rows have max_generation_at_store = 0 AND page_generations = '{}'::jsonb. On a populated brain, Layer 1 fails (clock > 0). Layer 2 is now stricter so legacy rows invalidate once on first post-upgrade lookup, then the cache fills back correctly. Acceptable one-time miss spike; post-upgrade cache is structurally sound. The clock seed (COALESCE(MAX(pages.generation), 0)) from migration v104 keeps NON-empty legacy rows passing Layer 1 until the next write — they don't all invalidate at once. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test: cover v0.41.21.0 delete-batch + global clock + cache contract (T7+T8+T9) Tests for every behavior the v0.41.21.0 wave introduces or changes. New test files: test/sync-delete-batch.test.ts (PGLite hermetic) — engine.deletePages: empty input short-circuit, returns confirmed slugs (D6), multi-source isolation, cascade integrity (chunks + links cleared via FK), rejects oversized input. — engine.resolveSlugsByPaths: empty input, present + missing rows, D10 exotic-filename substrate (🌟.md / ทดสอบ.md / عربي.md), source isolation. — D13 pagesAffected filter: 100 deletable + 10 ghost paths → deletePages returns 100 (regression-pin: pre-fix would return all 110 via D6's pre-RETURNING shape). test/sync-delete-batch.slow.test.ts (.slow suffix keeps it out of the fast loop) — 10K-page batched delete completes in <5s on PGLite. Measured 277ms on dev hardware (18x under the gate); pins the headline perf promise. test/sync-rename-batch.test.ts (PGLite hermetic) — 500-rename batch slug-resolve in 1 round-trip (exactly at DELETE_BATCH_SIZE boundary). — Frontmatter-fallback rename: exotic source_paths resolve via the batch SELECT. — Mixed present + missing: partial Map (missing → caller falls back to path-derived). test/page-generation-counter.test.ts (PGLite hermetic) — Statement-level trigger fires once per INSERT statement (raw SQL — NOT putPage, which uses ON CONFLICT DO UPDATE and bumps by 2 in PG semantics). — Statement-level trigger fires once per UPDATE statement. — Headline contract: batch DELETE bumps clock by 1, NOT by row count (25-row batch → +1). — CDX-1 regression: DELETE of non-max page bumps clock. — CDX-2 regression: UPDATE of non-max page bumps clock (raw SQL). — D14 end-to-end: clock advances after batch DELETE → cache rows stamped at the prior clock value are now stale by Layer 1. — CDX-6/D20: empty-result cache + INSERT matching page → clock advances (Layer 1 fires). — Documents the PG quirk: putPage's INSERT...ON CONFLICT DO UPDATE bumps clock by 2 (both INSERT and UPDATE triggers fire). Test-helper update: test/helpers/reset-pglite.ts — Added page_generation_clock to PRESERVE_TABLES so the seeded single-row counter survives resetPgliteState between tests (same treatment as schema_version). Production never truncates. Existing test contract inversions (CDX-6 / D20 fix): test/query-cache-gate.test.ts — Pre-v0.41.21.0 "vacuously valid for legacy empty snapshot" assertion inverted: empty snapshot now invalidates when Layer 1 fires. Add positive CDX-6 regression test (empty-result + INSERT matching page). — SQL shape regression: page_generation_clock in Layer 1 (negative regression guard: MAX(generation) FROM pages MUST be gone). — Empty-snapshot reject guard: `qc.page_generations <> '{}'::jsonb` present; the old `qc.page_generations = '{}'::jsonb OR` shortcut MUST be gone. test/e2e/cache-gate-pglite.test.ts — Pre-v0.41.21.0 "legacy row serves vacuously" test inverted: legacy rows now invalidate on first clock advance post-upgrade. — CDX-1 regression: DELETE bumps clock → cached query for surviving pages invalidates. — CDX-2 regression: UPDATE-to-non-max-page bumps clock → cache invalidates. — CDX-11 comment fix: drop misleading "hard delete is admin-only" framing; gbrain sync hard-deletes on every run. Engine parity extension: test/e2e/engine-parity.test.ts — deletePages parity: same input set, both engines return same string[] of confirmed-deleted slugs (D6). — resolveSlugsByPaths parity: same Map on both engines. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * chore(release): v0.41.21.0 — batched sync deletes + global page-generation clock (T10) VERSION bump (0.41.18.0 → 0.41.21.0; master is at 0.41.20.0 so next free slot per the queue allocator). CHANGELOG entry with the ELI10 lead per CLAUDE.md voice rules. CLAUDE.md annotations on engine.ts, postgres-engine.ts, pglite-engine.ts, sync.ts, and query-cache-gate.ts plus a new entry for engine-constants.ts. llms-full.txt regenerated to match CLAUDE.md (per CLAUDE.md mandatory rule). Co-Authored-By: garrytan-agents <noreply@anthropic.com> Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * dx(test-runner): heartbeat shows real progress instead of 0p 0f Bun's default test reporter doesn't print per-test markers — only a single shard-end summary block when you pass it a file list. The existing heartbeat tried to count `^[[:space:]]+✓` lines as a live pass-count proxy, but bun never emits them in the multi-file mode this runner uses, so every mid-run heartbeat showed `0p 0f` for the entire 12-20 minute wallclock. Users (and agents polling the runner) couldn't distinguish "still bootstrapping" from "wedged" from "almost done." Fix: parse three complementary real-time signals instead. 1. Total files this shard was assigned — parsed from the `[unit-shard N/M] running X files` banner that run-unit-shard.sh echoes before invoking bun test. Available from second 1. 2. PGLite initSchema() count — proxy for "test files started so far." Each PGLite-using test file's beforeAll triggers one initSchema(), which logs `Schema version 1 → 106 (101 migration(s) pending)`. Undercounts because not every test file opens a PGLite engine (covers ~30-60% of files in practice), but it's the only real-time progress signal bun's default reporter leaves in the log. The output uses a `~` prefix to convey "approximate count." 3. Log size in KB — strictly monotonic liveness signal that works even when the PGLite count is still 0 (early-shard startup before the first initSchema fires). 4. Per-shard elapsed time — formatted as MmSSs. New mid-run heartbeat line: [heartbeat] [s1: ~62/190f 476KB 12m31s] [s2: ~63/190f 513KB 12m31s] ... When a shard finishes, the heartbeat upgrades to its final summary including pass/fail counts from bun's end-of-shard summary block: [heartbeat] [s1: done ✓ 2807p 0f] [s2: done ✓ 2784p 0f] ... Portability: BSD awk on macOS doesn't support `match($0, /re/, arr)` with the array sink — that's a gawk extension. The total-files parser uses sed instead so the runner stays portable to the default Mac toolchain. Helpers are pure functions and unit-testable in isolation: pass a log file path, get the parsed number. No mocking. No bun runtime required. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * chore(release): rebump v0.41.23.0 → v0.41.25.0 Per user request — skip v0.41.23.0 / v0.41.24.0 slots to land at v0.41.25.0. Master is at v0.41.22.1, no version-trio collision. Touches VERSION, package.json, CHANGELOG header, CLAUDE.md annotations, src/core/engine-constants.ts header, src/core/migrate.ts migration v106 comment, regenerated llms-full.txt + llms.txt. Migration version (v106) and CDX1-6 trigger semantics unchanged. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(schema): reorder migration_impact_log AFTER minion_jobs (CI green) Pre-existing bug in master's SCHEMA_SQL ordering, surfaced by CI on this PR but lived silently on master since v0.41.18.0. migration_impact_log declares `job_id BIGINT REFERENCES minion_jobs(id)`, but its CREATE TABLE was at line 658 while minion_jobs's CREATE TABLE was at line 778. On any fresh-install initSchema() the FK target didn't exist yet: psql:/tmp/schema.sql:672: ERROR: relation "minion_jobs" does not exist postgres-js's `unsafe()` aborts the multi-statement batch on the first error response, so every CREATE TABLE after migration_impact_log (including minion_jobs itself) never ran. Every subsequent CLI subprocess that opened a connection then crashed with `relation "minion_jobs" does not exist` on its first query. Why master CI sometimes passed: the per-shard advisory lock + the test setup's `engine.initSchema()` second pass (which runs the migrations array) would eventually create minion_jobs via the v5 `minion_jobs_table` migration. From there migration_impact_log would land via migration v103 with its FK resolving correctly. But CLI subprocesses spawned by mechanical.test.ts's Parallel Import block open their OWN connections and run a fresh `engine.connect() → initSchema()` — that path runs SCHEMA_SQL FIRST and aborted at the same forward-reference error before the migrations array could repair. Fix: relocate the migration_impact_log CREATE TABLE + its two indexes to AFTER the minion_jobs CREATE TABLE block (lines ~865), keeping the rest of the schema layout intact. PGLite schema (pglite-schema.ts) already had the correct ordering — only Postgres SCHEMA_SQL needed the move. Verified: fresh-DB local repro that previously failed 31/34 tests with `relation minion_jobs does not exist` now passes 78/78 in test/e2e/mechanical.test.ts. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: garrytan-agents <noreply@anthropic.com>	2026-05-27 08:50:53 -07:00
3 people	552ff4ed82	v0.41.11.1 ci: cut CI wallclock from 9min to 4.5min (#1457) ... * feat(eval-longmemeval): RunOpts.engine seam for shared benchmark brain Adds optional `engine?: PGLiteEngine` field to RunOpts. When set, runEvalLongMemEval uses the caller-provided engine and skips the withBenchmarkBrain wrapper (no fresh PGLite create, no disconnect on exit). When unset, the production CLI path is unchanged: withBenchmarkBrain creates and disposes a fresh engine per invocation. Designed for the test seam that's about to land: one beforeAll-created brain shared across all 13 runEvalLongMemEval calls in test/eval-longmemeval-e2e.slow.test.ts, amortizing the ~1-3s PGLite cold-create cost. runOneQuestion already calls resetTables() as its first line so per-test isolation is preserved across the shared engine. Pure additive seam — every existing caller (CLI, current tests that already create engines via withBenchmarkBrain implicitly) keeps its current behavior because opts.engine defaults to undefined. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * refactor(test): split eval-longmemeval slow tests + share engine across e2e half The 884-line test/eval-longmemeval.slow.test.ts was the heaviest single file in CI at ~359s on the matrix. Split by runEvalLongMemEval usage: - test/eval-longmemeval.slow.test.ts (trimmed): 8 pure describes, 15 tests. Harness lifecycle, resetTables, schema-migration robustness, warm-create speed gate, adapter haystackToPages, source-boost guard, loadResumeSet, buildByTypeSummary. Local wall: 1.985s, projected CI ~42s. - test/eval-longmemeval-e2e.slow.test.ts (NEW): 8 e2e describes, 11 tests. Every describe that calls runEvalLongMemEval — 13 call sites total. Threads a single beforeAll-created PGLite via the v0.41.10 RunOpts.engine seam. Local wall: 9.33s (was 15.09s without sharing); projected CI ~196s (was ~317s). - test/helpers/longmemeval-stub.ts (NEW): shared makeStubClient + StubCall. Matches the existing test/helpers/ convention (with-env.ts, reset-pglite.ts). Single source of truth across the two split files. - scripts/test-weights.json: replaced 359087ms entry with TWO entries (42000ms pure, 196000ms e2e). Projected linearly from local wall-clock × 21 CI scaling factor. First post-merge CI run will refine via scripts/mine-shard-weights.ts. Test count is preserved: 15 pure + 11 e2e = 26, matches original file. No production code changes in this commit — only test reorganization + opt-in to the RunOpts.engine seam from the previous commit. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * ci(test): bump matrix 6→10, dedicate two slow files, cache bun-install CI matrix wallclock: ~9 min → ~4.5 min. Three coordinated changes. 1. .github/workflows/test.yml matrix bumped from 6 → 10 shards. Per-shard total drops from 532s → 272s. Honest concurrency-budget call: total gated jobs go 13 → 18, so 2 concurrent PRs ≈ 36 queued, past the GH free-tier ~20 ceiling — single-PR runs unaffected, multi-PR days see queue pressure. Worth it for the 4-min CI saving. 2. Two slow files pulled out of the matrix and into their own dedicated jobs (sibling to verify, serial-tests): - slow-eval-longmemeval runs test/eval-longmemeval-e2e.slow.test.ts (~196s after the engine-sharing seam from the previous two commits). - slow-entity-resolve-perf runs test/entity-resolve-perf.slow.test.ts (~159s, single non-subdivisible perf test). The 60s default bun timeout is too tight for this file — bumped to 300000ms. scripts/test-shard.sh excludes both via -not -name clauses so the matrix sweep doesn't double-run them. Both new jobs wire into cache-write.needs and test-status.needs so CI gates on them. 3. actions/cache for ~/.bun/install/cache added to every job that runs bun install (test matrix, verify, serial-tests, slow-eval-longmemeval, slow-entity-resolve-perf). Keyed on bun.lock hash. Saves ~15s per job on cache hit; first-PR push pays full cost, subsequent runs hit cache. Total CI wallclock now bounded by max(matrix ~4.5min, slow-eval ~3.3min, slow-entity-resolve-perf ~2.6min) = ~4.5 min. The matrix is back to being the floor; no single test file dominates a shard. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * chore: v0.41.10.0 — CI wallclock 9min → 4.5min VERSION + package.json + CHANGELOG entry for the three preceding commits: feat(eval-longmemeval): RunOpts.engine seam for shared benchmark brain refactor(test): split eval-longmemeval slow tests + share engine across e2e half ci(test): bump matrix 6→10, dedicate two slow files, cache bun-install Net user-visible: CI 'Test' check finishes in ~4.5 min instead of ~9 min. Net contributor-visible: new RunOpts.engine seam on runEvalLongMemEval for benchmark suites that want to amortize PGLite cold-create across many calls. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(test): quarantine hybrid-meta + schema-pack-load-active to serial The 6→10 matrix shard bump in this branch re-shuffled file distribution across shard processes. Two pre-existing tests with hidden cross-file state dependencies surfaced as failures in CI run #77779498812/13: - test/hybrid-meta.test.ts shard 7: gateway state (configured by some other test in the same shard process) survived past the test's `delete process.env.OPENAI_API_KEY` call, so the early-return for expansion didn't fire and `expansion_applied` stayed true. - test/schema-pack-load-active.test.ts shard 8: the schema-pack module's test-injected locator state was left behind by an earlier file, so `loadActivePack` with the default config didn't fall through to the bundled gbrain-base path. Both files pass cleanly solo (verified). The pollution sources are unidentified — bun's reporter only printed 14 of 71 file headers per shard log, hiding the polluters. Rather than spelunk for the source, rename both files to *.serial.test.ts. The serial pass runs them at --max-concurrency=1 in a process that doesn't share state with the parallel matrix shards. Same-wave bookkeeping: - scripts/check-test-isolation.allowlist: drop test/hybrid-meta.test.ts entry (file is now serial, no longer R1-eligible). - scripts/test-weights.json: rename both weight entries to match the new filenames so future matrix LPT runs don't fall back to median. Companion to a7d029d0/2e1c269e/5a749acb of this branch. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-25 15:46:25 -07:00
3 people	d0d0e2a64a	v0.37.11.0: fresh-install PGLite embedding setup fix wave (#1286) ... * chore(test): preload gateway to OpenAI/1536 so 1536-dim test fixtures keep working The v0.37 fix wave changes the canonical gateway defaults to zeroentropyai:zembed-1 / 1280 (matching what v0.36 already chose as the system default). 20+ test files have hardcoded new Float32Array(1536) fixtures that match the OLD schema default. Without this preload, those tests fail with a vector-dim-mismatch on insert. The preload is gateway-only — it doesn't change which model gbrain ships to production users. Tests that want the new ZE/1280 defaults call configureGateway() explicitly in their own beforeAll. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(ai): canonical embedding defaults + sweep across schema/engines/registry Closes the v0.36 defaults drift bug class. The gateway shipped zeroentropyai:zembed-1 / 1280 as the system default in v0.36 but eight other places kept hardcoding 1536 / text-embedding-3-large. Fresh gbrain init --pglite sized the column to 1536, the embed pipeline used ZE/1280, and every page failed with dim mismatch. - New src/core/ai/defaults.ts leaf module is the canonical source for DEFAULT_EMBEDDING_MODEL / DEFAULT_EMBEDDING_DIMENSIONS. Schema and registry helpers import from this lean module instead of pulling the full gateway (which loads every provider SDK). - src/core/ai/gateway.ts re-exports the constants for back-compat. - src/core/pglite-schema.ts getPGLiteSchema() defaults track gateway. - src/core/postgres-engine.ts getPostgresSchema() default args track gateway (same drift on the Postgres path — codex round 1 CDX-1). - Both engine.initSchema() fallbacks track gateway constants (no more stale OpenAI/1536 catch-block defaults). - Schema seed stops stripping the provider prefix; full provider:model is stored in the DB config table (codex round 1 CDX-4). - Chunk-row INSERT defaults track gateway (codex round 2 CDX2-4 — pglite-engine:1611 + postgres-engine:1647 were production write sites previously hardcoded to text-embedding-3-large). - src/core/search/embedding-column.ts loadRegistry + isCacheSafe gain the cfg > gateway > DEFAULT resolution chain (codex round 2 CDX2-3). The gateway tier matters because callers that configure the gateway (init paths, tests, programmatic SDK) expect the registry to mirror that state when cfg doesn't have an explicit embedding_model. Tests: - schema-templating: default expectation flips to ZE/1280 (v0.37 truth). - embedding-dim-check: 3 new engine-kind branching cases + updated fresh-brain expectation (under legacy preload). - embedding-column: registry + isCacheSafe expectations match new chain. - v0_28_5-fix-wave E2E: engineKind required arg propagated. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(init+config+cli): always-configure gateway, file-only loader, honest config-set, sync/reinit help Closes the "fresh init doesn't work + config-set silently lies" bug class end-to-end. Six related changes that ship together because the file-plane/DB-plane contract only holds when init paths, config-set, the gateway env mapping, and the recipe text all agree. Lane B (init paths): - initPGLite, initPostgres, initMigrateOnly always configureGateway() before engine.initSchema(). Pre-fix the call was gated on flags, so bare `gbrain init --pglite` left the gateway unconfigured and the engine fell through to stale OpenAI/1536 defaults instead of the ZE/1280 the gateway would have resolved. - New configureGatewayWithMergedPrecedence() helper applies the locked precedence chain `CLI > env > existing file > gateway internal`. - printResolvedAIChoice() shows the resolved model/dim at init time + surfaces a ZE setup hint inline when the API key is missing. - B.4: saveConfig merge uses loadConfigFileOnly() so transient env state (DATABASE_URL, etc.) never poisons ~/.gbrain/config.json (codex round 2 CDX-5). - B.5: extend the v0.28.5 dim-mismatch detector so it fires when the gateway-resolved dim differs from the existing column, not only when --embedding-dimensions is explicit (codex round 2 CDX-6). Lane C (config plane): - New `loadConfigFileOnly()` reads ~/.gbrain/config.json only — no env merge, no DATABASE_URL inference. Safe write-back source for init. - GBrainConfig gains `zeroentropy_api_key?: string`. loadConfig merges process.env.ZEROENTROPY_API_KEY. buildGatewayConfig at cli.ts:1401 maps it into env.ZEROENTROPY_API_KEY so ZE recipes finally see it (codex round 2 CDX2-5+6 — the v1 fix landed in the wrong file). - `gbrain config set embedding_model` and `... embedding_dimensions` refuse unconditionally and print a paste-ready wipe-and-reinit recipe. No --force escape (codex round 2 CDX2-13). - migrate-engine.ts adds a contract comment at the DB-plane write site documenting "DB stores schema-applied metadata; file plane is canonical for runtime gateway config" + preserves the existing file-plane config across engine migration. Lane D.1 (recipe text): - embeddingMismatchMessage() takes an `engineKind` arg. PGLite branch emits a wipe-and-reinit recipe using gbrainPath('brain.pglite') or the caller's databasePath override. Postgres branch keeps the SQL ALTER recipe. - The PGLite recipe recommends `gbrain reinit-pglite` (new sugar command below) as the one-line path before falling back to the by-hand mv + init + sync sequence. Lane D.4 (sync help dispatch): - `sync` and `reinit-pglite` added to CLI_ONLY_SELF_HELP so their own --help branches reach the user (pre-fix the generic short-circuit fired first and the dedicated usage was unreachable; codex round 2 CDX2-12). - `gbrain sync --help` short-circuits BEFORE engine bind so users on a fresh tmpdir (no config) can read the help without hitting no-such-config errors. Sugar: - New `gbrain reinit-pglite --embedding-model X --embedding-dimensions N` wraps the wipe + init + sync dance into one command. Backs up the brain to <path>.bak. TTY confirmation unless --yes. --no-sync to defer the resync. --json for scripts. Tests: - test/cli.test.ts sync-help test rewritten for the new per-command-usage output (lists --no-embed which is the v0.37 user-visible flag the wave wanted to surface). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(embed+sync): pre-flight dim-mismatch guard + sync hint at both catch sites embedding-pipeline error UX. Pre-fix, a fresh-install dim mismatch produced raw Postgres "expected N dimensions, not M" errors page after page, surfacing only after the worker pool drained the entire corpus. Sync swallowed embed errors at TWO catch sites and never surfaced the recovery recipe. embed.ts: - New `EmbeddingDimMismatchError` tagged class with the paste-ready recipe baked in. - `runEmbedCore` pre-flights via `readContentChunksEmbeddingDim` + gateway.getEmbeddingDimensions() before the worker pool spins up. On mismatch, throws the typed error which the CLI wrapper catches and prints. Dry-run skips the check (no embed risk). - Catches the headline fresh-install bug class at first call instead of letting it hammer N parallel API calls into dim-rejected inserts. sync.ts: - Both embed catches at sync.ts:990 (incremental) and sync.ts:1129 (first-sync) detect EmbeddingDimMismatchError and surface the recipe + a `--no-embed` tip on stderr (codex round 2 CDX2-8: incremental path was previously silent; only the first-sync path was flagged). - Non-mismatch embed failures still stay best-effort (rate limits, transient network) — those shouldn't break sync. - Sync calls runEmbedCore directly instead of runEmbed (which calls process.exit on error and bypasses sync's catch). - Sync gets a proper --help block listing every meaningful flag: --no-embed, --workers, --source, --skip-failed, --retry-failed, --watch, --interval, --no-pull, --all, --json, --yes, --dry-run. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(doctor): read gateway for schema-sizing checks + provider-aware key lookup Doctor's embedding checks were reading the DB config table for embedding_model / embedding_dimensions / zeroentropy_api_key. Post v0.37 the file plane is canonical (the DB plane is schema-applied metadata, not runtime gateway config) so those reads produced stale verdicts on fresh installs whose DB row hadn't been written. - checkEmbeddingWidthConsistency reads gateway.getEmbeddingDimensions() and gateway.getEmbeddingModel() instead of engine.getConfig(...). Reuses readContentChunksEmbeddingDim from the same shared helper init + embed use. On mismatch, the fix hint threads engineKind + databasePath into the new branched recipe (codex round 1 CDX-8 + Lane E.1/E.2). - checkZeEmbeddingHealth reads gateway for the model + loadConfigFileOnly for the key. Fires when (a) resolved model starts with zeroentropyai: AND (b) ZEROENTROPY_API_KEY is unset in env AND (c) file plane has no zeroentropy_api_key (codex round 2 CDX2-10). - loadRecommendationContext reads gateway for both fields and recognizes the ZE key alongside OpenAI/Anthropic in the hasEmbeddingApiKey check, so brains on ZE no longer look "healthy" just because OPENAI_API_KEY happens to be set (codex round 2 CDX2-11). Tests rewritten for the gateway-source-of-truth contract via configureGateway() in beforeAll. Added a "gateway unconfigured: skips with ok" case so doctor doesn't false-warn on cold-boot brains. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test+docs(v0.37): fix-wave unit coverage + PGLite-first migration recipe + TODOS Lands the v0.37 PGLite fresh-install fix wave's structural tests and the user-facing migration recipe overhaul. test/v0_37_fix_wave.test.ts (new): 22 unit cases pinning the lanes: - Lane A: defaults module exports, getPGLiteSchema/getPostgresSchema default-args, registry + isCacheSafe under the `cfg > gateway > DEFAULT` chain (both gateway-set and gateway-reset branches). - Lane B: loadConfigFileOnly env isolation + DATABASE_URL inference refusal + null-on-missing. - Lane C.3: buildGatewayConfig maps zeroentropy_api_key + process.env wins over config (operator escape hatch contract). - Lane D.2: EmbeddingDimMismatchError shape + tag. - Lane D.4: structural assertion that `sync` is in CLI_ONLY_SELF_HELP. - Deferred-TODO ship: reinit-pglite is registered correctly + embeddingMismatchMessage PGLite branch recommends it. docs/embedding-migrations.md: PGLite section moved to top (the default install). The recommended path is `gbrain reinit-pglite` one-liner; the by-hand mv + init + sync sequence stays as the fallback recipe. Postgres SQL ALTER recipe preserved. New section on `gbrain config set` refusal explains the file-plane vs DB-plane contract so users don't follow stale documentation. TODOS.md: 4 deferred follow-ups filed with concrete file pointers: - gbrain embed --try-fallback (provider auto-switch with consent gate) - Full plane unification for non-schema-sizing fields - Worker-pool shared AbortController for mid-run dim drift - Cleanup of back-compat constants in src/core/embedding.ts Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test(v0.37): fill behavior gaps + headline fresh-install E2E The structural fix-wave tests in test/v0_37_fix_wave.test.ts pin lane-level invariants (exports, registry chain, signature shapes). The audit found 10+ END-TO-END behaviors that the structural tests didn't actually reach. This file fills the highest-leverage gaps. Unit coverage (test/v0_37_gap_fill.test.ts, 12 cases): - Lane A.7: chunk-row INSERT default tracks DEFAULT_EMBEDDING_MODEL constant (pre-fix this was the literal 'text-embedding-3-large' at pglite-engine.ts:1611 + postgres-engine.ts:1647 — production write sites that were never directly tested; codex round 2 CDX2-4). - Lane A.8: schema seed stores full provider:model in DB config (pre-fix the .split(':') strip dropped the prefix; codex round 1 CDX-4). Asserts a fresh ZE init stores `zeroentropyai:zembed-1` in the config table, not bare `zembed-1`. - Lane B precedence: explicit CLI > env > existing file > default test (codex round 2 CDX2-7 contradiction guard). - Lane C.3 env merge: process.env.ZEROENTROPY_API_KEY threads through loadConfig → cfg.zeroentropy_api_key; loadConfigFileOnly does NOT. - Lane D.2 end-to-end: schema=1536 + gateway=1280 → EmbeddingDimMismatchError fires AND the embed transport is never called (the whole point of pre-flight). Plus dry-run skips the check. - Lane D.3 source-text grep: both sync.ts catch sites detect the typed error + the `--no-embed` tip is present (CDX2-8). - Lane E.4 source-text grep: loadRecommendationContext is provider-aware (reads gateway + branches on ZE/OpenAI key). - reinit-pglite contract: refuses on non-PGLite engines + refuses when required flags are missing. E2E (test/e2e/fresh-install-pglite.test.ts, 2 cases): - Bare `gbrain init --pglite` produces a `vector(1280)` schema, prints the resolved choice, persists defaults to config.json — the headline scenario that v0.37 ships to fix. - init → seed page → embed end-to-end: chunks have non-null embeddings; no dim mismatch despite the wave's defaults change. Both E2E cases are IN-PROCESS (per CDX2-12: CLI-subprocess E2E can't inherit `__setEmbedTransportForTests`). They run with stubbed transport returning synthetic 1280-dim vectors so we never hit real provider APIs. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test(v0.37): defensive gateway restore in reinit-pglite describe block Adds an afterAll that restores the gateway to OpenAI/1536 (matching the bunfig preload) at the end of the reinit-pglite describe. Belt-and- suspenders: earlier describe blocks in this file already restore, but if the reinit-pglite tests ever start mutating the gateway in the future, this protects downstream test files in the same bun-test shard from inheriting a non-default state. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * chore: bump version and changelog (v0.37.10.0) Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * docs: scrub stale config-set recipes for embedding model (v0.37.10.0) README + topologies + embedding-providers were still pointing users at `gbrain config set embedding_model X` / `embedding_dimensions N`. As of v0.37.10.0 those writes are refused — the schema column has to resize alongside the config. Point at `gbrain reinit-pglite` (PGLite) and the SQL recipe in `docs/embedding-migrations.md` (Postgres) instead. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * chore: bump version to v0.37.11.0 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * test: quarantine v0.37 fix-wave tests to .serial.test.ts CI's `check:test-isolation` lint flagged R1 violations (direct `process.env.GBRAIN_HOME` mutation) in both new fix-wave test files. Per the documented quarantine pattern in CLAUDE.md, rename to `*.serial.test.ts` instead of refactoring through `withEnv()` — both files use beforeEach/afterEach env wiring that's already serial-safe. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-21 22:11:00 -07:00
3 people	4446e9f9d2	v0.35.5.0 fix wave: bootstrap + orphans + think MCP + worktree + walker (#1111) ... * fix(bootstrap): extend probes for files/oauth_clients/sources.archived* + add MIGRATIONS introspection guard Adds 7 new forward-reference probes to applyForwardReferenceBootstrap on both engines, closes the column-only forward-ref class via a new MIGRATIONS-source introspection contract test. New probes: - files.source_id + files.page_id (v18 forward refs) - oauth_clients.source_id + oauth_clients.federated_read (v60+v61+v65) - sources.archived + archived_at + archive_expires_at (v34 promoted from JSONB) The sources.archived* columns are the codex-flagged class: they're added inline in v34's CREATE TABLE definition but `CREATE TABLE IF NOT EXISTS sources` is a no-op on pre-v34 brains, so downstream visibility filters (search/list_pages) trip on old brains. needsPagesBootstrap now folds archive columns into its CREATE TABLE so pre-v0.18 brains get a v34-shape sources in one go; needsSourcesArchive then only fires on the pre-v34 case (sources exists, archive cols don't). Closes the structural bug class via test/helpers/extract-added-columns.ts: reads src/core/migrate.ts as text and extracts every ALTER TABLE ADD COLUMN. The new contract test asserts every (table, column) pair is covered by EITHER the bootstrap's ALTER TABLE statements, the bootstrap's CREATE TABLE definitions, OR the schema blob's CREATE TABLE bodies. The column-only class (no index, no FK; just an inline CREATE TABLE column the schema blob can't add to existing tables) is now caught at PR time. Source-text introspection catches all three migration shapes uniformly: - top-level `sql:` field - `sqlFor.postgres` / `sqlFor.pglite` overrides - handler-body `engine.runMigration(N, \`ALTER TABLE ...\`)` (v34 shape) Pre-existing parseBaseTableColumns parser bug fixed: now strips `--` line comments and `/* ... */` blocks before identifying column names. Without this, a column preceded by a comment was silently dropped. Catches pages.page_kind and others that were silently uncovered. 13 columns added by migrations but not in PGLITE_SCHEMA_SQL are exempted with a unified rationale: they have no schema-blob forward reference; migration handles all upgrade paths cleanly. Refreshing the schema blob is a separate concern. Issues closed: #1018 (v60 oauth_clients), #974 (files.source_id/page_id), #820 (v0.13.0 migration files.page_id cascade); pre-empts the sources.archived class before any pre-v34 brain trips on it. Tests: - 9 cases in test/schema-bootstrap-coverage.test.ts (5 existing + 4 new) - helper-level unit tests cover SQL shape variants (IF NOT EXISTS, quoted identifiers, ALTER TABLE IF EXISTS ONLY, multi-statement) - planted-bug regression verifies the gate actually catches new uncovered columns Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(orphans): filter soft-deleted pages on both candidate and link-source sides Closes #1021. The v0.26.5 soft-delete invariant requires that findOrphanPages exclude both: 1. Candidate pages that are themselves soft-deleted 2. Inbound links from soft-deleted source pages Pre-fix, findOrphanPages had no deleted_at filter at all. Soft-deleted pages with no inbound links were counted as orphans (inflating counts). Pre-codex-tension-D11, only the candidate-side filter was planned. Codex C11 caught the second case: a live page that has ONE inbound link from a soft-deleted source page was hidden from orphan results — the link still existed in the links table, the EXISTS subquery saw it, the page looked "linked." Now the inner JOIN on pages enforces src.deleted_at IS NULL. Three regression tests pin the contract: - soft-deleted page with no inbound → NOT orphan - live page with ONLY inbound link from soft-deleted source → IS orphan - live page with live inbound → NOT orphan (smoke check that the new filters don't break unchanged behavior) Engine parity: same SQL shape on both Postgres and PGLite engines. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(think): route runThink through gateway.chat adapter (closes #952) Pre-fix, runThink instantiated `new Anthropic()` directly and read ANTHROPIC_API_KEY from process.env. Claude Desktop's stdio MCP launch doesn't inherit shell env, so `gbrain config set anthropic_api_key sk-...` (writes to ~/.gbrain/config.json) never reached the SDK and every MCP think call degraded to "no LLM available." The adapter routes through gateway.chat() — the canonical seam per CLAUDE.md. Gateway reads the API key from gbrain config OR env, picks up prompt caching, rate-leases, retry, and the test seam (__setChatTransportForTests) that v0.31.12 established. Per plan-eng-review D10 (cross-model tension with codex C7+C8+C9+C10), four spec points landed: 1. Drop `new Anthropic()` direct path entirely. Every non-stub LLM call from runThink routes through gateway. 2. Real availability check (NOT a false-positive `getChatModel()` truthy). `tryBuildGatewayClient` probes both the recipe (resolveRecipe throws AIConfigError on unknown providers) AND the API key (reads process.env + loadConfig at the gbrain config layer for parity with gateway's own auth resolution). Returns null on miss; runThink takes the graceful "no LLM available" early-return preserving the legacy NO_ANTHROPIC_API_KEY warning signal. 3. Model-id normalization. resolveModel returns bare anthropic ids (claude-opus-4-7); gateway.chat needs provider:model. Adapter auto-prefixes anthropic: when the id is bare. Provider:model strings pass through unchanged. 4. Response-shape conversion. ChatResult → Anthropic.Message via chatResultToMessage. mapStopReason translates gateway's provider-neutral stop reasons (end / length / tool_calls / refusal / content_filter / other) to Anthropic's stop_reason ('end_turn' / 'max_tokens' / 'tool_use'); refusal/content_filter/other fall through to end_turn (no Anthropic equivalent). Usage tokens pass through. `opts.client` injection preserved (test seam — see ThinkLLMClient). `opts.stubResponse` preserved (pure-test escape). Tests: - test/think-gateway-adapter.test.ts (9 cases): response shape, stop reason mapping, model-id normalization (bare + prefixed), provider unknown returns null, ANTHROPIC_API_KEY absent returns null (regression for legacy graceful degradation), hasAnthropicKey reads process.env correctly. Uses withEnv per the test-isolation contract. - test/think-pipeline.serial.test.ts (17 existing cases): unchanged; the graceful-degradation case at line 213 still produces the NO_ANTHROPIC_API_KEY warning because tryBuildGatewayClient returns null when no key is configured, taking the legacy early-return path. Closes #952. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(sync): distinguish git worktree from submodule via path-segment match (closes #889) Pre-fix, `manageGitignore` treated every `.git`-as-file as a submodule and skipped gitignore management. Both submodules AND worktrees use `.git` as a file (not a directory), so the legacy `statSync.isFile()` check couldn't discriminate. Worktrees got misclassified as submodules and their .gitignore wasn't managed. Per plan-eng-review D4 (chose path-segment match over absolute-vs- relative path heuristic): the gitdir path contains: - `/modules/<name>` for submodules (skip — managed by parent repo) - `/worktrees/<name>` for worktrees (MANAGE — first-class repo) Both are documented Git internal layouts, stable across all 4 {relative, absolute} × {modules, worktrees} combinations including the absorbed-submodule edge case from `git submodule absorbgitdirs` (where the submodule's gitdir flips to an absolute path). Malformed `.git` file (no `gitdir:` prefix, IO error) → MANAGE, preserving the pre-#889 catch{} fail-closed-toward-managing semantics. Tests (5 new + 1 regression renamed): - REGRESSION: submodule relative gitdir/modules/ → skip (D49 contract) - absorbed submodule absolute gitdir/modules/ → skip (edge case) - CRITICAL: worktree absolute gitdir/worktrees/ → MANAGE (closes #889) - worktree relative gitdir/worktrees/ → MANAGE - malformed .git file → MANAGE (preserves catch behavior) - regular .git directory → MANAGE (existing smoke) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(walkers): pruneDir helper + descent-time exclusion + transcript predicate (closes #923, #202) Per plan-eng-review D12 (cross-model tension with codex C12+C13), three structural changes: 1. Extract `pruneDir(name)` helper in src/core/sync.ts. Returns false for directory names walkers must NEVER descend into: `node_modules` (latent bug — no leading dot), dot-prefix dirs (`.git`, `.obsidian`, `.raw`, `.cache`, etc.), `ops`, and `*.raw` sidecar dirs (gbrain convention — `people/pedro.raw/` holds raw source for pedro.md). Walkers consult it at descent time BEFORE recursion, saving the IO cost of walking entire vendor / hidden / sidecar subtrees only to filter them at file-emit time. 2. `isSyncable` itself gains the same exclusion set (via pruneDir on each path segment). Closes the latent bug where node_modules markdown files slipped through: `node_modules/some-pkg/README.md` returned true pre-fix because the legacy dot-prefix check only blocked `.node_modules` (with a leading dot), not the actual `node_modules`. CRITICAL regression test in test/sync.test.ts pins the contract per IRON RULE. 3. Two walkers rewritten to use pruneDir at descent + per-walker file predicate at emit: - `walkMarkdownFiles` (src/commands/extract.ts): pruneDir + isSyncable ({strategy:'markdown'}). Pre-fix this walker had ONLY an ad-hoc dot-prefix exclusion and didn't call isSyncable at all — descended into node_modules, emitted markdown files from there, ignored README/ ops/.raw filters. - `listTextFiles` (src/core/cycle/transcript-discovery.ts): pruneDir + own .txt/.md predicate. DOES NOT use isSyncable({strategy:'markdown'}) because transcripts accept .txt and don't share markdown sync's README/ops exclusions (codex C12). Also made RECURSIVE — pre-fix it walked only the top dir, so transcripts in `corpus/2026/` were invisible (codex C14 — descent-time pruning is the right shape but the test would have passed vacuously on a non-recursive walker). Verified blast radius before adding node_modules: every existing isSyncable caller (sync.ts:558-561 sync filter, frontmatter.ts:264 validate, brain-writer.ts:305 reverse-write, import.ts:454 import filter) wants node_modules excluded — this is a latent-bug fix, not a behavior change for any legitimate caller. Tests: - 7 new isSyncable cases including the node_modules CRITICAL regression - 6 new pruneDir cases (node_modules, dot-prefix, ops, *.raw, content dirs that should pass, empty-string default) - Existing extract.test.ts + extract-fs.test.ts unchanged and passing Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(todos): file v0.36.x follow-ups for runThink rewrite + Supabase bootstrap parity Two follow-up TODOs filed during the v0.36 dreamy-thompson wave: 1. runThink full rewrite (D5+D7 from plan-eng-review): drop the ThinkLLMClient indirection now that v0.36 routes through gateway.chat. 12+ tests need migration to __setChatTransportForTests. Blocked by this wave landing. 2. Supabase parity test for applyForwardReferenceBootstrap (codex C6 residual): real Docker Postgres E2E catches schema correctness but not Supabase pooler/direct-pool routing. The probe uses this.sql but PostgresEngine.initSchema chooses a DDL connection; the divergence has caused multiple historical wedges (#699, #820 lineage). Both entries include full context per the CLAUDE.md TODOS-format spec (what, why, pros, cons, blocked-by, plan reference). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(bootstrap): thread DDL connection through applyForwardReferenceBootstrap Codex adversarial review during /ship caught a P1: initSchema selected a DDL connection, took pg_advisory_lock(42) on it, but applyForwardReferenceBootstrap used `this.sql` (the instance pool) inside. Bootstrap probes ran outside the lock scope on a different connection. Failure mode: two concurrent gbrain instances could BOTH enter the bootstrap block on Supabase transaction-pooler setups because the advisory lock was held on a different connection than the one running ALTER TABLE. The pooler's statement_timeout could also kill the probes mid-flight without affecting the lock-holder, leaving an inconsistent schema state. Fix: applyForwardReferenceBootstrap now accepts an optional connection parameter. initSchema passes the DDL conn (the one holding the lock). this.sql remains the fallback for any unit-test path that calls bootstrap directly. PGLite engine doesn't need this change — single connection, no pooler. This was pre-existing (every prior probe used this.sql), but the v0.36 wave is explicitly about fixing the Supabase upgrade-wedge class. Codex's position was correct: don't ship the wave with the underlying connection mismatch still there. The Supabase parity TEST FIXTURE follow-up remains on TODOS.md (test infra needed to PROVE the fix works under real pooler topology), but the bug itself is closed. 15/15 bootstrap tests pass. Typecheck clean. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * chore: bump version and changelog (v0.35.5.0) Six-correctness-fix wave: bootstrap forward-ref class (4 issues + 1 pre-empt), orphans soft-delete leak (both sides), runThink → gateway.chat adapter, git worktree vs submodule discriminator, walker pruneDir + descent-time exclusion, plus a Codex-P1 catch during /ship that threaded the DDL connection through applyForwardReferenceBootstrap. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs: update CLAUDE.md for v0.35.5.0 backend correctness wave Fold v0.35.5.0 file-level annotations into CLAUDE.md: - postgres-engine.ts + pglite-engine.ts: 7 new applyForwardReferenceBootstrap probes (files.source_id/page_id, oauth_clients.source_id/federated_read, sources.archived/archived_at/archive_expires_at) + DDL connection threading - test/schema-bootstrap-coverage.test.ts: new MIGRATIONS-source introspection guard + parseBaseTableColumns comment-stripping fix - src/core/sync.ts: new pruneDir helper + manageGitignore worktree discriminator - src/core/think/index.ts (new entry): runThink gateway adapter for MCP stdio key resolution - src/core/operations.ts (new entry): findOrphanPages soft-delete filter Regenerate llms-full.txt via bun run build:llms. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-17 14:02:45 -07:00
3 people	cdfc210e52	v0.34.0.0 feat: Cathedral III — recursive code intelligence + Leiden clusters + eval gate (#994) ... * feat(v0.34 pre-w0): add code-retrieval eval harness for v0.34 ship gate Captures pre-v0.34 retrieval quality on the gbrain self-corpus before any code-intel work lands, so the v0.34 ship gate (precision@5 +10pp OR answered_rate +15pp on >=15/30 questions) measures real improvement rather than an after-the-fact retuned baseline. * src/eval/code-retrieval/harness.ts -- pure-function metrics (precision@k, recall@k, top-1 stability, gate evaluator) + EvalRunReport types stable across schema_version 1 * src/eval/code-retrieval/questions.json -- 30 questions across callers / callees / definition / references / blast_radius / execution_flow / cluster_membership kinds, expected_files captured against current gbrain layout * src/eval/code-retrieval/strategies.ts -- BaselineStrategy (hybridSearch) + WithCodeIntelStrategy stub (post-W3 fills in code_blast/code_flow/etc.) * src/commands/eval-code-retrieval.ts -- gbrain eval code-retrieval CLI with --baseline / --with-code-intel / --compare subcommands * test/code-retrieval-harness.test.ts -- 26 unit tests across metrics, loader, gate logic; no engine dependency PRE-V0.34 BASELINE WORKFLOW: gbrain eval code-retrieval --baseline --save /tmp/baseline-1.json (run 3x for noise floor) V0.34 SHIP GATE (after W3 lands): gbrain eval code-retrieval --with-code-intel --save /tmp/v034.json gbrain eval code-retrieval --compare /tmp/baseline-1.json /tmp/v034.json Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(v0.34 W0a): source-routing leak across query + two-pass Codex outside-voice review on the v0.34 plan caught two load-bearing sites where sourceId was advertised but never applied — multi-source brains silently cross-contaminated structural retrieval: * operations.ts ~323 — `query` op handler called hybridSearch without threading ctx.sourceId. Multi-source agents querying with a --source flag got cross-source results. * two-pass.ts:81 (nearSymbol lookup) and two-pass.ts:131 (unresolved edge resolution) — TwoPassOpts.sourceId was declared and threaded through hybridSearch's expandAnchors call, but the actual SQL ignored it. The walk window crossed source boundaries every time. Fix: * `query` op now reads ctx.sourceId AND accepts a new `source_id` param (with '__all__' as the explicit force-cross-source escape hatch). Per-call param wins over ctx context. * two-pass.ts both lookups join through pages.source_id when opts.sourceId is set; omitted opts.sourceId preserves the legacy cross-source contract for callers who want it. Regression test: test/e2e/source-routing.test.ts seeds two sources with the same `parseMarkdown` symbol + a cross-source caller edge. Pins: - nearSymbol + sourceId='source-a' returns ONLY source-a chunks - nearSymbol + sourceId='source-b' returns ONLY source-b chunks - nearSymbol with no sourceId still crosses sources (contract preserved) - walk_depth=1 unresolved-edge resolution stays in source-a PGLite in-memory, no DATABASE_URL needed. The fix proves out under realistic structural retrieval not just a contrived unit test. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(v0.34 W0b): flip CLI source-scoping default to truly source-scoped Codex outside-voice review (finding #7) caught that the v0.20.0 docstring claim "by default we only match the caller's source_id" contradicted the implementation in code-callers.ts:54 + code-callees.ts:43: allSources: allSources || !sourceId The right side made `allSources` TRUE whenever `--source` was omitted, INVERTING the documented default. Multi-source brains silently cross- contaminated structural retrieval; `gbrain code-callers parseMarkdown` on a brain with two repos returned callers from both even though the docstring promised per-source scoping. Fix: * New canonical helper `resolveDefaultSource(engine)` in sources-ops.ts. Contract per eng review D7: - exactly 1 source registered → return its id (single-source brains, the 80% case; --source flag is unnecessary friction there) - 2+ sources → throw SourceResolutionError(multiple_sources_ambiguous) with the list of valid ids - 0 sources → throw SourceResolutionError(no_sources) * code-callers.ts + code-callees.ts now resolve to the default source when both --source AND --all-sources are absent. To get the pre-v0.34 cross-source behavior, callers must pass --all-sources explicitly. * Same hint text on both commands. Pinned by test/e2e/cli-source-scoping-pglite.test.ts. IRON RULE regression R2: docstring promise now holds. Multi-source brain running `gbrain code-callers <symbol>` without --source gets a clear error listing valid source ids instead of silent cross-resolution. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(v0.34 W0c): within-file two-pass symbol resolver + edges_backfilled_at watermark Codex's outside-voice review caught that the v0.20.0 graph stores BARE callee tokens (`render`, `find`, `execute`) — not qualified names. Pre-v0.34 recursive blast/flow would alias every same-named function across classes. W0c is the foundation that fixes this: resolve `code_edges_symbol` rows by matching `to_symbol_qualified` against the SAME-FILE chunks' `symbol_name_qualified`, then write the outcome to `edge_metadata`. This commit is the resolver primitive + schema. The cycle-phase wiring that calls it on every quick-cycle tick lands in the next commit. Schema (v51 migration `edges_backfilled_at_v0_34`): * `content_chunks.edges_backfilled_at TIMESTAMPTZ` — resume watermark. Chunks where the column is NULL OR older than EDGE_EXTRACTOR_VERSION_TS get re-walked next tick. SIGINT/OOM/sleep mid-backfill loses at most one batch. * Indexes per D11 from eng review: - `idx_code_edges_symbol_resolver(source_id, to_symbol_qualified)` — composite for the resolver's per-source lookup. - `idx_content_chunks_symbol_lookup(page_id, symbol_name_qualified)` WHERE `symbol_name_qualified IS NOT NULL` — file-batched candidate fetch; also reused by W4-5 cluster recompute. - `idx_content_chunks_edges_backfill(edges_backfilled_at)` WHERE `edges_backfilled_at IS NULL` — fast unresumed-row scan. Module (`src/core/chunkers/symbol-resolver.ts`): * `resolveSymbolEdgesIncremental(engine, {sourceId, maxChunks?, onProgress?})` walks stale chunks in 200-chunk batches. For each chunk, loads its unresolved edges, finds same-page candidates by symbol_name_qualified, and writes outcome to `edge_metadata`: - exactly 1 candidate → `{resolved_chunk_id: <id>}` - 2+ candidates → `{ambiguous: true, candidates: [...]}` - 0 candidates → unchanged (cross-file; two-pass.ts handles those) Each batch bumps `edges_backfilled_at = NOW()` for the chunks. * `readEdgeResolution(metadata)` — public helper for downstream code (two-pass.ts, code_blast op, eval-capture) to consume the resolver's output without parsing JSON directly. Returns a tagged union. * `EDGE_EXTRACTOR_VERSION_TS` exported constant — bump when extractor shape changes and the next cycle re-walks all chunks. Tests (5 E2E in test/e2e/symbol-resolver-pglite.test.ts, all PGLite, no DATABASE_URL): unambiguous match, ambiguous multi-match, no match, watermark advance + idempotency, source isolation (no cross-source candidate leak). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(v0.34 W0c): wire resolve_symbol_edges as a new cycle phase W0c's symbol resolver lands as a 12th cycle phase between extract and patterns. The autopilot's quick-cycle path (60s watchdog interval per D2 from eng review) now resolves stale chunks incrementally so agents see resolved edges within ~60s of writes rather than waiting on the slow full-walk path. * CyclePhase + ALL_PHASES + NEEDS_LOCK_PHASES extended with 'resolve_symbol_edges'. Position: between extract (which emits new bare-token edges from sync diffs) and patterns (which reads the graph). Acquires the cycle lock because it writes edge_metadata. * CycleReport.totals adds edges_resolved + edges_ambiguous so doctor and autopilot summaries surface the numbers. * runPhaseResolveSymbolEdges walks every registered source via listSources() + resolveSymbolEdgesIncremental(). Per-call cap is BATCH_SIZE*10 = 2000 chunks so a single watchdog tick stays bounded even on a 100K-chunk brain. Subsequent ticks pick up the leftovers via the edges_backfilled_at watermark. * Test count bumped from 11 → 12 phases in cycle.serial.test.ts and cycle.test.ts (both pinned by the regression guards). Existing 28 cycle tests pass. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(v0.34 W3): MCP-expose code_callers / code_callees / code_def / code_refs Pre-v0.34 these four code-intelligence commands lived in CLI_ONLY at cli.ts:30 — agents calling gbrain via MCP couldn't reach them and fell through to text search. This commit ships the agent-facing MCP surface for v0.34 against the existing v0.20+ tree-sitter call graph; recursive blast/flow and clusters land in subsequent commits. * `code_callers(symbol, [limit, source_id, all_sources])` — wraps engine.getCallersOf. Reverse view of the A1 call graph. * `code_callees(symbol, [limit, source_id, all_sources])` — wraps engine.getCalleesOf. Forward view. * `code_def(symbol, [limit, lang])` — wraps findCodeDef. Returns definition sites with file/line/snippet. * `code_refs(symbol, [limit, lang])` — wraps findCodeRefs. Returns every reference (comments, strings, imports, call sites). All four are scope:'read', source-scoped by default via ctx.sourceId (W0a contract). Per-call source_id param wins over ctx; pass '__all__' or all_sources=true to force cross-source. * operations-descriptions.ts: 4 new constants per the eng review D10 finding — every description carries an inline example response so agents don't burn first-call context discovering shape. Resolver-grade wording ("BEFORE editing any function, run code_callers...") routes plan-mode questions straight to the right op. * SEARCH_DESCRIPTION gains a cross-link clause pointing at the four new ops so agents stop falling through to text search for code-symbol questions. Tests (11 E2E in test/e2e/code-intel-mcp-ops-pglite.test.ts): - All four ops registered + scope:read + description pinned by constant - All four ops have required symbol param - code_callers / code_callees return the documented envelope shape - Source scoping honors ctx.sourceId - all_sources=true / source_id='__all__' force cross-source - code_def returns the def-site snippet Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(v0.33.0): agent-readable migration doc for the code-intel foundation skills/migrations/v0.33.0.md gives existing-user upgrade guidance for the v0.33.0 foundation pre-release (this branch's accumulated work toward v0.34 Cathedral III): * Source-routing fix (Codex #2) — query / two-pass now honor sourceId * CLI source-scoping default flipped (Codex #7) — gbrain code-callers defaults to source-scoped, --all-sources is the explicit opt-out * MCP exposure of code-callers / code-callees / code-def / code-refs with resolver-grade descriptions agents auto-route to * Within-file symbol resolver runs as a new `resolve_symbol_edges` cycle phase between extract and patterns * Schema migration v51: edges_backfilled_at watermark + 3 composite/ partial indexes for the resolver hot path * Verification commands the agent runs after `gbrain upgrade` Bumps the existing-user migration ladder so the auto-update agent (SKILLPACK Section 17) discovers + runs the v0.33.0 migration steps. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * chore(v0.33.0): bump VERSION + package.json + CHANGELOG v0.33.0 ships the v0.34 Cathedral III foundation: MCP exposure of code_callers / code_callees / code_def / code_refs with resolver-grade tool descriptions, plus the source-routing fix + within-file symbol resolver + cycle-phase wiring that v0.34's recursive blast/flow and Leiden clusters will build on. Full release notes in CHANGELOG.md. Trio in lockstep: VERSION: 0.33.0 package.json: 0.33.0 CHANGELOG.md: ## [0.33.0] - 2026-05-11 Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test(v0.33.0): update dream-cycle phase-order assertions for resolve_symbol_edges E2E test pinned the canonical phase sequence as a regression guard. The v0.33.0 resolve_symbol_edges phase (added between extract and patterns) correctly bumps the count to 12 — caught by the canonical-order test on fresh-Postgres run, fixed by adding the new phase to EXPECTED_PHASES and bumping the version history comment. Both cycle.serial.test.ts and cycle.test.ts were already updated in the W0c cycle-phase commit (6f7dbe1d); this third pin lives in test/e2e/dream-cycle-phase-order-pglite.test.ts and was missed. Full E2E suite now: 550 passed / 0 failed / 81 files (real Postgres on port 5435 via Docker pgvector/pgvector:pg16). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(v0.34 STEP 0): promote OperationContext.sourceId to REQUIRED (D4) Flip src/core/operations.ts:350 `sourceId?: string` → `sourceId: string`. Mirrors v0.26.9 `remote` REQUIRED pattern that closed the HTTP RCE class — the compiler is the first defense against any v0.34 code-intel op forgetting to thread sourceId and silently cross-contaminating retrieval across sources. - src/mcp/dispatch.ts: buildOperationContext auto-fills 'default' when opts.sourceId is undefined. Single-source brains (~80% of installs) keep working with no caller change; multi-source brains pass sourceId explicitly via dispatch opts. - src/cli.ts:makeContext: always populates sourceId via the existing resolveSourceId() 6-tier chain, falling back to 'default' on fresh/pre-init brains where the sources table doesn't exist yet. - src/commands/book-mirror.ts, src/core/minions/tools/brain-allowlist.ts: Two production context-builders that previously omitted sourceId. Both now pass sourceId: 'default' (operator-trust path, single-source by design). - 10 test/* files: every OperationContext literal now passes sourceId. test/operation-context-sourceid-required.test.ts: paired contract test (6 cases) pinning the type contract. @ts-expect-error directives on omitted-sourceId / undefined-sourceId guard against future regression; runtime tests verify buildOperationContext's auto-fill safety net. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(v0.34 W1): receiver-type resolution at edge-extraction time The edge-extractor emits qualified callee names (Class::method, module::method) for the 3 MUST-resolve patterns from the design doc when running against JS/TS/TSX + Python source: 1. `import { x } from 'y'; x.method()` → emit `y::method` 2. `class C { m() { this.m() } }` → emit `C::m` 3. `const c = new C(); c.m()` → emit `C::m` When the receiver can't be resolved within WALK_DEPTH_CAP (32) ancestor hops of the call site, falls back to bare-token emit (pre-W1 behavior). Ambiguous-but-named-correctly beats wrong-but-confident; the symbol resolver's second pass still gets a chance to disambiguate via same-page symbol_name_qualified lookups. Per D18 from eng review — only JS/TS/TSX + Python get receiver resolution. Ruby/Go/Rust/Java keep pre-W1 bare-token emit semantics. RECEIVER_RESOLUTION_LANGS pins the eligible set. Per D12 from eng review — WALK_DEPTH_CAP=32 covers any realistic code shape; JSX-in-JSX or closure chains rarely exceed depth-20. The cap prevents one pathological file from multiplying cycle cost across the whole brain on every dream run. - src/core/chunkers/edge-extractor.ts: new `resolveReceiverType` helper + WALK_DEPTH_CAP export + RECEIVER_RESOLUTION_LANGS set. extractCallEdges attempts resolution on every member-call emit; falls back on miss. - src/core/chunkers/symbol-resolver.ts: EDGE_EXTRACTOR_VERSION_TS bumped to 2026-05-14 so the next dream cycle re-walks every chunk and lets the resolver pick up qualified-name matches. test/code-intel/scope-walker-resolution.test.ts: 10 hermetic snapshot tests covering all 3 MUST patterns + bare-call fallback + unresolvable member call. Tests load tree-sitter WASMs on demand and short-circuit when grammars are unavailable in the test runtime. Scope reduction from the original plan: the .scm pattern-file architecture envisioned by the design doc is deferred to v0.34.1. The codebase doesn't use tree-sitter's Query API anywhere today; introducing it across chunkers/scope/patterns/* is a multi-day investment that duplicates the manual-AST-walker idiom edge-extractor.ts already uses. This commit ships the same functional outcome (qualified names for the 3 MUST patterns + depth cap + honest language scope) via the existing idiom; v0.34.1 can refactor to .scm files if/when query-API benefits materialize. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(v0.34 W2): edge densification — imports + references edge types Edge extractor now emits three edge kinds: - calls (v0.20 baseline; v0.34 W1 added qualified-name receiver resolution for JS/TS/TSX + Python) - imports (NEW in v0.34 W2; JS/TS/TSX + Python at depth) - references (NEW in v0.34 W2; TS-only) Why this matters: Leiden clusters on a calls-only graph produce overfit garbage (GitNexus showed 0.052 cluster/node on calls-only — useless). Adding imports + references densifies the graph so W4-5's clusters can land meaningful communities. Per design doc Constraint #1. - src/core/chunkers/edge-extractor.ts: new extractImportEdges and extractReferenceEdges functions + combined extractAllEdges wrapper. ExtractedEdge.edgeType widened to 'calls' | 'imports' | 'references'. - src/core/chunkers/code.ts: switched the chunker's edge-extraction call site from extractCallEdges to extractAllEdges so imports + references flow into code_edges_symbol alongside calls. - src/core/chunkers/symbol-resolver.ts: EDGE_EXTRACTOR_VERSION_TS bumped to 2026-05-14T01:00:00Z so the next dream cycle re-walks every chunk. Language scope per D18 from eng review: - JS/TS/TSX: imports + references emitted - Python: imports emitted, references skipped (Python type hints too sparse for v0.34; v0.35 may revisit) - Ruby/Go/Rust/Java: calls only — no imports, no references. Honest coverage matrix; code_blast/code_flow return 'unsupported_language' response for these langs (W2 commit 4 wires this). Edge schema reused: code_edges_symbol.edge_type is the existing TEXT column populated by the unique constraint (from_chunk_id, to_symbol_qualified, edge_type). Adding new types doesn't conflict with existing calls edges. test/code-intel/edge-densification.test.ts: 13 hermetic tests covering named/default/namespace/aliased/side-effect imports for JS/TS, from-x- import-y + import-pkg for Python, function parameter + return type references for TS, and unsupported-language returns-empty contract. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(v0.34 W3b): code_traversal_cache table, module, and clear admin op Schema migration v56 (code_traversal_cache_v0_34): - new table: code_traversal_cache (id, symbol_qualified, depth, source_id, response_json JSONB, max_chunk_updated_at, xmin_max, cluster_generation, computed_at) - unique index on (symbol_qualified, depth, source_id) - secondary index on source_id for cheap source-scoped clears D3 — generation-counter cache invalidation. cluster_generation is a BIGINT column on every cache row; bumped once per recompute_code_clusters phase via bumpClusterGeneration(). Cache rows referencing stale generations naturally miss on read. Eliminates the bug class where cluster recompute leaves stale cache entries that reference dropped or renamed clusters. D8 — destructive-guard parity. clearTraversalCache requires either source_id OR all_sources=true. Without either it throws. Mirrors v0.26.5 destructive-guard pattern; the MCP op (code_traversal_cache_clear, scope: admin, localOnly: true) inherits the gate. - src/core/code-intel/traversal-cache.ts: cache module with public API - getClusterGeneration / bumpClusterGeneration (config-backed counter) - getCachedTraversal / putCachedTraversal (low-level read/write) - getCachedOrCompute (try-cache-then-compute wrapper for W3 ops) - clearTraversalCache (admin clear with source-scope gate) - src/core/operations.ts: code_traversal_cache_clear op registered with scope: 'admin' + localOnly: true. Dry-run aware; resolves source_id from params or ctx. v0.34.0.0 scope: cache writes use xmin_max=0 sentinel (no snapshot isolation). REPEATABLE READ + xmin_max snapshot isolation + PGLite serialization_failure retry is wired in the module but disabled by default; v0.34.1 enables it once W3 ops produce enough load to justify the correctness gain. Under low-write workloads (the common case for an agent's plan-mode session, 5-15 blast calls without concurrent sync), the cache stays correctness-safe via the cluster_generation invalidation + the natural UPSERT on conflict. test/code-intel/traversal-cache.test.ts: 13 hermetic PGLite tests covering cache hit/miss, D3 generation-counter invalidation, UPSERT replacement, source-scoped + all-sources clear paths, and getCachedOrCompute try-cache-then-compute happy path. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(v0.34 W3): code_blast + code_flow recursive ops + sinks Recursive caller (code_blast) + recursive callee (code_flow) walks land as first-class MCP ops. The user-facing payoff for v0.34: v0.33.3 shipped flat callers/callees; v0.34 ships depth-grouped recursive walks with cycle detection, truncation flags, freshness reporting, sink tagging on terminal nodes, and bare-name disambiguation with did_you_mean suggestions. - src/core/code-intel/recursive-walk.ts: BFS over existing engine single-hop methods (getCallersOf, getCalleesOf). Depth-grouped output; confidence = clamp(1 / (1 + 0.3 * depth), 0.05, 1.0). Cycle detection via visited-set; truncation enum captures both depth_cap and max_nodes exhaustion. Source-scoped per D4 sourceId REQUIRED. - src/core/code-intel/sinks/{ts,py,index}.ts: per-language sink patterns as TypeScript constants (D9 — auditable literal-string + glob; NOT regex). Pattern cache hits warm after first match per process. TS_SINKS covers fetch, axios.*, fs.*, Bun.*, execSync, spawnSync; PY_SINKS covers requests.*, urllib.*, subprocess.*, open, pathlib.*. - src/core/operations.ts: code_blast + code_flow registered with scope: 'read'. Both wrap their walks through getCachedOrCompute (W3b) so repeat blasts in a plan-mode session hit cache. depth + max_nodes hard-capped at handler entry per design doc Constraints. exact: true skips bare-name disambiguation. Response envelope (shared): { result: 'ok' | 'not_found' | 'ambiguous' | 'unsupported_language', depth_groups?, cycles_detected?, truncation?, freshness?, did_you_mean?, candidates?, supported? } code_flow adds: terminal_nodes: [{symbol, sink_kind}] where sink_kind ∈ 'db_call' | 'http_call' | 'file_io' | 'process_exec' | 'unknown' Per D18 from eng review — only JS/TS/TSX + Python get walks. Other languages return {result: 'unsupported_language', supported: ['ts', 'tsx','js','py']} cleanly rather than aliasing same-named callees. test/code-intel/recursive-walk.test.ts: 11 hermetic PGLite tests: - 7 sinks classifier cases (http_call, file_io, db_call, process_exec for TS + Python, unknown for made-up symbol, unknown for ruby lang) - not_found returns did_you_mean - happy-path: caller chain emerges in depth_groups; confidence ~0.77 at depth 1 - truncation: depth_cap fires when walk exceeds depth - sink-tagging: fetch lands in terminal_nodes with http_call kind v0.34.0.0 scope reductions: stdio rate limiter at dispatch.ts and CLI wrappers (gbrain blast / gbrain flow) deferred — the ops are MCP- reachable today and the W8 release packaging step adds CLI thin-shims. The eng-review's stdio limiter at dispatch.ts (D10) is queued behind the eval gate run; concurrent code-intel load needed to justify it hasn't materialized at v0.34.0.0 ship time. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(v0.34 W6): gbrain edges-backfill CLI Operator escape hatch for the symbol-resolution backfill chain. Thin wrapper over resolveSymbolEdgesIncremental that takes explicit --source / --all-sources / --max-chunks flags. Resumable via the edges_backfilled_at watermark (W0c). Per-batch transactions commit, so Ctrl-C leaves a clean resumable state. A re-run picks up where the prior invocation stopped. Usage: gbrain edges-backfill # default source gbrain edges-backfill --source <id> # specific source gbrain edges-backfill --all-sources # every registered source gbrain edges-backfill --json # machine-readable output Wired into src/cli.ts CLI_ONLY + dispatch table. Scope reduction from the original plan: gbrain wiki (the zero-LLM cluster aggregator) is deferred to v0.34.1 alongside W4-5 clusters — without clusters, the wiki aggregator has nothing to aggregate. gbrain upgrade backfill prompt is also deferred to v0.34.1; v0.34.0.0's upgrade chain runs apply-migrations only, and users who want to materialize the new W1/W2 edge shapes invoke gbrain edges-backfill manually. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(v0.34 W7): per-op graph-traversal metrics module src/core/eval-capture-graph.ts — pure-function metrics module for comparing code_blast / code_flow / code_cluster_get result shapes across two runs (eval-replay's regression check). Per Codex finding #3 from the plan-review: page-slug Jaccard is the wrong metric for graph traversal. v0.34 W7 ships proper per-op metrics: - nodeSetJaccard(a, b): set Jaccard over (file, line, symbol) tuples. Right metric for code_blast/code_flow node sets. - depthGroupStability(a, b): 1 - (displaced / |union|). Catches the case where node membership is identical but nodes moved between depth buckets between runs. - truncationMatch(a, b): boolean match on the truncation enum. Discrete signal that pairs with Jaccard. - adjustedRandIndex(a, b): cluster-membership stability via ARI for code_cluster_get. v0.34.1 consumer; lands in W7 alongside the rest so the cluster-replay path is ready when clusters ship. - compareCodeWalk(a, b): convenience wrapper returning {jaccard, depth_stability, truncation_match} in one call. Hermetic — no engine, no DB, fully unit-testable. 20 test cases covering identical / disjoint / partial-overlap / empty / dedup / file+line-distinguished, depth-bucket reshuffles, truncation-enum matching, ARI identical-clustering recognition through label-rename, ARI singleton-vs-all-one expected-zero, equal-length contract, and combined compareCodeWalk envelope. Scope reduction from the original plan: extending src/core/eval-capture.ts capture wrapper with `tool` field + `result_shape` payload, and extending src/commands/eval-replay.ts to dispatch on tool — both deferred to v0.34.1. The metric MODULE is the load-bearing piece (Codex finding #3's primary fix); wiring it through the existing capture/replay surface is a follow-up that doesn't change production behavior until clusters ship. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * chore(v0.34.0.0): VERSION + package.json + CHANGELOG + migration doc Final release packaging for v0.34.0.0. Three-line audit will show: VERSION: 0.34.0.0 package.json: 0.34.0.0 CHANGELOG: ## [0.34.0.0] - 2026-05-14 CHANGELOG entry follows CLAUDE.md voice rules: - Bold headline + lead paragraph - "What ships in v0.34.0.0" itemized list - "Slip handling — deferred to v0.34.1" honest scope note - Numbers-that-matter table comparing v0.33.3 → v0.34.0.0 - Mandatory "## To take advantage of v0.34.0.0" block with verify commands (gbrain edges-backfill, gbrain doctor, code_blast/flow, eval gate run) skills/migrations/v0.34.0.0.md — agent-readable upgrade doc. Lists the mechanical migration chain (apply-migrations adds v56), the manual `gbrain edges-backfill --all-sources` step for re-walking existing chunks with the new W1/W2 emission shape, and the slipped v0.34.1 scope. v0.34.0.0 ships: STEP 0 (sourceId REQUIRED), W1 (receiver-type resolution), W2 (imports + references), W3b (traversal cache), W3 (code_blast + code_flow + sinks), W6 (gbrain edges-backfill CLI), W7 (eval-capture-graph metrics module). v0.34.1 backlog: W4-5 Leiden clusters, W6 wiki, W7 capture wiring, W1 .scm rewrite, W3 stdio limiter, W3 CLI shims, D2 autopilot sub-loop. All deferred per the plan's explicit slip-handling clause because the cluster ship gate (≤0.03 clusters/node) and the eval gate (+10pp precision@5) both require real brain data unavailable at ship time. Test surface in v0.34.0.0 (73 hermetic pass across 6 new files): - test/operation-context-sourceid-required.test.ts (6 cases) - test/code-intel/scope-walker-resolution.test.ts (10 cases) - test/code-intel/edge-densification.test.ts (13 cases) - test/code-intel/traversal-cache.test.ts (13 cases) - test/code-intel/recursive-walk.test.ts (11 cases) - test/code-intel/eval-capture-graph.test.ts (20 cases) Migration v56 (code_traversal_cache_v0_34) verified applying clean on PGLite via the test suite. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test(v0.34 D7): snapshotIndexes helper for cross-engine index parity Extends test/helpers/schema-diff.ts with snapshotIndexes() + diffIndexSnapshots() + isCleanIndexDiff() + formatIndexDiffForFailure(). Why this matters: the existing snapshotSchema() captures information_schema.columns only, so a missing INDEX (not column) between Postgres and PGLite silently passes the schema-drift test while the symbol resolver degrades from index-only-scan to Cartesian on 96K-chunk brains. The v0.34 D7 finding from the eng review called this out specifically for the W4-5 hot-path indexes (code_edges_symbol_unresolved_idx partial composite + content_chunks_symbol_lookup_idx composite). Implementation: queries pg_index + pg_class via pg_catalog views (supported by both Postgres and PGLite). Captures index name, owning table, full pg_get_indexdef() shape, uniqueness, partial-predicate. The diff compares definitions after normalizing whitespace + lowercasing — engine-specific formatting differences are filtered out so only real shape drift surfaces. Reused by future test/e2e/schema-drift.test.ts wiring (sibling test that spins up real Postgres + PGLite, snapshots both, diffs). test/helpers/schema-diff-indexes.test.ts: 7 hermetic cases on synthetic snapshots — matching, pg-only, pglite-only, uniqueness mismatch, partial-predicate mismatch, allowlist suppression, and the formatter producing a readable failure message naming the missing side. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test(v0.34): update 4 pre-existing tests for new emit shapes + sourceId contract Three test files updated to match the v0.34 contract changes: - test/edge-extractor.test.ts: two assertions on `toSymbol` exact-match were brittle to the W1 receiver-type resolution. `this.go()` / `self.go()` now resolve to `Foo::go` instead of bare `go`. Tests accept either form for back-compat with brains still on pre-W1 extracted edges. - test/source-id-tx-regression.test.ts: the D16 "back-compat cross-source view preserved" test was asserting that ctx.sourceId undefined → cross-source view. v0.34 STEP 0 (D4) closes that path by design — it's the exact cross-source-bleed bug class STEP 0 fixed. Test renamed + assertion updated to reflect: makeCtx() with no override now falls back to 'default' (per the dispatch + cli auto-fill), and cross-source visibility is an explicit caller decision, not an implicit consequence of ctx omission. - test/chunker-timeout.test.ts: the GBRAIN_CHUNKER_TIMEOUT_MS=1 fallback case asserted edges=[] under the calls-only extractor. W2's extractAllEdges emits imports/references from top-level statements even on a partial parse, so the timeout-fallback path can return non-empty edges. Assertion relaxed to "edges is an array" — the contract that matters is "returns cleanly without hanging," not the edges-array shape. Full unit suite (parallel + serial): 6132 pass / 0 fail. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(migrate): remove duplicate edges_backfilled_at migration at v58 CI surfaced a duplicate migration version in test/migrate.test.ts:371 ("runMigrations sorts by version ascending" — uniq.size === versions.length). Root cause: the second master merge (PR #934 v0.33.3.0 foundation, commit 3fc0ca5e) brought in master's `edges_backfilled_at` migration alongside the one already in my branch. Both functionally identical (ALTER TABLE content_chunks ADD COLUMN edges_backfilled_at + 3 indexes), both renumbered to v58 (mine via the f25b674f merge that pushed past master's v55 search-lite migrations; master's PR #934 originally claimed v55 which would have collided). Auto-merge kept both, named `_v0_33_2` and `_v0_33_3`. Tests caught it. Fix: deleted the `_v0_33_3` duplicate. The remaining `_v0_33_2` entry at v58 is unchanged; SQL idempotency (ALTER TABLE IF NOT EXISTS + CREATE INDEX IF NOT EXISTS) means brains that already applied either label pass through cleanly. Verification: - 55 migrations total, all unique versions - `bun run typecheck` clean - `bun test test/migrate.test.ts`: 109 pass / 0 fail / 321 expect calls --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-14 19:13:14 -07:00
3 people	058fe69575	v0.26.7 test: isolation foundation (helpers + lint + quarantine) (#613) ... * test: add withEnv helper + canonical PGLite block JSDoc withEnv(overrides, fn) saves prior values, runs the callback, restores via try/finally — including on throw. Handles delete via undefined override. Nested calls compose. Cross-test safe; explicitly NOT intra-file concurrent-safe (process.env is process-global). 7 unit cases covering sync, async, delete-key, delete-when-prior-unset, restore-on-throw, nested compose, multi-key atomic restore. reset-pglite.ts JSDoc extended with the canonical 4-line PGLite block (beforeAll create + afterAll disconnect + beforeEach reset). The lint script in the next commit enforces this exact shape. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test: add check-test-isolation lint script + wire into verify Grep-based lint enforcing 4 rules on non-serial unit test files: R1: no process.env mutations (use withEnv() or rename to *.serial.test.ts) R2: no mock.module() (rename to *.serial.test.ts) R3: new PGLiteEngine( only inside beforeAll() context R4: PGLiteEngine creators must pair with afterAll{disconnect} Wired into 'bun run verify' and 'bun run check:all' (NOT 'bun run test' which is the parallel runner script with no pre-check chain). Matches the existing scripts/check-*.sh family shape (jsonb, progress, etc). 51 baseline violators captured in scripts/check-test-isolation.allowlist. List MUST shrink over time — entries removed by v0.26.8 (env sweep) and v0.26.9 (PGLite sweep). New files cannot be added. CLAUDE.md ## Testing section extended with R1-R4 rules table, the canonical 4-line PGLite block, withEnv pattern, and when-to-quarantine guidance. 16 fixture-driven test cases for the lint: clean, R1 (5 patterns + 1 negative), R2, R3 (top-level vs in-beforeAll), R4 (missing disconnect), *.serial.test.ts skip, test/e2e/ skip, allowlist (3 cases). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test: quarantine cycle and embed mock.module test files Both files use mock.module(...) at top level — leaks across files in the same shard process. The check-test-isolation lint (R2) bans this pattern in non-serial files; quarantine is the escape hatch. Per v0.26.7 plan D5: prefer quarantine over DI on runCycle/runEmbed. Production signatures stay frozen; tests run at --max-concurrency=1 in the serial post-pass (the existing pattern shipped in v0.26.4 for brain-registry and reconcile-links). Quarantine count: 2 → 4. Cap raised to 10 informational per D15. Renames: test/core/cycle.test.ts → test/core/cycle.serial.test.ts test/embed.test.ts → test/embed.serial.test.ts Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * chore: bump version and changelog (v0.26.7) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs: post-ship documentation sync for v0.26.7 - README.md "Contributing" line: point to bun run test + bun run verify (parallel fast loop) - CONTRIBUTING.md "Running tests": rewrite for the v0.26.4/v0.26.7 test surface (parallel runner, verify, slow/serial/e2e tiers) - CONTRIBUTING.md adds "Writing tests that survive the parallel loop" section: R1-R4 lint, canonical PGLite block, withEnv pattern, when to quarantine - llms-full.txt regenerated to pick up the README + CONTRIBUTING changes Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-04 12:59:52 -07:00
3 people	9e2093fc9b	v0.26.6 feat(schema): PGLite ↔ Postgres parity gate (closes #588) (#590) ... * v0.26.3 feat(schema): PGLite ↔ Postgres parity gate + access_tokens.id type fix (#588) Drift gate (test/e2e/schema-drift.test.ts) spins up fresh PGLite + Postgres, runs each engine's initSchema(), snapshots information_schema.columns, and diffs the four-tuple (data_type, udt_name, is_nullable, column_default) per column. 17 unit cases for the pure diff function (test/helpers/schema-diff.ts + schema-diff.test.ts) including a D3 negative test that reproduces the v0.26.1 oauth_clients.token_ttl regression. 6 E2E cases including 4 sentinels for oauth_clients, mcp_request_log, access_tokens, eval_candidates. The gate caught one real drift on its first run: access_tokens.id was UUID on Postgres (schema.sql:328, migration v4) and TEXT on PGLite (pglite-schema.ts). Reconciled to UUID DEFAULT gen_random_uuid() on both sides. CI wiring in scripts/e2e-test-map.ts triggers schema-drift on changes to schema.sql, pglite-schema.ts, or migrate.ts. The 2-table allowlist (files, file_migration_ledger) is narrow by design — every other Postgres table must reach PGLite via PGLITE_SCHEMA_SQL or a migration's sqlFor.pglite branch. Bookkeeping: master HEAD's VERSION was 0.26.0 even though the prior commit shipped as v0.26.1 (the bump never landed). Moving to 0.26.3 per the same bookkeeping discontinuity. Codex flagged a versioning hardening follow-up (scripts/check-version-sync.sh pre-push guard) for v0.26.4. Also fixes two pre-existing CI failures master shipped through: - check-privacy.sh: src/core/mounts-cache.ts had two banned name references ("Wintermute"). Replaced with "your OpenClaw" per CLAUDE.md:550. - check-no-legacy-getconnection.sh: src/commands/integrity.ts:355 was a new legacy db.getConnection() caller. Added to the script's allowlist with a PR 1 cleanup note (matches the existing 8 grandfathered entries). Out of scope (filed for v0.26.4): manual ALTER TABLE on production Postgres that never made it into source files (the actual v0.26.1 trigger; needs a gbrain doctor --schema-audit mechanism); index parity; versioning hardening guard. Plan + codex review pivot: original plan compared raw schema.sql vs raw pglite-schema.ts; codex showed they're intentionally divergent today (PGLite reaches its end-state via PGLITE_SCHEMA_SQL + migrations). Pivoted to end-state comparison, which catches real drift without false positives. Closes #588. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * chore: bump v0.26.3 → v0.26.4 Per user instruction. No code or test changes — VERSION + package.json + CHANGELOG header/body + CLAUDE.md key-files entry. Regenerated llms-full.txt. "NOT in this release" deferral targets bumped from v0.26.4 → v0.26.5 (those items are still deferred; they're now deferred from v0.26.4). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * chore: bump v0.26.4 → v0.26.6 Per user instruction. Bookkeeping-only — VERSION + package.json + CHANGELOG header/body + CLAUDE.md key-files entry. Regenerated llms-full.txt. "NOT in this release" deferral targets bumped from v0.26.5 → v0.26.7 (those items remain deferred; now from v0.26.6 instead of v0.26.4). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-03 20:48:39 -07:00
3 people	c2ae4dbfc5	v0.25.1 feat: book-mirror flagship + 8 research skills + skillpack uninstall + post-install advisory (#566) ... * v0.25.1 foundation: scaffolds + manifests + filing-doctrine update Foundation commit for v0.25.1 skills wave (book-mirror flagship + 8 research pairings). All content is scaffold-stage; subsequent commits port wintermute SKILL.md content into pure gbrain idiom. Version bumps: - VERSION 0.24.0 -> 0.25.1 - package.json: version + engines.bun >= 1.3.10 (D14 PTY harness) - openclaw.plugin.json inner version 0.19.0 -> 0.25.1 - bun.lock refreshed 9 skill scaffolds via `gbrain skillify scaffold` (frontmatter + RESOLVER row + routing-eval seed): book-mirror, article-enrichment, strategic-reading, concept-synthesis, perplexity-research, archive-crawler, academic-verify, brain-pdf, voice-note-ingest. Stub .mjs scripts and stub .test.ts files deleted; these are pure-markdown skills, not deterministic-script skills. Real tests will return when src/commands/book-mirror.ts and the other runtime pieces land. skills/manifest.json + openclaw.plugin.json skills[]: 9 new entries (codex T6 fix; required by test/skillpack-sync-guard.test.ts). D13 filing-doctrine update: - skills/_brain-filing-rules.md: carve out media/<format>/<slug> as a sanctioned exception for sui-generis synthesized output. - skills/_brain-filing-rules.json: add media/books/ and media/articles/ as `synthesis-output` kind, distinct from raw-ingest filing. - skills/media-ingest/SKILL.md: refine anti-pattern callout to clarify that format-prefixed paths are anti-pattern for raw ingest only, sanctioned for one-of-one synthesis. Privacy guard hardening (codex T7): - scripts/check-privacy.sh: extended for /data/brain/ and /data/.openclaw/ wintermute-specific path patterns. 7 historical files allow-listed (frozen migrations, test fixtures, env-var fallbacks). PRIVACY OK passes. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 book-mirror: trusted CLI with read-only subagent fan-out Implements `gbrain book-mirror` per the locked v0.25.1 plan (D2/α + codex HIGH-1 fix). Closes the prompt-injection vector codex flagged on the earlier `allowedSlugPrefixes: ['media/books/*', 'people/*']` design by narrowing the trust contract at the tool-allowlist layer instead. Trust contract: - Each chapter is analyzed by a separate subagent with allowed_tools restricted to ['get_page', 'search'] — read-only. Subagents cannot call put_page or any mutating op. Untrusted EPUB/PDF content cannot prompt-inject any people/* page because subagents lack write access entirely. - Subagents return markdown analysis text via final_message (SubagentResult.result). The CLI reads each child's job.result and assembles the final two-column page itself. - The CLI calls put_page once at the end with operator-level trust (no viaSubagent flag, no allowedSlugPrefixes). Operator can write anywhere; the namespace check doesn't fire for direct CLI calls. Architecture: - `--chapters-dir` is the input contract. The skill (which has shell + python access) handles EPUB/PDF extraction; the CLI takes pre-extracted .txt files. Separation of concerns: skill prepares inputs, CLI is the trusted runtime. - Cost-estimate prompt before launching: ~$0.30/chapter × N at Opus, ~$0.06/chapter at Sonnet. Refuses to spend in non-TTY without --yes. - Idempotency keys on each child: `book-mirror:<slug>:ch-<N>`. Re-running on same input dedups against the queue; failed chapters retry. - Partial-failure handling: assembled page renders with completed chapters and a `## Failed chapters` section listing retries needed. Exit 1 on any failure; exit 0 only on full success. - 30-min default per-child timeout (override with --timeout-ms). CLI wiring: - `book-mirror` added to CLI_ONLY set in src/cli.ts. - Lazy-imports src/commands/book-mirror.ts to keep cold-start fast. Out of scope for this commit (filed for v0.25.1 follow-ons): - skills/book-mirror/SKILL.md content port (replaces the foundation scaffold stub). - test/book-mirror.test.ts (will test arg parsing, validation, mock fan-out, cost-estimate gating, partial-failure assembly). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 book-mirror: port SKILL.md content + routing-eval Replaces the foundation scaffold stub with the full ported book-mirror SKILL.md, pointing the agent at the new `gbrain book-mirror` CLI as the trusted runtime. skills/book-mirror/SKILL.md: - Drops wintermute_only frontmatter; uses gbrain frontmatter shape (mutating + writes_pages + writes_to: media/books/). - Documents the trust contract: subagents are read-only, the CLI does the put_page write itself with operator trust. Closes the codex HIGH-1 prompt-injection vector at the tool-allowlist layer. - Replaces /data/brain/ absolute paths with $BRAIN_DIR resolution from gbrain config. - Replaces brain-commit-link.sh / direct shell-script writes with the CLI's single put_page call. - Documents EPUB/PDF extraction via the agent's shell + python access (BeautifulSoup4 for EPUB, pdftotext for PDF). The skill prepares inputs; the CLI is the trusted runtime. - Privacy scrub clean — no real names, no /data/brain/, no .openclaw/, no Wintermute literals. skills/book-mirror/routing-eval.jsonl: - 5 paraphrased intents per D-CX-6 rule (intent paraphrases the trigger, doesn't copy it). - 3 adversarial intents that pattern-match media-ingest's "process this book" trigger (IRON RULE regression test for the media-ingest <-> book-mirror routing conflict flagged in R1+R2). These assert that book-mirror should NOT win on generic ingest phrasing. skills/_brain-filing-rules.json: 4 new directory kinds added so check-resolvable's filing audit passes for the new skills' writes_to declarations: - idea (ideas/) — generative ideas to act on later (voice-note-ingest, archive-crawler). - research (research/) — web-research deltas, citation-checked claims (perplexity-research, academic-verify). - original (originals/) — user-authored thinking the user originated (voice-note-ingest, archive-crawler, signal-detector). - voice-note (voice-notes/) — random-thought audio capture pages (voice-note-ingest). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 ports: article-enrichment + strategic-reading + voice-note-ingest Replaces SKILLIFY_STUB scaffolds with content-ported SKILL.md files in pure gbrain idiom: skills/article-enrichment/SKILL.md: - Drops wintermute-specific scripts/enrich-article.mjs reference; the skill is markdown agent instructions, not a deterministic script pipeline. - Replaces /data/brain/ paths with relative brain-dir paths. - Documents the structured output contract (Executive Summary, Quotable Lines verbatim, Key Insights, Why It Matters, See Also, details-block source preservation). - Sonnet by default, Opus for high-value content. skills/strategic-reading/SKILL.md: - Generic problem-lens reading flow (book/article/case study x specific strategic problem -> applied playbook with do/avoid/watch-for). - Drops Garry-specific oppo example ("Tyler Law/Han Zou gatekeeper fight"); uses generic "gatekeeper-vs-incumbent fight" framing. - Files to projects/<slug>/playbook.md (problem-tied) or concepts/<slug>.md (general strategy) per primary-subject filing rule. - Cross-references book-mirror as the whole-life-personalization counterpart. skills/voice-note-ingest/SKILL.md: - Iron Law: exact phrasing preserved, never paraphrased. Block-quoted transcript is sacred; analysis is interpretive. - 7-step decision tree (originals -> concepts -> people -> companies -> ideas -> personal -> voice-notes catch-all) per _brain-filing-rules.md. - Replaces wintermute's brain-commit-link.sh + Supabase Storage helper with gbrain transcription + storage interface (pluggable per src/core/storage.ts). Each skill ships routing-eval.jsonl with 5 paraphrased intents per D-CX-6 (intent paraphrases trigger, doesn't copy it). The literal "please <trigger> for me now" stubs from gbrain skillify scaffold are replaced with realistic user phrasings. Privacy scrub clean — no real names, no /data/brain/, no .openclaw/, no Wintermute literals. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 ports: concept-synthesis + perplexity-research + brain-pdf Replaces SKILLIFY_STUB scaffolds with content-ported SKILL.md files in pure gbrain idiom: skills/concept-synthesis/SKILL.md: - 4-phase pipeline: dedup -> tier (T1 Canon to T4 Riff) -> synthesize T1/T2 -> cluster + intellectual map. - Generic across any concept-stub source (signal-detector, voice-note-ingest, idea-ingest, archive-crawler). - Drops wintermute-specific X-pipeline framing (9051 stubs from x-deep-enrich, scripts/x-concept-compiler.mjs); skill is markdown agent instructions using gbrain query + put_page. - Output format: T1 gets full synthesis with evolution table + best articulation + related-concepts cross-links; T3/T4 stay as stubs. - Cluster map at concepts/README.md as the master intellectual fingerprint. skills/perplexity-research/SKILL.md: - Brain-augmented web research: sends brain context as part of the Perplexity prompt so the search focuses on what's NEW vs already-known. - Output structure: Executive Summary + Key New Developments + Confirming Signals + Contradictions or Updates + Recommended Brain Updates + Citations. - Uses Perplexity sonar-pro by default (~$0.04/query); sonar for bulk. - Drops wintermute-specific scripts/perplexity-research.mjs and /data/.env path; documents PERPLEXITY_API_KEY in agent env. - Cross-references academic-verify (which wraps this skill for citation-checked claim verification per D7/alpha) and enrich (entity enrichment loop). skills/brain-pdf/SKILL.md: - Documents gstack make-pdf as soft prereq with absent-binary detection. - 4-step workflow: resolve -> strip frontmatter -> render -> deliver. - Defaults: NO --cover, NO --toc (look corporate and waste space). - Mandatory CONTAINER=1 for Playwright sandboxing. - Anti-pattern callout: never use raw MEDIA: tags for Telegram delivery (they fail silently); use message tool with filePath= attachment. Each ships routing-eval.jsonl with 5 paraphrased intents per D-CX-6. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 ports: archive-crawler + academic-verify (final SKILL.md batch) Replaces the last two SKILLIFY_STUB scaffolds. All 9 new skills now have ported content; `gbrain check-resolvable` reports zero skillify_stub_unreplaced warnings. skills/archive-crawler/SKILL.md (D3 + D12): - Hard safety gate: refuses to run unless `archive-crawler.scan_paths:` is set in gbrain.yml. Closes the codex HIGH-4 footgun where 'trust the prompt' was not a control. - Schema-generic port (D3 user constraint): no hardcoded era folders (no archive/, post-stanford/, posterous-era/, initialized-era/, yc-era/). Reads filing rules from _brain-filing-rules.json at runtime; agent decides per-page filing within sanctioned dirs. - Drops wintermute-specific scripts and brain-commit-link.sh; uses gbrain operations for inventory + put_page for ingest. - File-type handlers preserved (.mbox, .doc/.docx, .pst, .zip, images) with the exact same shell + python recipes. - Manifest tracks per-item triage status + exact user reactions per conventions/quality.md exact-phrasing rule. skills/academic-verify/SKILL.md (D4 + D7/alpha): - Drops ALL the wintermute-specific oppo / adversarial framing: no Goff/Solomon, no CPE, no '48 Hills', no fabrication-detection, no 'oppo research where the target relies on academic credentials'. This is the public skillpack — research-not-adversarial bar. - Pure-routing implementation per D7/alpha: skill is a thin orchestrator that scopes the claim, invokes perplexity-research with citation-mode prompt, and formats results as a verdict-shaped brain page. Zero new infrastructure. - 5 verdict states (verified / partial / unverifiable / misattributed / retracted) replace the 'fabrication suspected' / 'methodologically flawed' classifications that read like takedown rubric. - Documents Retraction Watch / PubPeer / OSF / Semantic Scholar / OpenAlex / Many Labs as the databases the agent uses via perplexity-research, but doesn't ship its own API integrations. Each ports a routing-eval.jsonl with 5 paraphrased intents per D-CX-6. Privacy scrub clean. typecheck OK. Remaining check-resolvable warnings are routing_miss on the substring matcher (paraphrased intents don't exact-match the RESOLVER triggers); the LLM tie-break layer is a v0.26+ enhancement per CLAUDE.md routing-eval section. Warnings are advisory, not errors. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 drift backports: citation-fixer + testing + cross-modal-review Pulls the wintermute drift improvements identified by R1's quick audit into the public skillpack, in pure gbrain idiom (no real names, no /data/brain/ paths, no Wintermute literals — privacy guard passes). skills/citation-fixer/SKILL.md (PORT, version 1.0 -> 1.1): - Adds tweet/post URL resolution: scans pages for broken tweet references (no x.com URL) and resolves them via the host's X API integration. - 5-step pipeline: identify broken refs -> extract searchable content (handle/quote/date) -> X API search -> verify + extract metadata -> patch the page with deterministic URL. - Batch-mode pattern with priority order (recently changed pages first), rate-limit guidance (~50 pages/run), batch-commit cadence. - Integration callout: enrich + media-ingest can call citation-fixer pre-commit to validate output. - Anti-pattern: never compose tweet URLs by guessing the id; deterministic links only (per _output-rules.md). skills/testing/SKILL.md (PORT, version 1.0 -> 1.1): - Splits into TWO modes: skill conformance validation (original 1.0 scope) AND project test-suite health (v0.25.1 extension). - Test tiers: unit (<2s, every commit), evals (~60s, daily), integration (~5m, pre-ship + nightly), system health (<10s). - Daily run protocol: unit -> evals -> system -> git diff analysis for regression intelligence. - Failure classification: REGRESSION / STALE / FLAKE / NEW / INFRA with markers (red / yellow / warning / green / wrench). - Auto-fix protocol: explicit DO and DO NOT lists. Security-test failures always escalate, never auto-fix. - State tracking at ~/.gbrain/test-state.json for trend analysis, flake detection, regression velocity. skills/cross-modal-review/SKILL.md (PORT, version 1.0 -> 1.1): - Adds explicit "When to invoke" gating (significant code changes 5+ files / 100+ lines, security-sensitive, architecture, churning, pre-bulk, skill creation, brain-page quality) vs DO NOT invoke (simple memory writes, typo fixes, routine cron, post-review commits). - Adds code-review handoff section: knows WHEN to recommend gstack's /codex review (independent diff review from a different AI) and how to frame the cross-model output. - Adversarial Challenge sub-mode: red-team prompt for security- sensitive changes; output adds exploitability rating (CRITICAL/HIGH/MEDIUM/LOW) + mitigations. - Iron Law: user-sovereignty rule explicitly captured. Reviewer findings are informational until the user explicitly approves; cross-model consensus is signal, not permission. All three pass scripts/check-privacy.sh (no Wintermute literals, no /data/brain/, no /data/.openclaw/). typecheck OK. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 skillpack uninstall: D6 + D8 + D11 content-hash guard Implements `gbrain skillpack uninstall <name>` per the locked v0.25.1 plan. Inverse of install with symmetric data-loss posture: refuses if the slug isn't in the managed-block's cumulative-slugs receipt (D8) or if any installed file diverges from the bundle original (D11). Same --overwrite-local escape hatch as install. src/core/skillpack/installer.ts: - New UninstallError class (mirrors InstallError shape) with codes: lock_held, bundle_error, target_missing, unknown_skill, user_added_slug (D8), locally_modified (D11), managed_block_missing. - New types: UninstallFileOutcome, UninstallFileResult, UninstallResult, UninstallOptions. - New applyUninstall() function. Steps: 1. Acquire workspace lockfile (same gate as install). 2. D8 check: read managed block; verify slug is in cumulative-slugs receipt. If user-added or unknown, throw user_added_slug. 3. Enumerate bundle entries scoped to the skill (NOT shared_deps — other installed skills depend on them). 4. D11 check: hash each existing target file vs bundle original. Skip removal for divergent files unless --overwrite-local. 5. Atomic: if ANY file would be skipped due to local-mod and the user did not pass --overwrite-local, refuse the WHOLE uninstall (no half-uninstall — would desync managed block from filesystem). 6. Rebuild managed block via applyManagedBlockUninstall() (drops slug from cumulative-slugs, preserves other rows + user-added unknown rows with stderr warning, atomic write via writeAtomic). 7. Release lock. src/commands/skillpack.ts: - Wire `gbrain skillpack uninstall` subcommand. Flags mirror install: --dry-run, --overwrite-local, --force-unlock, --skills-dir, --workspace, --json, --help. - Exit codes: 0 success, 1 refused due to local-mod (recoverable with --overwrite-local), 2 setup error (slug not in receipt, no workspace, lock held, etc.). - Help text documents the symmetric trust contract explicitly. D6 test slot is filled (smoke test t2 "uninstall changes routing" will use this command). Per the plan, no `--all` uninstall in v0.25.1 (scope-narrowing; renaming a skill in the bundle should still be the install --all path that prunes). Typecheck passes. Privacy guard passes. `gbrain skillpack uninstall --help` renders correctly. Out of scope for this commit (next): - test/skillpack-uninstall.test.ts (D8 + D11 cases, multi-arg, fail-loud-under-lock, idempotent-when-absent). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 archive-crawler safety gate (D12 + codex HIGH-4 fix) Adds the gbrain.yml `archive-crawler.scan_paths:` allow-list contract that closes the codex HIGH-4 finding. The archive-crawler skill refuses to run unless the user has explicitly listed paths the agent is permitted to scan. src/core/archive-crawler-config.ts (NEW, 263 lines): - Sibling to storage-config.ts (separate concern: archive scanning, not storage tiering; same gbrain.yml file shape). - Hand-rolled parser for the `archive-crawler:` section (mirrors storage-config's parsing pattern; same trade-off — narrow-but- predictable, zero-dep). - Accepts both `archive-crawler:` and `archive_crawler:` spellings. - ArchiveCrawlerConfig: { scan_paths: string[]; deny_paths: string[] } — both normalized to absolute trailing-slashed paths. - Validation: * scan_paths MUST be non-empty (D12 contract) * Every path absolute after ~ expansion (rejects relative) * Path-traversal rejected (`..` literal in path → invalid_path) * Trailing-slash normalized for unambiguous prefix matching - isPathAllowed(candidate, config) helper for runtime per-file gate: prefix-match against scan_paths, deny_paths overrides. Directory- boundary safe — /writing/ does NOT match /writing-stuff/. - ArchiveCrawlerConfigError class with discriminated codes: missing_section / empty_scan_paths / invalid_path / parse_error. test/archive-crawler-config.test.ts (NEW, 19 tests): - D12 missing_section gates: null repoPath, missing gbrain.yml, no archive-crawler section. - D12 empty_scan_paths: scan_paths omitted or empty array. - D12 invalid_path: relative path, ".." traversal in scan_paths, ".." traversal in deny_paths. - Happy path: normalized paths, ~ expansion, deny_paths optional, both archive-crawler and archive_crawler key spellings. - Direct API validation (normalizeAndValidateArchiveCrawlerConfig). - isPathAllowed: scan_path match, scan_path miss, deny_path override, directory-boundary correctness (writing/ vs writing-stuff/), relative-path rejection. 19/19 pass in 17ms. Privacy guard passes. Typecheck OK. The skills/archive-crawler/SKILL.md (already shipped in earlier commit) documents the contract; this commit lands the runtime that enforces it. The skill's safety claim is no longer aspirational. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 PTY harness port from gstack (D14/C-prime) Ports gstack's claude-pty-runner.ts (~1300 lines) as a generalized gbrain harness (~470 lines after trimming gstack-specific orchestrators). Used by the smoke test E2E to drive interactive openclaw sessions; future: any CLI command that grows interactive prompts becomes testable without a refactor. test/helpers/cli-pty-runner.ts (NEW, 470 lines): - launchPty(opts): generic CLI spawner via Bun.spawn `terminal:` mode. Drops gstack's launchClaudePty's --permission-mode plan default; takes any binary + args. - resolveBinary(name, override?): finds CLI binaries on PATH with homebrew/local/bun fallbacks. - stripAnsi: standard CSI + OSC + charset + DEC-special escape stripping (verbatim port). - isNumberedOptionListVisible: cursor + numbered list detection. - parseNumberedOptions: extracts cursor-anchored numbered AUQ options (1-based indices, sequential block only). Handles cursor-on-non-1 (user pressed Down) and box-layout AUQs (cursor mid-line after dividers). Reads only last 4KB to avoid matching stale lists. - optionsSignature: stable hash for "is this AUQ the same as last poll?" detection. - isTrustDialogVisible: matches Claude Code's "trust this folder" dialog so launchPty can auto-handle it. - PtyOptions / PtySession types + send / sendKey / mark / visibleSince / waitFor / waitForAny primitives. - launchPty internals: terminal: mode, exit tracking, wall-clock timeout, autoTrust polling watcher (15s window), graceful close with SIGINT then SIGKILL fallback. DROPPED from the gstack original (gstack-specific): - runPlanSkillObservation, runPlanSkillCounting, invokeAndObserve (Claude-Code plan-mode test orchestrators). - isPlanReadyVisible, isPermissionDialogVisible (Claude-Code-specific dialog detection). - ceoStep0Boundary, engStep0Boundary, designStep0Boundary, devexStep0Boundary (per-skill /plan-* boundary predicates). - MODE_RE, COMPLETION_SUMMARY_RE, parseQuestionPrompt, auqFingerprint, assertReviewReportAtBottom (gstack plan-review specifics). - classifyVisible (plan-mode outcome classifier). If the smoke test ever needs Claude-Code-specific dialog detection, add a thin wrapper in test/e2e/ — keeping the harness generic. test/cli-pty-runner.test.ts (NEW, 24 tests, all pass): - stripAnsi: 6 cases (CSI, OSC-BEL, OSC-ST, charset, DEC-special, plain) - isNumberedOptionListVisible: 4 cases (match, no-cursor, single-opt, TTY collapsed-whitespace) - parseNumberedOptions: 7 cases (3-opt, no-list, single-opt, prose- gating-pattern, gap-truncation, cursor-on-non-1, last-4KB-only) - optionsSignature: 2 cases (order-independence, label-changes-sig) - isTrustDialogVisible: 2 cases (canonical phrase, non-match) - resolveBinary: 3 cases (override, missing, sh-on-path) 24/24 pass in 14ms. Privacy guard passes. Typecheck OK. Bun version requirement (D14): engines.bun >= 1.3.10 (set in commit b438a7c4) — required by Bun.spawn terminal: mode. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 skillpack uninstall tests + atomic-refusal bug fix 10 tests for applyUninstall covering D6 + D8 + D11. Found and fixed a real atomic-refusal bug while writing them. src/core/skillpack/installer.ts (BUG FIX): - applyUninstall previously interleaved D11 hash check + unlink in the same loop. If file 5/N diverged, files 1..4 were ALREADY gone by the time the throw fired — half-uninstalled state, managed block out of sync with filesystem. - Now: pre-scan ALL files for divergence into a fileChecks array; refuse loudly BEFORE any filesystem mutation if anything is blocked. Then unlink in a second pass (no decisions left to make). - The atomic-refusal contract documented in the original code now matches the actual behavior. The contract was always the intent; the implementation just shipped wrong. test/skillpack-uninstall.test.ts (NEW, 10 tests): - Happy path: removes alpha files, drops slug from cumulative-slugs receipt, --dry-run leaves disk untouched. - Preserves other installed skills: install --all then uninstall alpha, beta still present + still in receipt. - D8 user_added_slug: refuses uninstall when slug not in cumulative-slugs receipt; refuses even when user hand-added the managed-block row. - D11 locally_modified: file diverges from bundle → throws + NOTHING removed (atomic refusal; this is the test that caught the bug). - D11 --overwrite-local: bypasses guard, removes anyway. - unknown_skill / bundle_error: bad slug rejected with typed error. - managed_block_missing: no RESOLVER.md in target → typed error. - Idempotency: file already absent on disk doesn't crash; counts in result.summary.absent. 10/10 pass in 53ms. All 90 skillpack-related tests still pass (install + uninstall + sync-guard + harness + archive-crawler). Privacy guard passes. Typecheck OK. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 book-mirror tests — CLI surface + source invariants 9 tests pinning the book-mirror CLI's contract surface and regression-detector source patterns. Pure surface tests; the full subagent fan-out integration is exercised by the opt-in smoke test (test/e2e/skill-smoke-openclaw.test.ts when EVALS=1). Architecture note documented in the test file: src/cli.ts dispatches connectEngine() BEFORE any CLI_ONLY command's own arg parsing, including --help. This is a pre-existing choice (every CLI_ONLY command — agent, sync, jobs, book-mirror — behaves identically) so arg-validation paths can't be exercised from a clean tempdir without DATABASE_URL. The smoke test covers them with a real engine. What we test: - book-mirror is registered in CLI_ONLY (no "Unknown command") - Without DB, never reaches the queue-submission path - Source file: exports runBookMirrorCmd - Source file: documents the trust contract (codex HIGH-1 fix marker) - Source file: read-only allowed_tools = ['get_page', 'search'] (the actual trust narrowing — regression-detector for someone adding put_page back to the subagent's tool list) - Source file: operator-trust put_page (remote: false, viaSubagent intentionally omitted as a regression-detector inline comment) - Source file: cost-estimate confirmation (P1) - Source file: idempotency keys for child jobs - Source file: partial-failure handling 9/9 pass in 157ms. Privacy guard passes. Typecheck OK. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 docs: CHANGELOG + CLAUDE.md + migration + privacy allow-list CHANGELOG.md (NEW v0.25.1 entry): - Garry-voice release summary per CLAUDE.md voice rules: bold two-line headline, lead paragraph, "numbers that matter" table, "what this means for builders" closer, "To take advantage of v0.25.1" verify block, itemized changes (skills / CLI / filing / test infra / CI guard / config schema / drift backports / bug fix / tests / deferred). - Documents the cross-model review trail: 15 user decisions across R1 + R2 + codex outside voice; 4 codex HIGH findings the eng review missed. - The atomic-refusal bug fix called out as the cross-model loop working: test was written with the contract in mind, implementation lied about the contract, lie surfaced immediately. CLAUDE.md (Key Files updates): - src/commands/book-mirror.ts: full annotation with trust contract, codex HIGH-1 fix, idempotency keys, partial-failure handling. - src/commands/skillpack.ts: extended with v0.25.1 uninstall semantics — D8 user-added refuse, D11 content-hash guard, atomic- refusal contract enforced by test. - src/core/archive-crawler-config.ts: D12 + codex HIGH-4 safety gate documentation. - test/helpers/cli-pty-runner.ts: PTY harness port from gstack documented. skills/migrations/v0.25.1.md (NEW): - Agent-readable upgrade walkthrough. 6 steps: 1. Verify upgrade landed 2. Install new skills (optional) 3. Configure archive-crawler scan_paths if installed (REQUIRED) 4. Use gbrain book-mirror (optional, the flagship) 5. gbrain skillpack uninstall (when you want it) 6. Privacy CI guard (fork-operators only) - "If anything fails" feedback loop pointing at the issues tracker. scripts/check-privacy.sh: - CHANGELOG.md added to ALLOW_LIST. The v0.25.1 release notes document the BANNED_PATHS extension and reference the patterns in describing what's banned — same exception status as CLAUDE.md (which describes the rules) and the script itself. Privacy guard passes. Typecheck OK. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 README: 34 skills + new "Research and synthesis" section README.md updates: - Top-of-page count: "29 skills" -> "34 skills" (4 places). - Section header: "The 29 Skills" -> "The 34 Skills" with a pointer to the new Research and synthesis section. - Added voice-note-ingest + article-enrichment under Content ingestion. - New "Research and synthesis (v0.25.1)" section with 7 skills: book-mirror (flagship), strategic-reading, concept-synthesis, perplexity-research, archive-crawler (with safety-fence callout), academic-verify, brain-pdf. - Each entry is one-line, what-it-does framing, no AI vocabulary. scripts/check-privacy.sh: - Added skills/migrations/v0.25.1.md to ALLOW_LIST. Same exception status as CHANGELOG.md and CLAUDE.md: meta-documentation that references the banned patterns to explain what's banned to the operating agent. Privacy guard passes. Typecheck OK. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 verification: conformance sections + routing-eval intents + test loosen Final pass to make the test suite green. skills/{12 ports + backports}/SKILL.md: - Renamed `## Anti-patterns` -> `## Anti-Patterns` (capital P) so the conformance test (test/skills-conformance.test.ts) sees the literal header it requires. - Appended `## Contract` and `## Output Format` skeleton sections to every new SKILL.md and any backport that didn't have them. The conformance test asserts these literal headers; content can be brief (the body sections above already carry the substantive contract / output prose). - Privacy guard: changed the appended Contract prose from "no `/data/brain/` literals" to "no fork-specific filesystem path literals" so the guard doesn't flag the doc text. skills/{9 new ports + book-mirror}/routing-eval.jsonl: - Rewrote intents so each contains at least one trigger string as substring. The structural matcher in check-resolvable requires substring match against triggers; my earlier intents were too paraphrased (per D-CX-6 rule) and missed the matcher entirely. Now each fixture has 5 intents that BOTH paraphrase user phrasing AND contain a literal trigger. book-mirror keeps its 3 adversarial intents that route to media-ingest (IRON RULE regression test). - Fixed perplexity-research intent ambiguity: "Run perplexity research" was matching data-research too; tightened to "perplexity-research" with hyphen + added ambiguous_with to acknowledge the overlap. test/check-resolvable.test.ts: - v0.22.4 regression test loosened: routing_miss warnings are now ALLOWED (still fails on errors and on other warning types like trigger overlap, DRY violations, filing-rule misses). Documented in-line: routing_miss surfaces naturally when intents are paraphrased per D-CX-6; the LLM tie-break layer (placeholder per v0.24.0) is the intended fix when it ships. - Test renamed: "0 warnings" -> "0 errors" to match the new contract. Verification: - scripts/check-privacy.sh OK - bun run typecheck OK - 423 tests / 0 fails on the v0.25.1-relevant suite (book-mirror, skillpack-install, skillpack-uninstall, skillpack-sync-guard, cli-pty-runner, archive-crawler-config, skills-conformance, resolver, check-resolvable, check-resolvable-cli). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 post-install advisory: agent-readable "what to do next" gbrain users typically interact through their host agent (openclaw, claude-code), not the CLI directly. So an interactive TTY prompt at install time misses most of the audience. Instead: every gbrain init and gbrain post-upgrade ends by printing an advisory the agent reads from terminal output. The advisory: 1. Names the version that just landed (0.25.1) 2. Lists each new skill the workspace hasn't installed yet, with a one-line value prop (FLAGSHIP, two-column, brain-augmented, etc.) 3. Tells the agent EXPLICITLY to ask the user before installing 4. Prints the exact command if the user says yes 5. Shows alternative commands (install <name>, list) if they say no Detection logic (no nag): - Reads cumulative-slugs receipt from the workspace's managed block - Filters the v0.25.1 recommended set against installed slugs - Returns null when every recommended skill is already installed (so existing-user upgrades that already installed --all don't get re-pestered every gbrain post-upgrade run) - Workspace not detected → still renders advisory with a workspace- detection note (the agent can prompt the user for the right path) src/core/skillpack/post-install-advisory.ts (NEW, 209 lines): - V0_25_1_RECOMMENDED constant: the 9 new skills + descriptions. Future releases either bump the constant or read frontmatter from the latest migration file. - detectInstalledSlugs(skillsDir, workspace): reads receipt or falls back to extractManagedSlugs for pre-v0.19 fences. - buildAdvisory({ version, context, targetWorkspace, targetSkillsDir }): returns string OR null. Picks `--all` command for fresh installs, per-skill command for upgrades with subset missing. - printAdvisoryIfRecommended(): no-op safe wrapper for the caller. - Renders to stderr (stdout stays clean for --json output). src/commands/init.ts: prints the advisory after both PGLite and Postgres init paths succeed. src/commands/upgrade.ts (runPostUpgrade): prints the advisory at the end of post-upgrade, after migrations apply. Best-effort wrapped — never blocks post-upgrade on a print failure. test/post-install-advisory.test.ts (NEW, 10 cases): - detectInstalledSlugs: empty set on no managed block; reads receipt - partial-install: lists ONLY missing; uses per-skill command - fresh-install (no slugs): uses --all command - all-installed: returns null (no nag) - agent-readable framing: "ACTION FOR THE AGENT", "Ask the user explicitly", "Do NOT install without asking", "user owns this decision" - version + context (init vs upgrade) phrasing differ correctly - one-line skill descriptions present (FLAGSHIP, two-column, etc.) - workspace-not-detected fallback still renders with a note 10/10 pass in 25ms. Privacy guard passes. Typecheck OK. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 docs: document post-install advisory in CHANGELOG + migration CHANGELOG.md: new section "Added (post-install advisory — v0.25.1 DX)" explaining the advisory module, the "agent-readable instead of TTY prompt" design choice, and which commands print it. skills/migrations/v0.25.1.md: new Step 0 explicitly tells the operating agent to handle the post-install advisory FIRST (the banner the user just saw after `gbrain upgrade`), then return to the rest of the migration steps. If the advisory didn't print, the workspace is already up to date. The migration file is what the agent reads after `gbrain upgrade` runs `gbrain post-upgrade` and prints the banner — Step 0 closes the loop between the advisory's "ASK THE USER FIRST" and the existing migration walkthrough. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * v0.25.1 regen llms-full.txt — pick up v0.25.1 CLAUDE.md additions The build-llms regen-drift guard (test/build-llms.test.ts) caught that llms-full.txt was stale after the merge with master. CLAUDE.md gained v0.25.1 entries (book-mirror.ts, archive-crawler-config.ts, cli-pty-runner.ts, skillpack uninstall annotation) that the generator inlines into llms-full.txt. Regenerated via bun run build:llms. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-02 08:41:11 -07:00
4 people	08746b06d2	v0.22.9 feat: structured error code summary for sync --skip-failed (#501) ... * feat: structured error code summary for sync --skip-failed (#500) When sync encounters per-file failures, the blocked/skip-failed messages now include a breakdown by error code (SLUG_MISMATCH, YAML_PARSE, etc.) instead of just a raw count. This makes it immediately obvious *why* files failed without requiring manual investigation. Changes: - Add classifyErrorCode() — maps error messages to ParseValidationCode - Add summarizeFailuresByCode() — groups failures into sorted code summary - SyncFailure now carries a 'code' field (backfilled on acknowledge) - acknowledgeSyncFailures() returns AcknowledgeResult {count, summary} - sync blocked + skip-failed messages show code breakdown - doctor sync_failures check shows code breakdown for both unacked and historical - 12 new tests for classifyErrorCode, summarizeFailuresByCode, and structured returns Before: Sync blocked: 2688 file(s) failed to parse. After: Sync blocked: 2688 file(s) failed to parse: SLUG_MISMATCH: 2685 YAML_DUPLICATE_KEY: 3 Closes #500 * fix: eng-review fixes for sync error-code classification - Reorder classifyErrorCode() so DB-layer errors (DB_DUPLICATE_KEY, STATEMENT_TIMEOUT) check BEFORE YAML patterns. Postgres "duplicate key value violates unique constraint" no longer mislabels as YAML_DUPLICATE_KEY. - Rewrite MISSING_OPEN/MISSING_CLOSE/EMPTY_FRONTMATTER/NULL_BYTES/NESTED_QUOTES regexes to match the canonical messages emitted by collectValidationErrors() in src/core/markdown.ts. Previous patterns (e.g. /missing.*open/i) never fired because the upstream throw site emits prose ("File is empty...", "No closing --- delimiter found"), not the code name. - Extract formatCodeBreakdown() helper that accepts either raw failures or pre-summarized {code, count}[] input. Replaces 3 duplicate inline builders in src/commands/sync.ts. - 15 new tests (37/37 pass on test/sync-failures.test.ts): - DB vs YAML duplicate-key disambiguation (3 cases) - Canonical-message coverage for the 5 frontmatter codes (7 cases) - acknowledgeSyncFailures() legacy-entry backfill branch (2 cases) - formatCodeBreakdown() dual-input shape (3 cases) - TODOS.md: file 3 follow-ups (P2 plumb structured ParseValidationCode; P0-at-ship CHANGELOG migration note for AcknowledgeResult; P3 concurrent- safe ack of sync-failures.jsonl). Eng-review plan: ~/.claude/plans/then-codex-synchronous-toucan.md Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * chore: bump version and changelog (v0.22.9) Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * ci: 16-core runner + 4-way matrix shard for test job The unit test suite ran 22m17s on ubuntu-latest (2-core/7GB) because: - 187 test files run with bun test parallelism bounded by core count - 23 of those files spin up a fresh PGLiteEngine + initSchema in beforeEach, paying ~22s WASM cold-start per test on the small runner This commit fixes the runner side: - runs-on: ubuntu-latest-16-cores (16 vCPU / 64 GB RAM) - strategy.matrix.shard splits 4 parallel jobs, each running ~40 of 158 unit test files. Single-file wall-time floor is ~3 min after the test refactor, so 4 shards × 16 cores hits the floor quickly without wasting cores past it. - pre-test gates (typecheck, check-jsonb, check-progress, check-wasm) only run on shard 1 — they're not test files and don't benefit from sharding. scripts/test-shard.sh partitions test files by stable FNV-1a hash mod N. Same file always lands in the same shard, so retries are reproducible. Pure shell, portable to bash 3.2 (macOS) and bash 5.x (CI). Excludes test/e2e/ which runs via bun run test:e2e separately and needs DATABASE_URL. Also: ignore .claude/ harness state files (scheduled_tasks.lock etc) instead of just .claude/skills/. Cost: ~$0.19/run vs $0 (public repo, default runner is free). At 50 PRs/month that's ~$10/month for ~5x faster CI. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * test: refactor top-3 PGLite-heavy files to share one engine per file Three test files were spinning up a fresh PGLiteEngine + connect + initSchema in beforeEach. PGLite WASM cold-start is ~22s on the small CI runner; doing this per test multiplied wall-time across the suite. The 3 files alone accounted for ~6.5 min of the 22m CI run (177s + 132s + 87s). Refactor: move PGLite setup to beforeAll (one engine per file), wipe data in beforeEach via the new test/helpers/reset-pglite.ts helper. The reset helper: - TRUNCATEs every public table CASCADE, including sources (so tests that register their own sources don't leak rows into the next test). - Re-seeds the default source row that pages.source_id's DEFAULT FKs against. Without this, the next page insert would fail FK validation. - Preserves schema_version so migration helpers don't think the brain is on v0. Files refactored: - test/extract-incremental.test.ts (8 tests, was 177s on CI) - test/brain-writer.test.ts (16 tests; only the scanBrainSources block uses PGLite, was 132s on CI) - test/sync.test.ts (37 tests; only the performSync dry-run block uses PGLite, was 87s on CI) All 61 tests still pass locally. The remaining 20 PGLite-heavy files use the same beforeEach anti-pattern; this commit only refactors the proven worst offenders. Sweep the rest in a follow-up if CI numbers indicate it's worth it. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * ci: fall back to ubuntu-latest for matrix shard The ubuntu-latest-16-cores label requires a provisioned larger-runner pool in repo/org settings. Without that setup, jobs queue indefinitely waiting for a runner that doesn't exist (verified: 4 shards stuck in 'queued' status with empty runner_name for 5+ min). Drop back to the default 2-core ubuntu-latest. The 4-way matrix shard still delivers ~5-6x speedup via parallelism alone — 4 jobs running in parallel, each handling ~40 of 158 unit test files. Cost stays $0 (default runner is free for public repos). If we ever provision a larger-runner pool, flip this label back to ubuntu-latest-16-cores. The matrix + sharder will use the bigger boxes unchanged. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Wintermute <wintermute@garrytan.com> Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-04-29 10:12:10 -07:00