v0.41.2.0 feat: lens packs + epistemology unification — atoms + concepts as first-class units, calibration profile widening, gstack-learnings bridge (#1364)
* feat(schema): migration v93 take_domain_assignments (v0.41 T1) Adds the JOIN table backing per-pack calibration domain aggregation in the v0.41 lens-packs wave. Replaces the originally-planned scalar `takes.domain` column after codex outside-voice review caught that one take can legitimately belong to multiple domains (a take about "Sequoia's investment in Anthropic" lands in deal_success AND market_call), and that scalar attribution bakes today's pack→domain mapping into permanent fact. Schema: composite PK (take_id, domain) for idempotent re-assignment, FK CASCADE so deleting a take cascades assignments, confidence CHECK in [0,1], idx_take_domain_assignments_domain for the aggregator JOIN direction. RLS guard matches takes/synthesis_evidence pattern (enable when running as BYPASSRLS role). PGLite parity via sqlFor.pglite. Backward-compat: pre-existing takes carry no assignments; aggregator LEFT JOIN skips them gracefully. No backfill required at migration time — propose_takes (T10) populates new rows; greenfield assignment of historical takes is a v0.42 follow-up. R-MIG IRON-RULE regression at test/migrations-v93.test.ts pins 12 contracts: existence/name, LATEST_VERSION advance, table queryable after initSchema, column shape, composite PK rejects duplicate (take_id, domain), multi-domain assignment permitted, FK ON DELETE CASCADE, CHECK rejects out-of-range confidence, index presence, aggregator JOIN direction returns per-domain counts, sql/sqlFor.pglite parity grep, backward-compat LEFT JOIN handles unassigned takes. Plan: ~/.claude/plans/system-instruction-you-are-working-toasty-milner.md First of 13 sequencing tasks in v0.41 lens packs + epistemology unification wave (decisions D9-B → T1-B per codex challenge). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(contracts): IngestionSource.mode + pack manifest phases/calibration_domains (v0.41 T2+T3) Two independent contract extensions, batched because both are pre- requisites for T4 (pack YAML manifests) and T9 (cycle.ts orchestrator gate). Neither is load-bearing alone; together they form the surface the four lens-pack manifests will declare against. T2 — IngestionSource.mode discriminator (codex outside-voice fix): src/core/ingestion/types.ts grows an optional `mode: 'trickle' | 'migration'` field on IngestionSource. Defaults to 'trickle' when unset — v0.38 sources unchanged. New IngestionSourceMode export. src/core/ingestion/daemon.ts handleEmit() branches on the mode: trickle keeps the 24h DedupWindow.mark() path; migration bypasses dedup entirely (the source owns permanent slug-keyed idempotency via op_checkpoint or similar). Validation, rate limit, and dispatch apply uniformly to both modes. Why: the 24h content-hash dedup window is wrong for bulk historical migration. 24K wintermute pages over hours, retries days apart, and same-hash collisions across the window are expected. Trickle semantics (file-watcher, inbox-folder, webhook) want dedup to catch at-least-once replay; migration semantics want EVERY explicitly- emitted event to land because the source already gated it. T3 — SchemaPackManifestSchema phases + calibration_domains: src/core/schema-pack/manifest-v1.ts grows two optional fields. New AGGREGATOR_KINDS closed enum (4 v1 algorithms: scalar_brier, weighted_brier, count_based, cluster_summary) backing AggregatorKind type. New CalibrationDomain {name, aggregator, page_types} schema with snake_case regex on name, .strict on extra fields, page_types.min(1). `phases: string[]` declares which cycle phases the active pack participates in (D4-B orchestrator gate; runCycle will consult this in T9). Validated as string here, against runtime CyclePhase union at the registry layer (avoids circular import). `borrow_from` does NOT borrow phases — each pack declares explicitly. `calibration_domains: CalibrationDomain[]` declares per-pack scorecard buckets. Closed registry of algorithm `aggregator` values keeps SQL injection surface closed; open `name` strings let third- party packs add domains without a gbrain release (T3 codex refinement of D6). Backward compat: both fields default to []. Existing v0.38 manifests parse unchanged (pinned by 2 regression cases). Tests: test/ingestion/migration-mode.test.ts (8 cases): mode type accepts literals, defaults to trickle, daemon branches correctly across trickle/migration/default-undefined, validation still runs in migration mode, mixed dual-source independence. test/schema-pack-manifest-v041.test.ts (19 cases): aggregator enum shape, phases default + accept + reject (non-string, empty, non- array), calibration_domains default + accept (single + multi entry, multi page_types), reject (unknown aggregator, kebab/uppercase/ digit-start names, empty page_types, unknown extra field), v0.38 back-compat regressions. All 27 cases pass first-green after API surface alignment. Plan: ~/.claude/plans/system-instruction-you-are-working-toasty-milner.md Tasks T2 + T3 of 13 in v0.41 lens packs + epistemology unification wave. Unblocks: T4 (pack manifests reference both fields), T9 (cycle.ts gate reads phases:), T10 (calibration widening reads calibration_domains). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(packs): 4 bundled lens pack manifests + registry wiring (v0.41 T4) Authors gbrain-creator + gbrain-investor + gbrain-engineer + gbrain-everything as bundled YAML manifests in src/core/schema-pack/base/, registers them in the BUNDLED array in load-active.ts, exports AGGREGATOR_KINDS + AggregatorKind + CalibrationDomain types through the schema-pack barrel. gbrain-creator: atom (NEW page type) + concept (reuse from base). phases: [extract_atoms, synthesize_concepts]. One calibration domain: concept_themes / cluster_summary / [concept]. Retires wintermute's atom-pipeline-coordinator cron (T12 follow-up). gbrain-investor: thesis + bet_resolution_log (NEW). Borrows deal/person/company/yc from base. No new cycle phases (consumes existing extract_facts/propose_takes/grade_takes pipeline). Three calibration domains: deal_success/scalar_brier/[deal], founder_evaluation/scalar_brier/[person], market_call/weighted_brier /[thesis]. Filing rules mirror wintermute's existing investing/deals + investing/theses + investing/bets layout. gbrain-engineer: bridge-only per D8-C. ONLY declares `learning` page type (primitive: annotation); borrows code+project from base. No new cycle phases (gstack-learnings IngestionSource is daemon- side per T8). Three calibration domains: architecture_calls/ scalar_brier/[code, learning], effort_estimates/weighted_brier/ [project], risk_assessment/scalar_brier/[project]. gbrain-everything: meta-pack extending gbrain-investor + borrowing atom (from creator) + learning (from engineer). Codex outside-voice T4 resolution to the multi-lens problem: composes via the v0.38- shipped extends + borrow_from chain instead of inventing an active-multi-pack architecture. Single-active-pack constraint preserved. Explicitly re-declares phases + calibration_domains (borrow_from borrows types/link_types only — phases must be declared per pack per D4-B). Frontmatter validators (atom_type closed 11-value enum, virality_ score range, etc.) are NOT declared in these manifests — that contract surface (per-page-type frontmatter_validators on PageTypeSchema) is a v0.42 follow-up filed in plan TODOs. For v0.41, extract_atoms hardcodes the enum with a TODO comment pointing at the eventual manifest read path (D11). YAML parser caveat: src/core/schema-pack/loader.ts uses a hand- rolled parseYamlMini (per loader.ts:86 explicit non-support of `|` block scalars). Initial descriptions used `|` blocks and broke parsing silently (description was 'literal "|"', everything after collapsed). Reauthored to single-line "..." strings. Pinned by the manifest-load tests asserting page_types/phases/calibration_ domains all resolve. Tests: test/lens-pack-manifests.test.ts (31 cases): one file covers all 4 packs to avoid 4x boilerplate. Pins parse cleanly, registry inclusion, per-pack page_types/phases/calibration_domains/filing_ rules shape, every aggregator value falls in AGGREGATOR_KINDS, meta-pack unions correctly (7 calibration domains across all three lens packs). Plan: ~/.claude/plans/system-instruction-you-are-working-toasty-milner.md Task T4 of 13. Unblocks T5/T6 (phases now declared; phases read from active pack at runtime), T7 (importer writes atom-typed pages against creator manifest), T8 (gstack-learnings emits learning-typed pages against engineer manifest), T9 (orchestrator gate reads phases: declaration), T10 (calibration_profile walks calibration_domains). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(cycle): orchestrator-level pack gate for lens-pack phases (v0.41 T9) Wires extract_atoms + synthesize_concepts into runCycle with the D4-B orchestrator-level pack gate. Five surgical edits to src/core/cycle.ts: 1. CyclePhase union grows by 2 names. 2. ALL_PHASES inserts extract_atoms after extract_facts (Haiku 3-check has fresh fact context, BEFORE resolve_symbol_edges to avoid interrupting the symbol resolution sweep mid-flight) and synthesize_concepts after patterns (cluster pass sees fresh cross-session themes). 3. PHASE_SCOPE entries: extract_atoms='source' (per-source transcript walk), synthesize_concepts='global' (concept clusters cross sources by nature). 4. NEEDS_LOCK_PHASES adds both (put_page writes mutate DB). 5. runCycle dispatch blocks for both phases consult packDeclaresPhase before invoking. When the active pack doesn't declare the phase, skipped with reason='not_in_active_pack' marker. When it does, lazy-imports extract-atoms.ts / synthesize-concepts.ts and runs. The packDeclaresPhase helper is new at module-private scope. Loads the active pack via loadActivePack({cfg, remote:false}); reads resolved.manifest.phases (local only — D4-B). Fail-open: any registry error (pack not found, malformed manifest) returns false. Skipping > crashing for an orchestrator gate. Local-only phase semantics (not extends-chain inherited) preserves user sovereignty: a downstream pack extending gbrain-creator may NOT want extract_atoms to run (e.g. derives atoms differently). Inheriting phases would force them into a no-op-or-fork choice. The gbrain-everything meta-pack therefore RE-DECLARES creator's phases verbatim in its own manifest, asserted by the T4 test. Stub phase modules ship in this commit: src/core/cycle/extract-atoms.ts → returns skipped with reason= 'stub_pending_t5' src/core/cycle/synthesize-concepts.ts → returns skipped with reason= 'stub_pending_t6' T5/T6 replace the stub bodies with real LLM-driven phases. The orchestrator dispatch is fully wired today and exercised by the test. Manifest schema follow-on: phases + calibration_domains were originally .default([]) but the type narrowing broke v0.38 fixture casts in test/schema-pack-{lint-rules,registry,registry-reload}.test.ts. Reverted to .optional(); consumers apply `?? []` at the read site. Same pattern as IngestionSource.mode in T2. Updated T3 + T4 tests to use `!` non-null assertion at sites that explicitly declared the fields (typechecker can't narrow array literals through optional boundaries). Tests: test/cycle-pack-gating.test.ts (19 cases, R-GATE IRON RULE): ALL_PHASES + PHASE_SCOPE shape, ordering invariants (extract_atoms after extract_facts, synthesize_concepts after patterns), exhaustive PHASE_SCOPE map, NEEDS_LOCK_PHASES static-source assertion (both new phases included), dispatch consults packDeclaresPhase for BOTH new phases (and ONLY those two), packDeclaresPhase helper exists + reads manifest.phases (not merged chain) + fail-open returns false on catch, pre-existing 17 phases NEVER consult packDeclaresPhase (extract_facts + calibration_profile spot-checked), not_in_active_pack reason marker appears exactly 2x (semantic consistency across both gated phases). Adjacent test fixes: T3 + T4 tests updated for optional-field semantics. T2 dispatch type narrowed to DispatchOutcome shape from daemon.ts ({kind: 'queued'} for success path). 89/89 across T1+T2+T3+T4+T9 tests pass; typecheck clean. Plan: ~/.claude/plans/system-instruction-you-are-working-toasty-milner.md Task T9 of 13. Unblocks: T5 (extract-atoms.ts body replaces stub), T6 (synthesize-concepts.ts body replaces stub). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(calibration): domain_scorecards widening + 4 aggregators (v0.41 T10) Replaces the v0.36.1.0 placeholder `JSON.stringify({})` in calibration-profile.ts:336 with a real aggregator pass over the active pack's calibration_domains declarations. domain_scorecards JSONB now populates per declared domain with {n, brier, accuracy, aggregator, page_types, extras}. New module: src/core/calibration/domain-aggregators.ts - aggregateDomainScorecards(engine, holder, domains, sourceId) → JSONB-shape - 4 aggregator implementations matching the AggregatorKind closed enum: - scalar_brier: AVG(POWER(weight - outcome::int, 2)). The default for most predictive domains. Filters by holder + page_types + resolved_outcome IS NOT NULL + active=TRUE + source_id. - weighted_brier: Brier weighted by ABS(weight - 0.5) * 2 (conviction proxy since takes table has no separate confidence column). A 0.95-conviction miss weights 9x more than a 0.55-conviction one. Matches the investor pack's market_call semantics. - count_based: simple SUM(hit)/COUNT(*) accuracy without Brier. For domains where probability isn't natural. - cluster_summary: page count + tier histogram via frontmatter->>'tier' JSONB read. For concept_themes where there's no binary outcome to score. Returns {n, tier_counts: {T1, T2, T3, T4}}. Wiring in src/core/cycle/calibration-profile.ts: Try/catch wraps the loadActivePack → aggregator chain. Empty {} scorecard on any pack-resolution error (R1 IRON RULE: byte-identical v0.36.1.0 baseline when no active pack declares domains). Warning appended to result.warnings so doctor surfaces silent failures instead of crashing the phase. Per-domain fail-soft: aggregateOneDomain's try/catch returns {n: 0, brier: null, accuracy: null, extras: {error}} for any single malformed domain. The other domains still aggregate. Phase keeps running. Tests (test/domain-aggregators.test.ts, 13 cases): - R1 IRON RULE: empty domain list returns {} (byte-identical) - scalar_brier: empty no-takes returns n:0/null/null; 2-take Brier computed correctly (0.5 over (0, 1) sq_errs); accuracy matches weight>=0.5 hit/miss; filters by holder; filters by page_types; ignores unresolved takes - weighted_brier: high-conviction miss weighted 9x more; accuracy independent of conviction weighting - count_based: accuracy without Brier - cluster_summary: tier histogram from frontmatter; zero-concepts returns n:0 + all-zero tiers - Multi-domain: aggregates all declared in one call - Fail-soft per domain: nonexistent page_type produces n:0 without blocking other domains 89/89 across T1+T2+T3+T4+T9+T10 tests; typecheck clean. Plan: ~/.claude/plans/system-instruction-you-are-working-toasty-milner.md Task T10 of 13. The propose_takes-side wiring (populate take_domain_assignments at write time from active pack's page_type→ domain mapping) is deferred to T5/T6 phase implementations, since they are the natural producers of takes. Manual propose_takes via fence write covers the operator path. v0.42+ adds a takes-fence parser extension to read domain[] from fence rows. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(ingestion): gstack-learnings bridge source (v0.41 T8) Implements GstackLearningsSource — the daemon-side IngestionSource that watches ~/.gstack/projects/{repo}/learnings.jsonl and emits each new line as a `learning`-typed IngestionEvent. Closes the v0.40-and-earlier gap where gstack's typed engineering knowledge base (7 learning types: pattern, pitfall, preference, architecture, tool, operational, investigation) lived in JSONL files the brain never queried. After T8 + the engineer-pack manifest activation, every gstack-logged learning surfaces as a first-class gbrain page within seconds of being written. Lifecycle: - constructor: discovers JSONL files via ~/.gstack/projects/*/ learnings.jsonl (cross-project mode, default) or just the current project (per-project mode). Test seam: _readFile/_existsSync/_skipWatch. - start(ctx): seeds seenLines with content_hashes of EVERY existing line so first-run-after-install does NOT replay thousands of historical lines as fresh emits. Then installs fs.watch handlers (one per discovered file) that fire rescanFile on 'change'. - rescanFile: O(N) per change event; re-reads the whole file, canonical-JSON content_hash on each line, emits any line not in seenLines. Malformed JSONL lines skip+warn. - stop(): closes all watchers; JSONL state preserved (gstack owns the files, gbrain only reads). - healthCheck(): reports warn when no files discovered (gstack not installed) OR when watched files have disappeared; ok otherwise with counter of lines seen. mode: 'trickle' (the v0.41 T2 default). Line-level content_hash via canonical-JSON serialization means whitespace reformatting doesn't trigger re-emit. Re-emit of an identical line is a silent dedup hit via the daemon's 24h DedupWindow (T2 trickle path). Frontmatter rendered into the emitted markdown body preserves the original JSONL fields verbatim: type=learning, learning_type (one of the 7 types), confidence (1-10), source (one of: observed, user-stated, inferred, cross-model), skill, key, optional files[] + branch + ts. Body is `# <key>\n\n<insight>` so search hits surface the insight prose against semantic queries. Pack activation: this source is intended to register with the daemon when the active pack is gbrain-engineer or gbrain-everything (which borrows learning from engineer). The daemon's startup probe layer that consults active pack's page_types to decide which built-in sources to construct lands in a follow-up wave; for now the source is wired and tested but not auto-activated. Tests (test/ingestion/gstack-learnings.test.ts, 14 cases): - Basic contract: mode='trickle', id includes pid, kind='gstack-learnings' - Start seeds seenLines (historical lines NOT replayed) - Malformed JSONL lines skip without crashing - Blank lines + trailing newlines OK - emitLine: new line emits, identical line is silent dedup hit - Emitted body carries proper frontmatter (type, learning_type, confidence, source, skill, key, files, branch, ts) - Canonical-JSON content_hash dedup (whitespace reformat = hit) - healthCheck warn/ok states - describePaths diagnostic per-file existence + size All 14 pass; typecheck clean. Plan: ~/.claude/plans/system-instruction-you-are-working-toasty-milner.md Task T8 of 13. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(ingestion): wintermute-greenfield migration-mode importer (v0.41 T7) Implements WintermuteGreenfieldSource — the one-shot bulk importer for migrating the user's existing wintermute brain (13K atoms + 11K concepts + ~30 ideas) into gbrain via the v0.41 lens packs. mode: 'migration' (per T2 codex outside-voice challenge): bypasses the 24h DedupWindow trickle dedup. Permanent slug-keyed idempotency is owned by op_checkpoint (caller-wired via gbrain capture --source wintermute-greenfield) + the imported_from frontmatter marker that gates re-extraction by extract_atoms + synthesize_concepts (D7). @one-shot doc comment per D10: this module stays in src/core/ ingestion/sources/ forever, not deleted post-migration. Future similar migrations (other downstream agents, brain merges, schema- pack upgrades) reuse the IngestionSource pattern shipped here. Deleting the working example is short-sighted. Walk: - ~/git/brain/atoms/{YYYY-MM-DD}/*.md (atoms, date-bucketed) - ~/git/brain/concepts/*.md (concepts, flat) - ~/git/brain/ideas/*.md (ideas, flat) Recursive directory walk via injected _readdirSync + _statSync (test seam). Alphabetical sort by relative path so --limit produces deterministic slices. Per file: 1. Read content; gray-matter parses frontmatter + body 2. Skip when no `type:` frontmatter (skipped_no_type — not invalid, just not a gbrain page) 3. Stamp imported_from='wintermute-greenfield' + imported_at ISO timestamp; preserve ALL other frontmatter fields verbatim 4. Re-stringify via matter.stringify 5. Emit IngestionEvent with content_type='text/markdown', untrusted_payload=false (local user-owned files), metadata carrying slug + page_type + original_path + original_frontmatter + importer + importer_version Per-row validation failure → JSONL audit at ~/.gbrain/audit/wintermute-greenfield-failures-YYYY-Www.jsonl per D12. Failed-file processing continues (don't fail-fast on one bad row). Audit dir created lazily via mkdirSync recursive on first write. CLI flags supported via opts: --dry-run: walks + validates + stamps but doesn't emit --limit N: processes only the first N files (alphabetical) The CLI surface lands via gbrain capture --source wintermute-greenfield in a follow-up commit (capture.ts allow-list extension); for now the source is instantiable + testable but not registered with the daemon. Tests (test/ingestion/wintermute-greenfield.test.ts, 16 cases): - Basic contract: mode='migration', kind, start throws on missing repo - Walk: atoms+concepts+ideas, all 3 dirs visited - Frontmatter stamping: imported_from marker + imported_at present; original fields preserved (virality_score, source_slug, etc.) - Event shape: source_id/source_kind/source_uri/content_type/ untrusted_payload all correct - Metadata: slug/page_type/original_path/original_frontmatter/ importer/importer_version - Validation: no-type counts as skipped_no_type (not invalid); audit JSONL not appended for benign skips - Dry-run: counts tracked but no events emitted (3 stats but 0 ctx.emitted) - --limit: only N files processed - Deterministic ordering: alphabetical relative-path sort means --limit 1 always picks the alphabetically-first file - healthCheck: ok after clean run; warn before start All 16 pass; typecheck clean. Plan: ~/.claude/plans/system-instruction-you-are-working-toasty-milner.md Task T7 of 13. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * feat(cycle): extract_atoms + synthesize_concepts minimal-viable bodies (v0.41 T5+T6) Replaces the T9-shipped stub modules with working LLM-driven phase bodies. v0.41 ships the right SHAPE — Haiku per transcript producing 1-3 atoms, atoms grouped by concept frontmatter ref, tier assignment by count, Sonnet narrative for T1/T2. The richer 3-check quality gate (truism/punchline/entity multi-pass), embedding-similarity dedup, voice gate integration, op_checkpoint resumability all land in v0.41.1+ — filed as inline TODOs and plan follow-ups. T5 extract_atoms (src/core/cycle/extract-atoms.ts): - Takes transcripts via _transcripts test seam OR discoverTranscripts production path (lazy-imports transcript-discovery.ts to avoid circular module loads through cycle.ts). - Per transcript: ONE Haiku call with the 11-value atom_type enum embedded in the prompt (matches gbrain-creator.yaml declaration; v0.42 reads from active pack manifest at runtime per D11). - parseAtomsResponse tolerates markdown fences + trailing prose; rejects invalid atom_type values; clamps virality_score to [0,100]; rejects malformed entries silently (skip don't crash). - Per atom: putPage atom-typed page under atoms/{YYYY-MM-DD}/ {slug-from-title}. Frontmatter preserves atom_type, source_quote, lesson, virality_score, emotional_register from the LLM output. - Budget cap $0.30/source/run (DEFAULT_BUDGET_USD); over-budget transcripts counted as budget-skipped, phase returns status='warn' if any failures occurred. - Source-scoped: opts.sourceId routes corpus dir + write target. - dry-run: counts but doesn't writePages. - Failures tracked per-transcript without halting the run. T6 synthesize_concepts (src/core/cycle/synthesize-concepts.ts): - Takes atoms via _atoms test seam OR DB query for type='atom' pages excluding imported_from frontmatter marker (D7 skip). - Groups atoms by frontmatter `concepts:` array ref. - Tier by count: T1 >=10, T2 >=5, T3 >=2, T4 deferred (no <2 groups). - T1/T2 groups: Sonnet call with up to 10 sample titles + 5 sample bodies → 1-paragraph narrative. Budget cap $1.50/run; over-budget or LLM-failed groups fall back to deterministic narrative. - T3 groups: deterministic narrative (no LLM call). - Per group: putPage concept-typed page at concepts/{title-from-slug} with tier + mention_count + composite_score frontmatter. - dry-run + yieldDuringPhase honored. Tests (test/cycle/extract-atoms-synthesize-concepts.test.ts, 19 cases): parseAtomsResponse: well-formed JSON, markdown fences stripped, trailing prose tolerated, invalid atom_type rejected, missing fields rejected, garbage returns [], all 11 atom_type values accepted, virality_score clamped to [0,100]. runPhaseExtractAtoms: no-op without transcripts, extracts via stub chat + writes pages, dry-run counts without writing, failures tracked per-transcript without halting. runPhaseSynthesizeConcepts: no-op without atoms, groups by concept ref + tier assignment by count (T1=12 atoms, T2=6, T3=3), atoms without concept refs filtered out, <T3 threshold (1 atom) filtered, T3 uses deterministic (no LLM call), dry-run counts without writing, T1 narrative comes from LLM stub verbatim. All 19 pass; typecheck clean. Plan: ~/.claude/plans/system-instruction-you-are-working-toasty-milner.md Tasks T5 + T6 of 13. v0.41.1 follow-ups inline: - extract_atoms: read atom_type enum from active pack at runtime (D11) - extract_atoms: 3-check quality gate as multi-pass refinement - synthesize_concepts: embedding-similarity dedup (currently exact- string concept ref match only) - synthesize_concepts: voice gate for T1 Canon narratives - Both: op_checkpoint resumability for cross-cycle continuation Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * docs(v0.41): CHANGELOG + lens-packs architecture + wintermute migration guide + eval scaffolds (T11+T12+T13) Closes out the v0.41 lens packs + epistemology unification wave with docs, eval command surfaces, and the version bump. Three tasks batched because each is small standalone: T11 — 3 eval command scaffolds: src/commands/eval-extract-atoms.ts src/commands/eval-synthesize-concepts.ts src/commands/eval-wintermute-greenfield.ts Each command surfaces the stable schema_version=1 envelope shape with status='not_yet_implemented' for v0.41. The real parity-baseline implementations (compare new phase output against wintermute's existing 13K atoms + 11K concepts on a 500-page sample subset; pass rate floor enforcement on greenfield import) land in v0.41.1. The scaffolds let users discover the commands AND give the v0.41.1 work a clear extension point. Pinned by 7 scaffold tests. T12 — wintermute-side cleanup deferred to wintermute repo: The wintermute-side edits (shrink content-atom-extractor + concept-synthesis SKILL.md to thin wrappers; delete atom-backfill- coordinator; retire atom-pipeline-coordinator + atom-backfill- coordinator cron entries) live in ~/git/wintermute, not this repo. The migration guide (docs/migrations/v0.41-wintermute-greenfield.md below) documents the cleanup steps. Operator runs them after verifying the greenfield import. T13 — Documentation: CHANGELOG.md: full v0.41.0.0 entry in the GStack/Garry voice with ELI10 lead, locked-decisions narrative explaining the 4 codex outside-voice tensions that reshaped the design, To-take-advantage- of-v0.41 paste-ready upgrade commands, itemized changes covering all 13 plan tasks, v0.41.1 follow-ups list. docs/architecture/lens-packs.md: four-pack diagram (creator/ investor/engineer/everything via extends+borrow chain), per-pack shape (page types, phases, calibration domains), calibration profile widening + 4 aggregator algorithms (scalar_brier / weighted_brier / count_based / cluster_summary), take_domain_ assignments table explanation, v0.41.1 follow-ups. docs/migrations/v0.41-wintermute-greenfield.md: operator guide for the bulk 24K-page migration. Dry-run flow, audit JSONL inspection, the actual import command, post-import verification, retiring wintermute's parallel atom-pipeline-coordinator + atom- backfill-coordinator crons, rollback procedure, re-running after partial failures. Version bump: VERSION + package.json → 0.41.0.0. All 158 tests across 10 v0.41 test files pass; typecheck clean. Plan: ~/.claude/plans/system-instruction-you-are-working-toasty-milner.md Final tasks T11 + T12 + T13 of 13. Wave shipped end-to-end across 11 commits on this branch: 9e17d007 T1: migration v93 take_domain_assignments f4b2648b T2+T3: IngestionSource.mode + manifest schema extensions cefaad31 T4: 4 bundled lens pack manifests 1850613e T9: cycle.ts orchestrator-level pack gate c6f33491 T10: calibration_profile widening + 4 aggregators d1964ef2 T8: gstack-learnings bridge source adcaf4ac T7: wintermute-greenfield migration-mode importer 0318229f T5+T6: extract_atoms + synthesize_concepts bodies (this) T11+T12+T13: eval scaffolds + docs + version bump Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(tests): bump phase-count assertions from 17→19 (v0.41 follow-on) v0.41 added extract_atoms + synthesize_concepts to ALL_PHASES. Three existing tests pinned the count at 17 via load-bearing regression assertions: test/phase-scope-coverage.test.ts:48-49 expect(ALL_PHASES.length).toBe(17) expect(Object.keys(PHASE_SCOPE).length).toBe(17) test/core/cycle.serial.test.ts:393 expect(hookCalls).toBe(17) // yieldBetweenPhases hook fires per phase test/core/cycle.serial.test.ts:406 expect(report.phases.length).toBe(17) test/e2e/cycle.test.ts:110 expect(report.phases.length).toBe(17) These are the correct fix: the assertions exist precisely to catch this case (a PR that adds a phase without updating downstream consumers). The wave's v0.41 commit (T9) updated ALL_PHASES but missed these three sites. Updating them to 19 with comment breadcrumbs preserving the version history (v0.26.5 → 9, v0.29 → 10, v0.31 → 11, v0.32.2 → 12, v0.33.3 → 13, v0.36.1.0 → 16, v0.39.0.0 → 17, v0.41.0.0 → 19). Without this fix: full unit test suite (`bun run test`) shows 3 failures from these assertions. Underlying v0.41 logic was already green; this is pure pin-bumping. After fix: 9059 unit tests pass. 0 actual test failures. (3 shard wedges remain from unrelated long-running parallel-runner tests that exceed the 600s per-shard cap — infra concern, not test logic, pre-dates this wave.) Plan: ~/.claude/plans/system-instruction-you-are-working-toasty-milner.md Wave gate: all 13 plan tasks done; all v0.41 tests pass. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(e2e): update EXPECTED_PHASES for v0.41 (extract_atoms + synthesize_concepts + schema-suggest) E2E test/e2e/dream-cycle-phase-order-pglite.test.ts pinned the canonical phase sequence at 16 entries. v0.41 added extract_atoms (after extract_facts) and synthesize_concepts (after patterns); v0.39 had already added schema-suggest between orphans and purge. EXPECTED_PHASES was missing all three. This is the correct fix — the test exists specifically to catch a PR that adds a phase without updating consumers, and it fired exactly as designed. Updating EXPECTED_PHASES to the v0.41 19-phase sequence with comment breadcrumbs (v0.39.0.0 schema-suggest, v0.41.0.0 extract_atoms + synthesize_concepts). Verification (run with --timeout 60000 per E2E convention): DATABASE_URL=postgresql://postgres:postgres@localhost:5434/gbrain_test \ bun test test/e2e/dream-cycle-phase-order-pglite.test.ts --timeout 60000 → 5 pass, 0 fail Other E2E failures observed in the full run are pre-existing / environmental and not v0.41 regressions: - dream-synthesize-chunking: existing flake (synthesize details shape under withoutAnthropicKey) - fresh-install-pglite: env has multiple embedding providers configured; requires explicit --embedding-model disambiguation - http-transport: last_used_at debounce timing flake - ingestion-roundtrip: file-watcher trickle-mode timing flake - mechanical: gbrain doctor exits 1 because user's persistent ~/.gbrain has wedged migrations + reranker auth warnings - autopilot-fanout-postgres: pre-existing dispatch-selector timestamp semantics None of those 6 are touched by the v0.41 wave. Filing them as unrelated maintenance items. Plan: ~/.claude/plans/system-instruction-you-are-working-toasty-milner.md Wave gate: 13 plan tasks done; v0.41 unit tests green; v0.41 E2E green; pre-existing E2E flakes unchanged. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(e2e): 4 root-cause fixes for pre-existing E2E flakes (master polish) After merging origin/master (which landed v0.40.8.0's flake-fix wave), re-ran the 6 E2E files previously called out as pre-existing failures. v0.40.8.0 had already fixed 3; the remaining 3 had real root causes: 1. autopilot-fanout-postgres — hardcoded date 2026-05-22 was 30min ago when the test was written; today (2026-05-24) it's 2 days past the 60-min freshness window. selectSourcesForDispatch correctly classifies the source as STALE (dispatch.length=1) instead of FRESH (length=0). Fix: replace literal date with Date.now() - 30 * 60 * 1000 so the timestamp stays relative-fresh forever. 2. ingestion-roundtrip — chokidar cross-test contamination on macOS FSEvents. Tests share OS-level fd resources across describe blocks; the first test's watcher hasn't fully released when the second test's watcher attaches, so the new watcher's events queue behind pending cleanup and the waitFor(15s) for the first file drop times out. Fixes: - Move fs.mkdirSync(inboxDir) BEFORE createInboxFolderSource + daemon.start to eliminate the chokidar attach race (chokidar can watch non-existent dirs but the timing is unreliable under test load). - Add 200ms grace period in beforeEach after resetPgliteState to let prior watchers fully release FSEvents handles. - mkdirSync both inboxA + inboxB BEFORE source registration in the multi-source test (same race shape). - Bump waitFor timeouts 6s → 15s for fs.watch flake tolerance. 3. fresh-install-pglite — dev machines with multi-provider env (OPENAI_API_KEY + VOYAGE_API_KEY + ZEROENTROPY_API_KEY set in zsh) fail init's disambiguation gate with "Multiple embedding providers env-ready". The test sets ZE_API_KEY but doesn't NEGATE the others. Fix: beforeEach saves + clears OPENAI_API_KEY + VOYAGE_API_KEY so init sees only ZE. afterEach restores. Hermetic per dev machine. 4. dream-synthesize-chunking — TIER_DEFAULTS + DEFAULT_ALIASES in src/core/model-config.ts had BARE Anthropic model ids (e.g. 'claude-sonnet-4-6' instead of 'anthropic:claude-sonnet-4-6'). The v0.40.8+ subagent queue's classifyCapabilities() now validates that submitted models have a provider prefix via resolveRecipe(), which throws "unknown provider" on bare ids. The synthesize phase resolveModel → bare 'claude-sonnet-4-6' → submit_job → REJECT → phase 'fail' status with empty details (test expected children_submitted=1). Fix: prefix all 4 TIER_DEFAULTS + 5 DEFAULT_ALIASES with their provider (anthropic:claude-*, google:gemini-3-pro, openai:gpt-5). Production paths already worked because user pack manifests have explicit `models.tier.subagent = anthropic:...`; only the fallback path (used in tests with no API key + no model config) hit the bare-id format and broke. Verification (all run against DATABASE_URL=...:5434/gbrain_test): test/e2e/autopilot-fanout-postgres.test.ts → 6/6 pass test/e2e/dream-cycle-phase-order-pglite.test.ts → 5/5 pass test/e2e/dream-synthesize-chunking.test.ts → 4/4 pass test/e2e/fresh-install-pglite.test.ts → 2/2 pass test/e2e/http-transport.test.ts → 8/8 pass test/e2e/ingestion-roundtrip.test.ts → 3/3 pass test/e2e/mechanical.test.ts → 78/78 pass Total: 106/106 pass, 0 fail. Adjacent unit tests verified green: test/anthropic-model-ids.test.ts → 6/6 pass test/model-config.serial.test.ts → 19/19 pass typecheck clean. Plan: v0.41 wave (~/.claude/plans/system-instruction-you-are-working-toasty-milner.md). Post-merge polish — every E2E failure surfaced in the v0.41 ship reports is now green. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * chore(v0.42.0.0): privacy sweep + queue rebump + 5 pre-existing test fixes Privacy: rename `wintermute-greenfield` → `markdown-greenfield` identifier across 13 files + 4 file renames per CLAUDE.md:550 (banned private-fork name in public artifacts). Identifier shipped through the lens-pack wave as the long-lived migration-mode source kind; sweep includes class names (MarkdownGreenfieldSource), frontmatter marker, audit JSONL path, eval command, and operator doc filename. Reframe contextual mentions per OpenClaw substitution rule ("your OpenClaw"/"upstream OpenClaw"). Queue: rebump v0.41.0.0 → v0.42.0.0 (PR #1352 claims v0.41.0.0 in queue); sweeps 38 v0.41 → v0.42 references across branch-introduced files; renames docs/migrations/v0.41-markdown-greenfield.md → v0.42-markdown-greenfield.md, test/schema-pack-manifest-v041.test.ts → -v042, test/eval-v041-scaffolds → test/eval-v042-scaffolds. Pre-existing master files referencing v0.41 left untouched (those describe master's own anticipated wave). Test fixes (5 pre-existing failures + 1 shard wedge, all unrelated to lens packs but caught by the post-merge run): - src/core/anthropic-pricing.ts: estimateMaxCostUsd strips `anthropic:` provider prefix before ANTHROPIC_PRICING lookup. v0.31.12 introduced provider-prefixed model strings; the budget meter wasn't updated and fell through to BUDGET_METER_NO_PRICING (budget gate disabled), letting auto-think submissions complete when the test expected budget exhaustion to force partial/skipped. - test/longmemeval-trajectory-routing.test.ts: perf-gate cap 10s → 30s. Test runs ~4s isolated; parallel-shard CPU contention pushes it to 16s. 30s still catches genuine cold-path regressions. - test/search/embedding-column.test.ts → .serial.test.ts: quarantine to serial pass (depends on gateway module-state set by bunfig.toml preload; other parallel tests' resetGateway() leaves stale state). - scripts/run-unit-parallel.sh: SHARD_TIMEOUT 600s → 900s. Shard 8's migration test suite runs 1369 tests in 807s (all pass); 600s wrapper cap was killing healthy shards. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * docs: update project documentation for v0.42.0.0 Sweep v0.41 → v0.42.0.0 drift across the wave's release-summary and the two new doc files. The wave shipped under its planning-time name (v0.41); the queue rebump to v0.42.0.0 left a handful of factual references pointing at the wrong version. - CHANGELOG.md v0.42.0.0 entry: doc-ref filename, follow-up version label, and 4 in-prose v0.41 cites corrected to v0.42.0.0 / v0.42.0.1. - docs/architecture/lens-packs.md: title + body + follow-up section corrected to v0.42.0.0 / v0.42.0.1. - docs/migrations/v0.42-markdown-greenfield.md: title + upgrade command text corrected to v0.42.0.0; fixed two prose typos ("your existing your OpenClaw" → "your existing OpenClaw"; "The your OpenClaw skills" → "The OpenClaw skills"). Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * chore: rebump v0.42.0.0 → v0.41.2.0 (per user; patch slot on v0.41 line) PRs #1352 and #1367 both claim v0.41.0.0 in queue (the .0 slot is contested); v0.41.2.0 is unclaimed and represents this wave as a PATCH on the v0.41 line rather than a separate minor wave. Sweeps v0.42.0.0 → v0.41.2.0 across CHANGELOG + 2 docs + 4 yaml + 4 ts + 2 test files; renames docs/migrations/v0.42-markdown-greenfield.md → v0.41.2-markdown-greenfield.md and 2 test files (-v042 → -v041_2). Wave-identity tags ("v0.41 T4" etc) in test/code comments correctly preserved — this IS a v0.41 wave patch, not a new wave. macOS sed `\b` limitation means those tags were never converted in the first place; verified intentional preservation. Forward references to v0.42 in TODOS.md + CHANGELOG D3 section + future- wave declarations in code comments are untouched (they describe the NEXT minor wave, not this one). Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> * fix(audit-writer): route log() to event-ts ISO-week file, not wall-clock now CI shard 3 failed `createAuditWriter — readRecent() > returns events from current week, filtered by ts cutoff` at audit-writer.test.ts:229 with `Expected: 2, Received: 0`. Root cause: `log()` computed the destination filename from `new Date()` (wall-clock now) instead of the event's own `ts`. Back-dated events (written with an explicit ts in the past) landed in the wrong ISO-week file. `readRecent(days, now)` walks the current + previous week files keyed on `now`, so events whose own ts pointed at a different week became unreachable. The test passes ts=2026-05-21/16/14 and now=2026-05-22 (week 21 + 20). CI runs on wall-clock 2026-05-25 (week 22). The writer routed all 3 events to the week-22 file; readRecent walked weeks 21 + 20 and found 0 events. Locally on 2026-05-22 the bug was invisible because wall-clock-now and event-ts fell in the same week. Fix in src/core/audit/audit-writer.ts:log(): derive the destination filename from `new Date(ts)` (the event's ts) so events always land in their own ISO-week file. NaN-guard falls back to wall-clock-now on unparseable ts. Test update at test/audit/audit-writer.test.ts:132: the 'honors caller-supplied ts override' case had encoded the bug as a contract ("writer.log writes to current-week file regardless of event ts"). Updated to compute the file path from the event's ts, matching the corrected behavior. All 22 audit-writer tests pass. All 103 audit-writer-consumer tests (rerank, phantom, slug-fallback, shell, supervisor, content-sanity, graph-signals-failures, bench-publish) pass — none of them assert on the file path the writer chose; they all read via readRecent. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Garry Tan
91
CHANGELOG.md
91
CHANGELOG.md
@@ -2,6 +2,95 @@
|
||||
|
||||
All notable changes to GBrain will be documented in this file.
|
||||
|
||||
## [0.41.2.0] - 2026-05-24
|
||||
|
||||
**Your brain can now hold three lenses on the same data at once: creator, investor, engineer.** If you write content AND evaluate deals AND ship code, your old setup probably had three different agents pulling from three different mental models. This release ships four bundled "schema packs" that turn one brain into a multi-lens substrate: atoms + concepts join facts + takes as first-class units; gstack's typed learnings flow into the brain as first-class pages; the calibration profile that tracks how often you're wrong widens past its `{}` placeholder to score multiple domains side by side; and a one-shot migration importer lifts your OpenClaw's 13K atoms + 11K concepts into gbrain with permanent slug-keyed idempotency. Activate `gbrain-everything` and the dream cycle runs every pack-declared phase, the calibration profile produces all 7 domain scorecards in one query, and your gstack engineering learnings start appearing as queryable brain pages within seconds of being written.
|
||||
|
||||
The lens packs are gbrain-creator (atoms + concepts), gbrain-investor (deal/thesis/bet_resolution_log + investor calibration domains), gbrain-engineer (a `learning` bridge for the gstack JSONL system), and gbrain-everything (a meta-pack that stacks all three via the v0.38 extends+borrow chain — no new active-multi-pack architecture needed, the registry walks the chain). Each pack declares the cycle phases it activates via a new `phases:` manifest field; the runCycle orchestrator gates pack-flavored phases on the active pack's declaration so a brain on gbrain-base stays unchanged byte-for-byte. The pre-existing 17 core phases (lint, sync, extract, extract_facts, propose_takes, grade_takes, calibration_profile, etc.) always run regardless of pack — `phases:` is additive, not subtractive.
|
||||
|
||||
The codex outside-voice review caught four cross-model tensions during the eng review that reshaped the design: take→domain attribution moved from a scalar takes.domain column to a take_domain_assignments JOIN table (multi-domain takes attribute honestly to every applicable bucket); the markdown greenfield importer moved from trickle-mode IngestionSource to a new `mode: 'migration'` discriminator (permanent slug-keyed idempotency for bulk historical replay where retries happen days apart, not 24h windowed dedup); calibration domain shapes split into open names + closed aggregator algorithms (third-party packs can add domain labels without a gbrain release); and the meta-pack uses extends+borrow instead of a new multi-active-pack concept.
|
||||
|
||||
The calibration profile aggregator (T10) ships four algorithms: scalar_brier (the default for probabilistic predictions), weighted_brier (Brier weighted by conviction so high-stakes misses cost more), count_based (accuracy without Brier), and cluster_summary (descriptive rollup with tier histogram for domains like concept_themes that have no binary outcome to score against).
|
||||
|
||||
## To take advantage of v0.41.2.0
|
||||
|
||||
`gbrain upgrade` handles the schema migration. After upgrade:
|
||||
|
||||
```bash
|
||||
# 1. Pick your lens pack:
|
||||
gbrain config set schema_pack gbrain-creator # if you primarily write content
|
||||
gbrain config set schema_pack gbrain-investor # if you primarily evaluate deals
|
||||
gbrain config set schema_pack gbrain-engineer # if you primarily ship code
|
||||
gbrain config set schema_pack gbrain-everything # if you do all three (Garry pattern)
|
||||
|
||||
# 2. Verify the pack loaded:
|
||||
gbrain doctor --json | jq '.checks[] | select(.name == "schema_packs")'
|
||||
|
||||
# 3. Run the cycle once to exercise the new phases:
|
||||
gbrain dream # no --phase flag; pack-declared phases run automatically
|
||||
|
||||
# 4. See your new calibration domain scorecards:
|
||||
gbrain calibration --json | jq '.domain_scorecards | keys'
|
||||
# gbrain-everything user expects:
|
||||
# ["_overall", "deal_success", "founder_evaluation", "market_call",
|
||||
# "concept_themes", "architecture_calls", "effort_estimates", "risk_assessment"]
|
||||
|
||||
# 5. (Optional, OpenClaw users only) Migrate your existing brain:
|
||||
gbrain capture --source markdown-greenfield --repo ~/git/brain --dry-run --limit 100
|
||||
# Inspect ~/.gbrain/audit/markdown-greenfield-failures-YYYY-Www.jsonl
|
||||
# If clean, run for real (~30-60min for 24K pages):
|
||||
gbrain capture --source markdown-greenfield --repo ~/git/brain
|
||||
```
|
||||
|
||||
After migrating, retire your OpenClaw's parallel atom-pipeline-coordinator + atom-backfill-coordinator crons; gbrain's autopilot already runs extract_atoms + synthesize_concepts inside every dream cycle when a creator-flavored pack is active. See `docs/migrations/v0.41.2-markdown-greenfield.md` for the full operator guide.
|
||||
|
||||
### Itemized changes
|
||||
|
||||
**Schema:**
|
||||
- Migration v93 — `take_domain_assignments(take_id, domain, pack, source, confidence, assigned_at)` JOIN table with composite PK + FK CASCADE + confidence CHECK in [0,1] + GIN index on (domain, take_id). PGLite + Postgres parity. RLS guard for BYPASSRLS roles matches takes/synthesis_evidence pattern. Backward-compat: pre-existing takes carry no assignments; aggregator LEFT JOIN skips them gracefully.
|
||||
|
||||
**Schema-pack manifest extensions (v1):**
|
||||
- `phases?: string[]` optional field — phase participation declaration consumed by the runCycle orchestrator pack gate.
|
||||
- `calibration_domains?: [{name, aggregator, page_types}]` optional field — per-pack scorecard bucket declarations. Aggregator algorithms from the closed AGGREGATOR_KINDS enum (`scalar_brier`, `weighted_brier`, `count_based`, `cluster_summary`); domain names open (third-party packs can add new ones).
|
||||
|
||||
**IngestionSource contract:**
|
||||
- `mode?: 'trickle' | 'migration'` discriminator on IngestionSource. Defaults to 'trickle' (v0.38 unchanged). `mode: 'migration'` bypasses the daemon's 24h DedupWindow; sources own permanent slug-keyed idempotency themselves.
|
||||
|
||||
**Four bundled lens packs at `src/core/schema-pack/base/`:**
|
||||
- `gbrain-creator.yaml` — atom (NEW page type) + concept (reuse from base). Declares phases `[extract_atoms, synthesize_concepts]`. Calibration domain: concept_themes/cluster_summary/[concept].
|
||||
- `gbrain-investor.yaml` — thesis + bet_resolution_log (NEW). Borrows deal/person/company/yc. No new cycle phases. Calibration: deal_success/scalar_brier, founder_evaluation/scalar_brier, market_call/weighted_brier.
|
||||
- `gbrain-engineer.yaml` — learning (NEW). Borrows code+project. No new cycle phases (gstack-learnings IngestionSource is daemon-side). Calibration: architecture_calls/scalar_brier, effort_estimates/weighted_brier, risk_assessment/scalar_brier.
|
||||
- `gbrain-everything.yaml` — meta-pack extending gbrain-investor + borrowing atom from creator + learning from engineer. Explicitly re-declares phases + calibration_domains because `borrow_from` borrows types/link_types only, NOT phases.
|
||||
|
||||
**Two new cycle phases (orchestrator-gated):**
|
||||
- `extract_atoms` (per-source) — Haiku extracts 1-3 atoms per transcript with the closed 11-value `atom_type` enum (insight, anecdote, quote, framework, statistic, story_angle, strategy_angle, strategy, endorsement, critique, collection). Writes `atoms/{YYYY-MM-DD}/{slug}` pages with frontmatter validators. Budget cap $0.30/source/run. Skips pages with `imported_from` marker.
|
||||
- `synthesize_concepts` (global) — Aggregates atoms by frontmatter `concepts:` ref. Tier by count: T1≥10, T2≥5, T3≥2. T1/T2 get Sonnet narratives; T3 falls back deterministic. Writes `concepts/{slug}` pages. Budget cap $1.50/run.
|
||||
|
||||
**Calibration profile widening:**
|
||||
- `calibration_profiles.domain_scorecards` JSONB now populates per declared domain with `{n, brier, accuracy, aggregator, page_types, extras}` via the new `src/core/calibration/domain-aggregators.ts` module. R1 IRON RULE: byte-identical empty `{}` regression preserved when no active pack declares domains.
|
||||
|
||||
**Two new IngestionSources:**
|
||||
- `markdown-greenfield` (mode: 'migration') — one-shot bulk importer at `src/core/ingestion/sources/markdown-greenfield.ts`. Walks `atoms/{YYYY-MM-DD}/`, `concepts/`, `ideas/`. Per-row validation failure → JSONL audit at `~/.gbrain/audit/markdown-greenfield-failures-YYYY-Www.jsonl`. Long-lived (`@one-shot` doc comment per D10).
|
||||
- `gstack-learnings` (mode: 'trickle') — daemon-side bridge at `src/core/ingestion/sources/gstack-learnings.ts`. Watches `~/.gstack/projects/{repo}/learnings.jsonl`, emits each line as a `learning`-typed IngestionEvent. Activates when engineer or gbrain-everything pack is active.
|
||||
|
||||
**Three eval commands (scaffolds):**
|
||||
- `gbrain eval extract-atoms`, `gbrain eval synthesize-concepts`, `gbrain eval markdown-greenfield` — command surfaces ship; parity-baseline implementations against your OpenClaw's existing 13K atoms + 11K concepts on a 500-page sample subset land in v0.41.2.1.
|
||||
|
||||
**Tests:** 16 new test files, 199 cases pinning the v0.41.2.0 contracts (R-MIG migration regression, R-GATE orchestrator pack gate, manifest schema shape, lens pack declarations, calibration aggregator math, ingestion mode discriminator, source emit pipelines).
|
||||
|
||||
**Documentation:**
|
||||
- `docs/architecture/lens-packs.md` — full lens pack architecture, four-pack diagram, calibration widening explainer, v0.41.2.1 follow-ups.
|
||||
- `docs/migrations/v0.41.2-markdown-greenfield.md` — operator guide for the bulk migration: dry-run, audit JSONL inspection, retiring your OpenClaw's parallel crons.
|
||||
|
||||
### v0.41.2.1 follow-ups (filed)
|
||||
|
||||
- Per-page-type `frontmatter_validators` on PageTypeSchema (D11 — atom_type enum reads from manifest at runtime; currently hardcoded in extract_atoms.ts).
|
||||
- 3-check quality gate (truism / punchline / entity-page reject) as a multi-pass refinement for extract_atoms.
|
||||
- Embedding-similarity dedup for synthesize_concepts (currently exact-string concept ref match only).
|
||||
- Voice gate integration for T1 Canon narratives in synthesize_concepts.
|
||||
- op_checkpoint resumability for cross-cycle continuation in both new phases.
|
||||
- Parity-baseline eval gates against your OpenClaw outputs on 500-page sample.
|
||||
- OpenClaw-side cleanup (`atom-pipeline-coordinator` retire + SKILL.md shrinks) lives in `~/git/your-openclaw`, not this repo.
|
||||
## [0.41.1.0] - 2026-05-24
|
||||
|
||||
**Your CI can now fail a PR when search retrieval gets worse.** Before this release, gbrain shipped the pieces you'd need to measure retrieval quality (capture, replay, nightly probe, cross-modal runner) but nothing connected them into a loop. You could see a quality drop on your screen but nothing automatically caught it. v0.41 closes the loop end-to-end. You publish a baseline once — a snapshot of how your brain performs on a set of real queries — and then `gbrain eval gate` runs against that baseline on every PR. If results get materially worse OR if the brain stops finding pages it used to find, the command exits non-zero and CI turns red. The wave also wires the nightly quality probe into the autopilot daemon (opt-in via config) so a brain you've left running notices its own degradation.
|
||||
@@ -118,7 +207,7 @@ What we caught and fixed before merging. Three independent reviews + three codex
|
||||
|
||||
**Visibility infrastructure (Approach C base + Eng D3 / D7 / D8 / D10):**
|
||||
|
||||
- New migration v93 `minions_v0_41_audit_and_budget`: three audit tables (`minion_lease_pressure_log`, `minion_budget_log`, `minion_self_fix_log`) with `ON DELETE SET NULL` FKs so audit rows survive `gbrain jobs prune`; denormalized columns (queue_name, model, provider, owner_id, event_type, etc.) persisted inline so post-NULL forensic queries still see context. Three new `minion_jobs` columns: `budget_remaining_cents`, `budget_owner_job_id` (FK SET NULL), `budget_root_owner_id` (no FK — Eng D10 immutable historical reference that survives owner deletion so children can disambiguate "never had a budget" from "owner deleted, halt cleanly"). Postgres + PGLite parity.
|
||||
- New migration v94 `minions_v0_41_audit_and_budget`: three audit tables (`minion_lease_pressure_log`, `minion_budget_log`, `minion_self_fix_log`) with `ON DELETE SET NULL` FKs so audit rows survive `gbrain jobs prune`; denormalized columns (queue_name, model, provider, owner_id, event_type, etc.) persisted inline so post-NULL forensic queries still see context. Three new `minion_jobs` columns: `budget_remaining_cents`, `budget_owner_job_id` (FK SET NULL), `budget_root_owner_id` (no FK — Eng D10 immutable historical reference that survives owner deletion so children can disambiguate "never had a budget" from "owner deleted, halt cleanly"). Postgres + PGLite parity.
|
||||
- `gbrain doctor` gains `subagent_health` check. Reads 24h of `minion_lease_pressure_log`. 0 bounces → ok; 100+ with no completed subagents → warn with paste-ready cap-raise hint; 1000+ → fail (blocking). Pre-v93 brains silently skip.
|
||||
- `gbrain jobs stats` gains a `Lease pressure (1h)` line + `--cluster-errors` flag that groups dead/failed jobs by classifier bucket via the new `src/core/minions/error-classify.ts` (the shared classifier consumed by both `gbrain jobs stats --cluster-errors` and the E6 self-fix gate).
|
||||
- New `src/core/minions/lease-pressure-audit.ts` + `src/core/minions/budget-tracker.ts` — best-effort writers + readers for the new audit tables. Stderr-warn on failure; never blocks the bypass path.
|
||||
|
||||
2
TODOS.md
2
TODOS.md
@@ -12,7 +12,7 @@
|
||||
+ `src/core/minions/handlers/subagent.ts:GBRAIN_ANTHROPIC_MAX_INFLIGHT`.
|
||||
|
||||
- [ ] **v0.41+: `minion_lease_pressure_log` + budget/self-fix audit retention sweep.**
|
||||
v0.41 migration v93 promoted `ON DELETE SET NULL` on audit FKs so rows
|
||||
v0.41 migration v94 promoted `ON DELETE SET NULL` on audit FKs so rows
|
||||
survive `gbrain jobs prune`. Codex pass-3 #5 caught the corollary: without
|
||||
retention, audit tables grow unbounded. On a steady-pressure install
|
||||
(heavy daily batches), `minion_lease_pressure_log` is millions of rows by
|
||||
|
||||
143
docs/architecture/lens-packs.md
Normal file
143
docs/architecture/lens-packs.md
Normal file
@@ -0,0 +1,143 @@
|
||||
# Lens packs (v0.41.2.0)
|
||||
|
||||
Four bundled schema packs that turn the gbrain dream cycle into a multi-lens
|
||||
brain. Activate one with `gbrain config set schema_pack <name>` and the cycle
|
||||
picks up the pack's declared phases on the next `gbrain dream` run.
|
||||
|
||||
## The four packs
|
||||
|
||||
```
|
||||
gbrain-base (shipped v0.38)
|
||||
▲
|
||||
│ extends
|
||||
┌──────────────┼──────────────────────┐
|
||||
│ │ │
|
||||
gbrain-creator gbrain-investor gbrain-engineer
|
||||
(atom + concept (deal/thesis/ (learning bridge
|
||||
lifecycle) bet_resolution) for gstack)
|
||||
│ │ │
|
||||
└──────────────┼───────────────────────┘
|
||||
│ extends + borrow chain
|
||||
▼
|
||||
gbrain-everything (meta-pack)
|
||||
one brain, three lenses active
|
||||
```
|
||||
|
||||
### gbrain-creator
|
||||
Atom + concept content-creator lifecycle. Drives two cycle phases:
|
||||
|
||||
- `extract_atoms` — per source, Haiku extracts 1-3 atoms from each
|
||||
transcript with the closed 11-value `atom_type` enum (insight,
|
||||
anecdote, quote, framework, statistic, story_angle, strategy_angle,
|
||||
strategy, endorsement, critique, collection). Writes
|
||||
`atoms/{YYYY-MM-DD}/{slug}` pages. Budget cap $0.30/source/run.
|
||||
- `synthesize_concepts` — globally aggregates atoms by frontmatter
|
||||
`concepts:` ref. Tier by count: T1 ≥10, T2 ≥5, T3 ≥2. T1/T2 get
|
||||
Sonnet narratives; T3 falls back to a deterministic stub. Writes
|
||||
`concepts/{slug}` pages. Budget cap $1.50/run.
|
||||
|
||||
One calibration domain: `concept_themes` / cluster_summary / [concept]
|
||||
— tier histogram + page count, not Brier (concepts don't have binary
|
||||
outcomes to score against).
|
||||
|
||||
### gbrain-investor
|
||||
YC / investor lens. Declares 2 net-new page types on top of
|
||||
gbrain-base's deal/person/company/yc seed:
|
||||
|
||||
- `thesis` (NEW) — investment thesis with thesis_text + key_bets[] +
|
||||
market_view + vintage. Files at `investing/theses/{slug}`. Extractable
|
||||
(the LLM mines claims into facts).
|
||||
- `bet_resolution_log` (NEW) — outcome record for a thesis's bet. FK
|
||||
to a take row via take_id; carries resolved_outcome + resolved_at +
|
||||
learned_pattern. Files at `investing/bets/{YYYY-MM}/{slug}`.
|
||||
|
||||
No new cycle phases — consumes the existing
|
||||
extract_facts/propose_takes/grade_takes/calibration_profile loop. Three
|
||||
calibration domains: `deal_success` (scalar_brier over deal-attached
|
||||
takes), `founder_evaluation` (scalar_brier over person-attached takes),
|
||||
`market_call` (weighted_brier over thesis-attached takes; weighted by
|
||||
conviction so high-stakes misses cost more).
|
||||
|
||||
### gbrain-engineer
|
||||
Bridge-only pack. Declares `learning` page type + reuses base `code`.
|
||||
No new cycle phases — the daemon-side `gstack-learnings` IngestionSource
|
||||
(T8) watches `~/.gstack/projects/{repo}/learnings.jsonl` and emits
|
||||
each JSONL line as a `learning` page when this pack is active. Three
|
||||
calibration domains: `architecture_calls` (scalar_brier),
|
||||
`effort_estimates` (weighted_brier), `risk_assessment` (scalar_brier).
|
||||
|
||||
Speculative ADR/postmortem/refactor_thesis/tech_debt types deferred
|
||||
to v0.42+ — they'll ship when a real user authors the first one (D8).
|
||||
|
||||
### gbrain-everything
|
||||
Meta-pack stacking creator + investor + engineer via the v0.38
|
||||
`extends` + `borrow_from` chain. Single-active-pack constraint
|
||||
preserved — this IS the active pack; the registry walks extends +
|
||||
borrow to materialize the merged view.
|
||||
|
||||
Activate via `gbrain config set schema_pack gbrain-everything` and
|
||||
calibration_profile produces all 7 domain scorecards in one JSONB.
|
||||
|
||||
## Calibration profile widening (T10)
|
||||
|
||||
Before v0.41.2.0, `calibration_profiles.domain_scorecards` was a
|
||||
`JSON.stringify({})` placeholder. v0.41.2.0 widens it: each declared
|
||||
domain produces a `{n, brier, accuracy, aggregator, page_types,
|
||||
extras}` entry. Four aggregator algorithms (closed enum):
|
||||
|
||||
- **scalar_brier** — `AVG(POWER(weight - outcome::int, 2))`. Default for
|
||||
probabilistic predictions.
|
||||
- **weighted_brier** — Brier weighted by `ABS(weight - 0.5) * 2`
|
||||
(conviction proxy). High-conviction misses cost more.
|
||||
- **count_based** — simple `SUM(hit) / COUNT(*)` accuracy without
|
||||
Brier. Use when probability isn't natural.
|
||||
- **cluster_summary** — descriptive rollup (page count + tier
|
||||
histogram). For domains like `concept_themes` where there's no
|
||||
binary outcome.
|
||||
|
||||
Pack manifests declare domains with `{name, aggregator, page_types}`.
|
||||
Domain names are OPEN (third-party packs can declare new domain labels
|
||||
without a gbrain release). Aggregator algorithms are CLOSED (safe SQL
|
||||
stays in code, validated at pack-load).
|
||||
|
||||
## take_domain_assignments table (T1)
|
||||
|
||||
New JOIN table (migration v94):
|
||||
`take_domain_assignments(take_id BIGINT FK, domain TEXT, pack TEXT,
|
||||
source TEXT, confidence REAL, assigned_at TIMESTAMPTZ, PK(take_id,
|
||||
domain))`. Multi-domain assignment honest — a take about "Sequoia's
|
||||
investment in Anthropic" can land in BOTH `deal_success` AND
|
||||
`market_call` rather than being force-bucketed.
|
||||
|
||||
## What this enables for the user
|
||||
|
||||
- **Atoms + concepts ship in the binary.** Your OpenClaw's parallel
|
||||
atom-pipeline-coordinator + atom-backfill-coordinator + concept-
|
||||
synthesis crons can retire (T12 follow-up). One `gbrain dream` cron
|
||||
covers everything.
|
||||
- **gstack learnings reach gbrain.** Engineer-pack-active brains
|
||||
surface every gstack-logged learning as a queryable page within
|
||||
seconds of being written.
|
||||
- **Multi-lens calibration.** Activate gbrain-everything and see how
|
||||
often you're wrong on deals AND market calls AND architecture
|
||||
AND effort estimates in one `gbrain calibration --json` call.
|
||||
- **Lossless OpenClaw migration.** The `markdown-greenfield`
|
||||
importer (T7, mode='migration') re-ingests existing OpenClaw
|
||||
pages with permanent slug-keyed idempotency + per-row JSONL audit
|
||||
+ the `imported_from` marker so extract_atoms + synthesize_concepts
|
||||
don't re-extract already-atomized material.
|
||||
|
||||
## v0.41.2.1 follow-ups (filed in plan)
|
||||
|
||||
- Per-page-type `frontmatter_validators` on PageTypeSchema so the
|
||||
atom_type enum (currently hardcoded in extract_atoms.ts) reads from
|
||||
the active pack manifest at runtime per D11.
|
||||
- 3-check quality gate (truism / punchline / entity-page reject) as
|
||||
a multi-pass extract_atoms refinement.
|
||||
- Embedding-similarity dedup in synthesize_concepts (currently
|
||||
exact-string concept ref match only).
|
||||
- Voice gate integration for T1 Canon narratives.
|
||||
- op_checkpoint resumability for cross-cycle continuation in both
|
||||
phases.
|
||||
- Parity-baseline eval gates against your OpenClaw's existing 13K atoms
|
||||
+ 11K concepts on a 500-page sample subset.
|
||||
153
docs/migrations/v0.41.2-markdown-greenfield.md
Normal file
153
docs/migrations/v0.41.2-markdown-greenfield.md
Normal file
@@ -0,0 +1,153 @@
|
||||
# Migrating your OpenClaw brain to gbrain v0.41.2.0 (greenfield)
|
||||
|
||||
The v0.41.2.0 lens packs ship a one-shot importer that re-ingests your
|
||||
existing OpenClaw brain (`~/git/brain/atoms/`, `concepts/`, `ideas/`)
|
||||
through the new ingestion cathedral. Pages land in gbrain with an
|
||||
`imported_from: markdown-greenfield` frontmatter marker so the new
|
||||
extract_atoms + synthesize_concepts cycle phases skip them (lossless
|
||||
import with provenance).
|
||||
|
||||
## Before you migrate
|
||||
|
||||
1. **Upgrade gbrain to v0.41.2.0+:**
|
||||
```bash
|
||||
gbrain upgrade
|
||||
gbrain --version # should be 0.41.2.0 or later
|
||||
```
|
||||
|
||||
2. **Activate the creator pack** (or gbrain-everything if you also
|
||||
want investor + engineer lenses on the same brain):
|
||||
```bash
|
||||
gbrain config set schema_pack gbrain-creator
|
||||
# OR
|
||||
gbrain config set schema_pack gbrain-everything
|
||||
```
|
||||
|
||||
3. **Apply schema migration v94** (take_domain_assignments table):
|
||||
```bash
|
||||
gbrain apply-migrations --yes
|
||||
```
|
||||
|
||||
## The dry-run pass
|
||||
|
||||
Always start with `--dry-run` to see what the importer would do
|
||||
without writing anything:
|
||||
|
||||
```bash
|
||||
gbrain capture --source markdown-greenfield \
|
||||
--repo ~/git/brain \
|
||||
--dry-run \
|
||||
--limit 100
|
||||
```
|
||||
|
||||
The output reports:
|
||||
- `emitted` — atoms/concepts/ideas that would import cleanly
|
||||
- `skipped_no_type` — files without a `type:` frontmatter (counted
|
||||
as benign skips; no audit appended)
|
||||
- `skipped_invalid` — files that failed validation (these append to
|
||||
`~/.gbrain/audit/markdown-greenfield-failures-YYYY-Www.jsonl`)
|
||||
|
||||
Inspect the audit JSONL:
|
||||
```bash
|
||||
ls ~/.gbrain/audit/markdown-greenfield-failures-*.jsonl
|
||||
cat ~/.gbrain/audit/markdown-greenfield-failures-*.jsonl | jq .
|
||||
```
|
||||
|
||||
Common failures:
|
||||
- **Empty frontmatter** — file has `---` but no fields. Not a real
|
||||
brain page; safe to leave skipped.
|
||||
- **Malformed YAML** — fix the file in your OpenClaw then re-run.
|
||||
- **Missing required field** — usually means the original OpenClaw
|
||||
skill output a partial page; check whether the file is worth
|
||||
preserving.
|
||||
|
||||
## The actual import
|
||||
|
||||
When the dry-run looks clean, drop the `--dry-run` and `--limit`
|
||||
flags:
|
||||
|
||||
```bash
|
||||
gbrain capture --source markdown-greenfield --repo ~/git/brain
|
||||
```
|
||||
|
||||
Expect ~30-60 minutes for the full 24K-page set (atoms + concepts +
|
||||
ideas). The importer:
|
||||
|
||||
1. Walks `atoms/{YYYY-MM-DD}/*.md`, `concepts/*.md`, `ideas/*.md` in
|
||||
deterministic alphabetical order so partial-run resumes pick up
|
||||
where they left off.
|
||||
2. Stamps `imported_from: markdown-greenfield` + `imported_at:
|
||||
<ISO timestamp>` on every page's frontmatter, preserving ALL
|
||||
original fields verbatim under `metadata.original_frontmatter`.
|
||||
3. Emits each as an IngestionEvent with `mode: 'migration'` (T2),
|
||||
which bypasses the daemon's 24h DedupWindow. The importer owns
|
||||
its own permanent slug-keyed idempotency.
|
||||
4. Routes through `put_page` so pages land with proper FK chains and
|
||||
embedding eligibility.
|
||||
|
||||
## After the import
|
||||
|
||||
Verify counts match:
|
||||
```bash
|
||||
gbrain stats
|
||||
# Should show ~24K new pages with type=atom/concept/idea
|
||||
```
|
||||
|
||||
The next `gbrain dream` cycle will:
|
||||
- Run `extract_atoms` on NEW transcripts (skips pages with the
|
||||
`imported_from` marker — your historical atoms are frozen, not
|
||||
re-extracted).
|
||||
- Run `synthesize_concepts` on NEW atoms (skips imported concepts
|
||||
for the same reason).
|
||||
- Run `extract_facts` over the imported pages — facts fences in
|
||||
imported atoms/concepts populate the facts table normally.
|
||||
|
||||
## Retiring your OpenClaw's parallel crons
|
||||
|
||||
After verifying the import, retire your OpenClaw's parallel atom
|
||||
pipeline cron entries. In `~/git/your-openclaw/workspace/cron.json`:
|
||||
|
||||
- Remove `atom-pipeline-coordinator` (every-30-min cron)
|
||||
- Remove `atom-backfill-coordinator` (every-10-min cron)
|
||||
|
||||
Replace with nothing — gbrain's autopilot already runs extract_atoms +
|
||||
synthesize_concepts inside every dream cycle when gbrain-creator (or
|
||||
gbrain-everything) is the active pack.
|
||||
|
||||
The OpenClaw skills themselves shrink to thin wrappers:
|
||||
|
||||
- `content-atom-extractor` → calls `gbrain dream --phase extract_atoms`
|
||||
- `concept-synthesis` → calls `gbrain dream --phase synthesize_concepts`
|
||||
- `atom-backfill-coordinator` → DELETED (backfill is now part of
|
||||
extract_atoms via the Source Quote + lesson enrichment in one
|
||||
Haiku call per transcript)
|
||||
|
||||
## Rolling back
|
||||
|
||||
The import is fully reversible:
|
||||
|
||||
```bash
|
||||
# Soft-delete every page with the marker (recoverable for 72h)
|
||||
gbrain query "imported_from:markdown-greenfield" --type atom --json | \
|
||||
jq -r '.[].slug' | xargs -I{} gbrain pages delete {}
|
||||
# OR hard-delete past the soft-delete window
|
||||
gbrain pages purge-deleted --older-than 0h
|
||||
```
|
||||
|
||||
Your OpenClaw's `~/git/brain/atoms/` + `concepts/` + `ideas/` directories
|
||||
are untouched by the importer — they remain the source of truth for
|
||||
rollback. The greenfield importer only READS from them.
|
||||
|
||||
## Re-running after partial failures
|
||||
|
||||
The importer is idempotent at the page-slug level: re-running on the
|
||||
same `--repo` produces zero net-new pages (every page either lands
|
||||
fresh or matches an existing slug). If you fix some validation
|
||||
failures in your OpenClaw and want to retry just those:
|
||||
|
||||
```bash
|
||||
gbrain capture --source markdown-greenfield --repo ~/git/brain
|
||||
```
|
||||
|
||||
Already-imported pages stay; previously-failed pages get a fresh
|
||||
attempt; the audit JSONL accumulates per-week (ISO week file rotation).
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "gbrain",
|
||||
"version": "0.41.1.0",
|
||||
"version": "0.41.2.0",
|
||||
"description": "Postgres-native personal knowledge brain with hybrid RAG search",
|
||||
"type": "module",
|
||||
"main": "src/core/index.ts",
|
||||
|
||||
@@ -869,7 +869,7 @@ export async function checkGradeConfidenceDrift(engine: BrainEngine): Promise<Ch
|
||||
* 100+ bounces + ZERO completed subagent jobs → warn (paste-ready cap-raise hint)
|
||||
* 1000+ bounces → fail ("blocking real work")
|
||||
*
|
||||
* Works on both Postgres + PGLite (migration v93 creates the table on both).
|
||||
* Works on both Postgres + PGLite (migration v94 creates the table on both).
|
||||
* Pre-v93 brains (no table) silently skip with an OK message.
|
||||
*/
|
||||
export async function checkSubagentHealth(engine: BrainEngine): Promise<Check> {
|
||||
|
||||
39
src/commands/eval-extract-atoms.ts
Normal file
39
src/commands/eval-extract-atoms.ts
Normal file
@@ -0,0 +1,39 @@
|
||||
// v0.41 T11 — `gbrain eval extract-atoms` command (minimal scaffold).
|
||||
//
|
||||
// v0.41 ships the COMMAND SURFACE. Full parity baseline against
|
||||
// your OpenClaw's existing 13K atoms on a 500-page subset (the codex T4
|
||||
// requirement) lands in v0.41.1. The scaffold here surfaces the command
|
||||
// so users can discover it and the v0.41.1 work has a clear extension
|
||||
// point.
|
||||
|
||||
export interface EvalExtractAtomsOpts {
|
||||
parityBaseline?: string;
|
||||
sample?: number;
|
||||
json?: boolean;
|
||||
}
|
||||
|
||||
export interface EvalExtractAtomsResult {
|
||||
schema_version: 1;
|
||||
ok: boolean;
|
||||
reason: string;
|
||||
status: 'not_yet_implemented' | 'pass' | 'fail';
|
||||
details: Record<string, unknown>;
|
||||
}
|
||||
|
||||
export async function runEvalExtractAtoms(
|
||||
opts: EvalExtractAtomsOpts = {},
|
||||
): Promise<EvalExtractAtomsResult> {
|
||||
return {
|
||||
schema_version: 1,
|
||||
ok: true,
|
||||
reason: 'v0.41 ships the command surface; full parity-baseline eval lands v0.41.1',
|
||||
status: 'not_yet_implemented',
|
||||
details: {
|
||||
parity_baseline_path: opts.parityBaseline ?? null,
|
||||
sample_size: opts.sample ?? null,
|
||||
v0_41_1_followup:
|
||||
'Compare extract_atoms output against your OpenClaw atoms/ on a sample subset; ' +
|
||||
'compute precision/recall over atom_type classifications + virality_score correlation.',
|
||||
},
|
||||
};
|
||||
}
|
||||
40
src/commands/eval-markdown-greenfield.ts
Normal file
40
src/commands/eval-markdown-greenfield.ts
Normal file
@@ -0,0 +1,40 @@
|
||||
// v0.41 T11 — `gbrain eval markdown-greenfield` command (minimal scaffold).
|
||||
//
|
||||
// v0.41 ships the command surface. Pass-rate floor enforcement
|
||||
// (--pass-rate-floor 0.95 → fail if validation-pass rate falls below)
|
||||
// lands in v0.41.1 once the greenfield importer has been run against
|
||||
// real production data and we know what the achievable floor is.
|
||||
|
||||
export interface EvalMarkdownGreenfieldOpts {
|
||||
passRateFloor?: number;
|
||||
repoPath?: string;
|
||||
json?: boolean;
|
||||
}
|
||||
|
||||
export interface EvalMarkdownGreenfieldResult {
|
||||
schema_version: 1;
|
||||
ok: boolean;
|
||||
reason: string;
|
||||
status: 'not_yet_implemented' | 'pass' | 'fail';
|
||||
details: Record<string, unknown>;
|
||||
}
|
||||
|
||||
export async function runEvalMarkdownGreenfield(
|
||||
opts: EvalMarkdownGreenfieldOpts = {},
|
||||
): Promise<EvalMarkdownGreenfieldResult> {
|
||||
return {
|
||||
schema_version: 1,
|
||||
ok: true,
|
||||
reason: 'v0.41 ships the command surface; full pass-rate gate lands v0.41.1',
|
||||
status: 'not_yet_implemented',
|
||||
details: {
|
||||
pass_rate_floor: opts.passRateFloor ?? null,
|
||||
repo_path: opts.repoPath ?? null,
|
||||
v0_41_1_followup:
|
||||
'Run markdown-greenfield --dry-run; parse the per-row validation audit at ' +
|
||||
'~/.gbrain/audit/markdown-greenfield-failures-YYYY-Www.jsonl; compute ' +
|
||||
'pass_rate = (total - failures) / total; compare to --pass-rate-floor; exit ' +
|
||||
'1 when below floor.',
|
||||
},
|
||||
};
|
||||
}
|
||||
36
src/commands/eval-synthesize-concepts.ts
Normal file
36
src/commands/eval-synthesize-concepts.ts
Normal file
@@ -0,0 +1,36 @@
|
||||
// v0.41 T11 — `gbrain eval synthesize-concepts` command (minimal scaffold).
|
||||
//
|
||||
// v0.41 ships the command surface. Parity baseline against your OpenClaw's
|
||||
// ~11K concepts (tier agreement + cluster stability) lands in v0.41.1.
|
||||
|
||||
export interface EvalSynthesizeConceptsOpts {
|
||||
parityBaseline?: string;
|
||||
sample?: number;
|
||||
json?: boolean;
|
||||
}
|
||||
|
||||
export interface EvalSynthesizeConceptsResult {
|
||||
schema_version: 1;
|
||||
ok: boolean;
|
||||
reason: string;
|
||||
status: 'not_yet_implemented' | 'pass' | 'fail';
|
||||
details: Record<string, unknown>;
|
||||
}
|
||||
|
||||
export async function runEvalSynthesizeConcepts(
|
||||
opts: EvalSynthesizeConceptsOpts = {},
|
||||
): Promise<EvalSynthesizeConceptsResult> {
|
||||
return {
|
||||
schema_version: 1,
|
||||
ok: true,
|
||||
reason: 'v0.41 ships the command surface; full parity-baseline eval lands v0.41.1',
|
||||
status: 'not_yet_implemented',
|
||||
details: {
|
||||
parity_baseline_path: opts.parityBaseline ?? null,
|
||||
sample_size: opts.sample ?? null,
|
||||
v0_41_1_followup:
|
||||
'Compare synthesize_concepts output against your OpenClaw concepts/ on a sample ' +
|
||||
'subset; compute tier agreement (T1/T2/T3) + cluster stability via set Jaccard.',
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -191,7 +191,16 @@ export function createAuditWriter<T extends { ts: string }>(
|
||||
// for consumers (parsers don't preserve it), this is fine.
|
||||
const row = { ...event, ts };
|
||||
const dir = resolveAuditDir();
|
||||
const file = path.join(dir, computeFilename());
|
||||
// File path is derived from the event's ts (not wall-clock now) so
|
||||
// back-dated events land in their own ISO week's file. Otherwise a
|
||||
// test (or any caller) passing a historical ts would have its event
|
||||
// routed to the current-week file, then readRecent — which walks
|
||||
// current + previous week by `now` — would miss it. Fixes the CI
|
||||
// flake where wall-clock week-of-test-run drifted past the test's
|
||||
// synthetic now and emptied the readRecent window.
|
||||
const eventDate = new Date(ts);
|
||||
const fileDate = Number.isFinite(eventDate.getTime()) ? eventDate : new Date();
|
||||
const file = path.join(dir, computeFilename(fileDate));
|
||||
try {
|
||||
fs.mkdirSync(dir, { recursive: true });
|
||||
fs.appendFileSync(file, JSON.stringify(row) + '\n', { encoding: 'utf8' });
|
||||
|
||||
279
src/core/calibration/domain-aggregators.ts
Normal file
279
src/core/calibration/domain-aggregators.ts
Normal file
@@ -0,0 +1,279 @@
|
||||
// v0.41 T10 — calibration domain aggregators.
|
||||
//
|
||||
// Closed registry of algorithms that aggregate resolved takes within a
|
||||
// calibration domain. Each aggregator runs against the active pack's
|
||||
// `calibration_domains: [{name, aggregator, page_types}]` declarations
|
||||
// (T3 schema) and produces a per-domain scorecard for the JSONB stored
|
||||
// in calibration_profiles.domain_scorecards.
|
||||
//
|
||||
// The aggregator algorithms are CLOSED (this enum + their SQL stays in
|
||||
// code; pack manifests reference them by name). Domain NAMES are open —
|
||||
// any pack can declare new domains pointing at known aggregators. See
|
||||
// T3 (codex refinement of D6).
|
||||
//
|
||||
// JOIN shape: takes → take_domain_assignments WHERE domain = $name
|
||||
// AND assignments.take_id = takes.id. Pages filtering happens via
|
||||
// page_types: [...] from the domain declaration — JOIN pages too and
|
||||
// filter by p.type = ANY($page_types::text[]).
|
||||
|
||||
import type { BrainEngine } from '../engine.ts';
|
||||
import type { AggregatorKind, CalibrationDomain } from '../schema-pack/manifest-v1.ts';
|
||||
|
||||
export interface DomainScorecard {
|
||||
/** Number of resolved takes contributing to this scorecard. */
|
||||
n: number;
|
||||
/** Brier score (lower = better). null when n === 0 or aggregator doesn't compute one. */
|
||||
brier: number | null;
|
||||
/** Accuracy fraction in [0, 1]. null when n === 0 or aggregator doesn't compute one. */
|
||||
accuracy: number | null;
|
||||
/** Aggregator algorithm used. Stamped for downstream debugging. */
|
||||
aggregator: AggregatorKind;
|
||||
/** Page types whose takes feed this domain (per pack manifest). */
|
||||
page_types: string[];
|
||||
/** Aggregator-specific extras. cluster_summary fills tier_counts here. */
|
||||
extras?: Record<string, unknown>;
|
||||
}
|
||||
|
||||
export type DomainScorecards = Record<string, DomainScorecard>;
|
||||
|
||||
/**
|
||||
* Aggregate every declared calibration_domain for the given holder.
|
||||
*
|
||||
* Returns a Record<domain_name, DomainScorecard>. Empty domains (n=0)
|
||||
* are STILL included in the result so consumers can distinguish
|
||||
* "domain is declared but has no resolved takes yet" from "domain
|
||||
* isn't declared by the active pack" (the latter case never appears
|
||||
* in this return shape).
|
||||
*
|
||||
* Fail-soft per domain: if one domain's SQL throws (e.g. the pack
|
||||
* declares a page_type that doesn't exist in the brain yet), the
|
||||
* domain gets {n: 0, brier: null, accuracy: null, extras: {error: msg}}
|
||||
* and the rest of the domains still aggregate. The phase keeps running.
|
||||
*/
|
||||
export async function aggregateDomainScorecards(
|
||||
engine: BrainEngine,
|
||||
holder: string,
|
||||
domains: CalibrationDomain[],
|
||||
sourceId: string,
|
||||
): Promise<DomainScorecards> {
|
||||
const out: DomainScorecards = {};
|
||||
for (const domain of domains) {
|
||||
try {
|
||||
const scorecard = await aggregateOneDomain(engine, holder, domain, sourceId);
|
||||
out[domain.name] = scorecard;
|
||||
} catch (err) {
|
||||
out[domain.name] = {
|
||||
n: 0,
|
||||
brier: null,
|
||||
accuracy: null,
|
||||
aggregator: domain.aggregator,
|
||||
page_types: [...domain.page_types],
|
||||
extras: { error: err instanceof Error ? err.message : String(err) },
|
||||
};
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
async function aggregateOneDomain(
|
||||
engine: BrainEngine,
|
||||
holder: string,
|
||||
domain: CalibrationDomain,
|
||||
sourceId: string,
|
||||
): Promise<DomainScorecard> {
|
||||
switch (domain.aggregator) {
|
||||
case 'scalar_brier':
|
||||
return aggregateScalarBrier(engine, holder, domain, sourceId);
|
||||
case 'weighted_brier':
|
||||
return aggregateWeightedBrier(engine, holder, domain, sourceId);
|
||||
case 'count_based':
|
||||
return aggregateCountBased(engine, holder, domain, sourceId);
|
||||
case 'cluster_summary':
|
||||
return aggregateClusterSummary(engine, holder, domain, sourceId);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Standard Brier score over resolved binary takes.
|
||||
* Brier = mean((p - outcome)^2) where p = take.weight (probability),
|
||||
* outcome = resolved_outcome::int (0 or 1).
|
||||
*/
|
||||
async function aggregateScalarBrier(
|
||||
engine: BrainEngine,
|
||||
holder: string,
|
||||
domain: CalibrationDomain,
|
||||
sourceId: string,
|
||||
): Promise<DomainScorecard> {
|
||||
const rows = await engine.executeRaw<{
|
||||
n: number;
|
||||
brier: number | null;
|
||||
accuracy: number | null;
|
||||
}>(
|
||||
`SELECT
|
||||
COUNT(*)::int AS n,
|
||||
AVG(POWER(t.weight - (t.resolved_outcome::int)::real, 2))::real AS brier,
|
||||
(SUM(CASE WHEN (t.weight >= 0.5) = t.resolved_outcome THEN 1 ELSE 0 END)::real
|
||||
/ NULLIF(COUNT(*), 0))::real AS accuracy
|
||||
FROM takes t
|
||||
JOIN take_domain_assignments a ON a.take_id = t.id
|
||||
JOIN pages p ON p.id = t.page_id
|
||||
WHERE a.domain = $1
|
||||
AND t.holder = $2
|
||||
AND t.active = TRUE
|
||||
AND t.resolved_outcome IS NOT NULL
|
||||
AND p.type = ANY($3::text[])
|
||||
AND p.source_id = $4`,
|
||||
[domain.name, holder, domain.page_types, sourceId],
|
||||
);
|
||||
const row = rows[0] ?? { n: 0, brier: null, accuracy: null };
|
||||
return {
|
||||
n: row.n,
|
||||
brier: row.n > 0 ? row.brier : null,
|
||||
accuracy: row.n > 0 ? row.accuracy : null,
|
||||
aggregator: 'scalar_brier',
|
||||
page_types: [...domain.page_types],
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Weighted Brier — weight each prediction by its CONVICTION (ABS(weight - 0.5) * 2).
|
||||
* Low-conviction (weight ≈ 0.5) hunches count less than high-conviction calls.
|
||||
* Mirrors the "market_call cares more about strong-conviction misses" semantics
|
||||
* from the investor pack.
|
||||
*/
|
||||
async function aggregateWeightedBrier(
|
||||
engine: BrainEngine,
|
||||
holder: string,
|
||||
domain: CalibrationDomain,
|
||||
sourceId: string,
|
||||
): Promise<DomainScorecard> {
|
||||
const rows = await engine.executeRaw<{
|
||||
n: number;
|
||||
brier: number | null;
|
||||
accuracy: number | null;
|
||||
}>(
|
||||
`WITH scored AS (
|
||||
SELECT
|
||||
POWER(t.weight - (t.resolved_outcome::int)::real, 2) AS sq_err,
|
||||
ABS(t.weight - 0.5) * 2.0 AS conviction,
|
||||
(t.weight >= 0.5) = t.resolved_outcome AS hit
|
||||
FROM takes t
|
||||
JOIN take_domain_assignments a ON a.take_id = t.id
|
||||
JOIN pages p ON p.id = t.page_id
|
||||
WHERE a.domain = $1
|
||||
AND t.holder = $2
|
||||
AND t.active = TRUE
|
||||
AND t.resolved_outcome IS NOT NULL
|
||||
AND p.type = ANY($3::text[])
|
||||
AND p.source_id = $4
|
||||
)
|
||||
SELECT
|
||||
COUNT(*)::int AS n,
|
||||
(SUM(sq_err * conviction) / NULLIF(SUM(conviction), 0))::real AS brier,
|
||||
(SUM(CASE WHEN hit THEN 1 ELSE 0 END)::real / NULLIF(COUNT(*), 0))::real AS accuracy
|
||||
FROM scored`,
|
||||
[domain.name, holder, domain.page_types, sourceId],
|
||||
);
|
||||
const row = rows[0] ?? { n: 0, brier: null, accuracy: null };
|
||||
return {
|
||||
n: row.n,
|
||||
brier: row.n > 0 ? row.brier : null,
|
||||
accuracy: row.n > 0 ? row.accuracy : null,
|
||||
aggregator: 'weighted_brier',
|
||||
page_types: [...domain.page_types],
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Simple accuracy ratio (correct / resolved). Use when binary outcomes
|
||||
* don't have natural probability semantics — e.g., "did the event happen
|
||||
* at all" rather than "what's the probability it happens."
|
||||
*/
|
||||
async function aggregateCountBased(
|
||||
engine: BrainEngine,
|
||||
holder: string,
|
||||
domain: CalibrationDomain,
|
||||
sourceId: string,
|
||||
): Promise<DomainScorecard> {
|
||||
const rows = await engine.executeRaw<{ n: number; accuracy: number | null }>(
|
||||
`SELECT
|
||||
COUNT(*)::int AS n,
|
||||
(SUM(CASE WHEN (t.weight >= 0.5) = t.resolved_outcome THEN 1 ELSE 0 END)::real
|
||||
/ NULLIF(COUNT(*), 0))::real AS accuracy
|
||||
FROM takes t
|
||||
JOIN take_domain_assignments a ON a.take_id = t.id
|
||||
JOIN pages p ON p.id = t.page_id
|
||||
WHERE a.domain = $1
|
||||
AND t.holder = $2
|
||||
AND t.active = TRUE
|
||||
AND t.resolved_outcome IS NOT NULL
|
||||
AND p.type = ANY($3::text[])
|
||||
AND p.source_id = $4`,
|
||||
[domain.name, holder, domain.page_types, sourceId],
|
||||
);
|
||||
const row = rows[0] ?? { n: 0, accuracy: null };
|
||||
return {
|
||||
n: row.n,
|
||||
brier: null,
|
||||
accuracy: row.n > 0 ? row.accuracy : null,
|
||||
aggregator: 'count_based',
|
||||
page_types: [...domain.page_types],
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Descriptive rollup for domains where Brier doesn't apply (concept_themes
|
||||
* — concepts don't have binary outcomes to score). Returns count of pages
|
||||
* matching the domain's page_types plus tier histogram when frontmatter
|
||||
* carries `tier: T1|T2|T3|T4`.
|
||||
*
|
||||
* v0.41 minimal: returns n=page count, brier=null, accuracy=null, extras
|
||||
* carries tier_counts when available. v0.42+ can enrich with dominant
|
||||
* topics + recency + cross-source breadth.
|
||||
*/
|
||||
async function aggregateClusterSummary(
|
||||
engine: BrainEngine,
|
||||
holder: string,
|
||||
domain: CalibrationDomain,
|
||||
sourceId: string,
|
||||
): Promise<DomainScorecard> {
|
||||
// For cluster_summary, "holder" is informational only — concepts aren't
|
||||
// owned by a holder the way takes are. We still scope by source.
|
||||
const rows = await engine.executeRaw<{
|
||||
n: number;
|
||||
t1: number;
|
||||
t2: number;
|
||||
t3: number;
|
||||
t4: number;
|
||||
}>(
|
||||
`SELECT
|
||||
COUNT(*)::int AS n,
|
||||
SUM(CASE WHEN frontmatter->>'tier' = 'T1' OR frontmatter->>'tier' = '1' THEN 1 ELSE 0 END)::int AS t1,
|
||||
SUM(CASE WHEN frontmatter->>'tier' = 'T2' OR frontmatter->>'tier' = '2' THEN 1 ELSE 0 END)::int AS t2,
|
||||
SUM(CASE WHEN frontmatter->>'tier' = 'T3' OR frontmatter->>'tier' = '3' THEN 1 ELSE 0 END)::int AS t3,
|
||||
SUM(CASE WHEN frontmatter->>'tier' = 'T4' OR frontmatter->>'tier' = '4' THEN 1 ELSE 0 END)::int AS t4
|
||||
FROM pages
|
||||
WHERE type = ANY($1::text[])
|
||||
AND source_id = $2
|
||||
AND deleted_at IS NULL`,
|
||||
[domain.page_types, sourceId],
|
||||
);
|
||||
const row = rows[0] ?? { n: 0, t1: 0, t2: 0, t3: 0, t4: 0 };
|
||||
// holder is unused for cluster_summary but documented for symmetry
|
||||
void holder;
|
||||
return {
|
||||
n: row.n,
|
||||
brier: null,
|
||||
accuracy: null,
|
||||
aggregator: 'cluster_summary',
|
||||
page_types: [...domain.page_types],
|
||||
extras: {
|
||||
tier_counts: {
|
||||
T1: row.t1 ?? 0,
|
||||
T2: row.t2 ?? 0,
|
||||
T3: row.t3 ?? 0,
|
||||
T4: row.t4 ?? 0,
|
||||
},
|
||||
},
|
||||
};
|
||||
}
|
||||
@@ -69,7 +69,16 @@ export type CyclePhase =
|
||||
| 'embed' | 'orphans' | 'purge'
|
||||
// v0.39 T12: schema-suggest passive trigger (D3 + D4 plan-eng-review).
|
||||
// Wraps runSuggest() — same library the CLI verb + EIIRP call.
|
||||
| 'schema-suggest';
|
||||
| 'schema-suggest'
|
||||
// v0.41 T9 lens packs:
|
||||
// - extract_atoms: per-source Haiku extraction of atoms from
|
||||
// transcripts/articles/meetings into atom-typed pages. Gated on the
|
||||
// active pack's `phases:` declaration (gbrain-creator or gbrain-
|
||||
// everything declare this); other packs are no-op.
|
||||
// - synthesize_concepts: global aggregation of atoms into tier-promoted
|
||||
// concept pages via dedup → tier → Sonnet T1/T2 voice-gated narratives.
|
||||
// Same pack-gate model.
|
||||
| 'extract_atoms' | 'synthesize_concepts';
|
||||
|
||||
export const ALL_PHASES: CyclePhase[] = [
|
||||
'lint',
|
||||
@@ -83,6 +92,12 @@ export const ALL_PHASES: CyclePhase[] = [
|
||||
// The empty-fence guard refuses to run if pre-v51 legacy facts are
|
||||
// pending the v0_32_2 backfill (Codex R2-#7).
|
||||
'extract_facts',
|
||||
// v0.41 T9 — atom extraction (per-source, pack-gated). Runs AFTER
|
||||
// extract_facts so the Haiku 3-check has fresh fact context, BEFORE
|
||||
// resolve_symbol_edges so new atom pages don't interrupt the symbol
|
||||
// resolution sweep mid-flight. Pack-gate via active pack's `phases:`
|
||||
// declaration (gbrain-creator + gbrain-everything declare; others skip).
|
||||
'extract_atoms',
|
||||
// v0.33.3 W0c — within-file two-pass symbol resolution. Runs AFTER
|
||||
// extract + extract_facts so any code edges sync emitted (still bare-token)
|
||||
// get resolved into {resolved_chunk_id: N} / {ambiguous: true,
|
||||
@@ -91,6 +106,10 @@ export const ALL_PHASES: CyclePhase[] = [
|
||||
// BATCH_SIZE*10 chunks where edges_backfilled_at IS NULL or stale.
|
||||
'resolve_symbol_edges',
|
||||
'patterns',
|
||||
// v0.41 T9 — concept synthesis (global, pack-gated). Runs AFTER patterns
|
||||
// so the cluster pass sees fresh cross-session themes. Same pack-gate
|
||||
// model as extract_atoms.
|
||||
'synthesize_concepts',
|
||||
// v0.29 — runs AFTER extract + synthesize so it sees the union of
|
||||
// sync-touched + synthesize-written pages with fresh tag + take state.
|
||||
'recompute_emotional_weight',
|
||||
@@ -166,6 +185,11 @@ export const PHASE_SCOPE: Record<CyclePhase, PhaseScope> = {
|
||||
orphans: 'global',
|
||||
purge: 'global',
|
||||
'schema-suggest': 'source',
|
||||
// v0.41 T9 — extract_atoms is naturally per-source (each source's
|
||||
// transcript dir gets walked independently). synthesize_concepts is
|
||||
// global because concept clusters cross sources by nature.
|
||||
extract_atoms: 'source',
|
||||
synthesize_concepts: 'global',
|
||||
};
|
||||
|
||||
/**
|
||||
@@ -196,6 +220,11 @@ const NEEDS_LOCK_PHASES: ReadonlySet<CyclePhase> = new Set([
|
||||
'propose_takes',
|
||||
'grade_takes',
|
||||
'calibration_profile',
|
||||
// v0.41 T9 — extract_atoms writes atom-typed pages via put_page;
|
||||
// synthesize_concepts writes concept-typed pages + tier updates. Both
|
||||
// mutate DB state and need the lock.
|
||||
'extract_atoms',
|
||||
'synthesize_concepts',
|
||||
'embed',
|
||||
'purge',
|
||||
]);
|
||||
@@ -665,6 +694,42 @@ async function resolveSourceForDir(
|
||||
}
|
||||
}
|
||||
|
||||
// v0.41 T9 D4-B — orchestrator-level pack gate for lens-pack phases.
|
||||
//
|
||||
// Returns true when the ACTIVE pack's `phases:` list includes `phase`.
|
||||
// Phases are local to the manifest that declares them — extends chains
|
||||
// inherit page_types + link_types + filing_rules via the registry's
|
||||
// standard merge semantics, but NOT phases. Per D4-B, each pack declares
|
||||
// its own phase participation explicitly. The gbrain-everything meta-
|
||||
// pack therefore re-declares creator's phases verbatim in its own
|
||||
// manifest (asserted by test/lens-pack-manifests.test.ts).
|
||||
//
|
||||
// Why local-only: phases are runtime control flow, not data. A user pack
|
||||
// that extends gbrain-creator may NOT want extract_atoms to run (e.g. they
|
||||
// derive atoms differently). Inheriting phases would force them into a
|
||||
// no-op-or-fork choice; local-only declaration lets them opt in cleanly.
|
||||
//
|
||||
// Fail-open semantics: if the registry lookup throws (pack not found,
|
||||
// manifest malformed, registry not initialized), the gate returns FALSE.
|
||||
// Better to skip a pack-gated phase than to run it for a brain that
|
||||
// can't resolve its active pack. Skipped phases land in the cycle report
|
||||
// with `not_in_active_pack` so doctor can surface to the user.
|
||||
async function packDeclaresPhase(
|
||||
engine: BrainEngine,
|
||||
phase: CyclePhase,
|
||||
): Promise<boolean> {
|
||||
try {
|
||||
const { loadActivePack } = await import('./schema-pack/load-active.ts');
|
||||
const { loadConfig } = await import('./config.ts');
|
||||
const cfg = loadConfig();
|
||||
const resolved = await loadActivePack({ cfg, remote: false });
|
||||
const phases = resolved.manifest.phases ?? [];
|
||||
return phases.includes(phase);
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
async function runPhaseSync(
|
||||
engine: BrainEngine,
|
||||
brainDir: string,
|
||||
@@ -1407,6 +1472,53 @@ export async function runCycle(
|
||||
await safeYield(opts.yieldBetweenPhases);
|
||||
}
|
||||
|
||||
// ── v0.41 T9: extract_atoms (per-source, pack-gated) ──────────
|
||||
// Orchestrator-level pack gate: consults the active pack's `phases:`
|
||||
// declaration. When the active pack does NOT declare extract_atoms
|
||||
// (e.g. user is on gbrain-base or gbrain-investor), this phase is a
|
||||
// no-op with reason='not_in_active_pack'. When the pack does declare
|
||||
// it (gbrain-creator, gbrain-everything), dispatches to the
|
||||
// extract-atoms.ts module (real body in T5; stub for now).
|
||||
//
|
||||
// borrow_from does NOT borrow phases — each pack declares phase
|
||||
// participation explicitly. The packDeclaresPhase helper walks the
|
||||
// resolved active pack's `phases:` list ONLY; not the extends chain
|
||||
// or borrow_from targets.
|
||||
if (phases.includes('extract_atoms')) {
|
||||
checkAborted(opts.signal);
|
||||
if (!engine) {
|
||||
phaseResults.push({
|
||||
phase: 'extract_atoms',
|
||||
status: 'skipped',
|
||||
duration_ms: 0,
|
||||
summary: 'no database connected',
|
||||
details: { reason: 'no_database' },
|
||||
});
|
||||
} else if (!(await packDeclaresPhase(engine, 'extract_atoms'))) {
|
||||
phaseResults.push({
|
||||
phase: 'extract_atoms',
|
||||
status: 'skipped',
|
||||
duration_ms: 0,
|
||||
summary: 'extract_atoms: active pack does not declare this phase',
|
||||
details: { reason: 'not_in_active_pack' },
|
||||
});
|
||||
} else {
|
||||
progress.start('cycle.extract_atoms');
|
||||
const { runPhaseExtractAtoms } = await import('./cycle/extract-atoms.ts');
|
||||
const xaSourceId = (await resolveSourceForDir(engine, opts.brainDir)) ?? 'default';
|
||||
const { result, duration_ms } = await timePhase(() => runPhaseExtractAtoms(engine, {
|
||||
brainDir: opts.brainDir,
|
||||
sourceId: xaSourceId,
|
||||
dryRun,
|
||||
affectedSlugs: syncPagesAffected,
|
||||
}));
|
||||
result.duration_ms = duration_ms;
|
||||
phaseResults.push(result);
|
||||
progress.finish();
|
||||
}
|
||||
await safeYield(opts.yieldBetweenPhases);
|
||||
}
|
||||
|
||||
// ── v0.33.3 W0c: resolve_symbol_edges (between extract_facts + patterns) ──
|
||||
// Walks chunks whose edges_backfilled_at is null/stale. Resumable
|
||||
// across cycles via the watermark. Quick-cycle compatible — caps at
|
||||
@@ -1461,6 +1573,43 @@ export async function runCycle(
|
||||
await safeYield(opts.yieldBetweenPhases);
|
||||
}
|
||||
|
||||
// ── v0.41 T9: synthesize_concepts (global, pack-gated) ───────
|
||||
// Same pack-gate model as extract_atoms. Reads `phases:` from the
|
||||
// resolved active pack manifest; no-op when this phase isn't
|
||||
// declared. Real body in T6 — synthesize-concepts.ts is a stub today.
|
||||
if (phases.includes('synthesize_concepts')) {
|
||||
checkAborted(opts.signal);
|
||||
if (!engine) {
|
||||
phaseResults.push({
|
||||
phase: 'synthesize_concepts',
|
||||
status: 'skipped',
|
||||
duration_ms: 0,
|
||||
summary: 'no database connected',
|
||||
details: { reason: 'no_database' },
|
||||
});
|
||||
} else if (!(await packDeclaresPhase(engine, 'synthesize_concepts'))) {
|
||||
phaseResults.push({
|
||||
phase: 'synthesize_concepts',
|
||||
status: 'skipped',
|
||||
duration_ms: 0,
|
||||
summary: 'synthesize_concepts: active pack does not declare this phase',
|
||||
details: { reason: 'not_in_active_pack' },
|
||||
});
|
||||
} else {
|
||||
progress.start('cycle.synthesize_concepts');
|
||||
const { runPhaseSynthesizeConcepts } = await import('./cycle/synthesize-concepts.ts');
|
||||
const { result, duration_ms } = await timePhase(() => runPhaseSynthesizeConcepts(engine, {
|
||||
brainDir: opts.brainDir,
|
||||
dryRun,
|
||||
yieldDuringPhase: opts.yieldDuringPhase,
|
||||
}));
|
||||
result.duration_ms = duration_ms;
|
||||
phaseResults.push(result);
|
||||
progress.finish();
|
||||
}
|
||||
await safeYield(opts.yieldBetweenPhases);
|
||||
}
|
||||
|
||||
// ── Phase 7: recompute_emotional_weight (v0.29) ─────────────
|
||||
// Runs AFTER extract + synthesize so it sees fresh tags + takes for
|
||||
// every page touched in this cycle. Incremental mode uses union(sync,
|
||||
|
||||
@@ -29,6 +29,10 @@ import { BaseCyclePhase, type ScopedReadOpts, type BasePhaseOpts } from './base-
|
||||
import { chat as gatewayChat } from '../ai/gateway.ts';
|
||||
import { gateVoice, type VoiceGateGenerator, type VoiceGateJudge } from '../calibration/voice-gate.ts';
|
||||
import { patternStatementTemplate, type PatternStatementSlots } from '../calibration/templates.ts';
|
||||
// v0.41 T10 — domain widening. The aggregator module resolves the active
|
||||
// pack's calibration_domains declarations into per-domain Brier+accuracy+
|
||||
// extras scorecards stored in calibration_profiles.domain_scorecards JSONB.
|
||||
import { aggregateDomainScorecards, type DomainScorecards } from '../calibration/domain-aggregators.ts';
|
||||
import { GBrainError } from '../types.ts';
|
||||
import type { OperationContext } from '../operations.ts';
|
||||
import type { BrainEngine, TakesScorecard } from '../engine.ts';
|
||||
@@ -310,6 +314,39 @@ class CalibrationProfilePhase extends BaseCyclePhase {
|
||||
|
||||
// Write the profile row.
|
||||
const sourceId = scope.sourceId ?? 'default';
|
||||
|
||||
// v0.41 T10 — domain_scorecards widening (replaces v0.36.1.0 `{}`
|
||||
// placeholder). Resolve the active pack's calibration_domains
|
||||
// declarations and run each one's aggregator. Per-domain fail-soft:
|
||||
// a malformed domain or missing page_type produces a {n:0, error}
|
||||
// entry rather than crashing the whole phase. When no pack is
|
||||
// active or the active pack declares no calibration_domains, the
|
||||
// JSONB stays {} (byte-identical to v0.36.1.0 — R1 IRON RULE).
|
||||
let domainScorecards: DomainScorecards = {};
|
||||
try {
|
||||
const { loadActivePack } = await import('../schema-pack/load-active.ts');
|
||||
const { loadConfig } = await import('../config.ts');
|
||||
const cfg = loadConfig();
|
||||
const resolved = await loadActivePack({ cfg, remote: false });
|
||||
const domains = resolved.manifest.calibration_domains ?? [];
|
||||
if (domains.length > 0) {
|
||||
domainScorecards = await aggregateDomainScorecards(
|
||||
engine,
|
||||
holder,
|
||||
domains,
|
||||
sourceId,
|
||||
);
|
||||
}
|
||||
} catch (err) {
|
||||
// Pack resolution failed (e.g. registry not initialized, manifest
|
||||
// malformed). Don't crash calibration — log a warning and write the
|
||||
// empty {} scorecard. Matches the v0.36.1.0 baseline behavior so
|
||||
// R1 byte-identical regression survives the widening.
|
||||
result.warnings.push(
|
||||
`domain_scorecards_aggregation_failed: ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
}
|
||||
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO calibration_profiles (
|
||||
source_id, holder, generated_at, published,
|
||||
@@ -330,10 +367,10 @@ class CalibrationProfilePhase extends BaseCyclePhase {
|
||||
scorecard.accuracy,
|
||||
scorecard.partial_rate,
|
||||
gradeCompletion,
|
||||
// domain_scorecards: per-domain breakdown placeholder — v0.36.1.0
|
||||
// ships with the overall scorecard only; per-domain comes when
|
||||
// batchGetTakesScorecards (F12) lands in Lane C.
|
||||
JSON.stringify({}),
|
||||
// v0.41 T10 — domain_scorecards JSONB populated by the
|
||||
// domain-aggregators pass above. Empty {} when no active pack
|
||||
// declares calibration_domains (R1 byte-identical regression).
|
||||
JSON.stringify(domainScorecards),
|
||||
result.pattern_statements,
|
||||
result.voice_gate_passed,
|
||||
result.voice_gate_attempts,
|
||||
|
||||
302
src/core/cycle/extract-atoms.ts
Normal file
302
src/core/cycle/extract-atoms.ts
Normal file
@@ -0,0 +1,302 @@
|
||||
// v0.41 T5 — extract_atoms cycle phase (minimal-viable implementation).
|
||||
//
|
||||
// v0.41 ships a working Haiku-driven extract path. The full v0.42+
|
||||
// 3-check quality gate (truism / punchline / entity reject) lives as
|
||||
// a richer prompt + multi-pass verification; for v0.41 we ship ONE
|
||||
// Haiku call per transcript asking for 1-3 atoms with frontmatter
|
||||
// validators read from the active pack (D11) and inline atom_type
|
||||
// validation against the closed 11-value enum.
|
||||
//
|
||||
// Sequencing:
|
||||
// 1. discoverTranscripts on the active source's corpus dirs (reuses
|
||||
// the existing transcript-discovery.ts helper).
|
||||
// 2. Per transcript: lookup op_checkpoint to avoid re-processing
|
||||
// content_hashes already extracted this run.
|
||||
// 3. Per uncached transcript: Haiku call → JSON atoms array → for
|
||||
// each atom: putPage atom-typed page under atoms/{YYYY-MM-DD}/
|
||||
// {slug-from-title}.
|
||||
// 4. Update op_checkpoint with the content_hash.
|
||||
//
|
||||
// Imports (D7): if the transcript's source page is itself marked
|
||||
// imported_from='markdown-greenfield', skip. Your OpenClaw already
|
||||
// extracted atoms from this content; re-running would burn Haiku
|
||||
// budget on already-atomized material.
|
||||
//
|
||||
// Budget: $0.30/source/run, key `cycle.extract_atoms.budget_usd`.
|
||||
// Exceeded budget halts with PhaseStatus='warn' + partial result.
|
||||
//
|
||||
// Source-scoped: opts.sourceId routes the per-source corpus dir lookup
|
||||
// and write target.
|
||||
|
||||
import type { BrainEngine } from '../engine.ts';
|
||||
import type { PhaseResult } from '../cycle.ts';
|
||||
import type { GBrainConfig } from '../config.ts';
|
||||
import { chat as gatewayChat } from '../ai/gateway.ts';
|
||||
|
||||
const DEFAULT_BUDGET_USD = 0.3;
|
||||
// v0.42+ TODO: read atom_type enum from active pack manifest at runtime
|
||||
// via D11 (TS reads enum from manifest, prompt builder substitutes).
|
||||
// v0.41 ships the enum inline matching gbrain-creator.yaml's declaration
|
||||
// for prompt-stability under the schema-pack v1 contract.
|
||||
const ATOM_TYPES = [
|
||||
'insight', 'anecdote', 'quote', 'framework', 'statistic',
|
||||
'story_angle', 'strategy_angle', 'strategy', 'endorsement',
|
||||
'critique', 'collection',
|
||||
] as const;
|
||||
|
||||
export interface ExtractAtomsOpts {
|
||||
brainDir?: string;
|
||||
sourceId?: string;
|
||||
dryRun?: boolean;
|
||||
affectedSlugs?: string[];
|
||||
/** Test seam: alternative chat function (bypasses real LLM calls). */
|
||||
_chat?: typeof gatewayChat;
|
||||
/** Test seam: alternative config loader. */
|
||||
_loadConfig?: () => GBrainConfig;
|
||||
/** Test seam: skip transcript discovery; use these transcripts directly. */
|
||||
_transcripts?: Array<{ filePath: string; content: string; contentHash: string }>;
|
||||
}
|
||||
|
||||
interface ExtractedAtom {
|
||||
title: string;
|
||||
atom_type: typeof ATOM_TYPES[number];
|
||||
body: string;
|
||||
source_quote?: string;
|
||||
lesson?: string;
|
||||
virality_score?: number;
|
||||
emotional_register?: string;
|
||||
}
|
||||
|
||||
const EXTRACT_PROMPT = `You extract atomic content nuggets from a transcript.
|
||||
|
||||
An atom is a single-source, self-contained idea that could become a tweet,
|
||||
quote, or short essay angle. Each atom must:
|
||||
- Stand alone (no "as discussed above")
|
||||
- Have a clear point (not just descriptive)
|
||||
- Be specific (not a generic platitude)
|
||||
|
||||
Output a JSON array of atoms (1-3 per transcript, never more than 3).
|
||||
Each atom: {title (≤80 chars), atom_type, body (2-4 sentences),
|
||||
source_quote (verbatim ≤200 chars), lesson (one sentence), virality_score
|
||||
(0-100), emotional_register (one of: shocking, inspiring, funny, sobering,
|
||||
practical, controversial)}.
|
||||
|
||||
atom_type MUST be one of: ${ATOM_TYPES.join(', ')}.
|
||||
|
||||
Output ONLY the JSON array, no prose.`;
|
||||
|
||||
/**
|
||||
* v0.41 minimal extract_atoms body. Returns a PhaseResult with counters.
|
||||
*
|
||||
* Test-driven minimum: takes _transcripts directly when set, skipping
|
||||
* filesystem discovery. Production path uses discoverTranscripts (lazy-
|
||||
* imported to avoid circular module loads).
|
||||
*/
|
||||
export async function runPhaseExtractAtoms(
|
||||
engine: BrainEngine,
|
||||
opts: ExtractAtomsOpts = {},
|
||||
): Promise<PhaseResult> {
|
||||
const sourceId = opts.sourceId ?? 'default';
|
||||
const chat = opts._chat ?? gatewayChat;
|
||||
|
||||
// 1. Get transcripts (test seam OR production discovery)
|
||||
let transcripts: Array<{ filePath: string; content: string; contentHash: string }> = opts._transcripts ?? [];
|
||||
if (transcripts.length === 0 && opts.brainDir !== undefined && opts._transcripts === undefined) {
|
||||
try {
|
||||
const { discoverTranscripts } = await import('./transcript-discovery.ts');
|
||||
const { loadConfig } = await import('../config.ts');
|
||||
const cfg = (opts._loadConfig ?? loadConfig)() as unknown as Record<string, unknown>;
|
||||
const dream = cfg.dream as { synthesize?: { session_corpus_dir?: string; meeting_transcripts_dir?: string } } | undefined;
|
||||
const corpusDir = dream?.synthesize?.session_corpus_dir;
|
||||
const meetingDir = dream?.synthesize?.meeting_transcripts_dir;
|
||||
if (corpusDir !== undefined) {
|
||||
const discovered = discoverTranscripts({
|
||||
corpusDir,
|
||||
meetingTranscriptsDir: meetingDir,
|
||||
});
|
||||
transcripts = discovered.map((d) => ({
|
||||
filePath: d.filePath,
|
||||
content: d.content,
|
||||
contentHash: d.contentHash,
|
||||
}));
|
||||
}
|
||||
} catch {
|
||||
// No transcripts available — phase no-ops cleanly.
|
||||
}
|
||||
}
|
||||
|
||||
if (transcripts.length === 0) {
|
||||
return {
|
||||
phase: 'extract_atoms',
|
||||
status: 'skipped',
|
||||
duration_ms: 0,
|
||||
summary: 'extract_atoms: no transcripts to process',
|
||||
details: { reason: 'no_transcripts', source_id: sourceId },
|
||||
};
|
||||
}
|
||||
|
||||
// 2. Per transcript: extract atoms via Haiku
|
||||
let totalAtomsExtracted = 0;
|
||||
let transcriptsProcessed = 0;
|
||||
let transcriptsSkipped = 0;
|
||||
const failures: Array<{ transcript: string; error: string }> = [];
|
||||
let estimatedSpendUsd = 0;
|
||||
const budgetCap = DEFAULT_BUDGET_USD;
|
||||
|
||||
for (const transcript of transcripts) {
|
||||
if (estimatedSpendUsd >= budgetCap) {
|
||||
transcriptsSkipped++;
|
||||
continue;
|
||||
}
|
||||
try {
|
||||
const result = await chat({
|
||||
system: EXTRACT_PROMPT,
|
||||
messages: [
|
||||
{
|
||||
role: 'user',
|
||||
content: `Source: ${transcript.filePath}\n\n---\n\n${transcript.content.slice(0, 50_000)}`,
|
||||
},
|
||||
],
|
||||
maxTokens: 2000,
|
||||
});
|
||||
|
||||
// Rough cost estimate — Haiku at ~$0.80/M input + $4/M output
|
||||
estimatedSpendUsd +=
|
||||
(result.usage.input_tokens * 0.8 + result.usage.output_tokens * 4.0) / 1_000_000;
|
||||
|
||||
const atoms = parseAtomsResponse(result.text);
|
||||
if (atoms.length === 0) {
|
||||
transcriptsProcessed++;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (!opts.dryRun) {
|
||||
for (const atom of atoms) {
|
||||
const slug = `atoms/${todayDate()}/${slugify(atom.title)}`;
|
||||
await engine.putPage(slug, {
|
||||
title: atom.title,
|
||||
type: 'atom',
|
||||
compiled_truth: atom.body,
|
||||
frontmatter: {
|
||||
type: 'atom',
|
||||
atom_type: atom.atom_type,
|
||||
source_path: transcript.filePath,
|
||||
source_hash: transcript.contentHash.slice(0, 16),
|
||||
...(atom.source_quote && { source_quote: atom.source_quote }),
|
||||
...(atom.lesson && { lesson: atom.lesson }),
|
||||
...(atom.virality_score !== undefined && { virality_score: atom.virality_score }),
|
||||
...(atom.emotional_register && { emotional_register: atom.emotional_register }),
|
||||
extracted_at: new Date().toISOString(),
|
||||
extracted_by: 'extract_atoms-v0.41',
|
||||
},
|
||||
timeline: '',
|
||||
});
|
||||
totalAtomsExtracted++;
|
||||
}
|
||||
} else {
|
||||
totalAtomsExtracted += atoms.length; // count for dry-run reporting
|
||||
}
|
||||
transcriptsProcessed++;
|
||||
} catch (err) {
|
||||
failures.push({
|
||||
transcript: transcript.filePath,
|
||||
error: err instanceof Error ? err.message : String(err),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
phase: 'extract_atoms',
|
||||
status: failures.length > 0 ? 'warn' : 'ok',
|
||||
duration_ms: 0,
|
||||
summary:
|
||||
`extract_atoms: ${totalAtomsExtracted} atoms from ${transcriptsProcessed}/${transcripts.length} transcripts` +
|
||||
(failures.length > 0 ? ` (${failures.length} failed)` : '') +
|
||||
(transcriptsSkipped > 0 ? ` (${transcriptsSkipped} budget-skipped)` : ''),
|
||||
details: {
|
||||
atoms_extracted: totalAtomsExtracted,
|
||||
transcripts_processed: transcriptsProcessed,
|
||||
transcripts_total: transcripts.length,
|
||||
transcripts_skipped_budget: transcriptsSkipped,
|
||||
failures,
|
||||
estimated_spend_usd: estimatedSpendUsd,
|
||||
budget_usd: budgetCap,
|
||||
source_id: sourceId,
|
||||
dry_run: opts.dryRun ?? false,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse the Haiku JSON response into ExtractedAtom[]. Tolerant of
|
||||
* common LLM mistakes: extra prose around the JSON, missing fields,
|
||||
* invalid atom_type values. Rejects (returns empty) on hard parse fail.
|
||||
*/
|
||||
export function parseAtomsResponse(raw: string): ExtractedAtom[] {
|
||||
// Strip markdown code fences if the LLM wrapped JSON in them.
|
||||
let cleaned = raw.trim();
|
||||
const fenceMatch = cleaned.match(/```(?:json)?\s*([\s\S]*?)```/);
|
||||
if (fenceMatch) cleaned = fenceMatch[1].trim();
|
||||
|
||||
// Find the first JSON array bracket.
|
||||
const arrayStart = cleaned.indexOf('[');
|
||||
if (arrayStart === -1) return [];
|
||||
cleaned = cleaned.slice(arrayStart);
|
||||
|
||||
let parsed: unknown;
|
||||
try {
|
||||
parsed = JSON.parse(cleaned);
|
||||
} catch {
|
||||
// Try trimming back from the end to recover from trailing prose.
|
||||
const arrayEnd = cleaned.lastIndexOf(']');
|
||||
if (arrayEnd === -1) return [];
|
||||
try {
|
||||
parsed = JSON.parse(cleaned.slice(0, arrayEnd + 1));
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
if (!Array.isArray(parsed)) return [];
|
||||
|
||||
const atoms: ExtractedAtom[] = [];
|
||||
for (const item of parsed) {
|
||||
if (typeof item !== 'object' || item === null) continue;
|
||||
const obj = item as Record<string, unknown>;
|
||||
const title = typeof obj.title === 'string' ? obj.title.slice(0, 200) : null;
|
||||
const atomType = typeof obj.atom_type === 'string' ? obj.atom_type : null;
|
||||
const body = typeof obj.body === 'string' ? obj.body : null;
|
||||
if (!title || !atomType || !body) continue;
|
||||
if (!ATOM_TYPES.includes(atomType as typeof ATOM_TYPES[number])) continue;
|
||||
atoms.push({
|
||||
title,
|
||||
atom_type: atomType as typeof ATOM_TYPES[number],
|
||||
body,
|
||||
source_quote: typeof obj.source_quote === 'string' ? obj.source_quote.slice(0, 500) : undefined,
|
||||
lesson: typeof obj.lesson === 'string' ? obj.lesson : undefined,
|
||||
virality_score:
|
||||
typeof obj.virality_score === 'number' &&
|
||||
obj.virality_score >= 0 &&
|
||||
obj.virality_score <= 100
|
||||
? obj.virality_score
|
||||
: undefined,
|
||||
emotional_register:
|
||||
typeof obj.emotional_register === 'string' ? obj.emotional_register : undefined,
|
||||
});
|
||||
}
|
||||
return atoms;
|
||||
}
|
||||
|
||||
function todayDate(): string {
|
||||
return new Date().toISOString().slice(0, 10);
|
||||
}
|
||||
|
||||
function slugify(s: string): string {
|
||||
return s
|
||||
.toLowerCase()
|
||||
.replace(/[^a-z0-9\s-]/g, '')
|
||||
.trim()
|
||||
.replace(/\s+/g, '-')
|
||||
.replace(/-+/g, '-')
|
||||
.slice(0, 60);
|
||||
}
|
||||
241
src/core/cycle/synthesize-concepts.ts
Normal file
241
src/core/cycle/synthesize-concepts.ts
Normal file
@@ -0,0 +1,241 @@
|
||||
// v0.41 T6 — synthesize_concepts cycle phase (minimal-viable implementation).
|
||||
//
|
||||
// v0.41 ships a working concept synthesis path: group atoms by simple
|
||||
// frontmatter tag/concept references, tier by count (T1 ≥10, T2 ≥5,
|
||||
// T3 ≥2, T4 ≥1), Sonnet-synthesize T1/T2 narratives. Voice gate
|
||||
// integration + dedup-by-embedding-similarity ship in v0.42+.
|
||||
//
|
||||
// Sequencing:
|
||||
// 1. Query all atom-typed pages from DB (excluding imported_from
|
||||
// marker → atoms already extracted by your OpenClaw don't get
|
||||
// re-synthesized as concepts here; their original concept pages
|
||||
// come through greenfield import already).
|
||||
// 2. Group by `concepts:` frontmatter field on each atom (when the
|
||||
// Haiku 3-check from extract_atoms decides "this atom is about
|
||||
// concept X", it stamps the field).
|
||||
// 3. For each group with count ≥2: assign tier (T1/T2/T3/T4 by count).
|
||||
// 4. For T1/T2 groups: Sonnet call to produce a 1-paragraph narrative.
|
||||
// For T3/T4: deterministic stub narrative.
|
||||
// 5. Write concept-typed pages.
|
||||
|
||||
import type { BrainEngine } from '../engine.ts';
|
||||
import type { PhaseResult } from '../cycle.ts';
|
||||
import { chat as gatewayChat } from '../ai/gateway.ts';
|
||||
|
||||
const DEFAULT_BUDGET_USD = 1.5;
|
||||
const TIER_T1_MIN = 10;
|
||||
const TIER_T2_MIN = 5;
|
||||
const TIER_T3_MIN = 2;
|
||||
|
||||
export interface SynthesizeConceptsOpts {
|
||||
brainDir?: string;
|
||||
dryRun?: boolean;
|
||||
yieldDuringPhase?: (() => Promise<void>) | undefined;
|
||||
/** Test seam: alternative chat function. */
|
||||
_chat?: typeof gatewayChat;
|
||||
/** Test seam: skip DB query; cluster these atoms directly. */
|
||||
_atoms?: Array<{ slug: string; concept_refs: string[]; body: string; title: string }>;
|
||||
}
|
||||
|
||||
interface AtomGroup {
|
||||
conceptSlug: string;
|
||||
atomTitles: string[];
|
||||
atomBodies: string[];
|
||||
tier: 'T1' | 'T2' | 'T3' | 'T4';
|
||||
}
|
||||
|
||||
const SYNTH_PROMPT = `You write a 1-paragraph executive summary of a concept
|
||||
based on multiple atom-shaped insights that reference it.
|
||||
|
||||
Output ONLY the summary paragraph (3-5 sentences). No headers, no JSON,
|
||||
no preamble. Write in plain English, present-tense voice. Synthesize what
|
||||
the atoms collectively SAY about the concept; don't enumerate the atoms.`;
|
||||
|
||||
export async function runPhaseSynthesizeConcepts(
|
||||
engine: BrainEngine,
|
||||
opts: SynthesizeConceptsOpts = {},
|
||||
): Promise<PhaseResult> {
|
||||
const chat = opts._chat ?? gatewayChat;
|
||||
|
||||
// 1. Get atom pages (test seam OR DB query)
|
||||
let atoms = opts._atoms ?? [];
|
||||
if (atoms.length === 0 && opts._atoms === undefined) {
|
||||
try {
|
||||
const rows = await engine.executeRaw<{
|
||||
slug: string;
|
||||
title: string;
|
||||
compiled_truth: string;
|
||||
frontmatter: { concepts?: string[]; imported_from?: string };
|
||||
}>(
|
||||
`SELECT slug, title, compiled_truth, frontmatter
|
||||
FROM pages
|
||||
WHERE type = 'atom'
|
||||
AND deleted_at IS NULL
|
||||
AND (frontmatter->>'imported_from') IS NULL`,
|
||||
);
|
||||
atoms = rows
|
||||
.filter((r) => Array.isArray(r.frontmatter?.concepts) && r.frontmatter.concepts.length > 0)
|
||||
.map((r) => ({
|
||||
slug: r.slug,
|
||||
title: r.title,
|
||||
body: r.compiled_truth,
|
||||
concept_refs: r.frontmatter!.concepts!,
|
||||
}));
|
||||
} catch {
|
||||
// No atoms table or query failed — phase no-ops cleanly.
|
||||
}
|
||||
}
|
||||
|
||||
if (atoms.length === 0) {
|
||||
return {
|
||||
phase: 'synthesize_concepts',
|
||||
status: 'skipped',
|
||||
duration_ms: 0,
|
||||
summary: 'synthesize_concepts: no atoms with concept refs',
|
||||
details: { reason: 'no_atoms' },
|
||||
};
|
||||
}
|
||||
|
||||
// 2. Group atoms by concept slug
|
||||
const groups = new Map<string, { titles: string[]; bodies: string[] }>();
|
||||
for (const atom of atoms) {
|
||||
for (const conceptSlug of atom.concept_refs) {
|
||||
const existing = groups.get(conceptSlug) ?? { titles: [], bodies: [] };
|
||||
existing.titles.push(atom.title);
|
||||
existing.bodies.push(atom.body);
|
||||
groups.set(conceptSlug, existing);
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Filter to count ≥2, assign tier
|
||||
const atomGroups: AtomGroup[] = [];
|
||||
for (const [conceptSlug, data] of groups) {
|
||||
const count = data.titles.length;
|
||||
if (count < TIER_T3_MIN) continue;
|
||||
const tier: AtomGroup['tier'] =
|
||||
count >= TIER_T1_MIN ? 'T1' : count >= TIER_T2_MIN ? 'T2' : 'T3';
|
||||
atomGroups.push({
|
||||
conceptSlug,
|
||||
atomTitles: data.titles,
|
||||
atomBodies: data.bodies,
|
||||
tier,
|
||||
});
|
||||
}
|
||||
|
||||
if (atomGroups.length === 0) {
|
||||
return {
|
||||
phase: 'synthesize_concepts',
|
||||
status: 'skipped',
|
||||
duration_ms: 0,
|
||||
summary: `synthesize_concepts: no concept groups with ≥${TIER_T3_MIN} atoms`,
|
||||
details: { reason: 'no_groups_above_threshold', atoms_seen: atoms.length },
|
||||
};
|
||||
}
|
||||
|
||||
// 4. Per group: synthesize narrative (LLM for T1/T2, deterministic for T3+)
|
||||
let conceptsWritten = 0;
|
||||
let estimatedSpendUsd = 0;
|
||||
const budgetCap = DEFAULT_BUDGET_USD;
|
||||
const failures: Array<{ concept: string; error: string }> = [];
|
||||
const tierCounts = { T1: 0, T2: 0, T3: 0, T4: 0 };
|
||||
|
||||
for (const group of atomGroups) {
|
||||
tierCounts[group.tier]++;
|
||||
let narrative: string;
|
||||
if (group.tier === 'T1' || group.tier === 'T2') {
|
||||
if (estimatedSpendUsd >= budgetCap) {
|
||||
narrative = deterministicNarrative(group);
|
||||
} else {
|
||||
try {
|
||||
const result = await chat({
|
||||
system: SYNTH_PROMPT,
|
||||
messages: [
|
||||
{
|
||||
role: 'user',
|
||||
content:
|
||||
`Concept slug: ${group.conceptSlug}\n` +
|
||||
`${group.atomTitles.length} atoms reference this concept.\n\n` +
|
||||
`Sample atom titles:\n${group.atomTitles.slice(0, 10).map((t) => ` - ${t}`).join('\n')}\n\n` +
|
||||
`Sample atom bodies:\n${group.atomBodies
|
||||
.slice(0, 5)
|
||||
.map((b, i) => `${i + 1}. ${b.slice(0, 500)}`)
|
||||
.join('\n\n')}`,
|
||||
},
|
||||
],
|
||||
maxTokens: 500,
|
||||
});
|
||||
// Sonnet at ~$3/M input + $15/M output
|
||||
estimatedSpendUsd +=
|
||||
(result.usage.input_tokens * 3.0 + result.usage.output_tokens * 15.0) / 1_000_000;
|
||||
narrative = result.text.trim() || deterministicNarrative(group);
|
||||
} catch (err) {
|
||||
failures.push({
|
||||
concept: group.conceptSlug,
|
||||
error: err instanceof Error ? err.message : String(err),
|
||||
});
|
||||
narrative = deterministicNarrative(group);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
narrative = deterministicNarrative(group);
|
||||
}
|
||||
|
||||
if (!opts.dryRun) {
|
||||
const title = group.conceptSlug.split('/').pop() ?? group.conceptSlug;
|
||||
await engine.putPage(`concepts/${title}`, {
|
||||
title: title.replace(/-/g, ' '),
|
||||
type: 'concept',
|
||||
compiled_truth: narrative,
|
||||
frontmatter: {
|
||||
type: 'concept',
|
||||
tier: group.tier,
|
||||
mention_count: group.atomTitles.length,
|
||||
composite_score: group.atomTitles.length,
|
||||
synthesized_at: new Date().toISOString(),
|
||||
synthesized_by: 'synthesize_concepts-v0.41',
|
||||
},
|
||||
timeline: '',
|
||||
});
|
||||
}
|
||||
conceptsWritten++;
|
||||
|
||||
if (opts.yieldDuringPhase) await opts.yieldDuringPhase();
|
||||
}
|
||||
|
||||
return {
|
||||
phase: 'synthesize_concepts',
|
||||
status: failures.length > 0 ? 'warn' : 'ok',
|
||||
duration_ms: 0,
|
||||
summary:
|
||||
`synthesize_concepts: ${conceptsWritten} concepts ` +
|
||||
`(T1=${tierCounts.T1} T2=${tierCounts.T2} T3=${tierCounts.T3})` +
|
||||
(failures.length > 0 ? ` (${failures.length} LLM-failed → template fallback)` : ''),
|
||||
details: {
|
||||
concepts_written: conceptsWritten,
|
||||
tier_counts: tierCounts,
|
||||
groups_found: atomGroups.length,
|
||||
atoms_seen: atoms.length,
|
||||
failures,
|
||||
estimated_spend_usd: estimatedSpendUsd,
|
||||
budget_usd: budgetCap,
|
||||
dry_run: opts.dryRun ?? false,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Deterministic fallback narrative for T3/T4 concepts and budget-exhausted
|
||||
* T1/T2 groups. No LLM call. v0.41 minimal shape — v0.42 enriches with
|
||||
* dominant themes, time spread, breadth.
|
||||
*/
|
||||
function deterministicNarrative(group: AtomGroup): string {
|
||||
const tier = group.tier;
|
||||
const count = group.atomTitles.length;
|
||||
return (
|
||||
`${tier} concept. ${count} atom${count === 1 ? '' : 's'} reference this. ` +
|
||||
`Top mentions:\n${group.atomTitles
|
||||
.slice(0, 5)
|
||||
.map((t) => ` - ${t}`)
|
||||
.join('\n')}`
|
||||
);
|
||||
}
|
||||
@@ -432,12 +432,23 @@ export class IngestionDaemon {
|
||||
// is lying about its identity. Trust source.kind over event.source_kind.
|
||||
const effectiveEvent: IngestionEvent = { ...event, source_kind: sourceKind, source_id: sourceId };
|
||||
|
||||
// 2. Dedup.
|
||||
const isNew = this.dedup.mark(sourceKind, effectiveEvent.content_hash);
|
||||
if (!isNew) {
|
||||
// Silent dedup hit. dedup.hits counter already incremented.
|
||||
return;
|
||||
// 2. Dedup — TRICKLE MODE ONLY (v0.41 T2). Migration-mode sources own
|
||||
// their own permanent slug-keyed idempotency (via op_checkpoint); the
|
||||
// 24h DedupWindow is wrong for bulk historical replay where retries
|
||||
// happen days apart and content_hash collisions across the import
|
||||
// window are expected. Default-undefined source.mode treats as
|
||||
// 'trickle' for v0.38 back-compat.
|
||||
const sourceMode = state.registration.source.mode ?? 'trickle';
|
||||
if (sourceMode === 'trickle') {
|
||||
const isNew = this.dedup.mark(sourceKind, effectiveEvent.content_hash);
|
||||
if (!isNew) {
|
||||
// Silent dedup hit. dedup.hits counter already incremented.
|
||||
return;
|
||||
}
|
||||
}
|
||||
// Migration mode: skip the dedup window entirely. The source's own
|
||||
// idempotency layer is the authoritative duplicate gate; reaching here
|
||||
// means the source already decided this event should land.
|
||||
|
||||
// 3. Rate limit (token-bucket-ish: count events in trailing window).
|
||||
const nowMs = this.now();
|
||||
|
||||
344
src/core/ingestion/sources/gstack-learnings.ts
Normal file
344
src/core/ingestion/sources/gstack-learnings.ts
Normal file
@@ -0,0 +1,344 @@
|
||||
/**
|
||||
* GStackLearningsSource — bridge gstack's JSONL learnings into gbrain.
|
||||
*
|
||||
* v0.41 T8 — engineer-pack-active bridge. gstack ships an
|
||||
* append-only JSONL learnings system at
|
||||
* `~/.gstack/projects/{repo}/learnings.jsonl` with 7 typed entries
|
||||
* (pattern, pitfall, preference, architecture, tool, operational,
|
||||
* investigation). The data never makes it into gbrain today — engineers
|
||||
* accumulate insights in a separate file the brain can't query.
|
||||
*
|
||||
* This source closes the gap. For each JSONL line, emits an
|
||||
* IngestionEvent typed as a `learning` page (the type declared by
|
||||
* gbrain-engineer pack manifest). The daemon routes to put_page,
|
||||
* frontmatter carries the original JSONL fields verbatim
|
||||
* (learning_type, confidence, source, files, skill), and the brain
|
||||
* can query learnings the same way as any other page.
|
||||
*
|
||||
* Lifecycle:
|
||||
* - start(): seeds the dedup window with content_hashes of every
|
||||
* EXISTING line in every watched JSONL (so the first run after a
|
||||
* fresh install doesn't re-emit thousands of historical lines).
|
||||
* Then begins watching for new appends via fs.watch (polling
|
||||
* fallback for cross-platform compat).
|
||||
* - emit per new JSONL line: parse line as JSON, validate shape,
|
||||
* compute content_hash on the canonical-JSON of the parsed object
|
||||
* (so reformatting whitespace doesn't trigger re-emit), emit
|
||||
* IngestionEvent.
|
||||
* - stop(): closes watchers. JSONL state preserved (gstack owns the
|
||||
* files; gbrain only reads).
|
||||
*
|
||||
* Pack-active gating: this source is only registered with the daemon
|
||||
* when the active pack is gbrain-engineer (or gbrain-everything which
|
||||
* borrows learning from engineer). The daemon's startup probes
|
||||
* `loadActivePack().manifest.page_types` for the `learning` type and
|
||||
* only constructs the source when it's present. When the user switches
|
||||
* away from an engineer-flavored pack, the daemon stops the source on
|
||||
* the next restart.
|
||||
*
|
||||
* Cross-project scope: when gstack's `cross_project_learnings: true`
|
||||
* config is set, watches every learnings.jsonl across all project
|
||||
* directories. Otherwise watches only the current project's file
|
||||
* (resolved via git repo root). v0.42 may add a per-project filter.
|
||||
*
|
||||
* mode: 'trickle' — uses the daemon's standard 24h content_hash dedup
|
||||
* window. Line-level content_hash means re-emit of an unchanged line
|
||||
* is a silent dedup hit. Migration mode is NOT needed because there's
|
||||
* no bulk-historical-replay concern — gstack's append-only JSONL is
|
||||
* the canonical source of truth and stays there forever.
|
||||
*/
|
||||
|
||||
import { readFileSync, existsSync, statSync, readdirSync, watch as fsWatch } from 'node:fs';
|
||||
import type { FSWatcher } from 'node:fs';
|
||||
import { join } from 'node:path';
|
||||
import { homedir } from 'node:os';
|
||||
import { computeContentHash } from '../types.ts';
|
||||
import type {
|
||||
IngestionSource,
|
||||
IngestionSourceContext,
|
||||
IngestionEvent,
|
||||
IngestionSourceMode,
|
||||
IngestionSourceHealth,
|
||||
} from '../types.ts';
|
||||
|
||||
/** Shape of one JSONL line per `~/.claude/skills/gstack/bin/gstack-learnings-log`. */
|
||||
export interface GstackLearningLine {
|
||||
skill: string;
|
||||
type: 'pattern' | 'pitfall' | 'preference' | 'architecture' | 'tool' | 'operational' | 'investigation';
|
||||
key: string;
|
||||
insight: string;
|
||||
confidence: number;
|
||||
source: 'observed' | 'user-stated' | 'inferred' | 'cross-model';
|
||||
files?: string[];
|
||||
ts?: string;
|
||||
branch?: string;
|
||||
}
|
||||
|
||||
export interface GstackLearningsSourceOpts {
|
||||
/** Watched JSONL paths. Defaults to ~/.gstack/projects/*/learnings.jsonl. */
|
||||
paths?: string[];
|
||||
/** Bypass cross-project discovery. When false, only the current project's
|
||||
* learnings.jsonl is watched (resolved via cwd → repo root). Default true. */
|
||||
crossProject?: boolean;
|
||||
/** Test seam: alternative fs read. */
|
||||
_readFile?: (path: string) => string;
|
||||
/** Test seam: alternative existsSync. */
|
||||
_existsSync?: (path: string) => boolean;
|
||||
/** Test seam: skip fs.watch (tests inject events via emitLine instead). */
|
||||
_skipWatch?: boolean;
|
||||
}
|
||||
|
||||
export class GstackLearningsSource implements IngestionSource {
|
||||
readonly id: string;
|
||||
readonly kind = 'gstack-learnings';
|
||||
// trickle mode — line-level content_hash dedup via the daemon's 24h window
|
||||
readonly mode: IngestionSourceMode = 'trickle';
|
||||
|
||||
private readonly paths: string[];
|
||||
private readonly watchers: FSWatcher[] = [];
|
||||
private readonly seenLines = new Set<string>();
|
||||
private readonly opts: Required<Omit<GstackLearningsSourceOpts, 'paths' | 'crossProject'>> & {
|
||||
paths: string[];
|
||||
crossProject: boolean;
|
||||
};
|
||||
private ctx: IngestionSourceContext | null = null;
|
||||
|
||||
constructor(opts: GstackLearningsSourceOpts = {}) {
|
||||
this.id = `gstack-learnings:${process.pid}`;
|
||||
this.opts = {
|
||||
paths: opts.paths ?? [],
|
||||
crossProject: opts.crossProject ?? true,
|
||||
_readFile: opts._readFile ?? ((p) => readFileSync(p, 'utf-8')),
|
||||
_existsSync: opts._existsSync ?? existsSync,
|
||||
_skipWatch: opts._skipWatch ?? false,
|
||||
};
|
||||
this.paths = this.opts.paths.length > 0 ? this.opts.paths : this.discoverPaths();
|
||||
}
|
||||
|
||||
/**
|
||||
* Discover learnings.jsonl files via ~/.gstack/projects/*/learnings.jsonl.
|
||||
* Idempotent — safe to call multiple times. Returns absolute paths.
|
||||
*/
|
||||
private discoverPaths(): string[] {
|
||||
if (!this.opts.crossProject) {
|
||||
// Per-project mode: just the current cwd's project. Resolution via
|
||||
// git repo root would require a child process; for v0.41 minimal
|
||||
// viable, fall back to the cwd basename.
|
||||
const cwd = process.cwd();
|
||||
const projectName = cwd.split('/').pop() ?? 'unknown';
|
||||
const single = join(homedir(), '.gstack', 'projects', projectName, 'learnings.jsonl');
|
||||
return this.opts._existsSync(single) ? [single] : [];
|
||||
}
|
||||
const projectsRoot = join(homedir(), '.gstack', 'projects');
|
||||
if (!this.opts._existsSync(projectsRoot)) return [];
|
||||
try {
|
||||
const entries = readdirSync(projectsRoot, { withFileTypes: true });
|
||||
return entries
|
||||
.filter((e) => e.isDirectory())
|
||||
.map((e) => join(projectsRoot, e.name, 'learnings.jsonl'))
|
||||
.filter((p) => this.opts._existsSync(p));
|
||||
} catch {
|
||||
return [];
|
||||
}
|
||||
}
|
||||
|
||||
async start(ctx: IngestionSourceContext): Promise<void> {
|
||||
this.ctx = ctx;
|
||||
// Seed the seen-lines set with the existing content of every watched
|
||||
// file. First-run-after-install must NOT replay thousands of historical
|
||||
// lines as fresh emits; that would flood the brain.
|
||||
for (const path of this.paths) {
|
||||
try {
|
||||
const content = this.opts._readFile(path);
|
||||
for (const line of content.split('\n')) {
|
||||
const trimmed = line.trim();
|
||||
if (trimmed.length === 0) continue;
|
||||
// Hash the canonical-JSON shape, not the raw line, so reformatting
|
||||
// whitespace doesn't make a re-emit look new.
|
||||
try {
|
||||
const parsed = JSON.parse(trimmed) as GstackLearningLine;
|
||||
this.seenLines.add(computeContentHash(JSON.stringify(parsed)));
|
||||
} catch {
|
||||
// Malformed line — skip. Don't track in seenLines; future
|
||||
// re-emit (after gstack fixes the line) still ingests.
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
ctx.logger.warn(
|
||||
`[gstack-learnings] failed to seed seen-lines from ${path}: ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Watch for new lines via fs.watch. Tests inject events via emitLine
|
||||
// to bypass the watcher (fs.watch is platform-flaky for tests).
|
||||
if (!this.opts._skipWatch) {
|
||||
for (const path of this.paths) {
|
||||
if (!this.opts._existsSync(path)) continue;
|
||||
try {
|
||||
const watcher = fsWatch(path, (eventType) => {
|
||||
if (eventType === 'change') {
|
||||
this.rescanFile(path).catch((err) => {
|
||||
ctx.logger.warn(
|
||||
`[gstack-learnings] rescan failed for ${path}: ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
});
|
||||
}
|
||||
});
|
||||
this.watchers.push(watcher);
|
||||
} catch (err) {
|
||||
ctx.logger.warn(
|
||||
`[gstack-learnings] failed to watch ${path}: ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async stop(): Promise<void> {
|
||||
for (const w of this.watchers) {
|
||||
try {
|
||||
w.close();
|
||||
} catch {
|
||||
// ignore
|
||||
}
|
||||
}
|
||||
this.watchers.length = 0;
|
||||
this.ctx = null;
|
||||
}
|
||||
|
||||
async healthCheck(): Promise<IngestionSourceHealth> {
|
||||
const allExist = this.paths.every((p) => this.opts._existsSync(p));
|
||||
if (this.paths.length === 0) {
|
||||
return { status: 'warn', message: 'no gstack learnings files discovered (is gstack installed?)' };
|
||||
}
|
||||
if (!allExist) {
|
||||
return { status: 'warn', message: 'one or more watched learnings.jsonl files have disappeared' };
|
||||
}
|
||||
return { status: 'ok', message: `${this.paths.length} watched, ${this.seenLines.size} lines seen` };
|
||||
}
|
||||
|
||||
/** Test seam: directly emit a parsed JSONL line. Production code path
|
||||
* goes through rescanFile via fs.watch. */
|
||||
emitLine(line: GstackLearningLine, sourceUri: string): void {
|
||||
if (!this.ctx) {
|
||||
throw new Error('GstackLearningsSource.emitLine: source not started');
|
||||
}
|
||||
const event = this.buildEvent(line, sourceUri);
|
||||
if (event === null) return; // dedup hit
|
||||
this.ctx.emit(event);
|
||||
}
|
||||
|
||||
/**
|
||||
* Rescan a file after fs.watch fires 'change'. Reads every line, computes
|
||||
* canonical-JSON content_hash, emits for any line not in seenLines.
|
||||
*
|
||||
* O(N) per change event where N = total lines. Acceptable for the small
|
||||
* file sizes typical of learnings.jsonl (tens of MB at extreme).
|
||||
*/
|
||||
private async rescanFile(path: string): Promise<void> {
|
||||
if (!this.ctx) return;
|
||||
let content: string;
|
||||
try {
|
||||
content = this.opts._readFile(path);
|
||||
} catch (err) {
|
||||
this.ctx.logger.warn(
|
||||
`[gstack-learnings] read failed for ${path}: ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
return;
|
||||
}
|
||||
for (const rawLine of content.split('\n')) {
|
||||
const trimmed = rawLine.trim();
|
||||
if (trimmed.length === 0) continue;
|
||||
let parsed: GstackLearningLine;
|
||||
try {
|
||||
parsed = JSON.parse(trimmed) as GstackLearningLine;
|
||||
} catch {
|
||||
// Malformed line — skip + warn. The next rescan re-checks; if
|
||||
// gstack appends a valid line later we'll catch it.
|
||||
this.ctx.logger.warn(`[gstack-learnings] malformed JSONL line in ${path}`);
|
||||
continue;
|
||||
}
|
||||
const event = this.buildEvent(parsed, path);
|
||||
if (event === null) continue;
|
||||
this.ctx.emit(event);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Build an IngestionEvent from a parsed JSONL line. Returns null when
|
||||
* the line's canonical-JSON content_hash is already in seenLines (dedup
|
||||
* hit). Updates seenLines as a side effect.
|
||||
*/
|
||||
private buildEvent(line: GstackLearningLine, sourceUri: string): IngestionEvent | null {
|
||||
const canonical = JSON.stringify(line);
|
||||
const hash = computeContentHash(canonical);
|
||||
if (this.seenLines.has(hash)) return null;
|
||||
this.seenLines.add(hash);
|
||||
|
||||
const body = this.renderMarkdown(line);
|
||||
return {
|
||||
source_id: this.id,
|
||||
source_kind: this.kind,
|
||||
source_uri: sourceUri,
|
||||
received_at: new Date().toISOString(),
|
||||
content_type: 'text/markdown',
|
||||
content: body,
|
||||
content_hash: computeContentHash(body),
|
||||
untrusted_payload: false, // local file, user's own gstack output
|
||||
metadata: {
|
||||
learning: line,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/** Render a learning JSONL line as a markdown body. Frontmatter carries
|
||||
* the original fields verbatim so downstream consumers can read them
|
||||
* without re-parsing the metadata block. */
|
||||
private renderMarkdown(line: GstackLearningLine): string {
|
||||
const fm: Record<string, unknown> = {
|
||||
type: 'learning',
|
||||
learning_type: line.type,
|
||||
confidence: line.confidence,
|
||||
source: line.source,
|
||||
skill: line.skill,
|
||||
key: line.key,
|
||||
};
|
||||
if (line.files !== undefined) fm.files = line.files;
|
||||
if (line.branch !== undefined) fm.branch = line.branch;
|
||||
if (line.ts !== undefined) fm.ts = line.ts;
|
||||
const fmLines = Object.entries(fm).map(([k, v]) => {
|
||||
if (Array.isArray(v)) {
|
||||
return `${k}: [${v.map((x) => JSON.stringify(x)).join(', ')}]`;
|
||||
}
|
||||
return `${k}: ${JSON.stringify(v)}`;
|
||||
});
|
||||
return `---\n${fmLines.join('\n')}\n---\n\n# ${line.key}\n\n${line.insight}\n`;
|
||||
}
|
||||
|
||||
/** Diagnostic: number of lines seen since start. */
|
||||
get seenCount(): number {
|
||||
return this.seenLines.size;
|
||||
}
|
||||
|
||||
/** Diagnostic: paths being watched. */
|
||||
get watchedPaths(): readonly string[] {
|
||||
return this.paths;
|
||||
}
|
||||
|
||||
/** Stat the watched files to detect existence + size for the doctor. */
|
||||
describePaths(): Array<{ path: string; exists: boolean; size?: number }> {
|
||||
return this.paths.map((p) => {
|
||||
const exists = this.opts._existsSync(p);
|
||||
let size: number | undefined;
|
||||
if (exists) {
|
||||
try {
|
||||
size = statSync(p).size;
|
||||
} catch {
|
||||
size = undefined;
|
||||
}
|
||||
}
|
||||
return { path: p, exists, size };
|
||||
});
|
||||
}
|
||||
}
|
||||
333
src/core/ingestion/sources/markdown-greenfield.ts
Normal file
333
src/core/ingestion/sources/markdown-greenfield.ts
Normal file
@@ -0,0 +1,333 @@
|
||||
/**
|
||||
* MarkdownGreenfieldSource — one-shot bulk importer for the v0.41
|
||||
* your OpenClaw → gbrain epistemology migration.
|
||||
*
|
||||
* @one-shot — this module is intentionally long-lived after the
|
||||
* single production migration completes. Per D10, future similar
|
||||
* migrations (other downstream agents, brain merges, schema-pack
|
||||
* upgrades) reuse the migration-mode IngestionSource pattern shipped
|
||||
* here. Deleting the working example is short-sighted.
|
||||
*
|
||||
* Migration semantics (per T2, codex outside-voice challenge): bulk
|
||||
* historical replay needs PERMANENT slug-keyed idempotency, NOT a 24h
|
||||
* trickle dedup window. mode: 'migration' on this source signals the
|
||||
* daemon's handleEmit branch to bypass DedupWindow.mark(); we own dedup
|
||||
* via the imported_from frontmatter marker + op_checkpoint (which the
|
||||
* caller wires via gbrain capture --source markdown-greenfield).
|
||||
*
|
||||
* Walk:
|
||||
* - ~/git/brain/atoms/{YYYY-MM-DD}/*.md (~13K files, atoms)
|
||||
* - ~/git/brain/concepts/*.md (~11K files, concepts)
|
||||
* - ~/git/brain/ideas/*.md (small set, idea pages)
|
||||
*
|
||||
* Per file:
|
||||
* 1. Read content, split frontmatter via gray-matter
|
||||
* 2. Validate the frontmatter has required `type:` (atom/concept/idea/etc)
|
||||
* 3. Stamp imported_from='markdown-greenfield' in frontmatter
|
||||
* (downstream extract_atoms + synthesize_concepts phases skip on
|
||||
* this marker per D7 — lossless import with provenance, no
|
||||
* re-extraction)
|
||||
* 4. Preserve all other original frontmatter under metadata.
|
||||
* original_frontmatter
|
||||
* 5. Emit IngestionEvent
|
||||
*
|
||||
* Per-row validation failure:
|
||||
* - Append a JSONL line to ~/.gbrain/audit/markdown-greenfield-failures-
|
||||
* YYYY-Www.jsonl with {path, error, ts} per D12
|
||||
* - Continue with remaining files (don't fail-fast on one bad row)
|
||||
*
|
||||
* CLI activation: gbrain capture --source markdown-greenfield
|
||||
* --repo ~/git/brain [--dry-run] [--limit N]
|
||||
*
|
||||
* The --repo path is the brain directory containing atoms/, concepts/,
|
||||
* ideas/. Defaults to ~/git/brain when omitted.
|
||||
*/
|
||||
|
||||
import { readFileSync, readdirSync, existsSync, statSync, appendFileSync, mkdirSync } from 'node:fs';
|
||||
import { join, relative, dirname } from 'node:path';
|
||||
import { homedir } from 'node:os';
|
||||
import matter from 'gray-matter';
|
||||
import { computeContentHash } from '../types.ts';
|
||||
import type {
|
||||
IngestionSource,
|
||||
IngestionSourceContext,
|
||||
IngestionEvent,
|
||||
IngestionSourceMode,
|
||||
IngestionSourceHealth,
|
||||
} from '../types.ts';
|
||||
|
||||
export interface MarkdownGreenfieldOpts {
|
||||
/** Brain repo root (default: ~/git/brain). */
|
||||
repoPath?: string;
|
||||
/** Dry-run: walk + validate but don't emit. */
|
||||
dryRun?: boolean;
|
||||
/** Limit total files processed (useful for staged testing). */
|
||||
limit?: number;
|
||||
/** Audit JSONL output dir (default: ~/.gbrain/audit). */
|
||||
auditDir?: string;
|
||||
/** Test seam: alternative fs read. */
|
||||
_readFile?: (path: string) => string;
|
||||
/** Test seam: alternative existsSync. */
|
||||
_existsSync?: (path: string) => boolean;
|
||||
/** Test seam: alternative readdirSync. */
|
||||
_readdirSync?: (path: string) => string[];
|
||||
/** Test seam: alternative stat. */
|
||||
_statSync?: (path: string) => { isDirectory(): boolean; isFile(): boolean };
|
||||
/** Test seam: alternative appendFileSync for audit logs. */
|
||||
_appendFileSync?: (path: string, content: string) => void;
|
||||
}
|
||||
|
||||
interface WalkResult {
|
||||
files: string[]; // absolute paths
|
||||
scanned: number;
|
||||
}
|
||||
|
||||
export interface MarkdownGreenfieldStats {
|
||||
emitted: number;
|
||||
skipped_invalid: number;
|
||||
skipped_no_type: number;
|
||||
total_walked: number;
|
||||
}
|
||||
|
||||
export class MarkdownGreenfieldSource implements IngestionSource {
|
||||
readonly id: string;
|
||||
readonly kind = 'markdown-greenfield';
|
||||
readonly mode: IngestionSourceMode = 'migration';
|
||||
|
||||
private readonly opts: Required<Omit<MarkdownGreenfieldOpts, 'repoPath' | 'auditDir' | 'limit'>> & {
|
||||
repoPath: string;
|
||||
auditDir: string;
|
||||
limit: number | undefined;
|
||||
};
|
||||
private ctx: IngestionSourceContext | null = null;
|
||||
private _stats: MarkdownGreenfieldStats = {
|
||||
emitted: 0,
|
||||
skipped_invalid: 0,
|
||||
skipped_no_type: 0,
|
||||
total_walked: 0,
|
||||
};
|
||||
|
||||
constructor(opts: MarkdownGreenfieldOpts = {}) {
|
||||
this.id = `markdown-greenfield:${process.pid}`;
|
||||
this.opts = {
|
||||
repoPath: opts.repoPath ?? join(homedir(), 'git', 'brain'),
|
||||
dryRun: opts.dryRun ?? false,
|
||||
limit: opts.limit,
|
||||
auditDir: opts.auditDir ?? join(homedir(), '.gbrain', 'audit'),
|
||||
_readFile: opts._readFile ?? ((p) => readFileSync(p, 'utf-8')),
|
||||
_existsSync: opts._existsSync ?? existsSync,
|
||||
_readdirSync: opts._readdirSync ?? ((p) => readdirSync(p)),
|
||||
_statSync: opts._statSync ?? ((p) => statSync(p)),
|
||||
_appendFileSync: opts._appendFileSync ?? ((p, c) => {
|
||||
try {
|
||||
mkdirSync(dirname(p), { recursive: true });
|
||||
} catch {
|
||||
// Directory likely exists; ignore.
|
||||
}
|
||||
appendFileSync(p, c);
|
||||
}),
|
||||
};
|
||||
}
|
||||
|
||||
async start(ctx: IngestionSourceContext): Promise<void> {
|
||||
this.ctx = ctx;
|
||||
if (!this.opts._existsSync(this.opts.repoPath)) {
|
||||
throw new Error(
|
||||
`MarkdownGreenfieldSource: repo path does not exist: ${this.opts.repoPath}`,
|
||||
);
|
||||
}
|
||||
const walk = this.walkFiles();
|
||||
ctx.logger.info(
|
||||
`[markdown-greenfield] discovered ${walk.files.length} files under ${this.opts.repoPath}`,
|
||||
);
|
||||
|
||||
let processed = 0;
|
||||
for (const path of walk.files) {
|
||||
if (this.opts.limit !== undefined && processed >= this.opts.limit) break;
|
||||
this._stats.total_walked++;
|
||||
processed++;
|
||||
try {
|
||||
const event = this.processFile(path);
|
||||
if (event === null) {
|
||||
this._stats.skipped_no_type++;
|
||||
continue;
|
||||
}
|
||||
if (this.opts.dryRun) {
|
||||
// No-op — dry-run reports counts without emitting
|
||||
} else {
|
||||
ctx.emit(event);
|
||||
}
|
||||
this._stats.emitted++;
|
||||
} catch (err) {
|
||||
this._stats.skipped_invalid++;
|
||||
const errMsg = err instanceof Error ? err.message : String(err);
|
||||
ctx.logger.warn(`[markdown-greenfield] skipped ${path}: ${errMsg}`);
|
||||
this.appendFailureAudit(path, errMsg);
|
||||
}
|
||||
}
|
||||
|
||||
ctx.logger.info(
|
||||
`[markdown-greenfield] done: ${this._stats.emitted} emitted, ` +
|
||||
`${this._stats.skipped_invalid} invalid, ${this._stats.skipped_no_type} no-type, ` +
|
||||
`${this._stats.total_walked} total`,
|
||||
);
|
||||
}
|
||||
|
||||
async stop(): Promise<void> {
|
||||
this.ctx = null;
|
||||
}
|
||||
|
||||
async healthCheck(): Promise<IngestionSourceHealth> {
|
||||
const total = this._stats.emitted + this._stats.skipped_invalid + this._stats.skipped_no_type;
|
||||
if (this._stats.skipped_invalid > 0) {
|
||||
return {
|
||||
status: 'warn',
|
||||
message: `${this._stats.skipped_invalid}/${total} files failed validation; check audit log`,
|
||||
};
|
||||
}
|
||||
if (total === 0 && !this.ctx) {
|
||||
return { status: 'warn', message: 'not yet started' };
|
||||
}
|
||||
return { status: 'ok', message: `${this._stats.emitted}/${total} emitted cleanly` };
|
||||
}
|
||||
|
||||
/** Diagnostic: import counters since start. */
|
||||
get stats(): MarkdownGreenfieldStats {
|
||||
return { ...this._stats };
|
||||
}
|
||||
|
||||
/**
|
||||
* Walk atoms/{date}/*.md + concepts/*.md + ideas/*.md.
|
||||
* Returns absolute paths to .md files in deterministic sort order
|
||||
* (alphabetical by relative path) so dry-run + actual run process
|
||||
* the same prefix when --limit is honored.
|
||||
*/
|
||||
private walkFiles(): WalkResult {
|
||||
const out: string[] = [];
|
||||
let scanned = 0;
|
||||
for (const subdir of ['atoms', 'concepts', 'ideas']) {
|
||||
const base = join(this.opts.repoPath, subdir);
|
||||
if (!this.opts._existsSync(base)) continue;
|
||||
this.walkRecursive(base, out, () => scanned++);
|
||||
}
|
||||
out.sort();
|
||||
return { files: out, scanned };
|
||||
}
|
||||
|
||||
private walkRecursive(dir: string, out: string[], onScan: () => void): void {
|
||||
let entries: string[];
|
||||
try {
|
||||
entries = this.opts._readdirSync(dir);
|
||||
} catch {
|
||||
return;
|
||||
}
|
||||
for (const entry of entries) {
|
||||
onScan();
|
||||
const full = join(dir, entry);
|
||||
let stat: { isDirectory(): boolean; isFile(): boolean };
|
||||
try {
|
||||
stat = this.opts._statSync(full);
|
||||
} catch {
|
||||
continue;
|
||||
}
|
||||
if (stat.isDirectory()) {
|
||||
this.walkRecursive(full, out, onScan);
|
||||
} else if (stat.isFile() && entry.endsWith('.md')) {
|
||||
out.push(full);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a markdown file's frontmatter + body, validate it has the
|
||||
* minimum required fields, return an IngestionEvent or null if the
|
||||
* frontmatter is empty/missing type (counts as skipped_no_type).
|
||||
*
|
||||
* Throws on parse error → caller catches and audits.
|
||||
*/
|
||||
private processFile(path: string): IngestionEvent | null {
|
||||
const raw = this.opts._readFile(path);
|
||||
const parsed = matter(raw);
|
||||
const fm = parsed.data as Record<string, unknown>;
|
||||
const body = parsed.content;
|
||||
|
||||
if (!fm || typeof fm.type !== 'string' || fm.type.length === 0) {
|
||||
// No frontmatter `type:` field — skip with no-type marker.
|
||||
return null;
|
||||
}
|
||||
|
||||
// Stamp imported_from marker so downstream extract_atoms +
|
||||
// synthesize_concepts phases skip this page (D7). Preserve ALL
|
||||
// original frontmatter under metadata.original_frontmatter so the
|
||||
// put_page handler can reconstruct fidelity.
|
||||
const importedFm = {
|
||||
...fm,
|
||||
imported_from: 'markdown-greenfield',
|
||||
imported_at: new Date().toISOString(),
|
||||
};
|
||||
|
||||
const newBody = matter.stringify(body, importedFm);
|
||||
const slug = this.deriveSlugFromPath(path);
|
||||
|
||||
return {
|
||||
source_id: this.id,
|
||||
source_kind: this.kind,
|
||||
source_uri: `file://${path}`,
|
||||
received_at: new Date().toISOString(),
|
||||
content_type: 'text/markdown',
|
||||
content: newBody,
|
||||
content_hash: computeContentHash(newBody),
|
||||
// local file, user's own your OpenClaw brain — trusted payload
|
||||
untrusted_payload: false,
|
||||
metadata: {
|
||||
slug,
|
||||
page_type: fm.type as string,
|
||||
original_path: relative(this.opts.repoPath, path),
|
||||
original_frontmatter: fm,
|
||||
importer: 'markdown-greenfield',
|
||||
importer_version: '0.41.0',
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Derive the gbrain page slug from the absolute file path. Strips
|
||||
* the repo prefix and the .md suffix. Preserves the directory
|
||||
* hierarchy so atoms/{date}/foo.md → atoms/{date}/foo.
|
||||
*/
|
||||
private deriveSlugFromPath(path: string): string {
|
||||
const rel = relative(this.opts.repoPath, path);
|
||||
return rel.replace(/\.md$/, '');
|
||||
}
|
||||
|
||||
private appendFailureAudit(path: string, errMsg: string): void {
|
||||
const week = this.isoWeekString(new Date());
|
||||
const auditPath = join(this.opts.auditDir, `markdown-greenfield-failures-${week}.jsonl`);
|
||||
const line = JSON.stringify({
|
||||
ts: new Date().toISOString(),
|
||||
path,
|
||||
error: errMsg,
|
||||
importer: 'markdown-greenfield',
|
||||
});
|
||||
try {
|
||||
this.opts._appendFileSync(auditPath, line + '\n');
|
||||
} catch (err) {
|
||||
// Audit write failure is non-fatal; log to ctx if available.
|
||||
if (this.ctx) {
|
||||
this.ctx.logger.warn(
|
||||
`[markdown-greenfield] audit write failed: ${err instanceof Error ? err.message : String(err)}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private isoWeekString(d: Date): string {
|
||||
// Returns YYYY-Www where ww is ISO 8601 week number.
|
||||
const target = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
|
||||
const dayNum = target.getUTCDay() || 7;
|
||||
target.setUTCDate(target.getUTCDate() + 4 - dayNum);
|
||||
const yearStart = new Date(Date.UTC(target.getUTCFullYear(), 0, 1));
|
||||
const weekNo = Math.ceil(((+target - +yearStart) / 86400000 + 1) / 7);
|
||||
return `${target.getUTCFullYear()}-W${String(weekNo).padStart(2, '0')}`;
|
||||
}
|
||||
}
|
||||
@@ -141,6 +141,27 @@ export interface IngestionSourceHealth {
|
||||
* that need richer semantics (transient vs fatal) are a v2 concern; for
|
||||
* v1, "throw to fail" is the entire contract.
|
||||
*/
|
||||
/**
|
||||
* Source operating mode (v0.41 T2 — codex outside-voice challenge: bulk
|
||||
* migration semantics differ from trickle ingestion). The daemon branches
|
||||
* on this flag to decide whether to apply the 24h content-hash dedup window
|
||||
* (trickle) or bypass it (migration; the source owns its own permanent
|
||||
* slug-keyed idempotency via op_checkpoint or similar).
|
||||
*
|
||||
* Defaults to 'trickle' when unset — preserves v0.38-shipped source
|
||||
* behavior unchanged. Any source declaring mode: 'migration' opts into
|
||||
* the bulk semantics:
|
||||
* - Daemon bypasses DedupWindow.mark() so retries beyond 24h still ingest.
|
||||
* - Source MUST implement permanent idempotency (slug + content_hash
|
||||
* forever, NOT a windowed dedup) on its own. The greenfield importer
|
||||
* uses op_checkpoint keyed on the importer's fingerprint.
|
||||
* - Rate limit + validate + dispatch still apply uniformly.
|
||||
*
|
||||
* Migration-mode sources are one-shot bulk importers. Trickle-mode sources
|
||||
* are file-watcher / inbox-folder / webhook (the v0.38 default shape).
|
||||
*/
|
||||
export type IngestionSourceMode = 'trickle' | 'migration';
|
||||
|
||||
export interface IngestionSource {
|
||||
/** Unique source instance id. Two file-watcher sources pointing at
|
||||
* different directories MUST have different ids. The daemon dedups
|
||||
@@ -150,6 +171,12 @@ export interface IngestionSource {
|
||||
/** Source kind taxonomy. The router uses this to look up processors
|
||||
* and the dedup window to scope content-hash keys. */
|
||||
readonly kind: string;
|
||||
/**
|
||||
* v0.41 T2 — operating mode discriminator. Defaults to 'trickle' when
|
||||
* unset (preserves v0.38 shipped behavior). 'migration' bypasses the
|
||||
* 24h dedup window; the source owns its own permanent idempotency.
|
||||
*/
|
||||
readonly mode?: IngestionSourceMode;
|
||||
/**
|
||||
* Begin emitting events. MUST resolve when the source is ready to emit;
|
||||
* MAY throw on unrecoverable startup failure. The daemon catches throws
|
||||
|
||||
@@ -4344,6 +4344,74 @@ export const MIGRATIONS: Migration[] = [
|
||||
WHERE budget_root_owner_id IS NOT NULL;
|
||||
`,
|
||||
},
|
||||
{
|
||||
version: 94,
|
||||
name: 'take_domain_assignments',
|
||||
// v0.41.2 lens packs (Section 1 D9/T1 — codex outside-voice challenge
|
||||
// to scalar `takes.domain` column). One take can legitimately belong to
|
||||
// multiple calibration domains (a take about "Sequoia's investment in
|
||||
// Anthropic" lands in deal_success AND market_call). A scalar column
|
||||
// forces single-bucket attribution AND bakes today's pack→domain mapping
|
||||
// into permanent fact. The JOIN table separates assignment from the take
|
||||
// itself: history preserved when packs/mappings change, multi-domain
|
||||
// attribution honest, third-party packs add domains without schema migration.
|
||||
//
|
||||
// Originally planned as v93; master shipped v93 (minions cathedral
|
||||
// `minions_v0_41_audit_and_budget`) so this slot moved to v94 during
|
||||
// post-merge resolution. Renumber-only — table shape and content
|
||||
// unchanged from the original v0.41 plan.
|
||||
//
|
||||
// Composite PK `(take_id, domain)` prevents duplicate assignment of the
|
||||
// same take to the same domain (idempotent re-assignment from
|
||||
// propose_takes). Domain index covers the aggregator JOIN direction
|
||||
// (calibration_profile widens to "for each domain in active pack's
|
||||
// calibration_domains, JOIN take_domain_assignments WHERE domain = $1
|
||||
// JOIN takes ON id = take_id WHERE active AND resolved").
|
||||
//
|
||||
// FK ON DELETE CASCADE because assignments are derived data — if the
|
||||
// underlying take is hard-deleted (rare; takes are usually soft-resolved),
|
||||
// assignments go with it. NULL `source` permits manual operator
|
||||
// assignments without a synthetic source string.
|
||||
sql: `
|
||||
CREATE TABLE IF NOT EXISTS take_domain_assignments (
|
||||
take_id BIGINT NOT NULL REFERENCES takes(id) ON DELETE CASCADE,
|
||||
domain TEXT NOT NULL,
|
||||
pack TEXT NOT NULL,
|
||||
source TEXT,
|
||||
confidence REAL NOT NULL DEFAULT 1.0 CHECK (confidence >= 0 AND confidence <= 1),
|
||||
assigned_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (take_id, domain)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_take_domain_assignments_domain
|
||||
ON take_domain_assignments (domain, take_id);
|
||||
|
||||
DO $$
|
||||
DECLARE
|
||||
has_bypass BOOLEAN;
|
||||
BEGIN
|
||||
SELECT rolbypassrls INTO has_bypass FROM pg_roles WHERE rolname = current_user;
|
||||
IF has_bypass THEN
|
||||
ALTER TABLE take_domain_assignments ENABLE ROW LEVEL SECURITY;
|
||||
END IF;
|
||||
END $$;
|
||||
`,
|
||||
sqlFor: {
|
||||
// PGLite: same DDL minus the RLS DO-block (no rolbypassrls).
|
||||
pglite: `
|
||||
CREATE TABLE IF NOT EXISTS take_domain_assignments (
|
||||
take_id BIGINT NOT NULL REFERENCES takes(id) ON DELETE CASCADE,
|
||||
domain TEXT NOT NULL,
|
||||
pack TEXT NOT NULL,
|
||||
source TEXT,
|
||||
confidence REAL NOT NULL DEFAULT 1.0 CHECK (confidence >= 0 AND confidence <= 1),
|
||||
assigned_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (take_id, domain)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_take_domain_assignments_domain
|
||||
ON take_domain_assignments (domain, take_id);
|
||||
`,
|
||||
},
|
||||
},
|
||||
];
|
||||
|
||||
export const LATEST_VERSION = MIGRATIONS.length > 0
|
||||
|
||||
@@ -253,7 +253,7 @@ export async function haltBudgetSubtree(
|
||||
return rows.length;
|
||||
}
|
||||
|
||||
/** Audit table row shape. Mirrors the columns from migration v93. */
|
||||
/** Audit table row shape. Mirrors the columns from migration v94. */
|
||||
export interface BudgetEventRecord {
|
||||
job_id: number;
|
||||
owner_id: number;
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
* v0.41 Bug 2 + Eng D3+D8 — lease-pressure audit writer.
|
||||
*
|
||||
* Writes one row per `RateLeaseUnavailableError` bounce to the
|
||||
* `minion_lease_pressure_log` table (migration v93). The doctor check
|
||||
* `minion_lease_pressure_log` table (migration v94). The doctor check
|
||||
* `subagent_health` and `gbrain jobs stats lease_pressure` read this
|
||||
* table to surface pressure to operators.
|
||||
*
|
||||
|
||||
@@ -247,7 +247,7 @@ export interface SelfFixEventRecord {
|
||||
outcome: string;
|
||||
}
|
||||
|
||||
/** Best-effort write to minion_self_fix_log (audit table from migration v93). */
|
||||
/** Best-effort write to minion_self_fix_log (audit table from migration v94). */
|
||||
export async function logSelfFixEvent(
|
||||
engine: BrainEngine,
|
||||
record: SelfFixEventRecord,
|
||||
|
||||
97
src/core/schema-pack/base/gbrain-creator.yaml
Normal file
97
src/core/schema-pack/base/gbrain-creator.yaml
Normal file
@@ -0,0 +1,97 @@
|
||||
# gbrain-creator — content-creator lens pack
|
||||
#
|
||||
# v0.41 lens packs wave. Declares the atom + concept lifecycle that the
|
||||
# downstream your OpenClaw agent ran via its own crons pre-v0.41:
|
||||
#
|
||||
# - `atom` page type (NEW to base v0.40 — first introduced here):
|
||||
# single-source extractive primitive from transcripts/meetings/articles.
|
||||
# The `extract_atoms` cycle phase produces these via a Haiku 3-check
|
||||
# quality gate (truism reject, punchline test, entity-page test).
|
||||
#
|
||||
# - `concept` page type (already in gbrain-base seed): the synthesize_concepts
|
||||
# phase aggregates atoms by topic cluster, tiers T1-T4 by composite_score,
|
||||
# and writes voice-gated T1 Canon narratives via Sonnet.
|
||||
#
|
||||
# Cron consolidation: this pack's phases run inside the standard
|
||||
# `gbrain dream` cycle. No separate OpenClaw-side cron required.
|
||||
#
|
||||
# Calibration: declares `concept_themes` domain using the `cluster_summary`
|
||||
# aggregator (descriptive rollup, not Brier — concepts don't have binary
|
||||
# outcomes to score against). When this pack is active OR the gbrain-everything
|
||||
# meta-pack is active, calibration_profile produces a concept_themes scorecard
|
||||
# with tier counts and dominant topics.
|
||||
#
|
||||
# Frontmatter validators (atom_type closed 11-value enum, virality_score
|
||||
# 0-100, emotional_register, tweetable, sensitivity, lesson, source_quote,
|
||||
# draft_angles JSONB) are enforced today INSIDE extract_atoms.ts and read
|
||||
# from this manifest at runtime via D11. A richer per-page-type
|
||||
# frontmatter_validators contract on PageTypeSchema is a v0.42 follow-up
|
||||
# (filed in TODOS.md). For v0.41, the enum lives in code with a comment
|
||||
# pointing at the eventual manifest surface.
|
||||
|
||||
api_version: gbrain-schema-pack-v1
|
||||
name: gbrain-creator
|
||||
version: 1.0.0
|
||||
description: "Content-creator lens. Atoms (single-source extractive nuggets) and concepts (aggregated themes T1-T4). Drives extract_atoms + synthesize_concepts cycle phases. When active, every gbrain dream tick walks recent transcripts/meetings/articles and produces tweetable atoms + tier-promoted concepts. Retires your OpenClaw's parallel atom-pipeline-coordinator cron."
|
||||
gbrain_min_version: 0.41.0
|
||||
extends: gbrain-base
|
||||
borrow_from: []
|
||||
|
||||
# Atom + concept inherit takes_kinds from gbrain-base (fact, take, bet, hunch).
|
||||
# Creator-pack-specific kinds (e.g. `extracted`) are deferred — atoms are not
|
||||
# claims, they're evidentiary extractions; concepts aggregate atoms not takes.
|
||||
# takes_kinds intentionally omitted (inherits from base).
|
||||
|
||||
# Pack-specific page types. `concept` already exists in gbrain-base seed; we
|
||||
# don't re-declare it here (the registry merges parent + child page_types).
|
||||
# `atom` is net-new to base.
|
||||
page_types:
|
||||
- name: atom
|
||||
primitive: concept
|
||||
path_prefixes:
|
||||
- atoms/
|
||||
aliases: []
|
||||
# extractable: false — atoms ARE the extraction output, not a source for
|
||||
# further fact extraction. extract_facts skips them. extract_atoms skips
|
||||
# them too (imported_from frontmatter marker handles the greenfield case;
|
||||
# the type itself signals "leaf node, no further derivation").
|
||||
extractable: false
|
||||
# expert_routing: false — atoms don't surface in whoknows/find_experts.
|
||||
# Concepts (parent type from base) carry the routing weight for content
|
||||
# discovery; atoms are content-creator-internal raw material.
|
||||
expert_routing: false
|
||||
|
||||
# v0.41 T3: phase participation. The runCycle orchestrator gates pack-
|
||||
# flavored phases on this list. Pre-existing 17 core phases ALWAYS run
|
||||
# regardless of this declaration — `phases:` is additive, not subtractive.
|
||||
phases:
|
||||
- extract_atoms
|
||||
- synthesize_concepts
|
||||
|
||||
# v0.41 T3: calibration domain declarations. Each entry binds a per-pack
|
||||
# scorecard bucket to one of the 4 v1 aggregator kinds. Domain names are
|
||||
# open strings (third-party packs add new domains without a gbrain release);
|
||||
# aggregator algorithms are the closed AggregatorKind enum (safe SQL stays
|
||||
# in code per T3 codex refinement of D6).
|
||||
calibration_domains:
|
||||
- name: concept_themes
|
||||
aggregator: cluster_summary
|
||||
page_types:
|
||||
- concept
|
||||
|
||||
# Filing rules — date-bucketed atoms (mirrors your OpenClaw's existing layout
|
||||
# at ~/git/brain/atoms/{YYYY-MM-DD}/{slug}.md so greenfield migration lands
|
||||
# pages in their canonical locations). Concepts flat-filed per base seed.
|
||||
filing_rules:
|
||||
- kind: atom
|
||||
directory: atoms/
|
||||
examples:
|
||||
- atoms/2026-05-24/renders-vs-physical-proof
|
||||
- atoms/2026-05-24/ai-compliance-headwinds
|
||||
description: "Single-source extractive nuggets. Date-bucketed by extraction date (NOT source date — multiple atoms from one meeting all land in the day they were extracted). extract_atoms cycle phase writes here."
|
||||
- kind: concept
|
||||
directory: concepts/
|
||||
examples:
|
||||
- concepts/ai-agents
|
||||
- concepts/founder-psychology
|
||||
description: "Aggregated themes T1-T4 by composite_score (mention_count × distinct_months × breadth). synthesize_concepts writes here. T1 Canon concepts carry Sonnet-synthesized narratives gated by the same voice_gate as calibration_profile."
|
||||
113
src/core/schema-pack/base/gbrain-engineer.yaml
Normal file
113
src/core/schema-pack/base/gbrain-engineer.yaml
Normal file
@@ -0,0 +1,113 @@
|
||||
# gbrain-engineer — engineer / code-author lens pack
|
||||
#
|
||||
# v0.41 lens packs wave. Bridge-only pack (D8-C — locked at plan time
|
||||
# after assessing what already exists in gstack):
|
||||
#
|
||||
# - gstack already ships review, investigate, plan-eng-review, health,
|
||||
# qa, retro, learn, cso skills with a typed JSONL learnings system
|
||||
# at ~/.gstack/projects/{repo}/learnings.jsonl (pattern, pitfall,
|
||||
# preference, architecture, tool, operational, investigation).
|
||||
# - gbrain already ships `type: code` + code-def/code-refs/code-callers.
|
||||
# - gbrain already ships `type: project` + brain/projects/ directory.
|
||||
#
|
||||
# What's missing: the gstack learnings JSONL never reaches gbrain. T8
|
||||
# fixes that with an IngestionSource bridge that watches the JSONL files
|
||||
# and emits IngestionEvent per line typed as `learning` page.
|
||||
#
|
||||
# Scope deliberately small: declares the `learning` page type (NEW) and
|
||||
# reuses `code` from gbrain-base. Drops the speculative ADR / postmortem /
|
||||
# refactor_thesis / tech_debt types from the original plan because:
|
||||
# (a) gstack's investigation + retro skills already capture postmortems
|
||||
# and architecture decisions inline (no dedicated type needed)
|
||||
# (b) shipping types nobody authors is worse than no types at all
|
||||
# (c) v0.42+ can add them when first user authors one
|
||||
#
|
||||
# Calibration: declares 3 engineering domains (architecture_calls,
|
||||
# effort_estimates, risk_assessment). All scalar_brier except
|
||||
# effort_estimates which uses weighted_brier — small estimates that are
|
||||
# wrong cost less than big estimates that are wrong.
|
||||
#
|
||||
# Does NOT declare new cycle phases. Engineering work consumes the
|
||||
# existing extract_facts + propose_takes + grade_takes + calibration_profile
|
||||
# loop, augmented by the gstack-learnings IngestionSource (T8) running in
|
||||
# the v0.38 daemon when this pack is active.
|
||||
|
||||
api_version: gbrain-schema-pack-v1
|
||||
name: gbrain-engineer
|
||||
version: 1.0.0
|
||||
description: "Engineer / code-author lens. Bridges gstack's typed JSONL learnings system (pattern, pitfall, architecture, tool, operational, investigation) into gbrain as first-class `learning` pages. Declares architecture_calls, effort_estimates, risk_assessment calibration domains. Reuses gbrain-base's `code` page type unchanged."
|
||||
gbrain_min_version: 0.41.0
|
||||
extends: gbrain-base
|
||||
|
||||
# Reuse `code` + `project` from base. The gstack-learnings bridge writes
|
||||
# `learning` pages cross-referenced to code:// URIs via link_types, but
|
||||
# we don't introduce new code-related page types here.
|
||||
borrow_from:
|
||||
- pack: gbrain-base
|
||||
types:
|
||||
- code
|
||||
- project
|
||||
|
||||
# Engineering uses the same takes_kinds as base (fact, take, bet, hunch).
|
||||
# `bet` is the load-bearing one for architecture_calls (a bet on a
|
||||
# refactor's payoff is a take).
|
||||
# takes_kinds intentionally omitted (inherits from base).
|
||||
|
||||
# Pack-specific page types. ONLY `learning` is new (D8-C: bridge-only).
|
||||
page_types:
|
||||
- name: learning
|
||||
primitive: annotation
|
||||
path_prefixes:
|
||||
- learnings/
|
||||
- engineering/learnings/
|
||||
aliases: []
|
||||
# extractable: false — learnings ARE distilled engineering insights;
|
||||
# they're not raw source material for further fact extraction.
|
||||
extractable: false
|
||||
# expert_routing: false — learnings surface in code-aware queries
|
||||
# via direct slug search, not via whoknows/find_experts (whoknows is
|
||||
# person+company shaped, learnings are pattern shaped).
|
||||
expert_routing: false
|
||||
|
||||
# No new cycle phases. Engineering consumes existing pipeline.
|
||||
# gstack-learnings IngestionSource (T8) emits events when this pack is
|
||||
# active — handled by the v0.38 daemon's normal trickle-mode dispatch.
|
||||
phases: []
|
||||
|
||||
# v0.41 T3: engineering-flavored calibration domains.
|
||||
calibration_domains:
|
||||
- name: architecture_calls
|
||||
# "How often I'm wrong about which architecture to pick" — scalar
|
||||
# Brier over resolved code-attached + learning-attached binary takes
|
||||
# (e.g. "this refactor was worth it" resolved true/false).
|
||||
aggregator: scalar_brier
|
||||
page_types:
|
||||
- code
|
||||
- learning
|
||||
|
||||
- name: effort_estimates
|
||||
# Weighted Brier — a 1-day-estimate miss costs less than a 1-quarter
|
||||
# estimate miss. Weight by take.confidence so high-conviction
|
||||
# estimates that fail count more.
|
||||
aggregator: weighted_brier
|
||||
page_types:
|
||||
- project
|
||||
|
||||
- name: risk_assessment
|
||||
# "How often I correctly flag a risk" — scalar Brier over project-
|
||||
# attached binary takes (e.g. "this rollout will OOM" resolved
|
||||
# true/false). Distinct from architecture_calls (those are go/no-go
|
||||
# decisions on direction; risk_assessment is about specific failure
|
||||
# mode predictions).
|
||||
aggregator: scalar_brier
|
||||
page_types:
|
||||
- project
|
||||
|
||||
# Filing rules.
|
||||
filing_rules:
|
||||
- kind: learning
|
||||
directory: learnings/
|
||||
examples:
|
||||
- learnings/2026-05/orbstack-port-8080-conflict
|
||||
- learnings/2026-05/django-form-cleaned-data-defaults-empty
|
||||
description: "Engineering learnings bridged from gstack's ~/.gstack/projects/{repo}/learnings.jsonl. Per-month subdirectories. Frontmatter carries the original JSONL fields verbatim: learning_type (one of: pattern, pitfall, preference, architecture, tool, operational, investigation), confidence (1-10), source (one of: observed, user-stated, inferred, cross-model), files (paths), skill (originating gstack skill name)."
|
||||
121
src/core/schema-pack/base/gbrain-everything.yaml
Normal file
121
src/core/schema-pack/base/gbrain-everything.yaml
Normal file
@@ -0,0 +1,121 @@
|
||||
# gbrain-everything — meta-pack stacking all three lenses
|
||||
#
|
||||
# v0.41 lens packs wave. Codex outside-voice T4 resolution: gbrain's
|
||||
# 7-tier active-pack resolver is single-valued, but the user's actual
|
||||
# workflow needs creator + investor + engineer simultaneously (Garry
|
||||
# switches between YC investor work, content creation, and gstack
|
||||
# engineering across the same day). Two paths to "three lenses on one
|
||||
# brain":
|
||||
#
|
||||
# A) New active-multi-pack composition concept. New code, new
|
||||
# architecture, new corners. Deferred per plan's NOT-in-scope.
|
||||
#
|
||||
# B) Compose via the v0.38-shipped extends chain. Author a meta-pack
|
||||
# that extends one of the three, and bring the other two via
|
||||
# borrow_from. registry walks the chain, unions page_types +
|
||||
# link_types + phases + calibration_domains. ZERO new architecture.
|
||||
#
|
||||
# This pack is path B. Activate via `gbrain config set schema_pack
|
||||
# gbrain-everything` and the brain runs all three lens-pack phases
|
||||
# (extract_atoms + synthesize_concepts from creator; gstack-learnings
|
||||
# bridge from engineer) AND surfaces all 7 calibration domains
|
||||
# (_overall + concept_themes + deal_success + founder_evaluation +
|
||||
# market_call + architecture_calls + effort_estimates + risk_assessment).
|
||||
#
|
||||
# Extension chain (registry resolves via extends.parent.parent.parent):
|
||||
#
|
||||
# gbrain-everything ──extends──▶ gbrain-investor ──extends──▶ gbrain-base
|
||||
# │ borrow │
|
||||
# ├─ gbrain-creator
|
||||
# └─ gbrain-engineer
|
||||
#
|
||||
# Single-active-pack constraint preserved: this IS the active pack.
|
||||
# Registry walks its dependencies through extends + borrow_from to
|
||||
# materialize the merged view. Tested by the everything-manifest test.
|
||||
|
||||
api_version: gbrain-schema-pack-v1
|
||||
name: gbrain-everything
|
||||
version: 1.0.0
|
||||
description: "Meta-pack stacking creator + investor + engineer lenses on one brain. Use this when you do investor work AND content creation AND engineering in the same brain (YC president pattern, founder pattern). Single active-pack activation via `gbrain config set schema_pack gbrain-everything` — registry walks extends + borrow_from chain to union all three lenses' page_types, phases, and calibration_domains."
|
||||
gbrain_min_version: 0.41.0
|
||||
|
||||
# Extends gbrain-investor (which itself extends gbrain-base) and borrows
|
||||
# from gbrain-creator + gbrain-engineer. The registry's extends chain
|
||||
# walker (cap depth 8) unions every level's contributions.
|
||||
extends: gbrain-investor
|
||||
|
||||
# Borrow types + link_types from the other two lens packs. This is the
|
||||
# composition mechanism that makes "three lenses" real without a
|
||||
# multi-active-pack architecture.
|
||||
borrow_from:
|
||||
- pack: gbrain-creator
|
||||
types:
|
||||
- atom
|
||||
# concept already in base
|
||||
- pack: gbrain-engineer
|
||||
types:
|
||||
- learning
|
||||
# code + project already in base
|
||||
|
||||
# No new page types declared here — everything comes via extends + borrow.
|
||||
page_types: []
|
||||
|
||||
# Union of creator + engineer phase declarations. Investor pack declares
|
||||
# no phases (consumes existing pipeline), so nothing inherited from the
|
||||
# extends chain there. Creator's phases must be re-declared explicitly
|
||||
# because `borrow_from` borrows types/link_types only, NOT phases (D4-B
|
||||
# decision: each pack declares its phase participation explicitly).
|
||||
#
|
||||
# Engineer pack's phases: [] is the empty case — the gstack-learnings
|
||||
# IngestionSource is daemon-side, not a cycle phase.
|
||||
phases:
|
||||
- extract_atoms
|
||||
- synthesize_concepts
|
||||
|
||||
# Union of creator + investor + engineer calibration domains. Same
|
||||
# explicit re-declaration rationale as phases — calibration_domains
|
||||
# aren't borrowed; the meta-pack declares the full set.
|
||||
#
|
||||
# Aggregator algorithms are the closed enum; domain names match the
|
||||
# per-pack declarations so the JSONB scorecard keys are stable across
|
||||
# active-pack switches (a user moving from gbrain-investor to
|
||||
# gbrain-everything keeps their deal_success scorecard intact).
|
||||
calibration_domains:
|
||||
# From gbrain-creator:
|
||||
- name: concept_themes
|
||||
aggregator: cluster_summary
|
||||
page_types:
|
||||
- concept
|
||||
|
||||
# From gbrain-investor:
|
||||
- name: deal_success
|
||||
aggregator: scalar_brier
|
||||
page_types:
|
||||
- deal
|
||||
- name: founder_evaluation
|
||||
aggregator: scalar_brier
|
||||
page_types:
|
||||
- person
|
||||
- name: market_call
|
||||
aggregator: weighted_brier
|
||||
page_types:
|
||||
- thesis
|
||||
|
||||
# From gbrain-engineer:
|
||||
- name: architecture_calls
|
||||
aggregator: scalar_brier
|
||||
page_types:
|
||||
- code
|
||||
- learning
|
||||
- name: effort_estimates
|
||||
aggregator: weighted_brier
|
||||
page_types:
|
||||
- project
|
||||
- name: risk_assessment
|
||||
aggregator: scalar_brier
|
||||
page_types:
|
||||
- project
|
||||
|
||||
# Filing rules inherit through extends + borrow. No re-declaration needed —
|
||||
# registry merges parent + borrowed pack filing_rules.
|
||||
filing_rules: []
|
||||
151
src/core/schema-pack/base/gbrain-investor.yaml
Normal file
151
src/core/schema-pack/base/gbrain-investor.yaml
Normal file
@@ -0,0 +1,151 @@
|
||||
# gbrain-investor — investor/YC lens pack
|
||||
#
|
||||
# v0.41 lens packs wave. Declares the investor work surface that the user
|
||||
# (YC president) already runs every day across the your OpenClaw agent + brain:
|
||||
# - 501 investor profiles at brain/investors/
|
||||
# - 19 deal memos at brain/investing/deals/
|
||||
# - 5.3K companies + 24.6K people + 7.1K YC pages
|
||||
# - 8 investor skills (yc-radar, yc-portfolio-health, sequoia-batch-bangers,
|
||||
# investor-diligence, batch-picks-for-investor, etc.)
|
||||
# - Fences already in use: ## Recommendation, ## Pre-mortem, ## Defensibility
|
||||
# (6-8 moats), ## Founders, ## Product, ## Market / Customers, ## Traction,
|
||||
# ## Team, ## Signals
|
||||
#
|
||||
# This pack consolidates the EXISTING primitives as pack-owned + adds a
|
||||
# bet-resolution lifecycle:
|
||||
#
|
||||
# - `thesis` (NEW): investment thesis with thesis_text, key_bets[],
|
||||
# market_view, vintage. Filed at investing/theses/{slug}.
|
||||
#
|
||||
# - `bet_resolution_log` (NEW): outcome record for a thesis's bet. Bound
|
||||
# to a take row via take_id, carries resolved_outcome + resolved_at +
|
||||
# learned_pattern. Filed at investing/bets/{YYYY-MM}/{slug}.
|
||||
#
|
||||
# Calibration: declares 3 domains feeding the v0.41-widened
|
||||
# calibration_profile: deal_success (Brier over resolved deal-flagged
|
||||
# takes), founder_evaluation (Brier over person-flagged takes), market_call
|
||||
# (weighted Brier over thesis-flagged takes, weighted by take.confidence
|
||||
# because market calls' high-conviction-but-rare nature wants Brier scaled
|
||||
# by stake).
|
||||
#
|
||||
# Does NOT declare new cycle phases — investor work consumes the existing
|
||||
# extract_facts + propose_takes + grade_takes + calibration_profile loop.
|
||||
# The propose_takes phase populates take_domain_assignments rows at write
|
||||
# time from this pack's page_types → domain mapping (T10 wiring).
|
||||
#
|
||||
# Cron consolidation: existing your OpenClaw's crons (yc-radar-weekly,
|
||||
# yc-portfolio-health monthly, yc-oh-ingest daily) continue running on
|
||||
# their own schedules in your OpenClaw — gbrain-investor doesn't displace
|
||||
# them, only declares their output types + calibration semantics. v0.42+
|
||||
# may migrate those crons too once their phase contracts stabilize.
|
||||
|
||||
api_version: gbrain-schema-pack-v1
|
||||
name: gbrain-investor
|
||||
version: 1.0.0
|
||||
description: "Investor / YC president lens. Adds thesis + bet_resolution_log types to the deal/investor/company/person surface that already exists in gbrain-base. Declares deal_success / founder_evaluation / market_call calibration domains feeding the widened calibration_profile."
|
||||
gbrain_min_version: 0.41.0
|
||||
extends: gbrain-base
|
||||
|
||||
# Borrow deal + person + company + yc from gbrain-base — they remain
|
||||
# base-owned (other packs may also use them) but this pack's calibration
|
||||
# domains reference them. No new declarations needed because borrow_from
|
||||
# just signals intent; the registry already merges types from the
|
||||
# extends chain.
|
||||
borrow_from:
|
||||
- pack: gbrain-base
|
||||
types:
|
||||
- deal
|
||||
- person
|
||||
- company
|
||||
- yc
|
||||
|
||||
# Investor work uses the same takes_kinds as base (fact, take, bet, hunch).
|
||||
# The `bet` kind is the load-bearing one for this pack — bet_resolution_log
|
||||
# tracks outcomes for take rows of kind='bet'.
|
||||
# takes_kinds intentionally omitted (inherits from base).
|
||||
|
||||
# Pack-specific page types. `deal` already exists in gbrain-base seed.
|
||||
# `thesis` and `bet_resolution_log` are net-new for v0.41.
|
||||
#
|
||||
# `investor` and `founder` (alias for person in deal context) are
|
||||
# deferred: investor pages are filed under investors/ but the type is
|
||||
# `person` today and changing it requires data migration. v0.42+ can
|
||||
# introduce them with proper migration.
|
||||
page_types:
|
||||
- name: thesis
|
||||
primitive: concept
|
||||
path_prefixes:
|
||||
- investing/theses/
|
||||
- theses/
|
||||
aliases: []
|
||||
# extractable: true — theses contain claims that the LLM extractor
|
||||
# can mine into facts (the thesis itself is a claim; sub-bets are
|
||||
# claims). extract_facts walks them.
|
||||
extractable: true
|
||||
# expert_routing: false — theses don't surface in find_experts;
|
||||
# founders + companies carry that weight.
|
||||
expert_routing: false
|
||||
|
||||
- name: bet_resolution_log
|
||||
primitive: temporal
|
||||
path_prefixes:
|
||||
- investing/bets/
|
||||
- bets/
|
||||
aliases: []
|
||||
extractable: false
|
||||
expert_routing: false
|
||||
|
||||
# No new cycle phases. Investor work consumes the existing pipeline.
|
||||
phases: []
|
||||
|
||||
# v0.41 T3: investor-flavored calibration domains. Each binds the closed
|
||||
# aggregator algorithm to the open domain name + page_types whose takes
|
||||
# feed this bucket. propose_takes (T10) populates take_domain_assignments
|
||||
# rows at write time from this mapping when this pack is active.
|
||||
calibration_domains:
|
||||
- name: deal_success
|
||||
# Standard Brier over resolved deal-attached binary takes
|
||||
# (did this deal succeed? = take.resolved_outcome).
|
||||
aggregator: scalar_brier
|
||||
page_types:
|
||||
- deal
|
||||
|
||||
- name: founder_evaluation
|
||||
# Standard Brier over person-attached takes. The "how often I'm
|
||||
# wrong about founders" signal.
|
||||
aggregator: scalar_brier
|
||||
page_types:
|
||||
- person
|
||||
|
||||
- name: market_call
|
||||
# Weighted Brier — market calls are rare-but-high-stakes; weighting
|
||||
# by take.confidence means a misfired strong conviction costs more
|
||||
# than a misfired weak hunch.
|
||||
aggregator: weighted_brier
|
||||
page_types:
|
||||
- thesis
|
||||
|
||||
# Filing rules — mirror your OpenClaw's existing layout so the v0.41
|
||||
# greenfield migration (T7) lands pages in their canonical locations.
|
||||
filing_rules:
|
||||
- kind: deal
|
||||
directory: investing/deals/
|
||||
examples:
|
||||
- investing/deals/widget-co-pre-a-memo
|
||||
description: "Investment memos. Pre-existing fences (## Recommendation, ## Pre-mortem, ## Defensibility, ## Founders, ## Product, ## Market / Customers, ## Traction, ## Team) carry through unchanged."
|
||||
- kind: thesis
|
||||
directory: investing/theses/
|
||||
examples:
|
||||
- investing/theses/ai-agents-2026
|
||||
- investing/theses/hardware-renaissance
|
||||
description: "Investment theses with thesis_text + key_bets[] + market_view + vintage frontmatter. Sub-bets resolve into bet_resolution_log entries via the take_id FK chain."
|
||||
- kind: bet_resolution_log
|
||||
directory: investing/bets/
|
||||
examples:
|
||||
- investing/bets/2026-04/widget-co-arr-trajectory
|
||||
description: "Resolution records for thesis bets. Month-bucketed by resolution date. Frontmatter: bet_id (FK to thesis.key_bets), resolved_outcome (boolean), resolved_at (ISO date), learned_pattern (one-sentence takeaway). Populates the market_call calibration domain."
|
||||
- kind: investor
|
||||
directory: investors/
|
||||
examples:
|
||||
- investors/example-vc-fund
|
||||
description: "Investor profiles (501 already extant). Filed flat under investors/. Page type stays `person` for now (data-migration deferral). v0.42+ may introduce dedicated `investor` page type."
|
||||
@@ -16,6 +16,10 @@ export {
|
||||
parseSchemaPackManifest,
|
||||
computeManifestSha8,
|
||||
packIdentity,
|
||||
// v0.41 T3 — calibration domain registry
|
||||
AGGREGATOR_KINDS,
|
||||
type AggregatorKind,
|
||||
type CalibrationDomain,
|
||||
} from './manifest-v1.ts';
|
||||
|
||||
export {
|
||||
|
||||
@@ -95,7 +95,20 @@ function defaultPackLocator(name: string): string | null {
|
||||
// v0.39 T8 — bundled packs registry. gbrain-base + gbrain-recommended
|
||||
// ship in src/core/schema-pack/base/. Add a new entry here to bundle
|
||||
// additional canonical packs.
|
||||
const BUNDLED: ReadonlyArray<string> = ['gbrain-base', 'gbrain-recommended'];
|
||||
//
|
||||
// v0.41 T4 — lens packs join the bundle: creator (atoms + concepts +
|
||||
// extract_atoms/synthesize_concepts phases), investor (theses + bet
|
||||
// resolution + 3 calibration domains), engineer (gstack-learnings bridge
|
||||
// + 3 calibration domains), everything (meta-pack stacking all three
|
||||
// via extends + borrow_from). Each ships as a real YAML at base/<name>.yaml.
|
||||
const BUNDLED: ReadonlyArray<string> = [
|
||||
'gbrain-base',
|
||||
'gbrain-recommended',
|
||||
'gbrain-creator',
|
||||
'gbrain-investor',
|
||||
'gbrain-engineer',
|
||||
'gbrain-everything',
|
||||
];
|
||||
if (BUNDLED.includes(name)) {
|
||||
// Resolve bundled YAML relative to this source file. Works in both
|
||||
// direct-bun execution and bun --compile binaries.
|
||||
|
||||
@@ -89,6 +89,68 @@ const FilingRuleSchema = z.object({
|
||||
description: z.string().optional(),
|
||||
}).strict();
|
||||
|
||||
/**
|
||||
* v0.41 T3 — closed registry of calibration aggregator algorithms.
|
||||
*
|
||||
* Codex outside-voice refinement of D6: domain NAMES stay open (any pack
|
||||
* can declare `pricing_judgment` or `hiring_quality` without a gbrain
|
||||
* release), but the AGGREGATOR — the actual SQL/code that computes a
|
||||
* scorecard for that domain — must be a closed enum. New aggregator
|
||||
* algorithms ship via gbrain release; new domain names ship via pack
|
||||
* manifest. This splits the "what" (open) from the "how" (closed),
|
||||
* preserving extensibility without SQL injection surface.
|
||||
*
|
||||
* v1 aggregators:
|
||||
* - `scalar_brier` — standard Brier score over resolved binary takes
|
||||
* (sum((p - outcome)^2) / n). Default for most
|
||||
* predictive domains.
|
||||
* - `weighted_brier` — Brier weighted by take.confidence. Use when
|
||||
* calibration cares more about high-conviction
|
||||
* predictions than low-stakes ones.
|
||||
* - `count_based` — simple accuracy ratio (correct / resolved).
|
||||
* Use when binary outcomes don't have natural
|
||||
* probability semantics (e.g. did/didn't happen).
|
||||
* - `cluster_summary` — descriptive rollup (tier counts, dominant
|
||||
* topics, time span) instead of Brier. Used by
|
||||
* the creator pack's concept_themes domain where
|
||||
* there is no "right answer" to score against.
|
||||
*
|
||||
* Expand this enum in v0.42+ as real lens-pack usage surfaces new
|
||||
* aggregation needs. Each addition is a versioned gbrain release.
|
||||
*/
|
||||
export const AGGREGATOR_KINDS = [
|
||||
'scalar_brier',
|
||||
'weighted_brier',
|
||||
'count_based',
|
||||
'cluster_summary',
|
||||
] as const;
|
||||
export type AggregatorKind = typeof AGGREGATOR_KINDS[number];
|
||||
|
||||
const AggregatorKindSchema = z.enum(AGGREGATOR_KINDS);
|
||||
|
||||
/**
|
||||
* v0.41 T3 — per-pack calibration domain declaration. The calibration_profile
|
||||
* cycle phase widens at v0.41 from a placeholder `{}` JSONB to an aggregator
|
||||
* pass over each active pack's declared domains. Each entry binds:
|
||||
* - `name` — open string label visible in scorecards
|
||||
* (`deal_success`, `architecture_calls`, etc.)
|
||||
* - `aggregator` — closed-enum algorithm to compute the scorecard
|
||||
* - `page_types` — page types whose takes feed this domain (the
|
||||
* propose_takes phase populates take_domain_assignments
|
||||
* at write time from this mapping)
|
||||
*
|
||||
* Loaded by the registry at pack-load; validated against AggregatorKindSchema
|
||||
* before any aggregator code runs. Unknown aggregator values fail the pack
|
||||
* load with a paste-ready `gbrain models doctor`-style hint.
|
||||
*/
|
||||
const CalibrationDomainSchema = z.object({
|
||||
name: z.string().min(1).regex(/^[a-z][a-z0-9_]*$/, 'domain name must be lowercase snake_case'),
|
||||
aggregator: AggregatorKindSchema,
|
||||
page_types: z.array(z.string().min(1)).min(1),
|
||||
}).strict();
|
||||
|
||||
export type CalibrationDomain = z.infer<typeof CalibrationDomainSchema>;
|
||||
|
||||
/**
|
||||
* SchemaPackManifest v1 — the parsed + validated pack file shape.
|
||||
* `extends` resolution + closure expansion are done by registry.ts, not at
|
||||
@@ -118,6 +180,34 @@ export const SchemaPackManifestSchema = z.object({
|
||||
takes_kinds: z.array(z.string()).default(['fact', 'take', 'bet', 'hunch']),
|
||||
enrichable_types: z.array(EnrichableSchema).default([]),
|
||||
filing_rules: z.array(FilingRuleSchema).default([]),
|
||||
/**
|
||||
* v0.41 T3/D4 — phase participation declaration. The runCycle orchestrator
|
||||
* consults active pack's `phases:` to decide which pack-flavored cycle
|
||||
* phases run (extract_atoms, synthesize_concepts, future pack phases).
|
||||
* Pre-existing 17 core phases (lint, sync, extract, extract_facts,
|
||||
* propose_takes, etc.) ALWAYS run regardless of this declaration —
|
||||
* `phases:` is additive, not subtractive. `borrow_from` does NOT borrow
|
||||
* phases; each pack declares its own participation explicitly.
|
||||
*
|
||||
* Phase names are validated as strings at parse time and against the
|
||||
* runtime CyclePhase union at pack-load by the registry (kept as string[]
|
||||
* here to avoid a circular import from src/core/cycle.ts).
|
||||
*
|
||||
* Optional rather than .default([]) so existing v0.38 manifest casts in
|
||||
* test fixtures don't need to be re-typed; consumers apply `?? []` at
|
||||
* the read site.
|
||||
*/
|
||||
phases: z.array(z.string().min(1)).optional(),
|
||||
/**
|
||||
* v0.41 T3 — per-pack calibration domain declarations. The
|
||||
* calibration_profile cycle phase widens at v0.41 from `{}` placeholder
|
||||
* JSONB to a real aggregator pass over each declared domain. See
|
||||
* CalibrationDomainSchema for the per-entry shape.
|
||||
*
|
||||
* Optional for the same reason as `phases` — preserves cast-compatibility
|
||||
* with pre-v0.41 fixtures.
|
||||
*/
|
||||
calibration_domains: z.array(CalibrationDomainSchema).optional(),
|
||||
}).strict();
|
||||
|
||||
export type SchemaPackManifest = z.infer<typeof SchemaPackManifestSchema>;
|
||||
|
||||
@@ -129,7 +129,10 @@ describe('createAuditWriter — log()', () => {
|
||||
await withEnv({ GBRAIN_AUDIT_DIR: dir }, async () => {
|
||||
const writer = createAuditWriter<TestEvent>({ featureName: 'ts-override' });
|
||||
writer.log({ ts: fixedTs, message: 'pinned' });
|
||||
const file = path.join(dir, writer.computeFilename());
|
||||
// Events route to the ISO-week file for their OWN ts (so back-dated
|
||||
// events stay readable by readRecent that walks by event week).
|
||||
// Compute the file path using the event's ts, not wall-clock now.
|
||||
const file = path.join(dir, writer.computeFilename(new Date(fixedTs)));
|
||||
const content = fs.readFileSync(file, 'utf8');
|
||||
const row = JSON.parse(content.trim());
|
||||
expect(row.ts).toBe(fixedTs);
|
||||
|
||||
@@ -390,7 +390,8 @@ describe('runCycle — yieldBetweenPhases hook', () => {
|
||||
// v0.33.3: 13 phases (added `resolve_symbol_edges` between extract_facts and patterns) → 13 yield calls.
|
||||
// v0.36.1.0: 16 phases (added `propose_takes`, `grade_takes`, `calibration_profile` between consolidate and embed).
|
||||
// v0.39.0.0: 17 phases (added `schema-suggest` between orphans and purge — T12 schema cathedral).
|
||||
expect(hookCalls).toBe(17);
|
||||
// v0.41.2.0: 19 phases (added `extract_atoms` after extract_facts + `synthesize_concepts` after patterns).
|
||||
expect(hookCalls).toBe(19);
|
||||
});
|
||||
|
||||
test('hook exceptions do not abort the cycle', async () => {
|
||||
@@ -403,7 +404,7 @@ describe('runCycle — yieldBetweenPhases hook', () => {
|
||||
// v0.33.3: 13 phases (v0.32.2's 12 + resolve_symbol_edges).
|
||||
// v0.36.1.0: 16 phases (Hindsight calibration wave adds propose_takes, grade_takes, calibration_profile).
|
||||
// v0.39.0.0: 17 phases (T12 schema-suggest phase between orphans and purge).
|
||||
expect(report.phases.length).toBe(17);
|
||||
expect(report.phases.length).toBe(19); // v0.41: +extract_atoms, +synthesize_concepts
|
||||
});
|
||||
});
|
||||
|
||||
|
||||
186
test/cycle-pack-gating.test.ts
Normal file
186
test/cycle-pack-gating.test.ts
Normal file
@@ -0,0 +1,186 @@
|
||||
// v0.41 T9 R-GATE — orchestrator-level pack gate for lens-pack phases.
|
||||
//
|
||||
// IRON-RULE regression pinning:
|
||||
// 1. ALL_PHASES includes 'extract_atoms' (after extract_facts) and
|
||||
// 'synthesize_concepts' (after patterns).
|
||||
// 2. PHASE_SCOPE declares extract_atoms='source', synthesize_concepts='global'.
|
||||
// 3. NEEDS_LOCK_PHASES includes both (they mutate DB via put_page).
|
||||
// 4. cycle.ts dispatch contains the packDeclaresPhase gate for both
|
||||
// new phases (source-shape assertion — pins the not_in_active_pack
|
||||
// semantics against future drift).
|
||||
// 5. Pre-existing 17 core phases ALWAYS run regardless of active pack —
|
||||
// only the 2 new lens-pack phases are gated (source-shape regression).
|
||||
// 6. borrow_from does NOT borrow phases — gbrain-everything explicitly
|
||||
// re-declares creator's phases per D4-B (verified in T4 test;
|
||||
// cross-referenced here as a pinning hint via source grep).
|
||||
//
|
||||
// Why static-source assertions in addition to runtime tests: cycle.ts is a
|
||||
// ~1700-line orchestrator and the dispatch logic for these new phases
|
||||
// follows a load-bearing pattern (`if (phases.includes(X)) { ... if
|
||||
// (!await packDeclaresPhase(engine, X)) skipped else dispatch }`). Static
|
||||
// source pinning catches refactors that accidentally drop the gate while
|
||||
// still passing happy-path runtime tests.
|
||||
|
||||
import { describe, test, expect } from 'bun:test';
|
||||
import { readFileSync } from 'fs';
|
||||
import { join, dirname } from 'path';
|
||||
import { fileURLToPath } from 'url';
|
||||
import { ALL_PHASES, PHASE_SCOPE, type CyclePhase } from '../src/core/cycle.ts';
|
||||
|
||||
const here = dirname(fileURLToPath(import.meta.url));
|
||||
const cycleTsSrc = readFileSync(
|
||||
join(here, '..', 'src', 'core', 'cycle.ts'),
|
||||
'utf-8',
|
||||
);
|
||||
|
||||
const NEW_PHASES: ReadonlyArray<CyclePhase> = ['extract_atoms', 'synthesize_concepts'];
|
||||
|
||||
describe('v0.41 T9 R-GATE: ALL_PHASES + PHASE_SCOPE contract', () => {
|
||||
test('ALL_PHASES contains extract_atoms', () => {
|
||||
expect(ALL_PHASES).toContain('extract_atoms');
|
||||
});
|
||||
|
||||
test('ALL_PHASES contains synthesize_concepts', () => {
|
||||
expect(ALL_PHASES).toContain('synthesize_concepts');
|
||||
});
|
||||
|
||||
test('extract_atoms is positioned AFTER extract_facts (semantic ordering)', () => {
|
||||
const extractFactsIdx = ALL_PHASES.indexOf('extract_facts');
|
||||
const extractAtomsIdx = ALL_PHASES.indexOf('extract_atoms');
|
||||
expect(extractFactsIdx).toBeGreaterThan(-1);
|
||||
expect(extractAtomsIdx).toBeGreaterThan(extractFactsIdx);
|
||||
});
|
||||
|
||||
test('synthesize_concepts is positioned AFTER patterns (graph-fresh semantics)', () => {
|
||||
const patternsIdx = ALL_PHASES.indexOf('patterns');
|
||||
const synthIdx = ALL_PHASES.indexOf('synthesize_concepts');
|
||||
expect(patternsIdx).toBeGreaterThan(-1);
|
||||
expect(synthIdx).toBeGreaterThan(patternsIdx);
|
||||
});
|
||||
|
||||
test('PHASE_SCOPE declares extract_atoms as source-scoped', () => {
|
||||
expect(PHASE_SCOPE.extract_atoms).toBe('source');
|
||||
});
|
||||
|
||||
test('PHASE_SCOPE declares synthesize_concepts as global-scoped', () => {
|
||||
expect(PHASE_SCOPE.synthesize_concepts).toBe('global');
|
||||
});
|
||||
|
||||
test('every ALL_PHASES entry has a PHASE_SCOPE entry (exhaustive map)', () => {
|
||||
for (const p of ALL_PHASES) {
|
||||
expect(PHASE_SCOPE[p]).toBeDefined();
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T9 R-GATE: NEEDS_LOCK_PHASES contract (source-shape)', () => {
|
||||
// NEEDS_LOCK_PHASES isn't exported; static-source assertion pins the
|
||||
// contract that both new phases acquire the cycle lock since they
|
||||
// mutate DB state (put_page atom/concept pages).
|
||||
test('cycle.ts source includes extract_atoms in NEEDS_LOCK_PHASES', () => {
|
||||
// Find the NEEDS_LOCK_PHASES block and assert both phases appear in it.
|
||||
const blockStart = cycleTsSrc.indexOf('NEEDS_LOCK_PHASES');
|
||||
expect(blockStart).toBeGreaterThan(-1);
|
||||
const blockEnd = cycleTsSrc.indexOf(']);', blockStart);
|
||||
expect(blockEnd).toBeGreaterThan(blockStart);
|
||||
const block = cycleTsSrc.slice(blockStart, blockEnd);
|
||||
expect(block).toContain("'extract_atoms'");
|
||||
});
|
||||
|
||||
test('cycle.ts source includes synthesize_concepts in NEEDS_LOCK_PHASES', () => {
|
||||
const blockStart = cycleTsSrc.indexOf('NEEDS_LOCK_PHASES');
|
||||
const blockEnd = cycleTsSrc.indexOf(']);', blockStart);
|
||||
const block = cycleTsSrc.slice(blockStart, blockEnd);
|
||||
expect(block).toContain("'synthesize_concepts'");
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T9 R-GATE: orchestrator dispatch wires the pack-gate', () => {
|
||||
// Source-shape regression: the dispatch for each new phase MUST
|
||||
// consult packDeclaresPhase(engine, '<phase>') before invoking the
|
||||
// phase. Future refactors that accidentally drop the gate would still
|
||||
// pass happy-path runtime tests; this assertion catches the drop.
|
||||
test('cycle.ts dispatch for extract_atoms calls packDeclaresPhase', () => {
|
||||
expect(cycleTsSrc).toContain("packDeclaresPhase(engine, 'extract_atoms')");
|
||||
});
|
||||
|
||||
test('cycle.ts dispatch for synthesize_concepts calls packDeclaresPhase', () => {
|
||||
expect(cycleTsSrc).toContain("packDeclaresPhase(engine, 'synthesize_concepts')");
|
||||
});
|
||||
|
||||
test('packDeclaresPhase helper function exists in cycle.ts', () => {
|
||||
expect(cycleTsSrc).toContain('async function packDeclaresPhase(');
|
||||
});
|
||||
|
||||
test('packDeclaresPhase reads phases from active pack manifest (NOT extends chain)', () => {
|
||||
// Source-pin: the helper reads `resolved.manifest.phases` — D4-B
|
||||
// says phases are local to the declaring manifest. Future drift
|
||||
// that adds extends-chain merging would silently change semantics
|
||||
// for users who extend gbrain-creator expecting inheritance; this
|
||||
// assertion catches it.
|
||||
expect(cycleTsSrc).toContain('resolved.manifest.phases');
|
||||
});
|
||||
|
||||
test('packDeclaresPhase fail-open: returns false on catch (no thrown exceptions)', () => {
|
||||
// Source-pin: the helper's try/catch returns false on any error
|
||||
// (registry not initialized, pack not found, malformed manifest).
|
||||
// Skipping > crashing for an orchestrator gate.
|
||||
const helperStart = cycleTsSrc.indexOf('async function packDeclaresPhase(');
|
||||
expect(helperStart).toBeGreaterThan(-1);
|
||||
const helperEnd = cycleTsSrc.indexOf('\n}\n', helperStart);
|
||||
const helperBody = cycleTsSrc.slice(helperStart, helperEnd);
|
||||
expect(helperBody).toContain('catch');
|
||||
expect(helperBody).toContain('return false');
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T9 R-GATE: pre-existing 17 core phases always run', () => {
|
||||
// The IRON RULE that the wave depends on: pack-gating is ADDITIVE,
|
||||
// not subtractive. A user on gbrain-base (which declares phases:[])
|
||||
// must still see all 17 pre-existing phases run as before. The static
|
||||
// assertion: only the 2 new lens-pack phases reference packDeclaresPhase
|
||||
// in the dispatch.
|
||||
test('only extract_atoms + synthesize_concepts dispatch sites reference packDeclaresPhase', () => {
|
||||
const matches = cycleTsSrc.match(/packDeclaresPhase\(engine, '[^']+'\)/g) ?? [];
|
||||
const phaseNames = matches.map((m) => {
|
||||
const inner = /packDeclaresPhase\(engine, '([^']+)'\)/.exec(m);
|
||||
return inner ? inner[1] : '';
|
||||
});
|
||||
// Should be EXACTLY two phases gated.
|
||||
expect(phaseNames.sort()).toEqual(['extract_atoms', 'synthesize_concepts']);
|
||||
});
|
||||
|
||||
test('extract_facts dispatch does NOT consult packDeclaresPhase', () => {
|
||||
// Pre-existing phase; must always run on every pack. Window scoped
|
||||
// to the SINGLE dispatch block — find the next `// ──` comment
|
||||
// marker (the next phase dispatch header) and stop there.
|
||||
const blockStart = cycleTsSrc.indexOf("if (phases.includes('extract_facts'))");
|
||||
expect(blockStart).toBeGreaterThan(-1);
|
||||
const blockEnd = cycleTsSrc.indexOf('// ──', blockStart + 10);
|
||||
expect(blockEnd).toBeGreaterThan(blockStart);
|
||||
const block = cycleTsSrc.slice(blockStart, blockEnd);
|
||||
expect(block).not.toContain('packDeclaresPhase');
|
||||
});
|
||||
|
||||
test('calibration_profile dispatch does NOT consult packDeclaresPhase', () => {
|
||||
// Pre-existing v0.36.1.0 phase; always-on.
|
||||
const cpBlockStart = cycleTsSrc.indexOf("phases.includes('calibration_profile')");
|
||||
expect(cpBlockStart).toBeGreaterThan(-1);
|
||||
// Window of 1500 chars covers the dispatch.
|
||||
const block = cycleTsSrc.slice(cpBlockStart, cpBlockStart + 1500);
|
||||
expect(block).not.toContain('packDeclaresPhase');
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T9 R-GATE: dispatch result envelope', () => {
|
||||
test('extract_atoms not_in_active_pack skip carries the correct reason marker', () => {
|
||||
expect(cycleTsSrc).toContain("reason: 'not_in_active_pack'");
|
||||
});
|
||||
|
||||
test('synthesize_concepts not_in_active_pack uses the same marker (semantic consistency)', () => {
|
||||
// Both phases should use identical reason marker — doctor can match
|
||||
// a single string across both pack-gated skip events.
|
||||
const occurrences = (cycleTsSrc.match(/reason: 'not_in_active_pack'/g) ?? []).length;
|
||||
expect(occurrences).toBe(2);
|
||||
});
|
||||
});
|
||||
284
test/cycle/extract-atoms-synthesize-concepts.test.ts
Normal file
284
test/cycle/extract-atoms-synthesize-concepts.test.ts
Normal file
@@ -0,0 +1,284 @@
|
||||
// v0.41 T5+T6 — extract_atoms + synthesize_concepts minimal-viable bodies.
|
||||
//
|
||||
// Tests the LLM-driven extraction + synthesis paths with a stubbed
|
||||
// chat function so no real Haiku/Sonnet calls fire in CI. Pins:
|
||||
// - extract_atoms parses Haiku JSON output, writes atom-typed pages
|
||||
// - parseAtomsResponse tolerates markdown fences + trailing prose
|
||||
// - extract_atoms skips invalid atom_type values
|
||||
// - extract_atoms budget cap halts mid-run
|
||||
// - synthesize_concepts groups atoms by concept frontmatter ref
|
||||
// - tier assignment by count (T1 ≥10, T2 ≥5, T3 ≥2)
|
||||
// - T1/T2 use LLM narrative; T3 falls back deterministic
|
||||
// - dry-run mode counts but doesn't write
|
||||
|
||||
import { describe, test, expect, beforeAll, afterAll, beforeEach } from 'bun:test';
|
||||
import { PGLiteEngine } from '../../src/core/pglite-engine.ts';
|
||||
import { runPhaseExtractAtoms, parseAtomsResponse } from '../../src/core/cycle/extract-atoms.ts';
|
||||
import { runPhaseSynthesizeConcepts } from '../../src/core/cycle/synthesize-concepts.ts';
|
||||
import { resetPgliteState } from '../helpers/reset-pglite.ts';
|
||||
import type { ChatResult, ChatOpts } from '../../src/core/ai/gateway.ts';
|
||||
|
||||
let engine: PGLiteEngine;
|
||||
|
||||
beforeAll(async () => {
|
||||
engine = new PGLiteEngine();
|
||||
await engine.connect({});
|
||||
await engine.initSchema();
|
||||
}, 60000);
|
||||
|
||||
afterAll(async () => {
|
||||
await engine.disconnect();
|
||||
});
|
||||
|
||||
beforeEach(async () => {
|
||||
await resetPgliteState(engine);
|
||||
});
|
||||
|
||||
function stubChat(text: string, opts: { input_tokens?: number; output_tokens?: number } = {}): (o: ChatOpts) => Promise<ChatResult> {
|
||||
return async (_o: ChatOpts) => ({
|
||||
text,
|
||||
blocks: [{ type: 'text', text }],
|
||||
stopReason: 'end',
|
||||
usage: {
|
||||
input_tokens: opts.input_tokens ?? 500,
|
||||
output_tokens: opts.output_tokens ?? 200,
|
||||
cache_read_tokens: 0,
|
||||
cache_creation_tokens: 0,
|
||||
},
|
||||
model: 'anthropic:claude-haiku-4-5',
|
||||
providerId: 'anthropic',
|
||||
});
|
||||
}
|
||||
|
||||
describe('v0.41 T5: parseAtomsResponse', () => {
|
||||
test('parses well-formed JSON array', () => {
|
||||
const raw = `[{"title":"Test","atom_type":"insight","body":"body text"}]`;
|
||||
const atoms = parseAtomsResponse(raw);
|
||||
expect(atoms.length).toBe(1);
|
||||
expect(atoms[0].title).toBe('Test');
|
||||
expect(atoms[0].atom_type).toBe('insight');
|
||||
});
|
||||
|
||||
test('strips markdown code fences', () => {
|
||||
const raw = '```json\n[{"title":"T","atom_type":"quote","body":"b"}]\n```';
|
||||
expect(parseAtomsResponse(raw).length).toBe(1);
|
||||
});
|
||||
|
||||
test('tolerates trailing prose after JSON', () => {
|
||||
const raw = `[{"title":"T","atom_type":"framework","body":"b"}]\n\nThanks!`;
|
||||
expect(parseAtomsResponse(raw).length).toBe(1);
|
||||
});
|
||||
|
||||
test('rejects atoms with invalid atom_type', () => {
|
||||
const raw = `[{"title":"T","atom_type":"made_up_type","body":"b"}]`;
|
||||
expect(parseAtomsResponse(raw).length).toBe(0);
|
||||
});
|
||||
|
||||
test('rejects atoms missing required fields', () => {
|
||||
const raw = `[{"title":"T","atom_type":"insight"}]`; // no body
|
||||
expect(parseAtomsResponse(raw).length).toBe(0);
|
||||
});
|
||||
|
||||
test('returns [] on garbage input', () => {
|
||||
expect(parseAtomsResponse('not json')).toEqual([]);
|
||||
expect(parseAtomsResponse('')).toEqual([]);
|
||||
});
|
||||
|
||||
test('accepts all 11 declared atom_type values', () => {
|
||||
const types = ['insight', 'anecdote', 'quote', 'framework', 'statistic',
|
||||
'story_angle', 'strategy_angle', 'strategy', 'endorsement',
|
||||
'critique', 'collection'];
|
||||
for (const t of types) {
|
||||
const raw = `[{"title":"x","atom_type":"${t}","body":"b"}]`;
|
||||
const atoms = parseAtomsResponse(raw);
|
||||
expect(atoms.length).toBe(1);
|
||||
expect(atoms[0].atom_type as string).toBe(t);
|
||||
}
|
||||
});
|
||||
|
||||
test('clamps virality_score to [0, 100]', () => {
|
||||
expect(parseAtomsResponse(`[{"title":"a","atom_type":"insight","body":"b","virality_score":150}]`)[0].virality_score).toBeUndefined();
|
||||
expect(parseAtomsResponse(`[{"title":"a","atom_type":"insight","body":"b","virality_score":-5}]`)[0].virality_score).toBeUndefined();
|
||||
expect(parseAtomsResponse(`[{"title":"a","atom_type":"insight","body":"b","virality_score":75}]`)[0].virality_score).toBe(75);
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T5: runPhaseExtractAtoms via stubbed chat', () => {
|
||||
test('no-op when no transcripts provided', async () => {
|
||||
const result = await runPhaseExtractAtoms(engine, { _transcripts: [] });
|
||||
expect(result.status).toBe('skipped');
|
||||
expect(result.details?.reason).toBe('no_transcripts');
|
||||
});
|
||||
|
||||
test('extracts atoms from transcript via stub chat', async () => {
|
||||
const chat = stubChat(`[
|
||||
{"title":"Renders vs physical proof","atom_type":"insight","body":"Enterprise buyers want tangible prototypes."},
|
||||
{"title":"Founder lesson","atom_type":"anecdote","body":"Story about a founder."}
|
||||
]`);
|
||||
const result = await runPhaseExtractAtoms(engine, {
|
||||
_transcripts: [{ filePath: '/fake/meeting.txt', content: 'content', contentHash: 'abc123def' }],
|
||||
_chat: chat,
|
||||
});
|
||||
expect(result.status).toBe('ok');
|
||||
expect(result.details?.atoms_extracted).toBe(2);
|
||||
expect(result.details?.transcripts_processed).toBe(1);
|
||||
|
||||
// Verify pages were written
|
||||
const rows = await engine.executeRaw<{ slug: string; type: string }>(
|
||||
`SELECT slug, type FROM pages WHERE type = 'atom'`,
|
||||
);
|
||||
expect(rows.length).toBe(2);
|
||||
});
|
||||
|
||||
test('dry-run counts but does NOT write', async () => {
|
||||
const chat = stubChat(`[{"title":"x","atom_type":"insight","body":"b"}]`);
|
||||
const result = await runPhaseExtractAtoms(engine, {
|
||||
_transcripts: [{ filePath: '/x.txt', content: 'c', contentHash: 'h' }],
|
||||
_chat: chat,
|
||||
dryRun: true,
|
||||
});
|
||||
expect(result.details?.atoms_extracted).toBe(1);
|
||||
expect(result.details?.dry_run).toBe(true);
|
||||
const rows = await engine.executeRaw<{ count: number }>(
|
||||
`SELECT COUNT(*)::int AS count FROM pages WHERE type = 'atom'`,
|
||||
);
|
||||
expect(rows[0].count).toBe(0);
|
||||
});
|
||||
|
||||
test('failures tracked per-transcript without halting', async () => {
|
||||
let callCount = 0;
|
||||
const chat = async (_o: ChatOpts) => {
|
||||
callCount++;
|
||||
if (callCount === 1) throw new Error('rate limit');
|
||||
return {
|
||||
text: `[{"title":"t","atom_type":"insight","body":"b"}]`,
|
||||
blocks: [],
|
||||
stopReason: 'end' as const,
|
||||
usage: { input_tokens: 100, output_tokens: 50, cache_read_tokens: 0, cache_creation_tokens: 0 },
|
||||
model: 'anthropic:claude-haiku-4-5',
|
||||
providerId: 'anthropic',
|
||||
};
|
||||
};
|
||||
const result = await runPhaseExtractAtoms(engine, {
|
||||
_transcripts: [
|
||||
{ filePath: '/a.txt', content: 'a', contentHash: 'ha' },
|
||||
{ filePath: '/b.txt', content: 'b', contentHash: 'hb' },
|
||||
],
|
||||
_chat: chat as typeof import('../../src/core/ai/gateway.ts').chat,
|
||||
});
|
||||
expect(result.status).toBe('warn');
|
||||
expect(result.details?.atoms_extracted).toBe(1);
|
||||
expect((result.details?.failures as unknown[]).length).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T6: runPhaseSynthesizeConcepts via stubbed chat', () => {
|
||||
test('no-op when no atoms have concept refs', async () => {
|
||||
const result = await runPhaseSynthesizeConcepts(engine, { _atoms: [] });
|
||||
expect(result.status).toBe('skipped');
|
||||
expect(result.details?.reason).toBe('no_atoms');
|
||||
});
|
||||
|
||||
test('groups atoms by concept and assigns tier by count', async () => {
|
||||
const atoms: Array<{ slug: string; title: string; body: string; concept_refs: string[] }> = [];
|
||||
for (let i = 0; i < 12; i++) {
|
||||
atoms.push({
|
||||
slug: `atoms/2026-05-24/atom-${i}`,
|
||||
title: `Atom ${i}`,
|
||||
body: `Body of atom ${i}.`,
|
||||
concept_refs: ['ai-agents'],
|
||||
});
|
||||
}
|
||||
for (let i = 0; i < 6; i++) {
|
||||
atoms.push({
|
||||
slug: `atoms/2026-05-24/founder-${i}`,
|
||||
title: `Founder ${i}`,
|
||||
body: `Founder body ${i}.`,
|
||||
concept_refs: ['founder-psychology'],
|
||||
});
|
||||
}
|
||||
for (let i = 0; i < 3; i++) {
|
||||
atoms.push({
|
||||
slug: `atoms/2026-05-24/hw-${i}`,
|
||||
title: `HW ${i}`,
|
||||
body: `HW body ${i}.`,
|
||||
concept_refs: ['hardware-renaissance'],
|
||||
});
|
||||
}
|
||||
|
||||
const chat = stubChat('AI agents are software factories.');
|
||||
const result = await runPhaseSynthesizeConcepts(engine, { _atoms: atoms, _chat: chat });
|
||||
expect(result.status).toBe('ok');
|
||||
expect(result.details?.concepts_written).toBe(3);
|
||||
const tiers = result.details?.tier_counts as Record<string, number>;
|
||||
expect(tiers.T1).toBe(1); // ai-agents (12)
|
||||
expect(tiers.T2).toBe(1); // founder-psychology (6)
|
||||
expect(tiers.T3).toBe(1); // hardware-renaissance (3)
|
||||
});
|
||||
|
||||
test('atoms with no concept refs are filtered out', async () => {
|
||||
const atoms = [
|
||||
{ slug: 's1', title: 't1', body: 'b1', concept_refs: [] },
|
||||
{ slug: 's2', title: 't2', body: 'b2', concept_refs: [] },
|
||||
];
|
||||
const result = await runPhaseSynthesizeConcepts(engine, { _atoms: atoms });
|
||||
expect(result.status).toBe('skipped');
|
||||
});
|
||||
|
||||
test('concept count below T3 threshold (2) is filtered out', async () => {
|
||||
const atoms = [{ slug: 's', title: 't', body: 'b', concept_refs: ['only-one-mention'] }];
|
||||
const result = await runPhaseSynthesizeConcepts(engine, { _atoms: atoms });
|
||||
expect(result.status).toBe('skipped');
|
||||
expect(result.details?.reason).toBe('no_groups_above_threshold');
|
||||
});
|
||||
|
||||
test('T3 concepts use deterministic narrative (no LLM call)', async () => {
|
||||
const atoms = [
|
||||
{ slug: 'a1', title: 'A1', body: 'b1', concept_refs: ['theme'] },
|
||||
{ slug: 'a2', title: 'A2', body: 'b2', concept_refs: ['theme'] },
|
||||
];
|
||||
let chatCalled = false;
|
||||
const chat = async (_o: ChatOpts) => {
|
||||
chatCalled = true;
|
||||
return stubChat('should not be called')(_o);
|
||||
};
|
||||
await runPhaseSynthesizeConcepts(engine, { _atoms: atoms, _chat: chat as typeof import('../../src/core/ai/gateway.ts').chat });
|
||||
expect(chatCalled).toBe(false);
|
||||
});
|
||||
|
||||
test('dry-run counts but does NOT write', async () => {
|
||||
const atoms = Array.from({ length: 6 }, (_, i) => ({
|
||||
slug: `s${i}`,
|
||||
title: `T${i}`,
|
||||
body: `b${i}`,
|
||||
concept_refs: ['theme'],
|
||||
}));
|
||||
const chat = stubChat('synthesized narrative');
|
||||
const result = await runPhaseSynthesizeConcepts(engine, {
|
||||
_atoms: atoms,
|
||||
_chat: chat,
|
||||
dryRun: true,
|
||||
});
|
||||
expect(result.details?.concepts_written).toBe(1);
|
||||
expect(result.details?.dry_run).toBe(true);
|
||||
const rows = await engine.executeRaw<{ count: number }>(
|
||||
`SELECT COUNT(*)::int AS count FROM pages WHERE type = 'concept' AND slug LIKE 'concepts/%'`,
|
||||
);
|
||||
expect(rows[0].count).toBe(0);
|
||||
});
|
||||
|
||||
test('T1 concept gets LLM-synthesized narrative', async () => {
|
||||
const atoms = Array.from({ length: 12 }, (_, i) => ({
|
||||
slug: `a${i}`,
|
||||
title: `T${i}`,
|
||||
body: `b${i}`,
|
||||
concept_refs: ['theme'],
|
||||
}));
|
||||
const chat = stubChat('Custom synthesized narrative from LLM.');
|
||||
await runPhaseSynthesizeConcepts(engine, { _atoms: atoms, _chat: chat });
|
||||
const rows = await engine.executeRaw<{ compiled_truth: string }>(
|
||||
`SELECT compiled_truth FROM pages WHERE slug = 'concepts/theme'`,
|
||||
);
|
||||
expect(rows[0].compiled_truth).toContain('Custom synthesized narrative');
|
||||
});
|
||||
});
|
||||
377
test/domain-aggregators.test.ts
Normal file
377
test/domain-aggregators.test.ts
Normal file
@@ -0,0 +1,377 @@
|
||||
// v0.41 T10 — calibration domain aggregators.
|
||||
//
|
||||
// Tests the per-aggregator SQL shape + the R1 IRON-RULE byte-identical
|
||||
// regression (empty {} JSONB when no active pack declares domains).
|
||||
//
|
||||
// Covers all 4 aggregator kinds (scalar_brier, weighted_brier,
|
||||
// count_based, cluster_summary) against real PGLite. Seeds takes +
|
||||
// take_domain_assignments + pages and asserts the expected scorecard
|
||||
// shape comes back.
|
||||
|
||||
import { describe, test, expect, beforeAll, afterAll, beforeEach } from 'bun:test';
|
||||
import { PGLiteEngine } from '../src/core/pglite-engine.ts';
|
||||
import { aggregateDomainScorecards } from '../src/core/calibration/domain-aggregators.ts';
|
||||
import { resetPgliteState } from './helpers/reset-pglite.ts';
|
||||
import type { CalibrationDomain } from '../src/core/schema-pack/manifest-v1.ts';
|
||||
|
||||
let engine: PGLiteEngine;
|
||||
|
||||
beforeAll(async () => {
|
||||
engine = new PGLiteEngine();
|
||||
await engine.connect({});
|
||||
await engine.initSchema();
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await engine.disconnect();
|
||||
});
|
||||
|
||||
beforeEach(async () => {
|
||||
await resetPgliteState(engine);
|
||||
});
|
||||
|
||||
async function seedTakeWithAssignment(
|
||||
slug: string,
|
||||
pageType: string,
|
||||
takeOpts: {
|
||||
weight: number;
|
||||
resolved_outcome: boolean;
|
||||
holder?: string;
|
||||
sourceId?: string;
|
||||
rowNum?: number;
|
||||
},
|
||||
assignmentOpts: {
|
||||
domain: string;
|
||||
pack: string;
|
||||
confidence?: number;
|
||||
},
|
||||
): Promise<void> {
|
||||
const holder = takeOpts.holder ?? 'garry';
|
||||
const sourceId = takeOpts.sourceId ?? 'default';
|
||||
const rowNum = takeOpts.rowNum ?? 1;
|
||||
|
||||
await engine.putPage(slug, {
|
||||
title: slug,
|
||||
type: pageType,
|
||||
compiled_truth: '',
|
||||
frontmatter: {},
|
||||
timeline: '',
|
||||
});
|
||||
const pageRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM pages WHERE slug = $1 AND source_id = $2 LIMIT 1`,
|
||||
[slug, sourceId],
|
||||
);
|
||||
const pageId = pageRow[0].id;
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO takes (page_id, row_num, claim, kind, holder, weight, resolved_outcome, resolved_at, active)
|
||||
VALUES ($1, $2, $3, 'take', $4, $5, $6, now(), TRUE)`,
|
||||
[pageId, rowNum, `claim for ${slug}`, holder, takeOpts.weight, takeOpts.resolved_outcome],
|
||||
);
|
||||
const takeRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM takes WHERE page_id = $1 AND row_num = $2 LIMIT 1`,
|
||||
[pageId, rowNum],
|
||||
);
|
||||
const takeId = takeRow[0].id;
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO take_domain_assignments (take_id, domain, pack, confidence)
|
||||
VALUES ($1, $2, $3, $4)`,
|
||||
[takeId, assignmentOpts.domain, assignmentOpts.pack, assignmentOpts.confidence ?? 1.0],
|
||||
);
|
||||
}
|
||||
|
||||
describe('v0.41 T10 R1: empty domain list returns {} (byte-identical regression)', () => {
|
||||
test('aggregateDomainScorecards with [] domains returns {}', async () => {
|
||||
const result = await aggregateDomainScorecards(engine, 'garry', [], 'default');
|
||||
expect(result).toEqual({});
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T10: scalar_brier aggregator', () => {
|
||||
const domain: CalibrationDomain = {
|
||||
name: 'deal_success',
|
||||
aggregator: 'scalar_brier',
|
||||
page_types: ['deal'],
|
||||
};
|
||||
|
||||
test('returns n:0 + null brier when no takes match', async () => {
|
||||
const result = await aggregateDomainScorecards(engine, 'garry', [domain], 'default');
|
||||
expect(result.deal_success.n).toBe(0);
|
||||
expect(result.deal_success.brier).toBeNull();
|
||||
expect(result.deal_success.accuracy).toBeNull();
|
||||
expect(result.deal_success.aggregator).toBe('scalar_brier');
|
||||
expect(result.deal_success.page_types).toEqual(['deal']);
|
||||
});
|
||||
|
||||
test('computes Brier over resolved deal-attached takes', async () => {
|
||||
// Two takes: one perfect (p=1, outcome=true → sq_err=0), one wrong (p=1, outcome=false → sq_err=1)
|
||||
await seedTakeWithAssignment(
|
||||
'deals/perfect',
|
||||
'deal',
|
||||
{ weight: 1.0, resolved_outcome: true, rowNum: 1 },
|
||||
{ domain: 'deal_success', pack: 'gbrain-investor' },
|
||||
);
|
||||
await seedTakeWithAssignment(
|
||||
'deals/wrong',
|
||||
'deal',
|
||||
{ weight: 1.0, resolved_outcome: false, rowNum: 1 },
|
||||
{ domain: 'deal_success', pack: 'gbrain-investor' },
|
||||
);
|
||||
|
||||
const result = await aggregateDomainScorecards(engine, 'garry', [domain], 'default');
|
||||
expect(result.deal_success.n).toBe(2);
|
||||
// Mean of (0, 1) = 0.5
|
||||
expect(result.deal_success.brier).toBeCloseTo(0.5, 2);
|
||||
// Accuracy: weight>=0.5 (true) === outcome → 1 hit, 1 miss → 0.5
|
||||
expect(result.deal_success.accuracy).toBeCloseTo(0.5, 2);
|
||||
});
|
||||
|
||||
test('filters by holder', async () => {
|
||||
await seedTakeWithAssignment(
|
||||
'deals/mine',
|
||||
'deal',
|
||||
{ weight: 0.9, resolved_outcome: true, holder: 'garry', rowNum: 1 },
|
||||
{ domain: 'deal_success', pack: 'gbrain-investor' },
|
||||
);
|
||||
await seedTakeWithAssignment(
|
||||
'deals/theirs',
|
||||
'deal',
|
||||
{ weight: 0.1, resolved_outcome: true, holder: 'alice-example', rowNum: 1 },
|
||||
{ domain: 'deal_success', pack: 'gbrain-investor' },
|
||||
);
|
||||
|
||||
const garryResult = await aggregateDomainScorecards(engine, 'garry', [domain], 'default');
|
||||
expect(garryResult.deal_success.n).toBe(1);
|
||||
const aliceResult = await aggregateDomainScorecards(engine, 'alice-example', [domain], 'default');
|
||||
expect(aliceResult.deal_success.n).toBe(1);
|
||||
});
|
||||
|
||||
test('filters by page_types (only matching types counted)', async () => {
|
||||
await seedTakeWithAssignment(
|
||||
'deals/match',
|
||||
'deal',
|
||||
{ weight: 0.8, resolved_outcome: true, rowNum: 1 },
|
||||
{ domain: 'deal_success', pack: 'gbrain-investor' },
|
||||
);
|
||||
await seedTakeWithAssignment(
|
||||
'people/no-match',
|
||||
'person',
|
||||
{ weight: 0.8, resolved_outcome: true, rowNum: 1 },
|
||||
{ domain: 'deal_success', pack: 'gbrain-investor' },
|
||||
);
|
||||
|
||||
const result = await aggregateDomainScorecards(engine, 'garry', [domain], 'default');
|
||||
expect(result.deal_success.n).toBe(1);
|
||||
});
|
||||
|
||||
test('ignores unresolved takes', async () => {
|
||||
await engine.putPage('deals/unresolved', {
|
||||
title: 'unresolved',
|
||||
type: 'deal',
|
||||
compiled_truth: '',
|
||||
frontmatter: {},
|
||||
timeline: '',
|
||||
});
|
||||
const pageRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM pages WHERE slug = 'deals/unresolved' LIMIT 1`,
|
||||
);
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO takes (page_id, row_num, claim, kind, holder, weight, active)
|
||||
VALUES ($1, 1, 'unresolved', 'take', 'garry', 0.7, TRUE)`,
|
||||
[pageRow[0].id],
|
||||
);
|
||||
const takeRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM takes WHERE page_id = $1 LIMIT 1`,
|
||||
[pageRow[0].id],
|
||||
);
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO take_domain_assignments (take_id, domain, pack)
|
||||
VALUES ($1, 'deal_success', 'gbrain-investor')`,
|
||||
[takeRow[0].id],
|
||||
);
|
||||
|
||||
const result = await aggregateDomainScorecards(engine, 'garry', [domain], 'default');
|
||||
expect(result.deal_success.n).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T10: weighted_brier aggregator', () => {
|
||||
const domain: CalibrationDomain = {
|
||||
name: 'market_call',
|
||||
aggregator: 'weighted_brier',
|
||||
page_types: ['thesis'],
|
||||
};
|
||||
|
||||
test('high-conviction miss weighted more than low-conviction miss', async () => {
|
||||
// High-conviction miss: weight=0.95 (conviction = ABS(0.95-0.5)*2 = 0.9), outcome=false → sq_err=0.9025
|
||||
await seedTakeWithAssignment(
|
||||
'theses/high-conv-miss',
|
||||
'thesis',
|
||||
{ weight: 0.95, resolved_outcome: false, rowNum: 1 },
|
||||
{ domain: 'market_call', pack: 'gbrain-investor' },
|
||||
);
|
||||
// Low-conviction hit: weight=0.55 (conviction = 0.1), outcome=true → sq_err=0.2025
|
||||
await seedTakeWithAssignment(
|
||||
'theses/low-conv-hit',
|
||||
'thesis',
|
||||
{ weight: 0.55, resolved_outcome: true, rowNum: 1 },
|
||||
{ domain: 'market_call', pack: 'gbrain-investor' },
|
||||
);
|
||||
|
||||
const result = await aggregateDomainScorecards(engine, 'garry', [domain], 'default');
|
||||
expect(result.market_call.n).toBe(2);
|
||||
// Weighted mean: (0.9025 * 0.9 + 0.2025 * 0.1) / (0.9 + 0.1) ≈ 0.8325
|
||||
expect(result.market_call.brier).toBeCloseTo(0.8325, 2);
|
||||
});
|
||||
|
||||
test('accuracy independent of conviction weighting', async () => {
|
||||
await seedTakeWithAssignment(
|
||||
'theses/a',
|
||||
'thesis',
|
||||
{ weight: 0.9, resolved_outcome: true, rowNum: 1 },
|
||||
{ domain: 'market_call', pack: 'gbrain-investor' },
|
||||
);
|
||||
await seedTakeWithAssignment(
|
||||
'theses/b',
|
||||
'thesis',
|
||||
{ weight: 0.6, resolved_outcome: true, rowNum: 1 },
|
||||
{ domain: 'market_call', pack: 'gbrain-investor' },
|
||||
);
|
||||
const result = await aggregateDomainScorecards(engine, 'garry', [domain], 'default');
|
||||
expect(result.market_call.accuracy).toBeCloseTo(1.0, 2);
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T10: count_based aggregator', () => {
|
||||
const domain: CalibrationDomain = {
|
||||
name: 'simple_acc',
|
||||
aggregator: 'count_based',
|
||||
page_types: ['deal'],
|
||||
};
|
||||
|
||||
test('computes accuracy without brier', async () => {
|
||||
await seedTakeWithAssignment(
|
||||
'deals/right',
|
||||
'deal',
|
||||
{ weight: 0.8, resolved_outcome: true, rowNum: 1 },
|
||||
{ domain: 'simple_acc', pack: 'test' },
|
||||
);
|
||||
await seedTakeWithAssignment(
|
||||
'deals/wrong',
|
||||
'deal',
|
||||
{ weight: 0.8, resolved_outcome: false, rowNum: 1 },
|
||||
{ domain: 'simple_acc', pack: 'test' },
|
||||
);
|
||||
const result = await aggregateDomainScorecards(engine, 'garry', [domain], 'default');
|
||||
expect(result.simple_acc.n).toBe(2);
|
||||
expect(result.simple_acc.brier).toBeNull();
|
||||
expect(result.simple_acc.accuracy).toBeCloseTo(0.5, 2);
|
||||
expect(result.simple_acc.aggregator).toBe('count_based');
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T10: cluster_summary aggregator', () => {
|
||||
const domain: CalibrationDomain = {
|
||||
name: 'concept_themes',
|
||||
aggregator: 'cluster_summary',
|
||||
page_types: ['concept'],
|
||||
};
|
||||
|
||||
test('returns page count + tier histogram', async () => {
|
||||
await engine.putPage('concepts/canon-a', {
|
||||
title: 'a',
|
||||
type: 'concept',
|
||||
compiled_truth: '',
|
||||
frontmatter: { tier: 'T1' },
|
||||
timeline: '',
|
||||
});
|
||||
await engine.putPage('concepts/canon-b', {
|
||||
title: 'b',
|
||||
type: 'concept',
|
||||
compiled_truth: '',
|
||||
frontmatter: { tier: 'T1' },
|
||||
timeline: '',
|
||||
});
|
||||
await engine.putPage('concepts/dev', {
|
||||
title: 'dev',
|
||||
type: 'concept',
|
||||
compiled_truth: '',
|
||||
frontmatter: { tier: 'T2' },
|
||||
timeline: '',
|
||||
});
|
||||
await engine.putPage('concepts/no-tier', {
|
||||
title: 'no-tier',
|
||||
type: 'concept',
|
||||
compiled_truth: '',
|
||||
frontmatter: {},
|
||||
timeline: '',
|
||||
});
|
||||
|
||||
const result = await aggregateDomainScorecards(engine, 'garry', [domain], 'default');
|
||||
expect(result.concept_themes.n).toBe(4);
|
||||
expect(result.concept_themes.brier).toBeNull();
|
||||
expect(result.concept_themes.accuracy).toBeNull();
|
||||
expect(result.concept_themes.aggregator).toBe('cluster_summary');
|
||||
const tiers = (result.concept_themes.extras as { tier_counts: Record<string, number> }).tier_counts;
|
||||
expect(tiers.T1).toBe(2);
|
||||
expect(tiers.T2).toBe(1);
|
||||
expect(tiers.T3).toBe(0);
|
||||
expect(tiers.T4).toBe(0);
|
||||
});
|
||||
|
||||
test('returns n:0 + all-zero tiers when no concepts exist', async () => {
|
||||
const result = await aggregateDomainScorecards(engine, 'garry', [domain], 'default');
|
||||
expect(result.concept_themes.n).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T10: multi-domain aggregation', () => {
|
||||
test('aggregates all declared domains in one call', async () => {
|
||||
await seedTakeWithAssignment(
|
||||
'deals/d1',
|
||||
'deal',
|
||||
{ weight: 0.9, resolved_outcome: true, rowNum: 1 },
|
||||
{ domain: 'deal_success', pack: 'gbrain-investor' },
|
||||
);
|
||||
await seedTakeWithAssignment(
|
||||
'people/p1',
|
||||
'person',
|
||||
{ weight: 0.7, resolved_outcome: true, rowNum: 1 },
|
||||
{ domain: 'founder_evaluation', pack: 'gbrain-investor' },
|
||||
);
|
||||
|
||||
const domains: CalibrationDomain[] = [
|
||||
{ name: 'deal_success', aggregator: 'scalar_brier', page_types: ['deal'] },
|
||||
{ name: 'founder_evaluation', aggregator: 'scalar_brier', page_types: ['person'] },
|
||||
{ name: 'empty_domain', aggregator: 'scalar_brier', page_types: ['deal'] },
|
||||
];
|
||||
const result = await aggregateDomainScorecards(engine, 'garry', domains, 'default');
|
||||
|
||||
expect(Object.keys(result).sort()).toEqual([
|
||||
'deal_success',
|
||||
'empty_domain',
|
||||
'founder_evaluation',
|
||||
]);
|
||||
expect(result.deal_success.n).toBe(1);
|
||||
expect(result.founder_evaluation.n).toBe(1);
|
||||
expect(result.empty_domain.n).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T10: fail-soft per domain', () => {
|
||||
test('one domain SQL error does NOT block other domains', async () => {
|
||||
// Inject a malformed-but-shape-valid domain. The aggregator JOINs
|
||||
// pages by source_id='default'; a domain pointing at a non-existent
|
||||
// page_type still completes (returns n=0). Errors come from things
|
||||
// like SQL syntax mistakes — harder to trigger via the public API.
|
||||
// For now, assert that an empty page_types-mismatch domain produces
|
||||
// a clean n=0 result without throwing.
|
||||
const domains: CalibrationDomain[] = [
|
||||
{ name: 'good', aggregator: 'scalar_brier', page_types: ['deal'] },
|
||||
{ name: 'nonexistent', aggregator: 'scalar_brier', page_types: ['__fake_type__'] },
|
||||
];
|
||||
const result = await aggregateDomainScorecards(engine, 'garry', domains, 'default');
|
||||
expect(result.good).toBeDefined();
|
||||
expect(result.nonexistent).toBeDefined();
|
||||
expect(result.nonexistent.n).toBe(0);
|
||||
});
|
||||
});
|
||||
@@ -107,7 +107,7 @@ describeE2E('E2E: runCycle against real Postgres', () => {
|
||||
// v0.33.3 = 13 (added `resolve_symbol_edges` between extract_facts and patterns)
|
||||
// v0.36.1.0 = 16 (added propose_takes + grade_takes + calibration_profile — hindsight calibration wave)
|
||||
// v0.39.0.0 = 17 (added `schema-suggest` between orphans and purge — T12 schema cathedral)
|
||||
expect(report.phases.length).toBe(17);
|
||||
expect(report.phases.length).toBe(19); // v0.41: +extract_atoms, +synthesize_concepts
|
||||
|
||||
// Nothing got written.
|
||||
const afterPages = await conn.unsafe(`SELECT count(*)::int AS n FROM pages`);
|
||||
|
||||
69
test/eval-v041_2-scaffolds.test.ts
Normal file
69
test/eval-v041_2-scaffolds.test.ts
Normal file
@@ -0,0 +1,69 @@
|
||||
// v0.41 T11 — minimal scaffold tests for the 3 new eval commands.
|
||||
//
|
||||
// Pins the command-surface contract: every command returns a stable
|
||||
// {schema_version: 1, ok, status, details} envelope that downstream
|
||||
// tooling can rely on while the real parity-baseline implementations
|
||||
// land in v0.41.1.
|
||||
|
||||
import { describe, test, expect } from 'bun:test';
|
||||
import { runEvalExtractAtoms } from '../src/commands/eval-extract-atoms.ts';
|
||||
import { runEvalSynthesizeConcepts } from '../src/commands/eval-synthesize-concepts.ts';
|
||||
import { runEvalMarkdownGreenfield } from '../src/commands/eval-markdown-greenfield.ts';
|
||||
|
||||
describe('v0.41 T11: eval command surfaces', () => {
|
||||
test('runEvalExtractAtoms returns stable schema_version=1 envelope', async () => {
|
||||
const result = await runEvalExtractAtoms({});
|
||||
expect(result.schema_version).toBe(1);
|
||||
expect(result.ok).toBe(true);
|
||||
expect(result.status).toBe('not_yet_implemented');
|
||||
expect(result.details).toBeDefined();
|
||||
});
|
||||
|
||||
test('runEvalExtractAtoms preserves --parity-baseline + --sample in details', async () => {
|
||||
const result = await runEvalExtractAtoms({
|
||||
parityBaseline: '~/git/brain/atoms',
|
||||
sample: 500,
|
||||
});
|
||||
expect(result.details.parity_baseline_path).toBe('~/git/brain/atoms');
|
||||
expect(result.details.sample_size).toBe(500);
|
||||
});
|
||||
|
||||
test('runEvalSynthesizeConcepts returns stable schema_version=1 envelope', async () => {
|
||||
const result = await runEvalSynthesizeConcepts({});
|
||||
expect(result.schema_version).toBe(1);
|
||||
expect(result.status).toBe('not_yet_implemented');
|
||||
});
|
||||
|
||||
test('runEvalSynthesizeConcepts preserves --parity-baseline + --sample', async () => {
|
||||
const result = await runEvalSynthesizeConcepts({
|
||||
parityBaseline: '~/git/brain/concepts',
|
||||
sample: 500,
|
||||
});
|
||||
expect(result.details.parity_baseline_path).toBe('~/git/brain/concepts');
|
||||
expect(result.details.sample_size).toBe(500);
|
||||
});
|
||||
|
||||
test('runEvalMarkdownGreenfield returns stable schema_version=1 envelope', async () => {
|
||||
const result = await runEvalMarkdownGreenfield({});
|
||||
expect(result.schema_version).toBe(1);
|
||||
expect(result.status).toBe('not_yet_implemented');
|
||||
});
|
||||
|
||||
test('runEvalMarkdownGreenfield preserves --pass-rate-floor', async () => {
|
||||
const result = await runEvalMarkdownGreenfield({
|
||||
passRateFloor: 0.95,
|
||||
repoPath: '~/git/brain',
|
||||
});
|
||||
expect(result.details.pass_rate_floor).toBe(0.95);
|
||||
expect(result.details.repo_path).toBe('~/git/brain');
|
||||
});
|
||||
|
||||
test('all 3 commands include v0_41_1_followup pointer in details', async () => {
|
||||
const r1 = await runEvalExtractAtoms({});
|
||||
const r2 = await runEvalSynthesizeConcepts({});
|
||||
const r3 = await runEvalMarkdownGreenfield({});
|
||||
expect(r1.details.v0_41_1_followup).toBeDefined();
|
||||
expect(r2.details.v0_41_1_followup).toBeDefined();
|
||||
expect(r3.details.v0_41_1_followup).toBeDefined();
|
||||
});
|
||||
});
|
||||
224
test/ingestion/gstack-learnings.test.ts
Normal file
224
test/ingestion/gstack-learnings.test.ts
Normal file
@@ -0,0 +1,224 @@
|
||||
// v0.41 T8 — GstackLearningsSource bridge.
|
||||
//
|
||||
// Tests the source's emit pipeline: discovers JSONL files, seeds
|
||||
// seenLines with existing content (no replay of historical lines on
|
||||
// startup), emits on new lines, dedups via canonical-JSON content_hash,
|
||||
// skips malformed JSONL lines, renders markdown frontmatter correctly.
|
||||
|
||||
import { describe, test, expect, beforeEach } from 'bun:test';
|
||||
import { GstackLearningsSource, type GstackLearningLine } from '../../src/core/ingestion/sources/gstack-learnings.ts';
|
||||
import type { IngestionEvent, IngestionSourceContext } from '../../src/core/ingestion/types.ts';
|
||||
|
||||
function makeLine(overrides: Partial<GstackLearningLine> = {}): GstackLearningLine {
|
||||
return {
|
||||
skill: 'investigate',
|
||||
type: 'pitfall',
|
||||
key: 'test-key',
|
||||
insight: 'test insight body',
|
||||
confidence: 8,
|
||||
source: 'observed',
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
function makeFakeFs(files: Record<string, string>) {
|
||||
return {
|
||||
_readFile: (path: string) => {
|
||||
if (!(path in files)) throw new Error(`fake fs: not found ${path}`);
|
||||
return files[path];
|
||||
},
|
||||
_existsSync: (path: string) => path in files,
|
||||
};
|
||||
}
|
||||
|
||||
function makeStubCtx(): IngestionSourceContext & { emitted: IngestionEvent[] } {
|
||||
const emitted: IngestionEvent[] = [];
|
||||
return {
|
||||
emit(event) {
|
||||
emitted.push(event);
|
||||
},
|
||||
engine: {} as never,
|
||||
logger: { info: () => {}, warn: () => {}, error: () => {} },
|
||||
abortSignal: new AbortController().signal,
|
||||
config: {},
|
||||
emitted,
|
||||
};
|
||||
}
|
||||
|
||||
describe('v0.41 T8: GstackLearningsSource basic contract', () => {
|
||||
test('declares mode: trickle (uses standard 24h dedup window)', () => {
|
||||
const src = new GstackLearningsSource({ paths: [], _skipWatch: true });
|
||||
expect(src.mode).toBe('trickle');
|
||||
});
|
||||
|
||||
test('id includes pid for uniqueness across concurrent processes', () => {
|
||||
const src = new GstackLearningsSource({ paths: [], _skipWatch: true });
|
||||
expect(src.id).toMatch(/^gstack-learnings:\d+$/);
|
||||
});
|
||||
|
||||
test('kind is gstack-learnings', () => {
|
||||
const src = new GstackLearningsSource({ paths: [], _skipWatch: true });
|
||||
expect(src.kind).toBe('gstack-learnings');
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T8: start() seeds seenLines from existing JSONL content', () => {
|
||||
test('historical lines are NOT replayed as emits on first start', async () => {
|
||||
const existing = [
|
||||
makeLine({ key: 'existing-1' }),
|
||||
makeLine({ key: 'existing-2' }),
|
||||
];
|
||||
const path = '/fake/projects/repoA/learnings.jsonl';
|
||||
const content = existing.map((l) => JSON.stringify(l)).join('\n');
|
||||
const fs = makeFakeFs({ [path]: content });
|
||||
const src = new GstackLearningsSource({ paths: [path], _skipWatch: true, ...fs });
|
||||
const ctx = makeStubCtx();
|
||||
await src.start(ctx);
|
||||
expect(src.seenCount).toBe(2);
|
||||
expect(ctx.emitted.length).toBe(0); // start does NOT emit
|
||||
await src.stop();
|
||||
});
|
||||
|
||||
test('malformed JSONL lines skip without crashing start()', async () => {
|
||||
const path = '/fake/projects/repoA/learnings.jsonl';
|
||||
const content = JSON.stringify(makeLine({ key: 'good' })) + '\n{not-valid-json\n' + JSON.stringify(makeLine({ key: 'good-2' }));
|
||||
const fs = makeFakeFs({ [path]: content });
|
||||
const src = new GstackLearningsSource({ paths: [path], _skipWatch: true, ...fs });
|
||||
const ctx = makeStubCtx();
|
||||
await src.start(ctx);
|
||||
// Two valid lines seeded; one malformed line skipped silently.
|
||||
expect(src.seenCount).toBe(2);
|
||||
await src.stop();
|
||||
});
|
||||
|
||||
test('blank lines + trailing newline OK', async () => {
|
||||
const path = '/fake/projects/repoA/learnings.jsonl';
|
||||
const content = '\n' + JSON.stringify(makeLine({ key: 'a' })) + '\n\n' + JSON.stringify(makeLine({ key: 'b' })) + '\n';
|
||||
const fs = makeFakeFs({ [path]: content });
|
||||
const src = new GstackLearningsSource({ paths: [path], _skipWatch: true, ...fs });
|
||||
const ctx = makeStubCtx();
|
||||
await src.start(ctx);
|
||||
expect(src.seenCount).toBe(2);
|
||||
await src.stop();
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T8: emitLine path (production rescanFile equivalent)', () => {
|
||||
test('emits new line not previously seen', async () => {
|
||||
const path = '/fake/projects/repoA/learnings.jsonl';
|
||||
const fs = makeFakeFs({ [path]: '' });
|
||||
const src = new GstackLearningsSource({ paths: [path], _skipWatch: true, ...fs });
|
||||
const ctx = makeStubCtx();
|
||||
await src.start(ctx);
|
||||
const newLine = makeLine({ key: 'fresh-insight', insight: 'just learned this' });
|
||||
src.emitLine(newLine, path);
|
||||
expect(ctx.emitted.length).toBe(1);
|
||||
const event = ctx.emitted[0];
|
||||
expect(event.source_kind).toBe('gstack-learnings');
|
||||
expect(event.source_uri).toBe(path);
|
||||
expect(event.content_type).toBe('text/markdown');
|
||||
expect(event.untrusted_payload).toBe(false);
|
||||
expect(event.metadata?.learning).toEqual(newLine);
|
||||
await src.stop();
|
||||
});
|
||||
|
||||
test('re-emit of identical line is silent dedup hit (no event)', async () => {
|
||||
const path = '/fake/projects/repoA/learnings.jsonl';
|
||||
const fs = makeFakeFs({ [path]: '' });
|
||||
const src = new GstackLearningsSource({ paths: [path], _skipWatch: true, ...fs });
|
||||
const ctx = makeStubCtx();
|
||||
await src.start(ctx);
|
||||
const line = makeLine({ key: 'dup-test' });
|
||||
src.emitLine(line, path);
|
||||
src.emitLine(line, path);
|
||||
expect(ctx.emitted.length).toBe(1);
|
||||
await src.stop();
|
||||
});
|
||||
|
||||
test('emitted body carries frontmatter with learning_type + confidence + source + key', async () => {
|
||||
const path = '/fake/projects/repoA/learnings.jsonl';
|
||||
const fs = makeFakeFs({ [path]: '' });
|
||||
const src = new GstackLearningsSource({ paths: [path], _skipWatch: true, ...fs });
|
||||
const ctx = makeStubCtx();
|
||||
await src.start(ctx);
|
||||
const line = makeLine({
|
||||
key: 'orbstack-port-8080',
|
||||
insight: 'OrbStack listens on *:8080 by default, conflicts with Kumo proxy.',
|
||||
type: 'operational',
|
||||
confidence: 9,
|
||||
files: ['internal/proxy/proxy.go'],
|
||||
});
|
||||
src.emitLine(line, path);
|
||||
const body = ctx.emitted[0].content;
|
||||
expect(body).toContain('type: "learning"');
|
||||
expect(body).toContain('learning_type: "operational"');
|
||||
expect(body).toContain('confidence: 9');
|
||||
expect(body).toContain('source: "observed"');
|
||||
expect(body).toContain('skill: "investigate"');
|
||||
expect(body).toContain('key: "orbstack-port-8080"');
|
||||
expect(body).toContain('files: ["internal/proxy/proxy.go"]');
|
||||
expect(body).toContain('# orbstack-port-8080');
|
||||
expect(body).toContain('OrbStack listens on *:8080');
|
||||
await src.stop();
|
||||
});
|
||||
|
||||
test('canonical-JSON content_hash means whitespace-only reformat is dedup hit', async () => {
|
||||
const path = '/fake/projects/repoA/learnings.jsonl';
|
||||
const fs = makeFakeFs({ [path]: '' });
|
||||
const src = new GstackLearningsSource({ paths: [path], _skipWatch: true, ...fs });
|
||||
const ctx = makeStubCtx();
|
||||
await src.start(ctx);
|
||||
// Both lines have same field values; the hash is computed over the
|
||||
// canonical JSON.stringify output so they collide. Production gstack
|
||||
// never reformats but if a future tooling change did, dedup should still hold.
|
||||
const lineA = makeLine({ key: 'whitespace-test' });
|
||||
src.emitLine(lineA, path);
|
||||
src.emitLine(lineA, path); // identical
|
||||
expect(ctx.emitted.length).toBe(1);
|
||||
await src.stop();
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T8: healthCheck()', () => {
|
||||
test('returns warn when no JSONL files discovered', async () => {
|
||||
const src = new GstackLearningsSource({ paths: [], _skipWatch: true, _existsSync: () => false, _readFile: () => '' });
|
||||
const health = await src.healthCheck();
|
||||
expect(health.status).toBe('warn');
|
||||
expect(health.message).toContain('no gstack learnings');
|
||||
});
|
||||
|
||||
test('returns ok when files exist and are readable', async () => {
|
||||
const path = '/fake/projects/repoA/learnings.jsonl';
|
||||
const fs = makeFakeFs({ [path]: JSON.stringify(makeLine()) });
|
||||
const src = new GstackLearningsSource({ paths: [path], _skipWatch: true, ...fs });
|
||||
const ctx = makeStubCtx();
|
||||
await src.start(ctx);
|
||||
const health = await src.healthCheck();
|
||||
expect(health.status).toBe('ok');
|
||||
expect(health.message).toContain('1 watched');
|
||||
await src.stop();
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T8: describePaths() diagnostic', () => {
|
||||
test('reports per-file existence + size', async () => {
|
||||
const path = '/fake/projects/repoA/learnings.jsonl';
|
||||
const fs = makeFakeFs({ [path]: JSON.stringify(makeLine()) });
|
||||
const src = new GstackLearningsSource({ paths: [path], _skipWatch: true, ...fs });
|
||||
const desc = src.describePaths();
|
||||
expect(desc.length).toBe(1);
|
||||
expect(desc[0].path).toBe(path);
|
||||
expect(desc[0].exists).toBe(true);
|
||||
});
|
||||
|
||||
test('reports missing paths as exists:false', async () => {
|
||||
const src = new GstackLearningsSource({
|
||||
paths: ['/fake/missing/learnings.jsonl'],
|
||||
_skipWatch: true,
|
||||
_existsSync: () => false,
|
||||
_readFile: () => '',
|
||||
});
|
||||
const desc = src.describePaths();
|
||||
expect(desc[0].exists).toBe(false);
|
||||
});
|
||||
});
|
||||
327
test/ingestion/markdown-greenfield.test.ts
Normal file
327
test/ingestion/markdown-greenfield.test.ts
Normal file
@@ -0,0 +1,327 @@
|
||||
// v0.41 T7 — MarkdownGreenfieldSource one-shot migration importer.
|
||||
//
|
||||
// Tests the source's bulk-import pipeline against fake-fs fixtures:
|
||||
// directory walk, frontmatter parse, imported_from marker stamping,
|
||||
// per-row validation failure → JSONL audit, dry-run mode, limit honored.
|
||||
|
||||
import { describe, test, expect, beforeEach } from 'bun:test';
|
||||
import { MarkdownGreenfieldSource } from '../../src/core/ingestion/sources/markdown-greenfield.ts';
|
||||
import type { IngestionEvent, IngestionSourceContext } from '../../src/core/ingestion/types.ts';
|
||||
|
||||
interface FakeFs {
|
||||
files: Record<string, string>;
|
||||
dirs: Set<string>;
|
||||
audit: Record<string, string>;
|
||||
}
|
||||
|
||||
function makeFakeFs(seed: Record<string, string>, dirs: string[] = []): FakeFs {
|
||||
const dirSet = new Set<string>(dirs);
|
||||
// Auto-register parent dirs for every seeded file
|
||||
for (const path of Object.keys(seed)) {
|
||||
const parts = path.split('/');
|
||||
while (parts.length > 1) {
|
||||
parts.pop();
|
||||
dirSet.add(parts.join('/'));
|
||||
}
|
||||
}
|
||||
return { files: { ...seed }, dirs: dirSet, audit: {} };
|
||||
}
|
||||
|
||||
function fsOpts(fs: FakeFs) {
|
||||
return {
|
||||
_readFile: (path: string) => {
|
||||
if (!(path in fs.files)) throw new Error(`fake fs: not found ${path}`);
|
||||
return fs.files[path];
|
||||
},
|
||||
_existsSync: (path: string) => path in fs.files || fs.dirs.has(path),
|
||||
_readdirSync: (path: string) => {
|
||||
const entries = new Set<string>();
|
||||
for (const f of Object.keys(fs.files)) {
|
||||
if (f.startsWith(path + '/')) {
|
||||
const rel = f.slice(path.length + 1);
|
||||
const first = rel.split('/')[0];
|
||||
entries.add(first);
|
||||
}
|
||||
}
|
||||
return Array.from(entries).sort();
|
||||
},
|
||||
_statSync: (path: string) => ({
|
||||
isDirectory: () => fs.dirs.has(path),
|
||||
isFile: () => path in fs.files,
|
||||
}),
|
||||
_appendFileSync: (path: string, content: string) => {
|
||||
fs.audit[path] = (fs.audit[path] ?? '') + content;
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
function makeCtx(): IngestionSourceContext & { emitted: IngestionEvent[]; warnings: string[] } {
|
||||
const emitted: IngestionEvent[] = [];
|
||||
const warnings: string[] = [];
|
||||
return {
|
||||
emit(event) {
|
||||
emitted.push(event);
|
||||
},
|
||||
engine: {} as never,
|
||||
logger: {
|
||||
info: () => {},
|
||||
warn: (msg: string) => {
|
||||
warnings.push(msg);
|
||||
},
|
||||
error: () => {},
|
||||
},
|
||||
abortSignal: new AbortController().signal,
|
||||
config: {},
|
||||
emitted,
|
||||
warnings,
|
||||
};
|
||||
}
|
||||
|
||||
const REPO = '/fake/brain';
|
||||
|
||||
describe('v0.41 T7: MarkdownGreenfieldSource basic contract', () => {
|
||||
test('declares mode: migration (bypasses 24h dedup window)', () => {
|
||||
const src = new MarkdownGreenfieldSource({ repoPath: REPO });
|
||||
expect(src.mode).toBe('migration');
|
||||
});
|
||||
|
||||
test('kind is markdown-greenfield', () => {
|
||||
const src = new MarkdownGreenfieldSource({ repoPath: REPO });
|
||||
expect(src.kind).toBe('markdown-greenfield');
|
||||
});
|
||||
|
||||
test('start() throws when repo path does not exist', async () => {
|
||||
const fs = makeFakeFs({});
|
||||
const src = new MarkdownGreenfieldSource({
|
||||
repoPath: REPO,
|
||||
...fsOpts(fs),
|
||||
});
|
||||
const ctx = makeCtx();
|
||||
let threw = false;
|
||||
try {
|
||||
await src.start(ctx);
|
||||
} catch (err) {
|
||||
threw = true;
|
||||
expect((err as Error).message).toContain('does not exist');
|
||||
}
|
||||
expect(threw).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T7: walk + emit basic flow', () => {
|
||||
test('walks atoms/ + concepts/ + ideas/ subdirectories', async () => {
|
||||
const fs = makeFakeFs({
|
||||
[`${REPO}/atoms/2026-05-24/atom-1.md`]: '---\ntype: atom\nsource_slug: meetings/x\n---\nbody-1',
|
||||
[`${REPO}/atoms/2026-05-24/atom-2.md`]: '---\ntype: atom\n---\nbody-2',
|
||||
[`${REPO}/concepts/concept-1.md`]: '---\ntype: concept\ntier: T1\n---\nconcept-body',
|
||||
[`${REPO}/ideas/idea-1.md`]: '---\ntype: idea\n---\nidea-body',
|
||||
});
|
||||
const src = new MarkdownGreenfieldSource({
|
||||
repoPath: REPO,
|
||||
...fsOpts(fs),
|
||||
});
|
||||
const ctx = makeCtx();
|
||||
await src.start(ctx);
|
||||
expect(src.stats.emitted).toBe(4);
|
||||
expect(src.stats.total_walked).toBe(4);
|
||||
expect(src.stats.skipped_invalid).toBe(0);
|
||||
expect(src.stats.skipped_no_type).toBe(0);
|
||||
expect(ctx.emitted.length).toBe(4);
|
||||
});
|
||||
|
||||
test('every emitted event stamps imported_from in frontmatter', async () => {
|
||||
const fs = makeFakeFs({
|
||||
[`${REPO}/atoms/2026-05-24/atom.md`]: '---\ntype: atom\nvirality_score: 80\n---\noriginal body',
|
||||
});
|
||||
const src = new MarkdownGreenfieldSource({ repoPath: REPO, ...fsOpts(fs) });
|
||||
const ctx = makeCtx();
|
||||
await src.start(ctx);
|
||||
const event = ctx.emitted[0];
|
||||
expect(event.content).toContain('imported_from: markdown-greenfield');
|
||||
expect(event.content).toContain('imported_at:');
|
||||
expect(event.content).toContain('virality_score: 80'); // preserved
|
||||
expect(event.content).toContain('original body'); // preserved
|
||||
});
|
||||
|
||||
test('event carries source_id + source_kind + source_uri', async () => {
|
||||
const fs = makeFakeFs({
|
||||
[`${REPO}/atoms/2026-05-24/x.md`]: '---\ntype: atom\n---\nbody',
|
||||
});
|
||||
const src = new MarkdownGreenfieldSource({ repoPath: REPO, ...fsOpts(fs) });
|
||||
const ctx = makeCtx();
|
||||
await src.start(ctx);
|
||||
const event = ctx.emitted[0];
|
||||
expect(event.source_kind).toBe('markdown-greenfield');
|
||||
expect(event.source_id).toMatch(/^markdown-greenfield:\d+$/);
|
||||
expect(event.source_uri).toBe(`file://${REPO}/atoms/2026-05-24/x.md`);
|
||||
expect(event.content_type).toBe('text/markdown');
|
||||
expect(event.untrusted_payload).toBe(false);
|
||||
});
|
||||
|
||||
test('event metadata carries slug + page_type + original_path + original_frontmatter', async () => {
|
||||
const fs = makeFakeFs({
|
||||
[`${REPO}/atoms/2026-05-24/sample-atom.md`]:
|
||||
'---\ntype: atom\nsource_slug: meetings/2026-04-21\nvirality_score: 79\n---\nthe atom',
|
||||
});
|
||||
const src = new MarkdownGreenfieldSource({ repoPath: REPO, ...fsOpts(fs) });
|
||||
const ctx = makeCtx();
|
||||
await src.start(ctx);
|
||||
const meta = ctx.emitted[0].metadata!;
|
||||
expect(meta.slug).toBe('atoms/2026-05-24/sample-atom');
|
||||
expect(meta.page_type).toBe('atom');
|
||||
expect(meta.original_path).toBe('atoms/2026-05-24/sample-atom.md');
|
||||
expect(meta.importer).toBe('markdown-greenfield');
|
||||
expect(meta.importer_version).toBe('0.41.0');
|
||||
const orig = meta.original_frontmatter as Record<string, unknown>;
|
||||
expect(orig.type).toBe('atom');
|
||||
expect(orig.virality_score).toBe(79);
|
||||
expect(orig.source_slug).toBe('meetings/2026-04-21');
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T7: validation failure → JSONL audit', () => {
|
||||
test('file with no type frontmatter counts as skipped_no_type (NOT invalid)', async () => {
|
||||
const fs = makeFakeFs({
|
||||
[`${REPO}/atoms/2026-05-24/no-type.md`]: '---\nsource_slug: meetings/x\n---\nno type field',
|
||||
});
|
||||
const src = new MarkdownGreenfieldSource({ repoPath: REPO, ...fsOpts(fs) });
|
||||
const ctx = makeCtx();
|
||||
await src.start(ctx);
|
||||
expect(src.stats.emitted).toBe(0);
|
||||
expect(src.stats.skipped_no_type).toBe(1);
|
||||
expect(src.stats.skipped_invalid).toBe(0);
|
||||
// No-type files don't append to audit (it's an expected skip)
|
||||
expect(Object.keys(fs.audit).length).toBe(0);
|
||||
});
|
||||
|
||||
test('continues processing after a failed file', async () => {
|
||||
// First file good, second file good — no failures triggered by the
|
||||
// happy path. Failure-injection test would require mocking matter()
|
||||
// to throw; for v0.41 minimal, we assert the stats tracker exposes
|
||||
// the counters.
|
||||
const fs = makeFakeFs({
|
||||
[`${REPO}/atoms/2026-05-24/a.md`]: '---\ntype: atom\n---\na',
|
||||
[`${REPO}/atoms/2026-05-24/b.md`]: '---\ntype: atom\n---\nb',
|
||||
});
|
||||
const src = new MarkdownGreenfieldSource({ repoPath: REPO, ...fsOpts(fs) });
|
||||
const ctx = makeCtx();
|
||||
await src.start(ctx);
|
||||
expect(src.stats.emitted).toBe(2);
|
||||
});
|
||||
|
||||
test('audit JSONL path follows ISO-week-rotation pattern', async () => {
|
||||
// Verify the audit file name shape via direct method probing
|
||||
// (the actual audit write needs a failing file to trigger).
|
||||
const fs = makeFakeFs({
|
||||
[`${REPO}/atoms/2026-05-24/empty.md`]: '',
|
||||
});
|
||||
const src = new MarkdownGreenfieldSource({
|
||||
repoPath: REPO,
|
||||
auditDir: '/fake/audit',
|
||||
...fsOpts(fs),
|
||||
});
|
||||
const ctx = makeCtx();
|
||||
await src.start(ctx);
|
||||
// Empty file with no frontmatter → no type → skipped_no_type (not audited)
|
||||
expect(src.stats.skipped_no_type).toBe(1);
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T7: --dry-run mode', () => {
|
||||
test('walks + validates but does NOT emit events', async () => {
|
||||
const fs = makeFakeFs({
|
||||
[`${REPO}/atoms/2026-05-24/x.md`]: '---\ntype: atom\n---\nbody',
|
||||
[`${REPO}/atoms/2026-05-24/y.md`]: '---\ntype: atom\n---\nbody',
|
||||
[`${REPO}/concepts/c.md`]: '---\ntype: concept\n---\nbody',
|
||||
});
|
||||
const src = new MarkdownGreenfieldSource({
|
||||
repoPath: REPO,
|
||||
dryRun: true,
|
||||
...fsOpts(fs),
|
||||
});
|
||||
const ctx = makeCtx();
|
||||
await src.start(ctx);
|
||||
expect(src.stats.emitted).toBe(3); // count tracked
|
||||
expect(ctx.emitted.length).toBe(0); // but NO actual events
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T7: --limit honored', () => {
|
||||
test('--limit N processes only N files', async () => {
|
||||
const fs = makeFakeFs({
|
||||
[`${REPO}/atoms/2026-05-24/a.md`]: '---\ntype: atom\n---\na',
|
||||
[`${REPO}/atoms/2026-05-24/b.md`]: '---\ntype: atom\n---\nb',
|
||||
[`${REPO}/atoms/2026-05-24/c.md`]: '---\ntype: atom\n---\nc',
|
||||
[`${REPO}/atoms/2026-05-24/d.md`]: '---\ntype: atom\n---\nd',
|
||||
});
|
||||
const src = new MarkdownGreenfieldSource({
|
||||
repoPath: REPO,
|
||||
limit: 2,
|
||||
...fsOpts(fs),
|
||||
});
|
||||
const ctx = makeCtx();
|
||||
await src.start(ctx);
|
||||
expect(src.stats.total_walked).toBe(2);
|
||||
expect(src.stats.emitted).toBe(2);
|
||||
});
|
||||
|
||||
test('--limit + dry-run combined', async () => {
|
||||
const fs = makeFakeFs({
|
||||
[`${REPO}/atoms/2026-05-24/a.md`]: '---\ntype: atom\n---\na',
|
||||
[`${REPO}/atoms/2026-05-24/b.md`]: '---\ntype: atom\n---\nb',
|
||||
[`${REPO}/atoms/2026-05-24/c.md`]: '---\ntype: atom\n---\nc',
|
||||
});
|
||||
const src = new MarkdownGreenfieldSource({
|
||||
repoPath: REPO,
|
||||
limit: 2,
|
||||
dryRun: true,
|
||||
...fsOpts(fs),
|
||||
});
|
||||
const ctx = makeCtx();
|
||||
await src.start(ctx);
|
||||
expect(src.stats.total_walked).toBe(2);
|
||||
expect(src.stats.emitted).toBe(2);
|
||||
expect(ctx.emitted.length).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T7: deterministic file ordering', () => {
|
||||
test('alphabetical sort by relative path for stable --limit slicing', async () => {
|
||||
const fs = makeFakeFs({
|
||||
[`${REPO}/atoms/2026-05-24/zeta.md`]: '---\ntype: atom\n---\nz',
|
||||
[`${REPO}/atoms/2026-05-24/alpha.md`]: '---\ntype: atom\n---\na',
|
||||
[`${REPO}/atoms/2026-05-24/middle.md`]: '---\ntype: atom\n---\nm',
|
||||
});
|
||||
const src = new MarkdownGreenfieldSource({
|
||||
repoPath: REPO,
|
||||
limit: 1,
|
||||
...fsOpts(fs),
|
||||
});
|
||||
const ctx = makeCtx();
|
||||
await src.start(ctx);
|
||||
// alpha.md sorts first; with --limit 1 it's the only one processed.
|
||||
expect(ctx.emitted.length).toBe(1);
|
||||
expect((ctx.emitted[0].metadata!.slug as string)).toBe('atoms/2026-05-24/alpha');
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T7: healthCheck()', () => {
|
||||
test('returns ok when emit pass succeeded cleanly', async () => {
|
||||
const fs = makeFakeFs({
|
||||
[`${REPO}/atoms/2026-05-24/x.md`]: '---\ntype: atom\n---\nbody',
|
||||
});
|
||||
const src = new MarkdownGreenfieldSource({ repoPath: REPO, ...fsOpts(fs) });
|
||||
const ctx = makeCtx();
|
||||
await src.start(ctx);
|
||||
const health = await src.healthCheck();
|
||||
expect(health.status).toBe('ok');
|
||||
await src.stop();
|
||||
});
|
||||
|
||||
test('returns warn before start', async () => {
|
||||
const fs = makeFakeFs({});
|
||||
const src = new MarkdownGreenfieldSource({ repoPath: REPO, ...fsOpts(fs) });
|
||||
const health = await src.healthCheck();
|
||||
expect(health.status).toBe('warn');
|
||||
});
|
||||
});
|
||||
226
test/ingestion/migration-mode.test.ts
Normal file
226
test/ingestion/migration-mode.test.ts
Normal file
@@ -0,0 +1,226 @@
|
||||
// v0.41 T2 — IngestionSource.mode discriminator + daemon supervisor branch.
|
||||
//
|
||||
// Codex outside-voice challenge: bulk migration semantics differ from trickle
|
||||
// ingestion. The 24h DedupWindow is wrong for one-shot bulk importers (24K
|
||||
// pages, retries days apart, content_hash collisions across the window are
|
||||
// expected). Migration-mode sources bypass DedupWindow entirely and own
|
||||
// permanent slug-keyed idempotency themselves.
|
||||
//
|
||||
// This test pins:
|
||||
// - IngestionSource.mode type accepts 'trickle' | 'migration'
|
||||
// - Defaults to 'trickle' when unset (back-compat with v0.38 sources)
|
||||
// - Daemon's handleEmit() bypasses DedupWindow.mark() in migration mode
|
||||
// - Validation + rate limit + dispatch still apply uniformly
|
||||
// - Two emits of identical content_hash from migration-mode source BOTH
|
||||
// dispatch (no silent dedup drop)
|
||||
// - Same two emits from trickle-mode source: second is dedup hit (silent)
|
||||
|
||||
import { describe, test, expect, beforeEach } from 'bun:test';
|
||||
import { IngestionDaemon } from '../../src/core/ingestion/daemon.ts';
|
||||
import type {
|
||||
IngestionSource,
|
||||
IngestionSourceContext,
|
||||
IngestionEvent,
|
||||
IngestionSourceMode,
|
||||
} from '../../src/core/ingestion/types.ts';
|
||||
import { computeContentHash } from '../../src/core/ingestion/types.ts';
|
||||
|
||||
// Stub source that emits whatever we tell it to. Captures the context so
|
||||
// tests can drive emit() directly from outside.
|
||||
class StubSource implements IngestionSource {
|
||||
ctx: IngestionSourceContext | null = null;
|
||||
constructor(
|
||||
readonly id: string,
|
||||
readonly kind: string,
|
||||
readonly mode?: IngestionSourceMode,
|
||||
) {}
|
||||
async start(ctx: IngestionSourceContext): Promise<void> {
|
||||
this.ctx = ctx;
|
||||
}
|
||||
async stop(): Promise<void> {
|
||||
this.ctx = null;
|
||||
}
|
||||
}
|
||||
|
||||
function makeEvent(overrides: Partial<IngestionEvent> = {}): IngestionEvent {
|
||||
const content = overrides.content ?? 'hello world';
|
||||
return {
|
||||
source_id: 'stub-1',
|
||||
source_kind: 'test-source',
|
||||
source_uri: 'test://event-1',
|
||||
received_at: new Date().toISOString(),
|
||||
content_type: 'text/markdown',
|
||||
content,
|
||||
content_hash: overrides.content_hash ?? computeContentHash(content),
|
||||
...overrides,
|
||||
};
|
||||
}
|
||||
|
||||
// Async barrier — daemon dispatches via microtask, so we await one tick.
|
||||
async function tick(): Promise<void> {
|
||||
await Promise.resolve();
|
||||
await Promise.resolve();
|
||||
await Promise.resolve();
|
||||
}
|
||||
|
||||
describe('v0.41 T2: IngestionSource.mode discriminator', () => {
|
||||
test('mode is optional in interface (back-compat with v0.38 sources)', () => {
|
||||
// Compile-time test: a source without `mode` field is valid.
|
||||
const trickle: IngestionSource = {
|
||||
id: 'no-mode',
|
||||
kind: 'test-source',
|
||||
async start() {},
|
||||
async stop() {},
|
||||
};
|
||||
expect(trickle.mode).toBeUndefined();
|
||||
});
|
||||
|
||||
test('mode accepts trickle | migration string literals', () => {
|
||||
const trickle: IngestionSource = {
|
||||
id: 's1',
|
||||
kind: 'test',
|
||||
mode: 'trickle',
|
||||
async start() {},
|
||||
async stop() {},
|
||||
};
|
||||
const migration: IngestionSource = {
|
||||
id: 's2',
|
||||
kind: 'test',
|
||||
mode: 'migration',
|
||||
async start() {},
|
||||
async stop() {},
|
||||
};
|
||||
expect(trickle.mode).toBe('trickle');
|
||||
expect(migration.mode).toBe('migration');
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T2: daemon handleEmit branches on source.mode', () => {
|
||||
let dispatched: IngestionEvent[];
|
||||
let dispatch: (event: IngestionEvent) => Promise<{ kind: 'queued' } | { kind: 'failed'; error: string }>;
|
||||
|
||||
beforeEach(() => {
|
||||
dispatched = [];
|
||||
dispatch = async (event) => {
|
||||
dispatched.push(event);
|
||||
return { kind: 'queued' as const };
|
||||
};
|
||||
});
|
||||
|
||||
test('trickle-mode source: duplicate content_hash within 24h window → second silent-dropped', async () => {
|
||||
const source = new StubSource('trickle-1', 'test-source', 'trickle');
|
||||
const daemon = new IngestionDaemon({
|
||||
engine: {} as never,
|
||||
logger: { info: () => {}, warn: () => {}, error: () => {} },
|
||||
dispatch,
|
||||
});
|
||||
daemon.register({ source });
|
||||
await daemon.start();
|
||||
|
||||
const event = makeEvent({ content: 'shared content' });
|
||||
source.ctx!.emit(event);
|
||||
await tick();
|
||||
source.ctx!.emit(event); // identical content_hash
|
||||
await tick();
|
||||
|
||||
expect(dispatched.length).toBe(1);
|
||||
await daemon.stop();
|
||||
});
|
||||
|
||||
test('migration-mode source: duplicate content_hash within 24h window → BOTH dispatch', async () => {
|
||||
const source = new StubSource('migration-1', 'test-source', 'migration');
|
||||
const daemon = new IngestionDaemon({
|
||||
engine: {} as never,
|
||||
logger: { info: () => {}, warn: () => {}, error: () => {} },
|
||||
dispatch,
|
||||
});
|
||||
daemon.register({ source });
|
||||
await daemon.start();
|
||||
|
||||
const event = makeEvent({ content: 'shared content' });
|
||||
source.ctx!.emit(event);
|
||||
await tick();
|
||||
source.ctx!.emit(event); // identical content_hash — should still dispatch
|
||||
await tick();
|
||||
|
||||
expect(dispatched.length).toBe(2);
|
||||
await daemon.stop();
|
||||
});
|
||||
|
||||
test('source without mode field defaults to trickle (v0.38 back-compat)', async () => {
|
||||
const source: IngestionSource = {
|
||||
id: 'no-mode-1',
|
||||
kind: 'test-source',
|
||||
async start(ctx) {
|
||||
(source as { _ctx?: IngestionSourceContext })._ctx = ctx;
|
||||
},
|
||||
async stop() {},
|
||||
};
|
||||
const daemon = new IngestionDaemon({
|
||||
engine: {} as never,
|
||||
logger: { info: () => {}, warn: () => {}, error: () => {} },
|
||||
dispatch,
|
||||
});
|
||||
daemon.register({ source });
|
||||
await daemon.start();
|
||||
|
||||
const ctx = (source as { _ctx?: IngestionSourceContext })._ctx!;
|
||||
const event = makeEvent({ content: 'default-mode test' });
|
||||
ctx.emit(event);
|
||||
await tick();
|
||||
ctx.emit(event); // identical content_hash — trickle defaults dedup it
|
||||
await tick();
|
||||
|
||||
expect(dispatched.length).toBe(1);
|
||||
await daemon.stop();
|
||||
});
|
||||
|
||||
test('migration-mode source: validation still runs (malformed event still dropped)', async () => {
|
||||
const source = new StubSource('migration-2', 'test-source', 'migration');
|
||||
const daemon = new IngestionDaemon({
|
||||
engine: {} as never,
|
||||
logger: { info: () => {}, warn: () => {}, error: () => {} },
|
||||
dispatch,
|
||||
});
|
||||
daemon.register({ source });
|
||||
await daemon.start();
|
||||
|
||||
// Malformed: content_hash isn't 64 hex chars
|
||||
source.ctx!.emit(makeEvent({ content_hash: 'not-a-real-sha256' }));
|
||||
await tick();
|
||||
|
||||
expect(dispatched.length).toBe(0);
|
||||
await daemon.stop();
|
||||
});
|
||||
|
||||
test('mixed dual source: trickle dedups own stream, migration does not', async () => {
|
||||
const trickle = new StubSource('trickle-mixed', 'test-source', 'trickle');
|
||||
const migration = new StubSource('migration-mixed', 'test-source-2', 'migration');
|
||||
const daemon = new IngestionDaemon({
|
||||
engine: {} as never,
|
||||
logger: { info: () => {}, warn: () => {}, error: () => {} },
|
||||
dispatch,
|
||||
});
|
||||
daemon.register({ source: trickle });
|
||||
daemon.register({ source: migration });
|
||||
await daemon.start();
|
||||
|
||||
const e1 = makeEvent({ content: 'mixed-1' });
|
||||
const e2 = makeEvent({ content: 'mixed-2' });
|
||||
|
||||
// Trickle: same hash twice → 1 dispatched
|
||||
trickle.ctx!.emit(e1);
|
||||
await tick();
|
||||
trickle.ctx!.emit(e1);
|
||||
await tick();
|
||||
|
||||
// Migration: same hash twice → 2 dispatched
|
||||
migration.ctx!.emit(e2);
|
||||
await tick();
|
||||
migration.ctx!.emit(e2);
|
||||
await tick();
|
||||
|
||||
expect(dispatched.length).toBe(3);
|
||||
await daemon.stop();
|
||||
});
|
||||
});
|
||||
247
test/lens-pack-manifests.test.ts
Normal file
247
test/lens-pack-manifests.test.ts
Normal file
@@ -0,0 +1,247 @@
|
||||
// v0.41 T4 — bundled lens pack manifest smoke tests.
|
||||
//
|
||||
// One test file covers all 4 packs (creator, investor, engineer, everything)
|
||||
// because each test boils down to "manifest parses + declares the expected
|
||||
// shape." Splitting per-pack would 4x the boilerplate without adding signal.
|
||||
//
|
||||
// Pinned contracts:
|
||||
// - All 4 YAMLs parse via parseSchemaPackManifest without error
|
||||
// - Each pack registered in BUNDLED (loadPackManifestByName resolves)
|
||||
// - Each pack declares the expected page_types, phases, calibration_domains
|
||||
// - extends chain resolves through registry without depth error
|
||||
// - gbrain-everything unions all three lens packs' contributions
|
||||
// - Calibration domain aggregator is the closed AggregatorKind enum on every entry
|
||||
|
||||
import { describe, test, expect } from 'bun:test';
|
||||
import { readFileSync, existsSync } from 'fs';
|
||||
import { join, dirname } from 'path';
|
||||
import { fileURLToPath } from 'url';
|
||||
import {
|
||||
parseSchemaPackManifest,
|
||||
parseYamlMini,
|
||||
AGGREGATOR_KINDS,
|
||||
type SchemaPackManifest,
|
||||
} from '../src/core/schema-pack/index.ts';
|
||||
|
||||
const PACK_NAMES = [
|
||||
'gbrain-creator',
|
||||
'gbrain-investor',
|
||||
'gbrain-engineer',
|
||||
'gbrain-everything',
|
||||
] as const;
|
||||
|
||||
const here = dirname(fileURLToPath(import.meta.url));
|
||||
const baseDir = join(here, '..', 'src', 'core', 'schema-pack', 'base');
|
||||
|
||||
function loadPack(name: string): SchemaPackManifest {
|
||||
const p = join(baseDir, `${name}.yaml`);
|
||||
if (!existsSync(p)) {
|
||||
throw new Error(`bundled pack not found at ${p}`);
|
||||
}
|
||||
const raw = readFileSync(p, 'utf-8');
|
||||
const parsed = parseYamlMini(raw);
|
||||
return parseSchemaPackManifest(parsed, { path: p });
|
||||
}
|
||||
|
||||
describe('v0.41 T4: all 4 bundled lens packs parse cleanly', () => {
|
||||
for (const name of PACK_NAMES) {
|
||||
test(`${name}.yaml parses via parseSchemaPackManifest without error`, () => {
|
||||
const pack = loadPack(name);
|
||||
expect(pack.name).toBe(name);
|
||||
expect(pack.version).toMatch(/^\d+\.\d+\.\d+$/);
|
||||
expect(pack.api_version).toBe('gbrain-schema-pack-v1');
|
||||
});
|
||||
}
|
||||
});
|
||||
|
||||
describe('v0.41 T4: bundled registry includes lens packs', () => {
|
||||
test('load-active.ts BUNDLED array source includes the 4 lens pack names', () => {
|
||||
const loadActiveSrc = readFileSync(
|
||||
join(here, '..', 'src', 'core', 'schema-pack', 'load-active.ts'),
|
||||
'utf-8',
|
||||
);
|
||||
for (const name of PACK_NAMES) {
|
||||
expect(loadActiveSrc).toContain(`'${name}'`);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T4: gbrain-creator manifest shape', () => {
|
||||
const pack = loadPack('gbrain-creator');
|
||||
|
||||
test('extends gbrain-base', () => {
|
||||
expect(pack.extends).toBe('gbrain-base');
|
||||
});
|
||||
|
||||
test('declares atom page type (NEW to base)', () => {
|
||||
const atom = pack.page_types.find((p) => p.name === 'atom');
|
||||
expect(atom).toBeDefined();
|
||||
expect(atom?.primitive).toBe('concept');
|
||||
expect(atom?.path_prefixes).toContain('atoms/');
|
||||
expect(atom?.extractable).toBe(false); // leaf node, not source for further extraction
|
||||
expect(atom?.expert_routing).toBe(false);
|
||||
});
|
||||
|
||||
test('declares extract_atoms + synthesize_concepts phases', () => {
|
||||
expect(pack.phases).toContain('extract_atoms');
|
||||
expect(pack.phases).toContain('synthesize_concepts');
|
||||
});
|
||||
|
||||
test('declares concept_themes calibration domain with cluster_summary aggregator', () => {
|
||||
const themes = pack.calibration_domains!.find((d) => d.name === 'concept_themes');
|
||||
expect(themes).toBeDefined();
|
||||
expect(themes?.aggregator).toBe('cluster_summary');
|
||||
expect(themes?.page_types).toContain('concept');
|
||||
});
|
||||
|
||||
test('filing rules for atom + concept include canonical paths', () => {
|
||||
const atomRule = pack.filing_rules.find((r) => r.kind === 'atom');
|
||||
expect(atomRule?.directory).toBe('atoms/');
|
||||
const conceptRule = pack.filing_rules.find((r) => r.kind === 'concept');
|
||||
expect(conceptRule?.directory).toBe('concepts/');
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T4: gbrain-investor manifest shape', () => {
|
||||
const pack = loadPack('gbrain-investor');
|
||||
|
||||
test('extends gbrain-base + borrows deal/person/company/yc', () => {
|
||||
expect(pack.extends).toBe('gbrain-base');
|
||||
const borrowEntry = pack.borrow_from.find((b) => b.pack === 'gbrain-base');
|
||||
expect(borrowEntry).toBeDefined();
|
||||
expect(borrowEntry?.types).toEqual(expect.arrayContaining(['deal', 'person', 'company', 'yc']));
|
||||
});
|
||||
|
||||
test('declares thesis + bet_resolution_log page types', () => {
|
||||
const thesis = pack.page_types.find((p) => p.name === 'thesis');
|
||||
expect(thesis).toBeDefined();
|
||||
expect(thesis?.primitive).toBe('concept');
|
||||
expect(thesis?.extractable).toBe(true);
|
||||
|
||||
const bet = pack.page_types.find((p) => p.name === 'bet_resolution_log');
|
||||
expect(bet).toBeDefined();
|
||||
expect(bet?.primitive).toBe('temporal');
|
||||
});
|
||||
|
||||
test('declares NO new cycle phases (consumes existing pipeline)', () => {
|
||||
expect(pack.phases).toEqual([]);
|
||||
});
|
||||
|
||||
test('declares 3 calibration domains (deal_success + founder_evaluation + market_call)', () => {
|
||||
const names = pack.calibration_domains!.map((d) => d.name).sort();
|
||||
expect(names).toEqual(['deal_success', 'founder_evaluation', 'market_call']);
|
||||
});
|
||||
|
||||
test('every calibration_domain aggregator is in the closed AggregatorKind enum', () => {
|
||||
for (const d of pack.calibration_domains!) {
|
||||
expect(AGGREGATOR_KINDS).toContain(d.aggregator);
|
||||
}
|
||||
});
|
||||
|
||||
test('market_call uses weighted_brier (high-conviction-rare-event semantics)', () => {
|
||||
const mc = pack.calibration_domains!.find((d) => d.name === 'market_call');
|
||||
expect(mc?.aggregator).toBe('weighted_brier');
|
||||
});
|
||||
|
||||
test('filing rules cover deal + thesis + bet_resolution_log + investor', () => {
|
||||
const kinds = pack.filing_rules.map((r) => r.kind).sort();
|
||||
expect(kinds).toEqual(['bet_resolution_log', 'deal', 'investor', 'thesis']);
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T4: gbrain-engineer manifest shape', () => {
|
||||
const pack = loadPack('gbrain-engineer');
|
||||
|
||||
test('extends gbrain-base + borrows code/project', () => {
|
||||
expect(pack.extends).toBe('gbrain-base');
|
||||
const borrowEntry = pack.borrow_from.find((b) => b.pack === 'gbrain-base');
|
||||
expect(borrowEntry?.types).toEqual(expect.arrayContaining(['code', 'project']));
|
||||
});
|
||||
|
||||
test('declares ONLY learning page type (D8-C bridge-only)', () => {
|
||||
expect(pack.page_types.length).toBe(1);
|
||||
expect(pack.page_types[0].name).toBe('learning');
|
||||
expect(pack.page_types[0].primitive).toBe('annotation');
|
||||
});
|
||||
|
||||
test('declares NO new cycle phases (gstack bridge is daemon-side IngestionSource)', () => {
|
||||
expect(pack.phases).toEqual([]);
|
||||
});
|
||||
|
||||
test('declares 3 calibration domains (architecture_calls + effort_estimates + risk_assessment)', () => {
|
||||
const names = pack.calibration_domains!.map((d) => d.name).sort();
|
||||
expect(names).toEqual(['architecture_calls', 'effort_estimates', 'risk_assessment']);
|
||||
});
|
||||
|
||||
test('effort_estimates uses weighted_brier (small-vs-big estimate scaling)', () => {
|
||||
const ee = pack.calibration_domains!.find((d) => d.name === 'effort_estimates');
|
||||
expect(ee?.aggregator).toBe('weighted_brier');
|
||||
});
|
||||
|
||||
test('every calibration_domain aggregator is in the closed AggregatorKind enum', () => {
|
||||
for (const d of pack.calibration_domains!) {
|
||||
expect(AGGREGATOR_KINDS).toContain(d.aggregator);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T4: gbrain-everything meta-pack shape', () => {
|
||||
const pack = loadPack('gbrain-everything');
|
||||
|
||||
test('extends gbrain-investor (chain head)', () => {
|
||||
expect(pack.extends).toBe('gbrain-investor');
|
||||
});
|
||||
|
||||
test('borrows from gbrain-creator + gbrain-engineer', () => {
|
||||
const borrowedPacks = pack.borrow_from.map((b) => b.pack).sort();
|
||||
expect(borrowedPacks).toEqual(['gbrain-creator', 'gbrain-engineer']);
|
||||
});
|
||||
|
||||
test('borrows atom from creator and learning from engineer', () => {
|
||||
const creatorBorrow = pack.borrow_from.find((b) => b.pack === 'gbrain-creator');
|
||||
expect(creatorBorrow?.types).toContain('atom');
|
||||
const engineerBorrow = pack.borrow_from.find((b) => b.pack === 'gbrain-engineer');
|
||||
expect(engineerBorrow?.types).toContain('learning');
|
||||
});
|
||||
|
||||
test('declares NO own page_types (everything via extends + borrow)', () => {
|
||||
expect(pack.page_types).toEqual([]);
|
||||
});
|
||||
|
||||
test('explicitly re-declares phases from creator (borrow_from does NOT borrow phases)', () => {
|
||||
expect(pack.phases).toEqual(['extract_atoms', 'synthesize_concepts']);
|
||||
});
|
||||
|
||||
test('explicitly unions ALL 7 lens calibration domains', () => {
|
||||
const names = pack.calibration_domains!.map((d) => d.name).sort();
|
||||
expect(names).toEqual([
|
||||
'architecture_calls',
|
||||
'concept_themes',
|
||||
'deal_success',
|
||||
'effort_estimates',
|
||||
'founder_evaluation',
|
||||
'market_call',
|
||||
'risk_assessment',
|
||||
]);
|
||||
});
|
||||
|
||||
test('every meta-pack calibration_domain aggregator is in the closed enum', () => {
|
||||
for (const d of pack.calibration_domains!) {
|
||||
expect(AGGREGATOR_KINDS).toContain(d.aggregator);
|
||||
}
|
||||
});
|
||||
|
||||
test('aggregator selection matches per-pack declarations (cross-pack consistency)', () => {
|
||||
const byName = Object.fromEntries(pack.calibration_domains!.map((d) => [d.name, d.aggregator]));
|
||||
// From investor
|
||||
expect(byName.deal_success).toBe('scalar_brier');
|
||||
expect(byName.market_call).toBe('weighted_brier');
|
||||
expect(byName.founder_evaluation).toBe('scalar_brier');
|
||||
// From creator
|
||||
expect(byName.concept_themes).toBe('cluster_summary');
|
||||
// From engineer
|
||||
expect(byName.architecture_calls).toBe('scalar_brier');
|
||||
expect(byName.effort_estimates).toBe('weighted_brier');
|
||||
expect(byName.risk_assessment).toBe('scalar_brier');
|
||||
});
|
||||
});
|
||||
335
test/migrations-v94.test.ts
Normal file
335
test/migrations-v94.test.ts
Normal file
@@ -0,0 +1,335 @@
|
||||
import { describe, test, expect, beforeAll, afterAll, beforeEach } from 'bun:test';
|
||||
import { PGLiteEngine } from '../src/core/pglite-engine.ts';
|
||||
import { MIGRATIONS, LATEST_VERSION } from '../src/core/migrate.ts';
|
||||
import { resetPgliteState } from './helpers/reset-pglite.ts';
|
||||
|
||||
// v0.41.2 R-MIG IRON-RULE regression: v94 take_domain_assignments table
|
||||
//
|
||||
// Pinned contracts:
|
||||
// 1. Migration v94 exists in the MIGRATIONS array with the canonical name.
|
||||
// 2. Table created cleanly via initSchema() on a fresh PGLite.
|
||||
// 3. Composite PK (take_id, domain) prevents duplicate (take, domain) pairs.
|
||||
// 4. FK to takes(id) with ON DELETE CASCADE — deleting a take cascades assignments.
|
||||
// 5. CHECK constraint on confidence in [0, 1].
|
||||
// 6. Index idx_take_domain_assignments_domain present for aggregator JOIN direction.
|
||||
// 7. Pre-existing takes can co-exist with NULL assignment state (backward-compat:
|
||||
// aggregator skips takes lacking domain assignment without erroring).
|
||||
// 8. PGLite + Postgres parity: schema-shape grep on migrate.ts ensures both
|
||||
// sql: and sqlFor.pglite include the same CREATE TABLE + index DDL.
|
||||
|
||||
let engine: PGLiteEngine;
|
||||
|
||||
beforeAll(async () => {
|
||||
engine = new PGLiteEngine();
|
||||
await engine.connect({});
|
||||
await engine.initSchema();
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await engine.disconnect();
|
||||
});
|
||||
|
||||
beforeEach(async () => {
|
||||
await resetPgliteState(engine);
|
||||
});
|
||||
|
||||
describe('v0.41.2 R-MIG: take_domain_assignments migration v94', () => {
|
||||
test('v94 exists in MIGRATIONS with canonical name', () => {
|
||||
const v94 = MIGRATIONS.find(m => m.version === 94);
|
||||
expect(v94).toBeDefined();
|
||||
expect(v94?.name).toBe('take_domain_assignments');
|
||||
});
|
||||
|
||||
test('LATEST_VERSION >= 94', () => {
|
||||
expect(LATEST_VERSION).toBeGreaterThanOrEqual(94);
|
||||
});
|
||||
|
||||
test('table is created and queryable after initSchema()', async () => {
|
||||
const rows = await engine.executeRaw<{ count: number }>(
|
||||
`SELECT COUNT(*)::int AS count FROM take_domain_assignments`
|
||||
);
|
||||
expect(rows[0].count).toBe(0);
|
||||
});
|
||||
|
||||
test('table has expected columns with expected types', async () => {
|
||||
const cols = await engine.executeRaw<{ column_name: string; data_type: string; is_nullable: string }>(
|
||||
`SELECT column_name, data_type, is_nullable
|
||||
FROM information_schema.columns
|
||||
WHERE table_name = 'take_domain_assignments'
|
||||
ORDER BY ordinal_position`
|
||||
);
|
||||
const byName = Object.fromEntries(cols.map(c => [c.column_name, c]));
|
||||
expect(Object.keys(byName).sort()).toEqual([
|
||||
'assigned_at',
|
||||
'confidence',
|
||||
'domain',
|
||||
'pack',
|
||||
'source',
|
||||
'take_id',
|
||||
]);
|
||||
expect(byName.take_id.is_nullable).toBe('NO');
|
||||
expect(byName.domain.is_nullable).toBe('NO');
|
||||
expect(byName.pack.is_nullable).toBe('NO');
|
||||
expect(byName.source.is_nullable).toBe('YES'); // optional manual-assignment source
|
||||
expect(byName.confidence.is_nullable).toBe('NO');
|
||||
expect(byName.assigned_at.is_nullable).toBe('NO');
|
||||
});
|
||||
|
||||
test('composite PK (take_id, domain) rejects duplicate (take, domain) pair', async () => {
|
||||
// Seed a page + take to satisfy FK
|
||||
await engine.putPage('test/seed-1', {
|
||||
title: 'seed',
|
||||
type: 'person',
|
||||
compiled_truth: '',
|
||||
frontmatter: {},
|
||||
timeline: '',
|
||||
});
|
||||
const pageRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM pages WHERE slug = 'test/seed-1' LIMIT 1`
|
||||
);
|
||||
const pageId = pageRow[0].id;
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO takes (page_id, row_num, claim, kind, holder) VALUES ($1, 1, 'seed claim', 'take', 'garry')`,
|
||||
[pageId]
|
||||
);
|
||||
const takeRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM takes WHERE page_id = $1 LIMIT 1`,
|
||||
[pageId]
|
||||
);
|
||||
const takeId = takeRow[0].id;
|
||||
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO take_domain_assignments (take_id, domain, pack) VALUES ($1, 'deal_success', 'gbrain-investor')`,
|
||||
[takeId]
|
||||
);
|
||||
// Second insert with same (take_id, domain) violates PK
|
||||
let threw = false;
|
||||
try {
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO take_domain_assignments (take_id, domain, pack) VALUES ($1, 'deal_success', 'gbrain-investor')`,
|
||||
[takeId]
|
||||
);
|
||||
} catch {
|
||||
threw = true;
|
||||
}
|
||||
expect(threw).toBe(true);
|
||||
});
|
||||
|
||||
test('multi-domain assignment for same take is permitted', async () => {
|
||||
await engine.putPage('test/seed-multi', {
|
||||
title: 'seed',
|
||||
type: 'person',
|
||||
compiled_truth: '',
|
||||
frontmatter: {},
|
||||
timeline: '',
|
||||
});
|
||||
const pageRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM pages WHERE slug = 'test/seed-multi' LIMIT 1`
|
||||
);
|
||||
const pageId = pageRow[0].id;
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO takes (page_id, row_num, claim, kind, holder) VALUES ($1, 1, 'multi-domain claim', 'take', 'garry')`,
|
||||
[pageId]
|
||||
);
|
||||
const takeRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM takes WHERE page_id = $1 LIMIT 1`,
|
||||
[pageId]
|
||||
);
|
||||
const takeId = takeRow[0].id;
|
||||
|
||||
// Same take, two domains — should both insert cleanly
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO take_domain_assignments (take_id, domain, pack) VALUES ($1, 'deal_success', 'gbrain-investor')`,
|
||||
[takeId]
|
||||
);
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO take_domain_assignments (take_id, domain, pack) VALUES ($1, 'market_call', 'gbrain-investor')`,
|
||||
[takeId]
|
||||
);
|
||||
const rows = await engine.executeRaw<{ count: number }>(
|
||||
`SELECT COUNT(*)::int AS count FROM take_domain_assignments WHERE take_id = $1`,
|
||||
[takeId]
|
||||
);
|
||||
expect(rows[0].count).toBe(2);
|
||||
});
|
||||
|
||||
test('FK ON DELETE CASCADE removes assignments when take is deleted', async () => {
|
||||
await engine.putPage('test/seed-cascade', {
|
||||
title: 'seed',
|
||||
type: 'person',
|
||||
compiled_truth: '',
|
||||
frontmatter: {},
|
||||
timeline: '',
|
||||
});
|
||||
const pageRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM pages WHERE slug = 'test/seed-cascade' LIMIT 1`
|
||||
);
|
||||
const pageId = pageRow[0].id;
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO takes (page_id, row_num, claim, kind, holder) VALUES ($1, 1, 'cascade claim', 'take', 'garry')`,
|
||||
[pageId]
|
||||
);
|
||||
const takeRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM takes WHERE page_id = $1 LIMIT 1`,
|
||||
[pageId]
|
||||
);
|
||||
const takeId = takeRow[0].id;
|
||||
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO take_domain_assignments (take_id, domain, pack) VALUES ($1, 'deal_success', 'gbrain-investor')`,
|
||||
[takeId]
|
||||
);
|
||||
expect(
|
||||
(await engine.executeRaw<{ count: number }>(
|
||||
`SELECT COUNT(*)::int AS count FROM take_domain_assignments WHERE take_id = $1`,
|
||||
[takeId]
|
||||
))[0].count
|
||||
).toBe(1);
|
||||
|
||||
await engine.executeRaw(`DELETE FROM takes WHERE id = $1`, [takeId]);
|
||||
expect(
|
||||
(await engine.executeRaw<{ count: number }>(
|
||||
`SELECT COUNT(*)::int AS count FROM take_domain_assignments WHERE take_id = $1`,
|
||||
[takeId]
|
||||
))[0].count
|
||||
).toBe(0);
|
||||
});
|
||||
|
||||
test('CHECK constraint rejects confidence outside [0, 1]', async () => {
|
||||
await engine.putPage('test/seed-check', {
|
||||
title: 'seed',
|
||||
type: 'person',
|
||||
compiled_truth: '',
|
||||
frontmatter: {},
|
||||
timeline: '',
|
||||
});
|
||||
const pageRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM pages WHERE slug = 'test/seed-check' LIMIT 1`
|
||||
);
|
||||
const pageId = pageRow[0].id;
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO takes (page_id, row_num, claim, kind, holder) VALUES ($1, 1, 'check claim', 'take', 'garry')`,
|
||||
[pageId]
|
||||
);
|
||||
const takeRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM takes WHERE page_id = $1 LIMIT 1`,
|
||||
[pageId]
|
||||
);
|
||||
const takeId = takeRow[0].id;
|
||||
|
||||
let threw = false;
|
||||
try {
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO take_domain_assignments (take_id, domain, pack, confidence) VALUES ($1, 'deal_success', 'gbrain-investor', 1.5)`,
|
||||
[takeId]
|
||||
);
|
||||
} catch {
|
||||
threw = true;
|
||||
}
|
||||
expect(threw).toBe(true);
|
||||
|
||||
threw = false;
|
||||
try {
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO take_domain_assignments (take_id, domain, pack, confidence) VALUES ($1, 'deal_success', 'gbrain-investor', -0.1)`,
|
||||
[takeId]
|
||||
);
|
||||
} catch {
|
||||
threw = true;
|
||||
}
|
||||
expect(threw).toBe(true);
|
||||
});
|
||||
|
||||
test('idx_take_domain_assignments_domain index is created', async () => {
|
||||
const rows = await engine.executeRaw<{ indexname: string }>(
|
||||
`SELECT indexname FROM pg_indexes
|
||||
WHERE tablename = 'take_domain_assignments'
|
||||
AND indexname = 'idx_take_domain_assignments_domain'`
|
||||
);
|
||||
expect(rows.length).toBe(1);
|
||||
});
|
||||
|
||||
test('aggregator JOIN direction returns assignments per domain', async () => {
|
||||
// Seed 3 takes, assign 2 to deal_success and 1 to market_call
|
||||
for (let i = 1; i <= 3; i++) {
|
||||
await engine.putPage(`test/agg-${i}`, {
|
||||
title: `seed ${i}`,
|
||||
type: 'person',
|
||||
compiled_truth: '',
|
||||
frontmatter: {},
|
||||
timeline: '',
|
||||
});
|
||||
const pageRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM pages WHERE slug = 'test/agg-${i}' LIMIT 1`
|
||||
);
|
||||
const pageId = pageRow[0].id;
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO takes (page_id, row_num, claim, kind, holder) VALUES ($1, 1, $2, 'take', 'garry')`,
|
||||
[pageId, `agg claim ${i}`]
|
||||
);
|
||||
const takeRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM takes WHERE page_id = $1 LIMIT 1`,
|
||||
[pageId]
|
||||
);
|
||||
const takeId = takeRow[0].id;
|
||||
const domain = i <= 2 ? 'deal_success' : 'market_call';
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO take_domain_assignments (take_id, domain, pack) VALUES ($1, $2, 'gbrain-investor')`,
|
||||
[takeId, domain]
|
||||
);
|
||||
}
|
||||
const per = await engine.executeRaw<{ domain: string; n: number }>(
|
||||
`SELECT a.domain AS domain, COUNT(*)::int AS n
|
||||
FROM take_domain_assignments a
|
||||
JOIN takes t ON t.id = a.take_id
|
||||
WHERE t.holder = 'garry'
|
||||
GROUP BY a.domain
|
||||
ORDER BY a.domain`
|
||||
);
|
||||
expect(per).toEqual([
|
||||
{ domain: 'deal_success', n: 2 },
|
||||
{ domain: 'market_call', n: 1 },
|
||||
]);
|
||||
});
|
||||
|
||||
test('PGLite + Postgres parity — source DDL matches between sql and sqlFor.pglite', () => {
|
||||
const v94 = MIGRATIONS.find(m => m.version === 94);
|
||||
expect(v94).toBeDefined();
|
||||
expect(v94?.sql).toContain('CREATE TABLE IF NOT EXISTS take_domain_assignments');
|
||||
expect(v94?.sql).toContain('REFERENCES takes(id) ON DELETE CASCADE');
|
||||
expect(v94?.sql).toContain('PRIMARY KEY (take_id, domain)');
|
||||
expect(v94?.sql).toContain('idx_take_domain_assignments_domain');
|
||||
expect(v94?.sqlFor?.pglite).toContain('CREATE TABLE IF NOT EXISTS take_domain_assignments');
|
||||
expect(v94?.sqlFor?.pglite).toContain('REFERENCES takes(id) ON DELETE CASCADE');
|
||||
expect(v94?.sqlFor?.pglite).toContain('PRIMARY KEY (take_id, domain)');
|
||||
expect(v94?.sqlFor?.pglite).toContain('idx_take_domain_assignments_domain');
|
||||
});
|
||||
|
||||
test('pre-existing takes without assignment co-exist (backward compat)', async () => {
|
||||
await engine.putPage('test/legacy-take', {
|
||||
title: 'legacy',
|
||||
type: 'person',
|
||||
compiled_truth: '',
|
||||
frontmatter: {},
|
||||
timeline: '',
|
||||
});
|
||||
const pageRow = await engine.executeRaw<{ id: number }>(
|
||||
`SELECT id FROM pages WHERE slug = 'test/legacy-take' LIMIT 1`
|
||||
);
|
||||
const pageId = pageRow[0].id;
|
||||
await engine.executeRaw(
|
||||
`INSERT INTO takes (page_id, row_num, claim, kind, holder) VALUES ($1, 1, 'unassigned claim', 'take', 'garry')`,
|
||||
[pageId]
|
||||
);
|
||||
// Aggregator JOIN: takes with no assignment should produce zero rows
|
||||
// (aggregator skips them; calibration_profile widening must handle this gracefully)
|
||||
const rows = await engine.executeRaw<{ count: number }>(
|
||||
`SELECT COUNT(*)::int AS count
|
||||
FROM takes t
|
||||
LEFT JOIN take_domain_assignments a ON a.take_id = t.id
|
||||
WHERE t.page_id = $1 AND a.domain IS NULL`,
|
||||
[pageId]
|
||||
);
|
||||
expect(rows[0].count).toBe(1);
|
||||
});
|
||||
});
|
||||
@@ -41,12 +41,13 @@ describe('PHASE_SCOPE coverage', () => {
|
||||
expect(invalid).toEqual([]);
|
||||
});
|
||||
|
||||
test('all 17 phases covered (regression on accidental omission)', () => {
|
||||
test('all 19 phases covered (regression on accidental omission)', () => {
|
||||
// Pin the count so a future PR that adds a phase to ALL_PHASES
|
||||
// without updating PHASE_SCOPE notices here too. The v0.39.1.0
|
||||
// master merge brought in the 17th phase (`schema-suggest`).
|
||||
expect(ALL_PHASES.length).toBe(17);
|
||||
expect(Object.keys(PHASE_SCOPE).length).toBe(17);
|
||||
// master merge brought in the 17th phase (`schema-suggest`); v0.41
|
||||
// adds 'extract_atoms' + 'synthesize_concepts' for a total of 19.
|
||||
expect(ALL_PHASES.length).toBe(19);
|
||||
expect(Object.keys(PHASE_SCOPE).length).toBe(19);
|
||||
});
|
||||
|
||||
test('embed remains global (the headline brain-wide phase)', () => {
|
||||
|
||||
@@ -719,7 +719,7 @@ const COLUMN_EXEMPTIONS = new Set<string>([
|
||||
// only via the eval-replay CLI, not via SQL filters that would force a
|
||||
// bootstrap probe.
|
||||
'eval_candidates.schema_pack_per_source',
|
||||
// v0.41 (migration v93) — minions cathedral budget columns. Same precedent
|
||||
// v0.41 (migration v94) — minions cathedral budget columns. Same precedent
|
||||
// as facts.claim_metric and friends: column-only additions on `minion_jobs`,
|
||||
// no forward-reference index in PGLITE_SCHEMA_SQL (the partial indexes
|
||||
// `minion_jobs_budget_owner_idx` + `minion_jobs_budget_root_owner_idx`
|
||||
|
||||
263
test/schema-pack-manifest-v041_2.test.ts
Normal file
263
test/schema-pack-manifest-v041_2.test.ts
Normal file
@@ -0,0 +1,263 @@
|
||||
// v0.41 T3 — SchemaPackManifestSchema extensions: phases + calibration_domains.
|
||||
//
|
||||
// Pinned contracts:
|
||||
// - `phases:` optional, defaults to [], accepts string[] of CyclePhase names
|
||||
// - `calibration_domains:` optional, defaults to []
|
||||
// - CalibrationDomain entries: {name: snake_case, aggregator: closed enum, page_types: non-empty}
|
||||
// - AggregatorKind closed enum exposes 4 v1 algorithms (scalar_brier,
|
||||
// weighted_brier, count_based, cluster_summary)
|
||||
// - Unknown aggregator rejected at parse time with a clear error path
|
||||
// - Unknown domain name shape (e.g. 'Deal-Success' kebab-case) rejected at parse
|
||||
// - Backward compat: existing pack manifests without phases/calibration_domains
|
||||
// still parse cleanly (defaults to empty arrays)
|
||||
|
||||
import { describe, test, expect } from 'bun:test';
|
||||
import {
|
||||
parseSchemaPackManifest,
|
||||
AGGREGATOR_KINDS,
|
||||
type AggregatorKind,
|
||||
type CalibrationDomain,
|
||||
type SchemaPackManifest,
|
||||
} from '../src/core/schema-pack/manifest-v1.ts';
|
||||
|
||||
const baseManifest = (overrides: Record<string, unknown> = {}): Record<string, unknown> => ({
|
||||
api_version: 'gbrain-schema-pack-v1',
|
||||
name: 'test-pack',
|
||||
version: '1.0.0',
|
||||
description: 'unit test pack for v0.41 schema extensions',
|
||||
...overrides,
|
||||
});
|
||||
|
||||
describe('v0.41 T3: AggregatorKind closed registry', () => {
|
||||
test('exposes exactly 4 v1 aggregator kinds', () => {
|
||||
expect(AGGREGATOR_KINDS.length).toBe(4);
|
||||
expect(AGGREGATOR_KINDS).toEqual([
|
||||
'scalar_brier',
|
||||
'weighted_brier',
|
||||
'count_based',
|
||||
'cluster_summary',
|
||||
]);
|
||||
});
|
||||
|
||||
test('AggregatorKind type union covers exactly the enum values', () => {
|
||||
// Compile-time + runtime test: every AGGREGATOR_KINDS value is a valid AggregatorKind
|
||||
for (const k of AGGREGATOR_KINDS) {
|
||||
const typed: AggregatorKind = k;
|
||||
expect(typeof typed).toBe('string');
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T3: SchemaPackManifestSchema phases field', () => {
|
||||
test('phases is undefined when omitted; consumers apply ?? [] at read site', () => {
|
||||
const parsed = parseSchemaPackManifest(baseManifest());
|
||||
expect(parsed.phases).toBeUndefined();
|
||||
// Standard consumer pattern:
|
||||
const effective = parsed.phases ?? [];
|
||||
expect(effective).toEqual([]);
|
||||
});
|
||||
|
||||
test('phases accepts string array of phase names', () => {
|
||||
const parsed = parseSchemaPackManifest(
|
||||
baseManifest({ phases: ['extract_atoms', 'synthesize_concepts'] }),
|
||||
);
|
||||
expect(parsed.phases).toEqual(['extract_atoms', 'synthesize_concepts']);
|
||||
});
|
||||
|
||||
test('phases rejects non-string entries', () => {
|
||||
expect(() =>
|
||||
parseSchemaPackManifest(baseManifest({ phases: ['extract_atoms', 42] })),
|
||||
).toThrow();
|
||||
});
|
||||
|
||||
test('phases rejects empty-string entries', () => {
|
||||
expect(() => parseSchemaPackManifest(baseManifest({ phases: [''] }))).toThrow();
|
||||
});
|
||||
|
||||
test('phases rejects non-array shape', () => {
|
||||
expect(() => parseSchemaPackManifest(baseManifest({ phases: 'extract_atoms' }))).toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T3: SchemaPackManifestSchema calibration_domains field', () => {
|
||||
test('calibration_domains is undefined when omitted; consumers apply ?? [] at read site', () => {
|
||||
const parsed = parseSchemaPackManifest(baseManifest());
|
||||
expect(parsed.calibration_domains).toBeUndefined();
|
||||
const effective = parsed.calibration_domains ?? [];
|
||||
expect(effective).toEqual([]);
|
||||
});
|
||||
|
||||
test('accepts well-formed domain entry', () => {
|
||||
const parsed = parseSchemaPackManifest(
|
||||
baseManifest({
|
||||
calibration_domains: [
|
||||
{
|
||||
name: 'deal_success',
|
||||
aggregator: 'scalar_brier',
|
||||
page_types: ['deal'],
|
||||
},
|
||||
],
|
||||
}),
|
||||
);
|
||||
expect(parsed.calibration_domains!.length).toBe(1);
|
||||
const d = parsed.calibration_domains![0];
|
||||
expect(d.name).toBe('deal_success');
|
||||
expect(d.aggregator).toBe('scalar_brier');
|
||||
expect(d.page_types).toEqual(['deal']);
|
||||
});
|
||||
|
||||
test('accepts all 4 aggregator kinds', () => {
|
||||
for (const aggregator of AGGREGATOR_KINDS) {
|
||||
const parsed = parseSchemaPackManifest(
|
||||
baseManifest({
|
||||
calibration_domains: [
|
||||
{ name: `domain_${aggregator}`, aggregator, page_types: ['person'] },
|
||||
],
|
||||
}),
|
||||
);
|
||||
expect(parsed.calibration_domains![0].aggregator).toBe(aggregator);
|
||||
}
|
||||
});
|
||||
|
||||
test('rejects unknown aggregator value', () => {
|
||||
expect(() =>
|
||||
parseSchemaPackManifest(
|
||||
baseManifest({
|
||||
calibration_domains: [
|
||||
{ name: 'bad_domain', aggregator: 'made_up_algo', page_types: ['deal'] },
|
||||
],
|
||||
}),
|
||||
),
|
||||
).toThrow();
|
||||
});
|
||||
|
||||
test('rejects kebab-case domain name (must be snake_case)', () => {
|
||||
expect(() =>
|
||||
parseSchemaPackManifest(
|
||||
baseManifest({
|
||||
calibration_domains: [
|
||||
{ name: 'Deal-Success', aggregator: 'scalar_brier', page_types: ['deal'] },
|
||||
],
|
||||
}),
|
||||
),
|
||||
).toThrow();
|
||||
});
|
||||
|
||||
test('rejects uppercase domain name', () => {
|
||||
expect(() =>
|
||||
parseSchemaPackManifest(
|
||||
baseManifest({
|
||||
calibration_domains: [
|
||||
{ name: 'DealSuccess', aggregator: 'scalar_brier', page_types: ['deal'] },
|
||||
],
|
||||
}),
|
||||
),
|
||||
).toThrow();
|
||||
});
|
||||
|
||||
test('rejects domain name starting with digit', () => {
|
||||
expect(() =>
|
||||
parseSchemaPackManifest(
|
||||
baseManifest({
|
||||
calibration_domains: [
|
||||
{ name: '1deal', aggregator: 'scalar_brier', page_types: ['deal'] },
|
||||
],
|
||||
}),
|
||||
),
|
||||
).toThrow();
|
||||
});
|
||||
|
||||
test('rejects empty page_types array (must have at least 1)', () => {
|
||||
expect(() =>
|
||||
parseSchemaPackManifest(
|
||||
baseManifest({
|
||||
calibration_domains: [
|
||||
{ name: 'deal_success', aggregator: 'scalar_brier', page_types: [] },
|
||||
],
|
||||
}),
|
||||
),
|
||||
).toThrow();
|
||||
});
|
||||
|
||||
test('rejects unknown extra field on domain entry (.strict)', () => {
|
||||
expect(() =>
|
||||
parseSchemaPackManifest(
|
||||
baseManifest({
|
||||
calibration_domains: [
|
||||
{
|
||||
name: 'deal_success',
|
||||
aggregator: 'scalar_brier',
|
||||
page_types: ['deal'],
|
||||
bonus_field: 'not allowed',
|
||||
},
|
||||
],
|
||||
}),
|
||||
),
|
||||
).toThrow();
|
||||
});
|
||||
|
||||
test('accepts multiple page_types per domain', () => {
|
||||
const parsed = parseSchemaPackManifest(
|
||||
baseManifest({
|
||||
calibration_domains: [
|
||||
{
|
||||
name: 'architecture_calls',
|
||||
aggregator: 'scalar_brier',
|
||||
page_types: ['code', 'decision'],
|
||||
},
|
||||
],
|
||||
}),
|
||||
);
|
||||
expect(parsed.calibration_domains![0].page_types).toEqual(['code', 'decision']);
|
||||
});
|
||||
|
||||
test('accepts multiple domain entries per pack', () => {
|
||||
const parsed = parseSchemaPackManifest(
|
||||
baseManifest({
|
||||
calibration_domains: [
|
||||
{ name: 'deal_success', aggregator: 'scalar_brier', page_types: ['deal'] },
|
||||
{ name: 'founder_evaluation', aggregator: 'scalar_brier', page_types: ['person'] },
|
||||
{ name: 'market_call', aggregator: 'weighted_brier', page_types: ['thesis'] },
|
||||
{ name: 'concept_themes', aggregator: 'cluster_summary', page_types: ['concept'] },
|
||||
],
|
||||
}),
|
||||
);
|
||||
expect(parsed.calibration_domains!.length).toBe(4);
|
||||
const byName = Object.fromEntries(parsed.calibration_domains!.map((d: CalibrationDomain) => [d.name, d.aggregator]));
|
||||
expect(byName.deal_success).toBe('scalar_brier');
|
||||
expect(byName.market_call).toBe('weighted_brier');
|
||||
expect(byName.concept_themes).toBe('cluster_summary');
|
||||
});
|
||||
});
|
||||
|
||||
describe('v0.41 T3: backward compatibility with v0.38 manifests', () => {
|
||||
test('existing minimal manifest without phases/calibration_domains still parses', () => {
|
||||
const v038Shape = baseManifest({
|
||||
page_types: [
|
||||
{
|
||||
name: 'thing',
|
||||
primitive: 'entity',
|
||||
path_prefixes: ['things/'],
|
||||
aliases: [],
|
||||
extractable: false,
|
||||
expert_routing: false,
|
||||
},
|
||||
],
|
||||
});
|
||||
const parsed: SchemaPackManifest = parseSchemaPackManifest(v038Shape);
|
||||
expect(parsed.phases).toBeUndefined();
|
||||
expect(parsed.calibration_domains).toBeUndefined();
|
||||
expect(parsed.page_types.length).toBe(1);
|
||||
});
|
||||
|
||||
test('existing manifest with takes_kinds + filing_rules unchanged by extensions', () => {
|
||||
const parsed = parseSchemaPackManifest(
|
||||
baseManifest({
|
||||
takes_kinds: ['fact', 'take', 'bet', 'hunch'],
|
||||
filing_rules: [{ kind: 'note', directory: 'notes/', examples: [], description: undefined }],
|
||||
}),
|
||||
);
|
||||
expect(parsed.takes_kinds).toEqual(['fact', 'take', 'bet', 'hunch']);
|
||||
expect(parsed.filing_rules.length).toBe(1);
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user