fix(skills): green CI for vault skills — resolver health, fixture lint, privacy literal, llms bundle

- RESOLVER.md rows now round-trip against SKILL.md frontmatter triggers ('put this setup change in the vault'; replace 'safe/free gbrain index' with 'import my vault to gbrain'). - Rewrite both routing-eval.jsonl fixture sets: positives embed a trigger phrase in natural context (fixture linter rejects verbatim tautologies), declare ambiguous_with for legitimate co-fires (capture, idea-ingest), and negatives no longer collide with skillpack-harvest/setup triggers. check:resolver --strict is clean (0 errors, 0 warnings). - Privacy: the vault-capture regression test sources the banned fork-name pattern from harvest-lint's DEFAULT_PRIVATE_PATTERNS instead of the literal, so scripts/check-privacy.sh passes. - Regenerate llms-full.txt after the RESOLVER.md edit (build-llms freshness gate). Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
feat(skills): skillify vault skills — obsidian-gbrain-safe-index + skill-vault-capture-policy (takeover of #2685 )
2026-08-16 09:52:22 +00:00 · 2026-07-22 11:03:38 -07:00 · 2026-07-21 14:27:59 -07:00
20 changed files with 534 additions and 375 deletions
@@ -1411,7 +1411,8 @@ This is the dispatcher. Skills are the implementation. **Read the skill file bef
 | "get more out of gbrain", "is my brain set up right", "weekly brain checkup", "advise me on my brain", "gbrain advisor" | `skills/gbrain-advisor/SKILL.md` |
 | Save or load reports | `skills/reports/SKILL.md` |
 | "Create a skill", "improve this skill" | `skills/skill-creator/SKILL.md` |
-| "Skillify this", "is this a skill?", "make this proper" | `skills/skillify/SKILL.md` |
+| "save this learning to the vault", "capture this skill in Obsidian", "record this workflow in my notes", "put this setup change in the vault" | `skills/skill-vault-capture-policy/SKILL.md` |
+| "Skillify this", "is this a skill?", "make this proper", "add tests and evals for this" | `skills/skillify/SKILL.md` |
 | "Compress my resolver", "AGENTS.md too large", "RESOLVER.md too big", "functional area dispatcher", "shrink routing table" | `skills/functional-area-resolver/SKILL.md` |
 | "Is gbrain healthy?", morning health check, skillpack-check | `skills/skillpack-check/SKILL.md` |
 | "harvest this skill into gbrain", "publish this skill to gbrain", "lift this skill upstream", "share this skill with other gbrain clients", "promote my skill to gbrain" | `skills/skillpack-harvest/SKILL.md` |
@@ -1429,6 +1430,7 @@ This is the dispatcher. Skills are the implementation. **Read the skill file bef
 | "Set up GBrain", first boot | `skills/setup/SKILL.md` |
 | "Now what?", "fill my brain", "cold start", "bootstrap", "import my data", "what should I import first" | `skills/cold-start/SKILL.md` |
 | "Migrate from Obsidian/Notion/Logseq" | `skills/migrate/SKILL.md` |
+| "Connect Obsidian to gbrain", "import my vault to gbrain", "sync vault and gbrain", "embed gbrain after vault update", "is gbrain synced with my vault" | `skills/obsidian-gbrain-safe-index/SKILL.md` |
 | Brain health check, maintenance run | `skills/maintain/SKILL.md` |
 | "Extract links", "build link graph", "populate timeline" | `skills/maintain/SKILL.md` (extraction sections) |
 | "Run dream", "process today's session", "synthesize my conversations", "consolidate yesterday's conversations", "what patterns did you see", "did the dream cycle run" | `skills/maintain/SKILL.md` (dream cycle section) |
@@ -39,8 +39,8 @@
    "skills/briefing",
    "skills/citation-fixer",
    "skills/concept-synthesis",
-    "skills/cross-modal-review",
    "skills/cron-scheduler",
+    "skills/cross-modal-review",
    "skills/daily-task-manager",
    "skills/daily-task-prep",
    "skills/data-research",
@@ -54,10 +54,11 @@
    "skills/media-ingest",
    "skills/meeting-ingestion",
    "skills/minion-orchestrator",
+    "skills/obsidian-gbrain-safe-index",
    "skills/perplexity-research",
    "skills/query",
-    "skills/reports",
    "skills/repo-architecture",
+    "skills/reports",
    "skills/signal-detector",
    "skills/skill-creator",
    "skills/skillify",
@@ -60,7 +60,8 @@ This is the dispatcher. Skills are the implementation. **Read the skill file bef
 | "get more out of gbrain", "is my brain set up right", "weekly brain checkup", "advise me on my brain", "gbrain advisor" | `skills/gbrain-advisor/SKILL.md` |
 | Save or load reports | `skills/reports/SKILL.md` |
 | "Create a skill", "improve this skill" | `skills/skill-creator/SKILL.md` |
-| "Skillify this", "is this a skill?", "make this proper" | `skills/skillify/SKILL.md` |
+| "save this learning to the vault", "capture this skill in Obsidian", "record this workflow in my notes", "put this setup change in the vault" | `skills/skill-vault-capture-policy/SKILL.md` |
+| "Skillify this", "is this a skill?", "make this proper", "add tests and evals for this" | `skills/skillify/SKILL.md` |
 | "Compress my resolver", "AGENTS.md too large", "RESOLVER.md too big", "functional area dispatcher", "shrink routing table" | `skills/functional-area-resolver/SKILL.md` |
 | "Is gbrain healthy?", morning health check, skillpack-check | `skills/skillpack-check/SKILL.md` |
 | "harvest this skill into gbrain", "publish this skill to gbrain", "lift this skill upstream", "share this skill with other gbrain clients", "promote my skill to gbrain" | `skills/skillpack-harvest/SKILL.md` |
@@ -78,6 +79,7 @@ This is the dispatcher. Skills are the implementation. **Read the skill file bef
 | "Set up GBrain", first boot | `skills/setup/SKILL.md` |
 | "Now what?", "fill my brain", "cold start", "bootstrap", "import my data", "what should I import first" | `skills/cold-start/SKILL.md` |
 | "Migrate from Obsidian/Notion/Logseq" | `skills/migrate/SKILL.md` |
+| "Connect Obsidian to gbrain", "import my vault to gbrain", "sync vault and gbrain", "embed gbrain after vault update", "is gbrain synced with my vault" | `skills/obsidian-gbrain-safe-index/SKILL.md` |
 | Brain health check, maintenance run | `skills/maintain/SKILL.md` |
 | "Extract links", "build link graph", "populate timeline" | `skills/maintain/SKILL.md` (extraction sections) |
 | "Run dream", "process today's session", "synthesize my conversations", "consolidate yesterday's conversations", "what patterns did you see", "did the dream cycle run" | `skills/maintain/SKILL.md` (dream cycle section) |
@@ -2,7 +2,7 @@
  "name": "gbrain",
  "version": "0.32.3.0",
  "conformance_version": "1.0.0",
-  "description": "Personal knowledge brain with hybrid RAG search \u2014 GStack mod for agent platforms",
+  "description": "Personal knowledge brain with hybrid RAG search — GStack mod for agent platforms",
  "skills": [
    {
      "name": "ingest",
@@ -34,6 +34,11 @@
      "path": "migrate/SKILL.md",
      "description": "Universal migration from Obsidian, Notion, Logseq, markdown, CSV, JSON, Roam"
    },
+    {
+      "name": "obsidian-gbrain-safe-index",
+      "path": "obsidian-gbrain-safe-index/SKILL.md",
+      "description": "Connect and sync an Obsidian-style Markdown vault with gbrain using a cost-controlled import-first workflow, explicit embedding gates, and durable skill/workflow capture."
+    },
    {
      "name": "setup",
      "path": "setup/SKILL.md",
@@ -263,6 +268,11 @@
      "name": "skill-optimizer",
      "path": "skill-optimizer/SKILL.md",
      "description": "Self-evolving skill optimization via gbrain skillopt — SkillOpt-paper-grounded text-space optimizer with validation gating (median-of-3 + epsilon=0.05), bundled-skill safety, bootstrap review sentinel, per-skill DB lock, and atomic versioned writes."
+    },
+    {
+      "name": "skill-vault-capture-policy",
+      "path": "skill-vault-capture-policy/SKILL.md",
+      "description": "Capture durable operational learnings, new agent skills, and environment/setup changes into the Obsidian vault instead of transient chat memory."
    }
  ],
  "dependencies": {
@@ -0,0 +1,137 @@
+---
+name: obsidian-gbrain-safe-index
+version: 1.0.0
+description: |
+  Connect, maintain, and sync an Obsidian-style Markdown vault with gbrain while preserving a cost-controlled workflow: the vault remains the source of truth, gbrain is the searchable/embedded index, durable skills/workflows are captured into the vault, and paid embedding runs only after explicit approval.
+triggers:
+  - "connect Obsidian to gbrain"
+  - "import my vault to gbrain"
+  - "sync vault and gbrain"
+  - "capture this skill in my vault"
+  - "embed gbrain after vault update"
+  - "is gbrain synced with my vault"
+tools:
+  - terminal
+  - read_file
+  - search_files
+  - write_file
+  - patch
+mutating: true
+---
+
+# Obsidian → gbrain Safe Index and Capture
+
+## Contract
+
+This skill guarantees:
+
+- Treats the user's Obsidian-style Markdown vault as the source of truth before gbrain indexing.
+- Keeps gbrain in conservative mode unless the user explicitly approves a more expensive mode.
+- Imports vault changes with `--no-embed` first, then embeds only after explicit approval for the specific paid action.
+- Captures durable new skills, workflows, and environment learnings into the vault instead of leaving them only in chat memory.
+- Verifies every sync with concrete `gbrain stats`, search mode, and, when embeddings run, exact embedded chunk counts.
+
+## Phases
+
+1. **Resolve the vault path.**
+   - Prefer an existing environment variable such as `OBSIDIAN_VAULT_PATH` or `WIKI_PATH`.
+   - If no path is configured, search likely note directories and ask the user before writing.
+   - Verify the directory exists and contains markdown files or an `.obsidian` directory.
+
+2. **Read vault operating rules before writing.**
+   - If the vault has `SCHEMA.md`, `index.md`, `log.md`, `AGENTS.md`, or similar operating files, read them before ingest/query/major edit.
+   - Respect immutable source folders such as `raw/` when the vault declares them.
+   - Use the vault's native link convention, usually Obsidian `[[wikilinks]]`, for durable relationships.
+
+3. **MECE/capture decision.**
+   - If new knowledge belongs on an existing page, update that page.
+   - If it is a distinct recurring workflow or operational policy, create a small meta or concept page following the vault schema.
+   - Update the vault index/catalog for every new page when the vault maintains one.
+   - Append a log entry for meaningful vault updates when the vault maintains a log.
+
+4. **Safe gbrain import path.**
+   - Pre-check source directory; do not import a nonexistent path.
+   - Run `gbrain config set search.mode conservative` before/after risky reinit steps.
+   - Run `gbrain import "$OBSIDIAN_VAULT_PATH" --no-embed`.
+   - Run `gbrain extract links --source fs --dir "$OBSIDIAN_VAULT_PATH"` when wikilinks changed materially.
+
+5. **Paid embedding gate.**
+   - Do not run `gbrain embed --stale` unless the user explicitly asks or a prior instruction clearly approved this exact paid action.
+   - Before embedding, verify provider readiness with `gbrain providers test --model <provider:model>`.
+   - Confirm the configured embedding dimensions match the local schema.
+   - After embedding, verify `gbrain stats` and record exact `Pages`, `Chunks`, `Embedded`, and `Links` counts.
+
+6. **Final verification and vault echo.**
+   - Run `gbrain stats` and `gbrain search modes`.
+   - If vault files changed, re-import with `--no-embed`; if embedding was approved, embed stale chunks afterward.
+   - Report what changed, what was free/local, what used API billing, and what remains pending.
+
+## Output Format
+
+Use a compact status table:
+
+| Item | Status |
+|---|---|
+| Vault path | `/path` |
+| Vault updated | yes/no + files |
+| gbrain mode | conservative/balanced/tokenmax |
+| Import | `--no-embed` completed / skipped / failed |
+| Pages/chunks | exact counts from `gbrain stats` |
+| Embeddings | exact count; note whether this run used API billing |
+| Links | exact count |
+| Background jobs | none / list exact jobs |
+
+Then include:
+
+- **Safe next step:** free/local action.
+- **Paid next step:** embedding/LLM action, if any, with explicit approval requirement.
+
+## Anti-Patterns
+
+- Creating a duplicate skill/page when an existing Obsidian, gbrain, or vault-ingest skill already covers the workflow.
+- Running `gbrain embed --stale`, `gbrain dream`, `gbrain autopilot --install`, `gbrain onboard --auto`, or `tokenmax` without explicit cost approval.
+- Importing a nonexistent or wrong directory and treating a zero-page import as success.
+- Forgetting to update the vault index/catalog and log after creating or materially updating vault pages.
+- Recording API keys, tokens, or raw secrets in the vault or final response.
+
+## Tools Used
+
+- `read_file` — read vault schema/index/log and target notes.
+- `search_files` — find existing vault pages and avoid duplicates.
+- `write_file` / `patch` — create or update vault pages.
+- `terminal` — run `gbrain`, `git`, and environment checks with secret values redacted.
+
+## Safe Commands
+
+```bash
+export PATH="$HOME/.bun/bin:$PATH"
+gbrain config set search.mode conservative
+gbrain import "$OBSIDIAN_VAULT_PATH" --no-embed
+gbrain extract links --source fs --dir "$OBSIDIAN_VAULT_PATH"
+gbrain stats
+gbrain search modes
+```
+
+## Paid / Approval-Gated Commands
+
+```bash
+gbrain providers test --model <provider:model>
+gbrain embed --stale
+gbrain dream
+gbrain autopilot --install
+gbrain onboard --auto --max-usd 5
+gbrain config set search.mode tokenmax
+```
+
+## Verification Checklist
+
+- [ ] Vault path exists and is the intended source.
+- [ ] Vault operating files were read before edits when present.
+- [ ] Existing pages/skills were searched to avoid duplicates.
+- [ ] New/updated vault pages follow the vault schema and link convention.
+- [ ] Vault index/catalog updated for new pages when present.
+- [ ] Vault log appended for meaningful actions when present.
+- [ ] `gbrain import ... --no-embed` completed.
+- [ ] `gbrain stats` recorded pages/chunks/embeddings/links.
+- [ ] `gbrain search modes` confirms conservative mode unless a different mode was explicitly approved.
+- [ ] No paid/background commands ran without approval.
@@ -0,0 +1,11 @@
+// Routing eval fixtures for skills/obsidian-gbrain-safe-index.
+// Positive cases: intents embed a trigger phrase in natural surrounding context
+// (never verbatim-identical to a trigger — the fixture linter rejects tautologies).
+{"intent": "help me connect Obsidian to gbrain for my notes", "expected_skill": "obsidian-gbrain-safe-index"}
+{"intent": "import my vault to gbrain but skip embeddings for now", "expected_skill": "obsidian-gbrain-safe-index"}
+{"intent": "please sync vault and gbrain after I edit notes", "expected_skill": "obsidian-gbrain-safe-index"}
+{"intent": "run embed gbrain after vault update tonight", "expected_skill": "obsidian-gbrain-safe-index"}
+{"intent": "hey is gbrain synced with my vault right now", "expected_skill": "obsidian-gbrain-safe-index"}
+// Negative cases: related but owned by other skills. Assert NO route to this skill.
+{"intent": "migrate my notes from Notion to gbrain", "expected_skill": null}
+{"intent": "what is on my calendar tomorrow", "expected_skill": null}
@@ -0,0 +1,100 @@
+---
+name: skill-vault-capture-policy
+version: 1.0.0
+description: |
+  Use when the user wants a durable operational learning, new agent skill, or
+  important environment/setup change to be captured into the Obsidian vault
+  instead of left only in transient chat memory. Covers the capture rule,
+  preferred page patterns, and index/log update obligations.
+triggers:
+  - "save this learning to the vault"
+  - "capture this skill in Obsidian"
+  - "record this workflow in my notes"
+  - "put this setup change in the vault"
+  - "should we add this to the knowledge base"
+tools:
+  - read_file
+  - search_files
+  - write_file
+  - patch
+mutating: true
+---
+
+# Skill Vault Capture Policy
+
+## Contract
+
+This skill guarantees:
+
+- Durable operational learnings, newly adopted skills, and important environment/setup changes are captured into the Obsidian vault rather than left only in chat memory.
+- An existing page is updated when the knowledge clearly belongs there; a new page is created only when the topic is distinct and likely to recur.
+- Every new vault page is added to `index.md`.
+- Every meaningful create/update appends a dated entry to `log.md`.
+- Small linked pages are preferred over one giant running note.
+
+## Phases
+
+1. **Classify the learning.**
+   - New gbrain operating rule, cost control, or embedding/provider change.
+   - New agent-fork / harness / coding-tool integration fact.
+   - New Obsidian vault workflow or structure decision.
+   - New recurring agent skill that changes how the agent should operate here.
+
+2. **Avoid duplicates.**
+   - Search the vault for an existing page that already owns the topic.
+   - If found, update it with a new section or dated note rather than creating a near-duplicate.
+
+3. **Create when distinct.**
+   - Place new pages under the vault schema: `_meta/` for operating notes, `concepts/` for workflows, `entities/` for tools/people.
+   - Use YAML frontmatter and at least two `[[wikilinks]]` unless it is a short seed page.
+
+4. **Update navigation.**
+   - Add the page to `index.md` under the correct type heading.
+   - Append a `## [YYYY-MM-DD] create|update | subject` entry to `log.md`.
+
+5. **Report the capture.**
+   - State which files changed and whether `index.md` / `log.md` were updated.
+
+## Output Format
+
+Use a short status block:
+
+| Item | Status |
+|---|---|
+| Learning classified | type |
+| Page created/updated | path |
+| index.md updated | yes/no |
+| log.md updated | yes/no |
+
+## Anti-Patterns
+
+- Leaving durable learnings only in chat memory.
+- Creating a near-duplicate page instead of updating the existing one.
+- Forgetting to update `index.md` and `log.md`.
+- Writing one giant running note instead of small linked pages.
+- Recording secrets, API keys, or raw credentials in the vault.
+
+## Tools Used
+
+- `read_file` — read `SCHEMA.md`, `index.md`, `log.md`, and target pages.
+- `search_files` — find existing pages to avoid duplicates.
+- `write_file` / `patch` — create or update vault pages and navigation.
+
+## Safe Commands
+
+```bash
+# inspect vault navigation before writing
+read SCHEMA.md index.md log.md
+# create or update a page, then refresh catalog/log
+# index.md: add [[page-slug]] under the matching type heading
+# log.md: append ## [YYYY-MM-DD] create|update | subject
+```
+
+## Verification Checklist
+
+- [ ] Vault schema/read files were checked before writing.
+- [ ] Existing pages were searched to avoid duplicates.
+- [ ] New/updated page has frontmatter and wikilinks.
+- [ ] `index.md` updated for new pages.
+- [ ] `log.md` appended for meaningful actions.
+- [ ] No secrets or raw credentials were written.
@@ -0,0 +1,10 @@
+// Routing eval fixtures for skills/skill-vault-capture-policy.
+// Positive cases: intents embed a trigger phrase in natural surrounding context
+// (never verbatim-identical to a trigger — the fixture linter rejects tautologies).
+{"intent": "please save this learning to the vault so we keep it", "expected_skill": "skill-vault-capture-policy", "ambiguous_with": ["idea-ingest"]}
+{"intent": "we should capture this skill in Obsidian for reuse", "expected_skill": "skill-vault-capture-policy", "ambiguous_with": ["capture"]}
+{"intent": "can you record this workflow in my notes for next time", "expected_skill": "skill-vault-capture-policy"}
+{"intent": "put this setup change in the vault before we forget", "expected_skill": "skill-vault-capture-policy"}
+// Negative cases: related but owned by other skills or out of scope.
+{"intent": "connect my Obsidian vault to gbrain", "expected_skill": null}
+{"intent": "what is on my calendar tomorrow", "expected_skill": null}
@@ -428,13 +428,8 @@ export async function runPhaseSynthesize(

    const queue = new MinionQueue(engine);
    const childIds: number[] = [];
-    /**
-     * Map child job_id → transcript metadata. Drives D6 orchestrator-side
-     * slug rewrite for chunked transcripts AND the deterministic frontmatter
-     * stampDreamProvenance merges into each written page. Populated for
-     * every child (single-chunk children carry chunkTotal=1).
-     */
-    const childMeta = new Map<number, ChildMeta>();
+    /** Map child job_id → chunk metadata for D6 orchestrator-side slug rewrite. */
+    const chunkInfo = new Map<number, { idx: number; hash6: string }>();
    /** Skip reasons for the cycle report (D5 cap hits, D8 legacy-key skips). */
    const skipReports: Array<{ filePath: string; reason: string }> = [];

@@ -518,14 +513,9 @@ export async function runPhaseSynthesize(
          { allowProtectedSubmit: true },
        );
        childIds.push(child.id);
-        childMeta.set(child.id, {
-          idx: i,
-          hash6,
-          chunkTotal: chunks.length,
-          transcriptSource: t.transcriptSource,
-          transcriptId: stripContentVersionSuffix(t.basename),
-          inferredDate: t.inferredDate,
-        });
+        if (isChunked) {
+          chunkInfo.set(child.id, { idx: i, hash6 });
+        }
      }
    }

@@ -554,14 +544,14 @@ export async function runPhaseSynthesize(

    // Collect slugs from put_page tool executions across the children
    // (codex finding #2: deterministic provenance, NOT pages.updated_at).
-    // D6 orchestrator slug rewrite: childMeta drives post-hoc rewrite of
+    // D6 orchestrator slug rewrite: chunkInfo drives post-hoc rewrite of
    // bare-hash slugs to `<hash6>-c<idx>` so chunked siblings can't collide
    // even if Sonnet drops the chunk suffix.
    // v0.32.8: refs carry source_id so reverseWriteRefs picks the correct
    // (source, slug) row. #1586: refs are stamped with the cycle's resolved
    // source (children write there via SubagentHandlerData.source_id).
    const cycleSourceId = opts.sourceId ?? 'default';
-    const writtenRefs = await collectChildPutPageSlugs(engine, childIds, childMeta, cycleSourceId);
+    const writtenRefs = await collectChildPutPageSlugs(engine, childIds, chunkInfo, cycleSourceId);

    const summaryDate = opts.date ?? today();

@@ -569,12 +559,7 @@ export async function runPhaseSynthesize(
    // of every child-written page BEFORE reverse-rendering, so generated pages
    // are queryable (`frontmatter->>'dream_generated'`) and a later put_page
    // write-through (which re-renders from the DB row) can't erase the stamp.
-    // #2285: the stamp also carries the orchestrator-owned deterministic
-    // frontmatter (transcript_id, transcript_source, transcript_hash, date,
-    // chunk) derived from childMeta — subagent drift on those fields can't
-    // leak, and reverseWriteRefs below re-reads the row so the same fields
-    // land in the on-disk markdown.
-    await stampDreamProvenance(engine, writtenRefs, summaryDate, childMeta);
+    await stampDreamProvenance(engine, writtenRefs, summaryDate);

    // Dual-write: reverse-render each DB row → markdown file.
    const reverseWriteCount = await reverseWriteRefs(engine, opts.brainDir, writtenRefs, cycleSourceId);
@@ -1110,17 +1095,15 @@ function sanitizeForSlug(s: string): string {
 * fake"): we no longer need detection because the rewrite enforces
 * uniqueness at slug-write time.
 *
- * `childMeta` maps child job_id → per-child transcript metadata. Chunked
- * children (chunkTotal > 1) get the slug rewrite; single-chunk children
- * pass through unchanged. Each returned ref carries the job_id that wrote
- * it so stampDreamProvenance can pair the slug back to its childMeta entry.
+ * `chunkInfo` maps child job_id → { chunk_index, hash6 }. Single-chunk
+ * children are absent from the map and pass through unchanged.
 */
 async function collectChildPutPageSlugs(
  engine: BrainEngine,
  childIds: number[],
-  childMeta: Map<number, ChildMeta>,
+  chunkInfo: Map<number, { idx: number; hash6: string }>,
  sourceId = 'default',
-): Promise<Array<{ slug: string; source_id: string; jobId: number }>> {
+): Promise<Array<{ slug: string; source_id: string }>> {
  if (childIds.length === 0) return [];
  // Raw fetch — NO SELECT DISTINCT. Preserves per-child slug duplicates so
  // the orchestrator sees what each child wrote. COALESCE handles both
@@ -1139,73 +1122,16 @@ async function collectChildPutPageSlugs(
       FROM subagent_tool_executions
      WHERE job_id = ANY($1::int[])
        AND tool_name = 'brain_put_page'
-        AND status = 'complete'
-      ORDER BY id`,
+        AND status = 'complete'`,
    [childIds],
  );
-  const rewritten = new Map<string, number>();
+  const rewritten = new Set<string>();
  for (const r of rows) {
    if (typeof r.slug !== 'string' || r.slug.length === 0) continue;
-    const meta = childMeta.get(r.job_id);
-    const finalSlug = meta && meta.chunkTotal > 1
-      ? rewriteChunkedSlug(r.slug, meta.hash6, meta.idx)
-      : r.slug;
-    // Last writer wins, in execution-row order (ORDER BY id): if two children
-    // collide on a final slug, the pages row holds the LAST put_page write, so
-    // the stamp must attribute that child's transcript — not an arbitrary one.
-    rewritten.set(finalSlug, r.job_id);
+    const ci = chunkInfo.get(r.job_id);
+    rewritten.add(ci ? rewriteChunkedSlug(r.slug, ci.hash6, ci.idx) : r.slug);
  }
-  return [...rewritten.entries()]
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([slug, jobId]) => ({ slug, source_id: sourceId, jobId }));
-}
-
-/**
- * Per-child orchestrator state. Drives D6 chunked-slug rewrite (idx + hash6)
- * AND the deterministic frontmatter stampDreamProvenance merges into each
- * written page. Populated for every child, not just chunked ones.
- */
-interface ChildMeta {
-  idx: number;
-  hash6: string;
-  chunkTotal: number;
-  transcriptSource: string | null;
-  transcriptId: string;
-  inferredDate: string | null;
-}
-
-/**
- * Strip the content-version suffix that claude-code-archive appends when a
- * conversation is edited (`<uuid>--<contentHash>.md`). The session UUID is
- * the stable transcript identifier; the suffix changes with content. Used to
- * populate `transcript_id` so edits of the same session collapse to one id.
- */
-function stripContentVersionSuffix(basename: string): string {
-  return basename.replace(/--[a-f0-9]+$/i, '');
-}
-
-/**
- * Deterministic frontmatter for one synthesized page (#2285). Every field
- * here is owned by the orchestrator — the subagent's value for any of these
- * is overwritten. The subagent retains authority over type / title / tags /
- * body. `date` feeds the effective-date precedence chain
- * (src/core/effective-date.ts) so re-imports keep the conversation date even
- * when sync tools re-stamp file mtimes.
- */
-function buildDeterministicFrontmatter(
-  meta: ChildMeta,
-  cycleDate: string,
-): Record<string, unknown> {
-  const overrides: Record<string, unknown> = {
-    dream_generated: true,
-    dream_cycle_date: cycleDate,
-    transcript_id: meta.transcriptId,
-    transcript_hash: meta.hash6,
-  };
-  if (meta.transcriptSource) overrides.transcript_source = meta.transcriptSource;
-  if (meta.chunkTotal > 1) overrides.chunk = `${meta.idx + 1}/${meta.chunkTotal}`;
-  if (meta.inferredDate) overrides.date = meta.inferredDate;
-  return overrides;
+  return Array.from(rewritten).sort().map(slug => ({ slug, source_id: sourceId }));
 }

 /**
@@ -1251,19 +1177,12 @@ async function hasLegacySingleChunkCompletion(
 */
 async function stampDreamProvenance(
  engine: BrainEngine,
-  refs: Array<{ slug: string; source_id: string; jobId?: number }>,
+  refs: Array<{ slug: string; source_id: string }>,
  cycleDate: string,
-  childMeta?: Map<number, ChildMeta>,
 ): Promise<void> {
  if (refs.length === 0) return;
  const { executeRawJsonb } = await import('../sql-query.ts');
-  for (const { slug, source_id, jobId } of refs) {
-    // #2285: when the ref pairs back to a child, the stamp also carries the
-    // orchestrator-owned deterministic frontmatter for that transcript.
-    const meta = jobId !== undefined ? childMeta?.get(jobId) : undefined;
-    const stamp = meta
-      ? buildDeterministicFrontmatter(meta, cycleDate)
-      : { dream_generated: true, dream_cycle_date: cycleDate };
+  for (const { slug, source_id } of refs) {
    try {
      await executeRawJsonb(
        engine,
@@ -1271,7 +1190,7 @@ async function stampDreamProvenance(
            SET frontmatter = COALESCE(frontmatter, '{}'::jsonb) || $3::jsonb
          WHERE slug = $1 AND source_id = $2`,
        [slug, source_id],
-        [stamp],
+        [{ dream_generated: true, dream_cycle_date: cycleDate }],
      );
    } catch (e) {
      const msg = e instanceof Error ? e.message : String(e);
@@ -10,7 +10,7 @@
 */

 import { readFileSync, readdirSync, statSync } from 'node:fs';
-import { join, basename, dirname } from 'node:path';
+import { join, basename } from 'node:path';
 import { createHash } from 'node:crypto';
 import { pruneDir } from '../sync.ts';

@@ -23,22 +23,8 @@ export interface DiscoveredTranscript {
  content: string;
  /** Filename basename without extension; used as a topic-slug seed. */
  basename: string;
-  /**
-   * Inferred conversation date (YYYY-MM-DD) or null. Precedence: the
-   * `| First message | <ISO> |` row in the transcript's `## Metadata`
-   * table (stable across mtime-restamping re-syncs) wins; a leading
-   * `YYYY-MM-DD` in the basename is the fallback.
-   */
+  /** Inferred date if the basename matches `YYYY-MM-DD...` (or null). */
  inferredDate: string | null;
-  /**
-   * Transcript source archive name, derived from the path's grandparent
-   * directory (the immediate parent of the date directory). For the
-   * canonical layout `<corpus>/<source>/<date>/<id>.md` this yields the
-   * source-name segment — e.g. `claude-code` for the claude-code-archive
-   * output, `meetings` for meeting recordings. Null when the file does
-   * not live under a `<source>/<date>/` pair (ad-hoc inputs).
-   */
-  transcriptSource: string | null;
 }

 export interface DiscoverOpts {
@@ -175,36 +161,6 @@ function matchesAnyExclude(text: string, patterns: RegExp[]): boolean {
  return false;
 }

-/**
- * Content-based conversation date: the `| First message | <ISO timestamp> |`
- * row claude-code-archive writes into the transcript's `## Metadata` table.
- * Stable across rsync/Dropbox/Syncthing/B2 re-syncs that re-stamp mtime,
- * unlike anything derived from file metadata. Returns YYYY-MM-DD or null.
- */
-const FIRST_MESSAGE_RE = /^\|\s*First message\s*\|\s*(\d{4}-\d{2}-\d{2})/im;
-
-export function inferContentDate(content: string): string | null {
-  const m = FIRST_MESSAGE_RE.exec(content);
-  return m ? m[1] : null;
-}
-
-/**
- * Derive the archive source name from a transcript path. Returns the basename
- * of the directory two levels above the file when the immediate parent is a
- * date directory and the grandparent looks like a source-name slug (lowercase
- * alphanumeric segments separated by hyphens); otherwise null. This pins the
- * canonical claude-code-archive layout `<corpus>/<source>/<date>/<id>.md`
- * without claiming a source for ad-hoc inputs that don't match.
- */
-export function deriveTranscriptSource(filePath: string): string | null {
-  const parentName = basename(dirname(filePath));
-  if (!/^\d{4}-\d{2}-\d{2}/.test(parentName)) return null;
-  const grandparentName = basename(dirname(dirname(filePath)));
-  if (!grandparentName) return null;
-  if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(grandparentName)) return null;
-  return grandparentName;
-}
-
 function listTextFiles(dir: string): string[] {
  // Recursive walk with descent-time pruning (closes codex C12/C13 spec gap).
  // Accepts BOTH .txt and .md per transcript-discovery's domain rules — does
@@ -269,11 +225,8 @@ export function discoverTranscripts(opts: DiscoverOpts): DiscoveredTranscript[]
      const ext = filePath.endsWith('.md') ? '.md' : '.txt';
      const baseName = basename(filePath, ext);
      const dateMatch = DATE_RE.exec(baseName);
-      const filenameDate = dateMatch ? dateMatch[1] : null;
-      // Fast path: date-named files outside the window skip before the read.
-      // ponytail: a date-named file whose content date differs is filtered on
-      // its filename date — acceptable; archive layouts use UUID basenames.
-      if (filenameDate && !isInDateRange(filenameDate, opts)) continue;
+      const inferredDate = dateMatch ? dateMatch[1] : null;
+      if (!isInDateRange(inferredDate, opts)) continue;

      let content: string;
      try {
@@ -288,17 +241,12 @@ export function discoverTranscripts(opts: DiscoverOpts): DiscoveredTranscript[]
      }
      if (matchesAnyExclude(content, excludeRes)) continue;

-      // Content-metadata date wins (survives mtime restamps); filename next.
-      const inferredDate = inferContentDate(content) ?? filenameDate;
-      if (!isInDateRange(inferredDate, opts)) continue;
-
      results.push({
        filePath,
        contentHash: hashContent(content),
        content,
        basename: baseName,
        inferredDate,
-        transcriptSource: deriveTranscriptSource(filePath),
      });
    }
  }
@@ -342,7 +290,6 @@ export function readSingleTranscript(
    contentHash: hashContent(content),
    content,
    basename: baseName,
-    inferredDate: inferContentDate(content) ?? (dateMatch ? dateMatch[1] : null),
-    transcriptSource: deriveTranscriptSource(filePath),
+    inferredDate: dateMatch ? dateMatch[1] : null,
  };
 }
@@ -26,7 +26,6 @@ const transcript: DiscoveredTranscript = {
  content: 'User: hello world',
  contentHash: 'abcdef0123456789',
  inferredDate: '2026-07-17',
-  transcriptSource: null,
 } as DiscoveredTranscript;

 describe('#2415: buildSynthesisPrompt output root', () => {
@@ -152,94 +152,3 @@ describe('#2569: stampDreamProvenance persists the marker into DB frontmatter',
    await stampDreamProvenance(engine as any, refs, '2026-07-17'); // idempotent
  });
 });
-
-describe('#2285: orchestrator-owned deterministic transcript frontmatter', () => {
-  const meta = {
-    idx: 1,
-    hash6: 'abc123',
-    chunkTotal: 3,
-    transcriptSource: 'claude-code',
-    transcriptId: 'session-uuid',
-    inferredDate: '2026-05-15',
-  };
-
-  test('collectChildPutPageSlugs pairs each ref back to the writing job', async () => {
-    const refs = await collectChildPutPageSlugs(
-      engine as any, [1001], new Map([[1001, { ...meta, chunkTotal: 1 }]]), 'mybrain',
-    );
-    expect(refs.length).toBeGreaterThan(0);
-    for (const r of refs) {
-      expect(r.jobId).toBe(1001);
-      expect(r.source_id).toBe('mybrain'); // #1586: cycle source, never hardcoded 'default'
-    }
-  });
-
-  test('slug collision across children attributes the LAST writer (matches surviving putPage)', async () => {
-    const db = (engine as any).db;
-    // Jobs 1001 then 1002 write the same slug; the pages row would hold
-    // 1002's content (last put_page wins), so the ref must carry jobId 1002.
-    await db.query(
-      `INSERT INTO subagent_tool_executions (job_id, message_idx, tool_use_id, tool_name, status, input)
-       VALUES (1001, 9, 'tool_dup_a', 'brain_put_page', 'complete', $1::jsonb)`,
-      [JSON.stringify({ slug: 'wiki/agents/test/collision', body: 'first' })],
-    );
-    await db.query(
-      `INSERT INTO subagent_tool_executions (job_id, message_idx, tool_use_id, tool_name, status, input)
-       VALUES (1002, 9, 'tool_dup_b', 'brain_put_page', 'complete', $1::jsonb)`,
-      [JSON.stringify({ slug: 'wiki/agents/test/collision', body: 'second' })],
-    );
-    const refs = await collectChildPutPageSlugs(engine as any, [1001, 1002], new Map());
-    const hit = refs.find((r: { slug: string }) => r.slug === 'wiki/agents/test/collision');
-    expect(hit?.jobId).toBe(1002);
-  });
-
-  test('stampDreamProvenance merges the transcript metadata into DB frontmatter', async () => {
-    const slug = 'wiki/originals/ideas/2026-07-17-transcript-meta-abc123';
-    await engine.putPage(slug, {
-      type: 'note',
-      title: 'Meta stamp',
-      compiled_truth: 'body',
-      timeline: '',
-      frontmatter: { keep_me: 'yes', transcript_id: 'subagent-drift' },
-    });
-    await stampDreamProvenance(
-      engine as any,
-      [{ slug, source_id: 'default', jobId: 42 }],
-      '2026-07-17',
-      new Map([[42, meta]]),
-    );
-    const rows = await engine.executeRaw<{ fm: Record<string, unknown> }>(
-      `SELECT frontmatter AS fm FROM pages WHERE slug = $1`, [slug],
-    );
-    const fm = rows[0].fm as Record<string, unknown>;
-    expect(fm.dream_generated).toBe(true);
-    expect(fm.dream_cycle_date).toBe('2026-07-17');
-    expect(fm.transcript_id).toBe('session-uuid'); // orchestrator wins over subagent drift
-    expect(fm.transcript_hash).toBe('abc123');
-    expect(fm.transcript_source).toBe('claude-code');
-    expect(fm.chunk).toBe('2/3');
-    expect(fm.date).toBe('2026-05-15');
-    expect(fm.keep_me).toBe('yes'); // subagent-owned keys survive
-  });
-
-  test('single-chunk children with no inferredDate stamp only the applicable fields', async () => {
-    const slug = 'wiki/originals/ideas/2026-07-17-minimal-meta-abc123';
-    await engine.putPage(slug, {
-      type: 'note', title: 'Minimal', compiled_truth: 'b', timeline: '', frontmatter: {},
-    });
-    await stampDreamProvenance(
-      engine as any,
-      [{ slug, source_id: 'default', jobId: 43 }],
-      '2026-07-17',
-      new Map([[43, { ...meta, chunkTotal: 1, transcriptSource: null, inferredDate: null }]]),
-    );
-    const rows = await engine.executeRaw<{ fm: Record<string, unknown> }>(
-      `SELECT frontmatter AS fm FROM pages WHERE slug = $1`, [slug],
-    );
-    const fm = rows[0].fm as Record<string, unknown>;
-    expect(fm.transcript_id).toBe('session-uuid');
-    expect(fm.chunk).toBeUndefined();
-    expect(fm.transcript_source).toBeUndefined();
-    expect(fm.date).toBeUndefined();
-  });
-});
@@ -302,7 +302,6 @@ describe('judgeSignificance', () => {
      content: 'A short conversation about something interesting.',
      basename: 'x',
      inferredDate: null,
-      transcriptSource: null,
    };
  }

@@ -416,7 +415,6 @@ describe('judgeSignificance — UTF-16 safety (v0.41.13)', () => {
      content,
      basename: 'long',
      inferredDate: null,
-      transcriptSource: null,
    };
  }

@@ -45,7 +45,6 @@ const FIXTURE_TRANSCRIPT: DiscoveredTranscript = {
  content: 'Synthetic transcript content for gateway-adapter parity tests.',
  contentHash: 'sha-fixture-1',
  inferredDate: '2026-05-24',
-  transcriptSource: null,
 };

 describe('makeJudgeClient — construction-time provider probe', () => {
@@ -1,109 +0,0 @@
-/**
- * #2285 — transcript metadata discovery.
- *
- * Pins the two discovery-side additions:
- *   1. `transcriptSource` — derived from the `<source>/<date>/<file>` path
- *      layout; null for ad-hoc inputs that don't match.
- *   2. Content-based date inference — the `| First message | <ISO> |` row in
- *      the transcript's `## Metadata` table wins over the filename-regex
- *      date (stable across mtime-restamping re-syncs); filename is the
- *      fallback.
- *
- * Pure filesystem; no engine, no LLM.
- */
-
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { mkdtempSync, rmSync, writeFileSync, mkdirSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join, dirname } from 'node:path';
-import {
-  discoverTranscripts,
-  readSingleTranscript,
-  deriveTranscriptSource,
-  inferContentDate,
-} from '../../src/core/cycle/transcript-discovery.ts';
-
-let tmpDir: string;
-
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(tmpdir(), 'gbrain-transcript-meta-'));
-});
-
-afterEach(() => {
-  rmSync(tmpDir, { recursive: true, force: true });
-});
-
-function write(relPath: string, body: string): string {
-  const full = join(tmpDir, relPath);
-  mkdirSync(dirname(full), { recursive: true });
-  writeFileSync(full, body);
-  return full;
-}
-
-const FILLER = 'User: hello world. '.repeat(200);
-const METADATA_BLOCK =
-  '## Metadata\n\n| Key | Value |\n| --- | --- |\n| First message | 2026-05-15T03:51:11.584Z |\n\n';
-
-describe('deriveTranscriptSource', () => {
-  test('extracts the source slug from <source>/<date>/<file> layout', () => {
-    expect(deriveTranscriptSource('/corpus/claude-code/2026-06-12/abc.md')).toBe('claude-code');
-    expect(deriveTranscriptSource('/corpus/voice-notes/2026-06-12/xyz.md')).toBe('voice-notes');
-  });
-
-  test('null when the parent dir is not a date dir or grandparent is not a slug', () => {
-    expect(deriveTranscriptSource('/corpus/flat-file.md')).toBeNull();
-    expect(deriveTranscriptSource('/corpus/claude-code/not-a-date/abc.md')).toBeNull();
-    expect(deriveTranscriptSource('/corpus/Not A Slug/2026-06-12/abc.md')).toBeNull();
-  });
-});
-
-describe('inferContentDate', () => {
-  test('parses the | First message | row', () => {
-    expect(inferContentDate(METADATA_BLOCK)).toBe('2026-05-15');
-  });
-  test('null when absent', () => {
-    expect(inferContentDate(FILLER)).toBeNull();
-  });
-});
-
-describe('discoverTranscripts — transcriptSource + date cascade', () => {
-  test('populates transcriptSource per file; null for flat files', () => {
-    write('claude-code/2026-06-12/aaaa.md', FILLER);
-    write('2026-06-12-flat.md', FILLER);
-    const out = discoverTranscripts({ corpusDir: tmpDir, minChars: 100 });
-    const byBase = new Map(out.map(t => [t.basename, t.transcriptSource]));
-    expect(byBase.get('aaaa')).toBe('claude-code');
-    expect(byBase.get('2026-06-12-flat')).toBeNull();
-  });
-
-  test('content First-message date wins over the filename date', () => {
-    write('2026-01-01-named.md', METADATA_BLOCK + FILLER);
-    const out = discoverTranscripts({ corpusDir: tmpDir, minChars: 100 });
-    expect(out).toHaveLength(1);
-    expect(out[0].inferredDate).toBe('2026-05-15');
-  });
-
-  test('filename date remains the fallback when content has no metadata row', () => {
-    write('2026-01-01-named.md', FILLER);
-    const out = discoverTranscripts({ corpusDir: tmpDir, minChars: 100 });
-    expect(out[0].inferredDate).toBe('2026-01-01');
-  });
-
-  test('date filter matches on the content date for UUID-named transcripts', () => {
-    write('claude-code/2026-05-15/uuid-basename.md', METADATA_BLOCK + FILLER);
-    const hit = discoverTranscripts({ corpusDir: tmpDir, minChars: 100, date: '2026-05-15' });
-    expect(hit).toHaveLength(1);
-    const miss = discoverTranscripts({ corpusDir: tmpDir, minChars: 100, date: '2026-05-16' });
-    expect(miss).toHaveLength(0);
-  });
-});
-
-describe('readSingleTranscript — same metadata surface', () => {
-  test('carries transcriptSource and prefers the content date', () => {
-    const p = write('claude-code/2026-05-15/2026-01-01-single.md', METADATA_BLOCK + FILLER);
-    const t = readSingleTranscript(p, { minChars: 100 });
-    expect(t).not.toBeNull();
-    expect(t!.transcriptSource).toBe('claude-code');
-    expect(t!.inferredDate).toBe('2026-05-15');
-  });
-});
@@ -0,0 +1,61 @@
+/**
+ * E2E smoke for skills/obsidian-gbrain-safe-index.
+ *
+ * Verifies the from-trigger-to-side-effect path that skillify requires:
+ * a real user trigger phrase routes to the skill, the resolver/check
+ * pipeline treats it as reachable, and the skill file exposes the
+ * gbrain commands the workflow actually runs.
+ *
+ * This stays local-only (no paid embedding, no external API): it asserts
+ * the documented safe/import path is present and parseable, not that it
+ * mutates a live brain.
+ */
+
+import { describe, expect, it } from 'bun:test';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const SKILLS = join(import.meta.dir, '..', '..', 'skills');
+const SKILL_MD = join(SKILLS, 'obsidian-gbrain-safe-index', 'SKILL.md');
+const RESOLVER = join(SKILLS, 'RESOLVER.md');
+
+const TRIGGER_PHRASES = [
+  'connect my Obsidian vault to gbrain',
+  'import my vault to gbrain',
+  'sync vault and gbrain',
+  'capture this skill in my vault',
+  'embed gbrain after vault update',
+  'is gbrain synced with my vault',
+];
+
+describe('obsidian-gbrain-safe-index E2E', () => {
+  it('resolver maps real trigger phrasings to the skill', () => {
+    const resolver = readFileSync(RESOLVER, 'utf-8');
+    expect(resolver).toContain('obsidian-gbrain-safe-index/SKILL.md');
+    // Each representative phrase shares a token substring with a resolver row.
+    const rows = resolver
+      .split('\n')
+      .filter((l) => l.includes('obsidian-gbrain-safe-index/SKILL.md'))
+      .join('\n');
+    for (const phrase of TRIGGER_PHRASES) {
+      const hit = phrase
+        .toLowerCase()
+        .split(/\s+/)
+        .some((tok) => tok.length > 3 && rows.toLowerCase().includes(tok));
+      expect(hit, `no resolver token for: ${phrase}`).toBe(true);
+    }
+  });
+
+  it('skill documents the gbrain import-first safe path', () => {
+    const body = readFileSync(SKILL_MD, 'utf-8');
+    expect(body).toContain('gbrain import');
+    expect(body).toContain('--no-embed');
+    expect(body).toContain('gbrain config set search.mode conservative');
+    // Paid gate must be explicit, not a silent default.
+    expect(body).toContain('gbrain embed --stale');
+  });
+
+  it('skill is reachable from the skill tree', () => {
+    expect(existsSync(SKILL_MD)).toBe(true);
+  });
+});
@@ -0,0 +1,52 @@
+/**
+ * E2E smoke for skills/skill-vault-capture-policy.
+ *
+ * Verifies the from-trigger-to-side-effect path: a real capture request
+ * routes to the skill, and the skill documents the vault navigation
+ * obligations (index.md / log.md) that make a capture durable.
+ *
+ * Local-only: it asserts documented behavior, not live vault writes.
+ */
+
+import { describe, expect, it } from 'bun:test';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+const SKILLS = join(import.meta.dir, '..', '..', 'skills');
+const SKILL_MD = join(SKILLS, 'skill-vault-capture-policy', 'SKILL.md');
+const RESOLVER = join(SKILLS, 'RESOLVER.md');
+
+const TRIGGER_PHRASES = [
+  'save this learning to the vault',
+  'capture this skill in Obsidian',
+  'record this workflow in my notes',
+  'put this setup change in the knowledge base',
+];
+
+describe('skill-vault-capture-policy E2E', () => {
+  it('resolver maps real capture phrasings to the skill', () => {
+    const resolver = readFileSync(RESOLVER, 'utf-8');
+    expect(resolver).toContain('skill-vault-capture-policy/SKILL.md');
+    const rows = resolver
+      .split('\n')
+      .filter((l) => l.includes('skill-vault-capture-policy/SKILL.md'))
+      .join('\n');
+    for (const phrase of TRIGGER_PHRASES) {
+      const hit = phrase
+        .toLowerCase()
+        .split(/\s+/)
+        .some((tok) => tok.length > 3 && rows.toLowerCase().includes(tok));
+      expect(hit, `no resolver token for: ${phrase}`).toBe(true);
+    }
+  });
+
+  it('skill documents index.md and log.md update obligations', () => {
+    const body = readFileSync(SKILL_MD, 'utf-8');
+    expect(body).toContain('index.md');
+    expect(body).toContain('log.md');
+  });
+
+  it('skill is reachable from the skill tree', () => {
+    expect(existsSync(SKILL_MD)).toBe(true);
+  });
+});
@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'bun:test';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const SKILL_DIR = join(import.meta.dir, '..', 'skills', 'obsidian-gbrain-safe-index');
+const SKILL_MD = join(SKILL_DIR, 'SKILL.md');
+const RESOLVER = join(import.meta.dir, '..', 'skills', 'RESOLVER.md');
+
+function parseFrontmatter(raw: string): Record<string, unknown> {
+  const m = raw.match(/^---\n([\s\S]*?)\n---/);
+  if (!m) throw new Error('no frontmatter');
+  const out: Record<string, unknown> = {};
+  for (const line of m[1].split('\n')) {
+    const mm = line.match(/^([a-zA-Z_]+):\s*(.*)$/);
+    if (mm) out[mm[1]] = mm[2].trim();
+  }
+  return out;
+}
+
+describe('obsidian-gbrain-safe-index skill', () => {
+  it('has a SKILL.md with required frontmatter', () => {
+    expect(existsSync(SKILL_MD)).toBe(true);
+    const fm = parseFrontmatter(readFileSync(SKILL_MD, 'utf-8'));
+    expect(fm['name']).toBe('obsidian-gbrain-safe-index');
+    expect(fm['description']).toBeTruthy();
+  });
+
+  it('has the required conformance sections', () => {
+    const body = readFileSync(SKILL_MD, 'utf-8');
+    for (const section of ['## Contract', '## Phases', '## Output Format', '## Anti-Patterns']) {
+      expect(body.includes(section), `missing ${section}`).toBe(true);
+    }
+  });
+
+  it('is registered in RESOLVER.md', () => {
+    expect(existsSync(RESOLVER)).toBe(true);
+    const resolver = readFileSync(RESOLVER, 'utf-8');
+    expect(resolver.includes('obsidian-gbrain-safe-index/SKILL.md')).toBe(true);
+  });
+
+  it('has routing-eval fixtures that exercise real trigger phrasings', () => {
+    const evalPath = join(SKILL_DIR, 'routing-eval.jsonl');
+    expect(existsSync(evalPath)).toBe(true);
+    const lines = readFileSync(evalPath, 'utf-8')
+      .split('\n')
+      .filter((l) => l.trim() && !l.trim().startsWith('//'))
+      .map((l) => JSON.parse(l));
+    const positives = lines.filter((l) => l.expected_skill === 'obsidian-gbrain-safe-index');
+    expect(positives.length).toBeGreaterThanOrEqual(5);
+  });
+});
@@ -216,21 +216,17 @@ describe('progress reporter', () => {
  });

  test('only one process-level signal handler installed across many reporters', () => {
-    // Baseline: one handler already installed by prior tests in this file, and
-    // possibly live reporters from OTHER test files sharing this bun process
-    // (shard composition is not this test's invariant — assert the delta, not
-    // an absolute zero, or shard reshuffles make this fail spuriously).
+    // Baseline: one handler already installed by prior tests in this file.
    const installedBefore = __signalHandlerInstalledForTest();
-    const liveBefore = __liveReporterCountForTest();
    const { stream } = sink(false);
    for (let i = 0; i < 50; i++) {
      const p = createProgress({ mode: 'json', stream, minIntervalMs: 0, minItems: 1 });
      p.start(`phase_${i}`, 1);
      p.finish();
    }
-    // After 50 reporter lifecycles, still exactly one handler and zero NET leaked live entries.
+    // After 50 reporter lifecycles, still exactly one handler and zero leaked live entries.
    expect(__signalHandlerInstalledForTest()).toBe(installedBefore || true);
-    expect(__liveReporterCountForTest()).toBe(liveBefore);
+    expect(__liveReporterCountForTest()).toBe(0);
  });

  test('startHeartbeat() fires heartbeats and stop() clears', async () => {
@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'bun:test';
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { DEFAULT_PRIVATE_PATTERNS } from '../src/core/skillpack/harvest-lint.ts';
+
+const SKILL_DIR = join(import.meta.dir, '..', 'skills', 'skill-vault-capture-policy');
+const SKILL_MD = join(SKILL_DIR, 'SKILL.md');
+const RESOLVER = join(import.meta.dir, '..', 'skills', 'RESOLVER.md');
+
+function parseFrontmatter(raw: string): Record<string, unknown> {
+  const m = raw.match(/^---\n([\s\S]*?)\n---/);
+  if (!m) throw new Error('no frontmatter');
+  const out: Record<string, unknown> = {};
+  for (const line of m[1].split('\n')) {
+    const mm = line.match(/^([a-zA-Z_]+):\s*(.*)$/);
+    if (mm) out[mm[1]] = mm[2].trim();
+  }
+  return out;
+}
+
+describe('skill-vault-capture-policy skill', () => {
+  it('has a SKILL.md with required frontmatter', () => {
+    expect(existsSync(SKILL_MD)).toBe(true);
+    const fm = parseFrontmatter(readFileSync(SKILL_MD, 'utf-8'));
+    expect(fm['name']).toBe('skill-vault-capture-policy');
+    expect(fm['description']).toBeTruthy();
+  });
+
+  it('has the required conformance sections', () => {
+    const body = readFileSync(SKILL_MD, 'utf-8');
+    for (const section of ['## Contract', '## Phases', '## Output Format', '## Anti-Patterns']) {
+      expect(body.includes(section), `missing ${section}`).toBe(true);
+    }
+  });
+
+  it('is registered in RESOLVER.md', () => {
+    expect(existsSync(RESOLVER)).toBe(true);
+    expect(readFileSync(RESOLVER, 'utf-8').includes('skill-vault-capture-policy/SKILL.md')).toBe(true);
+  });
+
+  it('contains no private user or agent-fork names (privacy rule)', () => {
+    for (const file of [SKILL_MD, join(SKILL_DIR, 'routing-eval.jsonl')]) {
+      const body = readFileSync(file, 'utf-8');
+      // DEFAULT_PRIVATE_PATTERNS[0] is the banned fork-name pattern; sourced
+      // from harvest-lint so this file never contains the literal itself
+      // (scripts/check-privacy.sh would reject it).
+      const forkName = new RegExp(DEFAULT_PRIVATE_PATTERNS[0], 'i');
+      for (const name of [/\bAdam\b/, /\bHermes\b/, /\bHerdr\b/, /\bArk\b/, forkName]) {
+        expect(name.test(body), `private name ${name} in ${file}`).toBe(false);
+      }
+    }
+  });
+
+  it('has routing-eval fixtures', () => {
+    const evalPath = join(SKILL_DIR, 'routing-eval.jsonl');
+    expect(existsSync(evalPath)).toBe(true);
+    const positives = readFileSync(evalPath, 'utf-8')
+      .split('\n')
+      .filter((l) => l.trim() && !l.trim().startsWith('//'))
+      .map((l) => JSON.parse(l))
+      .filter((l) => l.expected_skill === 'skill-vault-capture-policy');
+    expect(positives.length).toBeGreaterThanOrEqual(4);
+  });
+});