fix(config): configDir honors $HOME over Bun's cached os.homedir()

The gbrainDir()->configDir() unification dropped preferences.ts's process.env.HOME fallback; Bun caches homedir()'s initial value and ignores later HOME mutations, so per-test HOME isolation broke and test/migration-resume.test.ts leaked ledger entries across tests. Restore the env-first fallback in the one shared place. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
fix(sync): suppress last_sync_at when git pull failed (takeover of #1430 )
2026-08-17 02:12:40 +00:00 · 2026-07-22 10:50:19 -07:00 · 2026-07-21 14:47:21 -07:00 · 2026-07-21 14:44:14 -07:00 · 2026-07-21 14:43:11 -07:00 · 2026-07-21 14:42:53 -07:00
33 changed files with 553 additions and 1975 deletions
@@ -7,7 +7,7 @@
  <link rel="preconnect" href="https://fonts.googleapis.com" />
  <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
  <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
-  <script type="module" crossorigin src="/admin/assets/index-BpDk4NI4.js"></script>
+  <script type="module" crossorigin src="/admin/assets/index-CoGEje3-.js"></script>
  <link rel="stylesheet" crossorigin href="/admin/assets/index-GxkWX7v3.css">
 </head>
 <body>
@@ -5,14 +5,13 @@ import { AgentsPage } from './pages/Agents';
 import { RequestLogPage } from './pages/RequestLog';
 import { CalibrationPage } from './pages/Calibration';
 import { JobsWatchPage } from './pages/JobsWatch';
-import { SourcesPage } from './pages/Sources';
 import { api } from './api';

-type Page = 'login' | 'dashboard' | 'agents' | 'sources' | 'log' | 'calibration' | 'jobs';
+type Page = 'login' | 'dashboard' | 'agents' | 'log' | 'calibration' | 'jobs';

 function getPage(): Page {
  const hash = window.location.hash.replace('#', '') || 'dashboard';
-  if (['login', 'dashboard', 'agents', 'sources', 'log', 'calibration', 'jobs'].includes(hash)) return hash as Page;
+  if (['login', 'dashboard', 'agents', 'log', 'calibration', 'jobs'].includes(hash)) return hash as Page;
  return 'dashboard';
 }

@@ -55,8 +54,6 @@ export function App() {
             onClick={() => navigate('dashboard')}>Dashboard</a>
          <a className={`nav-item ${page === 'agents' ? 'active' : ''}`}
             onClick={() => navigate('agents')}>Agents</a>
-          <a className={`nav-item ${page === 'sources' ? 'active' : ''}`}
-             onClick={() => navigate('sources')}>Sources</a>
          <a className={`nav-item ${page === 'log' ? 'active' : ''}`}
             onClick={() => navigate('log')}>Request Log</a>
          <a className={`nav-item ${page === 'calibration' ? 'active' : ''}`}
@@ -86,7 +83,6 @@ export function App() {
      <main className="main">
        {page === 'dashboard' && <DashboardPage />}
        {page === 'agents' && <AgentsPage />}
-        {page === 'sources' && <SourcesPage />}
        {page === 'log' && <RequestLogPage />}
        {page === 'calibration' && <CalibrationPage />}
        {page === 'jobs' && <JobsWatchPage />}
@@ -52,22 +52,4 @@ export const api = {
    apiFetchText(`/admin/api/calibration/charts/${encodeURIComponent(type)}${holder ? `?holder=${encodeURIComponent(holder)}` : ''}`),
  // v0.41 D2 — live minion-jobs dashboard snapshot.
  jobsWatch: () => apiFetch('/admin/api/jobs/watch'),
-  // v0.41.29 Sources tab + federated-read management
-  sources: () => apiFetch('/admin/api/sources'),
-  agentsFederatedRead: () => apiFetch('/admin/api/agents/federated-read'),
-  grantRead: (clientId: string, sourceId: string) =>
-    apiFetch(`/admin/api/agents/${encodeURIComponent(clientId)}/grant-read`, {
-      method: 'POST',
-      body: JSON.stringify({ source_id: sourceId }),
-    }),
-  revokeRead: (clientId: string, sourceId: string) =>
-    apiFetch(`/admin/api/agents/${encodeURIComponent(clientId)}/revoke-read`, {
-      method: 'POST',
-      body: JSON.stringify({ source_id: sourceId }),
-    }),
-  setFederatedRead: (clientId: string, sourceIds: string[]) =>
-    apiFetch(`/admin/api/agents/${encodeURIComponent(clientId)}/set-federated-read`, {
-      method: 'POST',
-      body: JSON.stringify({ source_ids: sourceIds }),
-    }),
 };
@@ -381,16 +381,8 @@ function CredentialsModal({ credentials, onClose }: {
  );
 }

-interface FederationState {
-  source_id: string | null;
-  federated_read: string[];
-}
-
 function AgentDrawer({ agent, onClose, onRevoked }: { agent: Agent; onClose: () => void; onRevoked: () => void }) {
  const [tab, setTab] = useState<'claude-code' | 'chatgpt' | 'claude-cowork' | 'perplexity' | 'cursor' | 'json'>('claude-code');
-  const [federation, setFederation] = useState<FederationState | null>(null);
-  const [allSources, setAllSources] = useState<string[]>([]);
-  const [showFederation, setShowFederation] = useState(false);
  const copy = (text: string) => navigator.clipboard.writeText(text);
  const serverUrl = window.location.origin;

@@ -398,30 +390,6 @@ function AgentDrawer({ agent, onClose, onRevoked }: { agent: Agent; onClose: ()
  const isOAuth = agent.auth_type === 'oauth';
  const agentName = agent.name || agent.client_name || 'unknown';

-  // Lazy-load federation state when the drawer opens for an OAuth client.
-  // The /admin/api/agents endpoint doesn't carry source_id / federated_read,
-  // so we fetch /admin/api/agents/federated-read separately and pair by id.
-  useEffect(() => {
-    if (!isOAuth || !cid) return;
-    let cancelled = false;
-    Promise.all([
-      api.agentsFederatedRead().catch(() => ({ clients: [] })),
-      api.sources().catch(() => ({ sources: [] })),
-    ]).then(([feds, srcs]: any) => {
-      if (cancelled) return;
-      const me = (feds.clients || []).find((c: any) => c.client_id === cid);
-      setFederation(me ? { source_id: me.source_id, federated_read: me.federated_read || [] } : null);
-      setAllSources((srcs.sources || []).map((s: any) => s.source_id));
-    });
-    return () => { cancelled = true; };
-  }, [cid, isOAuth]);
-
-  const reloadFederation = async () => {
-    const feds: any = await api.agentsFederatedRead().catch(() => ({ clients: [] }));
-    const me = (feds.clients || []).find((c: any) => c.client_id === cid);
-    setFederation(me ? { source_id: me.source_id, federated_read: me.federated_read || [] } : null);
-  };
-
  // For API keys, we can't show the actual token (it was shown once at creation).
  // For OAuth, we show the client_id and tell them to use their secret.

@@ -585,34 +553,6 @@ function AgentDrawer({ agent, onClose, onRevoked }: { agent: Agent; onClose: ()
          <span>{agent.token_ttl ? (agent.token_ttl >= 31536000 ? 'No expiry' : agent.token_ttl >= 86400 ? `${Math.floor(agent.token_ttl / 86400)}d` : agent.token_ttl >= 3600 ? `${Math.floor(agent.token_ttl / 3600)}h` : `${agent.token_ttl}s`) : '1h (default)'}</span>
        </div>

-        {isOAuth && federation && (
-          <>
-            <div className="section-title" style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
-              <span>Federation</span>
-              <button
-                className="btn btn-secondary"
-                style={{ padding: '4px 10px', fontSize: 12 }}
-                onClick={() => setShowFederation(true)}
-              >
-                Manage reads
-              </button>
-            </div>
-            <div style={{ display: 'grid', gridTemplateColumns: '120px 1fr', gap: '6px 12px', fontSize: 13 }}>
-              <span style={{ color: 'var(--text-secondary)' }}>Write source</span>
-              <span className="mono">{federation.source_id || '(none)'}</span>
-              <span style={{ color: 'var(--text-secondary)' }}>Federated reads</span>
-              <span style={{ fontSize: 12 }}>
-                {federation.federated_read.length === 0
-                  ? <span style={{ color: 'var(--text-muted)' }}>(empty — no federated reads)</span>
-                  : federation.federated_read.map((s) => (
-                      <span key={s} className="badge badge-read" style={{ marginRight: 4, marginBottom: 2 }}>{s}</span>
-                    ))
-                }
-              </span>
-            </div>
-          </>
-        )}
-
        {/*
          Config Export visible for both auth_type=oauth AND auth_type=api_key.
          Claude Code + Cursor + JSON tabs render real snippets regardless
@@ -688,142 +628,6 @@ function AgentDrawer({ agent, onClose, onRevoked }: { agent: Agent; onClose: ()
          )}
        </div>
      </div>
-
-      {showFederation && federation && (
-        <FederationModal
-          clientId={cid}
-          clientName={agentName}
-          allSources={allSources}
-          currentReads={federation.federated_read}
-          writeSource={federation.source_id}
-          onClose={() => setShowFederation(false)}
-          onSaved={async () => {
-            await reloadFederation();
-            setShowFederation(false);
-          }}
-        />
-      )}
    </>
  );
 }
-
-/**
- * FederationModal — admin counterpart of `gbrain auth set-federated-read`.
- * Source checkbox list; "Save" submits the full new list via the
- * race-safe atomic SQL path in setFederatedReadCore. Per the CLI's
- * documented contract, this is wholesale-replace semantics — concurrent
- * grant/revoke from a CLI operator would be last-writer-wins against
- * a Save here.
- */
-function FederationModal({
-  clientId, clientName, allSources, currentReads, writeSource, onClose, onSaved,
-}: {
-  clientId: string;
-  clientName: string;
-  allSources: string[];
-  currentReads: string[];
-  writeSource: string | null;
-  onClose: () => void;
-  onSaved: () => Promise<void> | void;
-}) {
-  const [selected, setSelected] = useState<Set<string>>(new Set(currentReads));
-  const [saving, setSaving] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-
-  const toggle = (id: string) => {
-    const next = new Set(selected);
-    if (next.has(id)) next.delete(id); else next.add(id);
-    setSelected(next);
-  };
-
-  const handleSave = async () => {
-    setSaving(true);
-    setError(null);
-    try {
-      await api.setFederatedRead(clientId, Array.from(selected));
-      await onSaved();
-    } catch (e: any) {
-      setError(e.message || 'save failed');
-      setSaving(false);
-    }
-  };
-
-  // Union: all known sources + any current reads not in the source list
-  // (e.g. orphan entries from before the source was deleted). The latter
-  // surface as "(missing source)" so operators can revoke them.
-  const allKnown = new Set([...allSources, ...currentReads]);
-  const ordered = Array.from(allKnown).sort();
-
-  return (
-    <div className="modal-overlay" onClick={onClose}>
-      <div className="modal" onClick={(e) => e.stopPropagation()} style={{ maxWidth: 520 }}>
-        <div className="modal-header">
-          <div style={{ fontSize: 16, fontWeight: 600 }}>Manage federated reads</div>
-          <div style={{ fontSize: 13, color: 'var(--text-secondary)', marginTop: 4 }}>
-            <strong>{clientName}</strong> — pick which sources this client can read in addition to its
-            {writeSource ? <> write source <code className="mono">{writeSource}</code></> : <> write source</>}.
-          </div>
-        </div>
-        <div className="modal-body" style={{ maxHeight: '50vh', overflowY: 'auto' }}>
-          {ordered.length === 0 && (
-            <div style={{ color: 'var(--text-muted)', fontSize: 13 }}>
-              No sources registered. Use <code>gbrain sources add &lt;id&gt; --path &lt;dir&gt;</code> from the CLI first.
-            </div>
-          )}
-          {ordered.map((id) => {
-            const isOrphan = !allSources.includes(id);
-            const isWriteSource = id === writeSource;
-            return (
-              <label
-                key={id}
-                style={{
-                  display: 'flex',
-                  alignItems: 'center',
-                  gap: 10,
-                  padding: '8px 10px',
-                  borderBottom: '1px solid var(--border)',
-                  cursor: 'pointer',
-                  fontSize: 13,
-                }}
-              >
-                <input
-                  type="checkbox"
-                  checked={selected.has(id)}
-                  onChange={() => toggle(id)}
-                  style={{ width: 16, height: 16, margin: 0, flexShrink: 0, cursor: 'pointer' }}
-                />
-                <span className="mono" style={{ flex: 1, minWidth: 0, overflow: 'hidden', textOverflow: 'ellipsis', whiteSpace: 'nowrap' }}>{id}</span>
-                {isWriteSource && <span className="badge badge-write" style={{ fontSize: 10, flexShrink: 0 }}>write source</span>}
-                {isOrphan && <span className="badge badge-danger" style={{ fontSize: 10, flexShrink: 0 }}>missing source</span>}
-              </label>
-            );
-          })}
-        </div>
-        {error && (
-          <div style={{
-            background: 'rgba(239,68,68,0.08)',
-            border: '1px solid rgba(239,68,68,0.3)',
-            color: '#ef4444',
-            padding: '10px 12px',
-            borderRadius: 6,
-            margin: '12px 0',
-            fontSize: 12,
-          }}>
-            {error}
-          </div>
-        )}
-        <div className="modal-footer">
-          <button type="button" className="btn btn-secondary" onClick={onClose} disabled={saving}>Cancel</button>
-          <button
-            type="button"
-            className="btn btn-primary"
-            onClick={handleSave}
-            disabled={saving}
-          >
-            {saving ? 'Saving…' : `Save (${selected.size} source${selected.size === 1 ? '' : 's'})`}
-          </button>
-        </div>
-      </div>
-    </div>
-  );
-}
@@ -1,195 +0,0 @@
-import React, { useState, useEffect } from 'react';
-import { api } from '../api';
-
-interface SourceRow {
-  source_id: string;
-  name: string;
-  local_path: string | null;
-  sync_enabled: boolean;
-  last_sync_at: string | null;
-  staleness_hours: number | null;
-  staleness_class: 'fresh' | 'stale' | 'severe' | 'unknown';
-  last_commit: string | null;
-  pages: number;
-  chunks_total: number;
-  chunks_unembedded: number;
-  embedding_coverage_pct: number;
-}
-
-interface FederatedClient {
-  client_id: string;
-  client_name: string;
-  source_id: string | null;
-  federated_read: string[];
-}
-
-function timeAgo(iso: string | null): string {
-  if (!iso) return 'never';
-  const s = Math.floor((Date.now() - new Date(iso).getTime()) / 1000);
-  if (s < 0) return 'in the future?';
-  if (s < 60) return 'just now';
-  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
-  if (s < 86400) return `${Math.floor(s / 3600)}h ago`;
-  return `${Math.floor(s / 86400)}d ago`;
-}
-
-function stalenessColor(cls: string): string {
-  switch (cls) {
-    case 'fresh': return '#4ade80';
-    case 'stale': return '#fbbf24';
-    case 'severe': return '#ef4444';
-    default: return 'var(--text-muted)';
-  }
-}
-
-function coverageColor(pct: number): string {
-  if (pct >= 99) return '#4ade80';
-  if (pct >= 90) return '#fbbf24';
-  return '#ef4444';
-}
-
-export function SourcesPage() {
-  const [sources, setSources] = useState<SourceRow[]>([]);
-  const [clients, setClients] = useState<FederatedClient[]>([]);
-  const [loading, setLoading] = useState(true);
-  const [error, setError] = useState<string | null>(null);
-
-  const load = async () => {
-    setLoading(true);
-    setError(null);
-    try {
-      const [srcReport, clientsResp] = await Promise.all([
-        api.sources(),
-        api.agentsFederatedRead(),
-      ]);
-      setSources(srcReport.sources || []);
-      setClients(clientsResp.clients || []);
-    } catch (e: any) {
-      setError(e.message || 'load failed');
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  useEffect(() => { load(); }, []);
-
-  // Reverse-lookup: for each source, which clients can read it?
-  const readersBySource = (sourceId: string): string[] =>
-    clients.filter((c) => c.federated_read.includes(sourceId)).map((c) => c.client_name);
-
-  // Reverse-lookup: which clients WRITE to this source (source_id == sourceId)?
-  const writersBySource = (sourceId: string): string[] =>
-    clients.filter((c) => c.source_id === sourceId).map((c) => c.client_name);
-
-  return (
-    <div style={{ padding: 24, maxWidth: 1200 }}>
-      <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between', marginBottom: 24 }}>
-        <h1 style={{ fontSize: 24, margin: 0 }}>Sources</h1>
-        <button
-          onClick={load}
-          style={{
-            background: 'transparent',
-            border: '1px solid var(--border)',
-            color: 'var(--text-secondary)',
-            padding: '6px 12px',
-            borderRadius: 6,
-            fontSize: 12,
-            cursor: 'pointer',
-          }}
-        >
-          Refresh
-        </button>
-      </div>
-
-      {loading && <div style={{ color: 'var(--text-muted)' }}>Loading…</div>}
-      {error && (
-        <div style={{
-          background: 'rgba(239,68,68,0.08)',
-          border: '1px solid rgba(239,68,68,0.3)',
-          color: '#ef4444',
-          padding: 12,
-          borderRadius: 6,
-          marginBottom: 16,
-          fontSize: 13,
-        }}>
-          Failed to load sources: {error}
-        </div>
-      )}
-
-      {!loading && !error && sources.length === 0 && (
-        <div style={{ color: 'var(--text-muted)', padding: 16 }}>
-          No active sources with a local_path. Use{' '}
-          <code style={{ background: 'var(--bg-elevated)', padding: '2px 6px', borderRadius: 4 }}>
-            gbrain sources add &lt;id&gt; --path &lt;dir&gt;
-          </code>{' '}
-          to register one.
-        </div>
-      )}
-
-      {!loading && !error && sources.length > 0 && (
-        <div style={{ overflowX: 'auto' }}>
-          <table style={{ width: '100%', borderCollapse: 'collapse', fontSize: 13 }}>
-            <thead>
-              <tr style={{ borderBottom: '1px solid var(--border)', textAlign: 'left', color: 'var(--text-muted)' }}>
-                <th style={{ padding: '10px 12px' }}>ID</th>
-                <th style={{ padding: '10px 12px', textAlign: 'right' }}>Pages</th>
-                <th style={{ padding: '10px 12px', textAlign: 'right' }}>Chunks</th>
-                <th style={{ padding: '10px 12px', textAlign: 'right' }}>Embed%</th>
-                <th style={{ padding: '10px 12px' }}>Last Sync</th>
-                <th style={{ padding: '10px 12px' }}>Writers</th>
-                <th style={{ padding: '10px 12px' }}>Readers (federated)</th>
-              </tr>
-            </thead>
-            <tbody>
-              {sources.map((s) => {
-                const readers = readersBySource(s.source_id);
-                const writers = writersBySource(s.source_id);
-                return (
-                  <tr key={s.source_id} style={{ borderBottom: '1px solid var(--border)' }}>
-                    <td style={{ padding: '10px 12px', fontFamily: 'JetBrains Mono, monospace' }}>
-                      <div>{s.source_id}</div>
-                      {s.name !== s.source_id && (
-                        <div style={{ fontSize: 11, color: 'var(--text-muted)', fontFamily: 'inherit' }}>{s.name}</div>
-                      )}
-                    </td>
-                    <td style={{ padding: '10px 12px', textAlign: 'right', fontFamily: 'JetBrains Mono, monospace' }}>{s.pages.toLocaleString()}</td>
-                    <td style={{ padding: '10px 12px', textAlign: 'right', fontFamily: 'JetBrains Mono, monospace' }}>{s.chunks_total.toLocaleString()}</td>
-                    <td style={{ padding: '10px 12px', textAlign: 'right', color: coverageColor(s.embedding_coverage_pct), fontFamily: 'JetBrains Mono, monospace' }}>
-                      {s.embedding_coverage_pct.toFixed(0)}%
-                    </td>
-                    <td style={{ padding: '10px 12px', color: s.local_path == null ? 'var(--text-muted)' : stalenessColor(s.staleness_class) }}>
-                      {s.local_path == null ? 'push-only' : timeAgo(s.last_sync_at)}
-                    </td>
-                    <td style={{ padding: '10px 12px', fontSize: 12, color: 'var(--text-secondary)' }}>
-                      {writers.length === 0 ? <span style={{ color: 'var(--text-muted)' }}>none</span> : writers.join(', ')}
-                    </td>
-                    <td style={{ padding: '10px 12px', fontSize: 12, color: 'var(--text-secondary)' }}>
-                      {readers.length === 0 ? <span style={{ color: 'var(--text-muted)' }}>none</span> : readers.join(', ')}
-                    </td>
-                  </tr>
-                );
-              })}
-            </tbody>
-          </table>
-        </div>
-      )}
-
-      <div style={{
-        marginTop: 24,
-        padding: 12,
-        background: 'var(--bg-elevated)',
-        border: '1px solid var(--border)',
-        borderRadius: 6,
-        fontSize: 12,
-        color: 'var(--text-muted)',
-        lineHeight: 1.6,
-      }}>
-        <strong style={{ color: 'var(--text-secondary)' }}>Two scopes per OAuth client:</strong>{' '}
-        <em>Writers</em> = clients with this source as their <code>source_id</code> (write authority).{' '}
-        <em>Readers</em> = clients with this source in their <code>federated_read</code> list (read access via federation).
-        Manage federation per-client from the <a href="#agents" style={{ color: '#60a5fa' }}>Agents</a> tab using the
-        "Manage reads" action.
-      </div>
-    </div>
-  );
-}
@@ -1,13 +1,13 @@
 // AUTO-GENERATED — do not edit by hand.
 // Run `bun run scripts/build-admin-embedded.ts` to regenerate.
-// Source: admin/dist/ at 2026-07-22.
+// Source: admin/dist/ at 2026-05-27.
 //
 // Bun resolves the file: imports to a path that works at runtime even
 // inside a compiled binary (`bun build --compile`). The manifest maps
 // the request path the express handler sees to (resolved-path, mime).

 // @ts-ignore — type: 'file' is Bun ESM, not in lib.d.ts
-import A_0_assets_index_BpDk4NI4_js from '../admin/dist/assets/index-BpDk4NI4.js' with { type: 'file' };
+import A_0_assets_index_CoGEje3__js from '../admin/dist/assets/index-CoGEje3-.js' with { type: 'file' };
 // @ts-ignore — type: 'file' is Bun ESM, not in lib.d.ts
 import A_1_assets_index_GxkWX7v3_css from '../admin/dist/assets/index-GxkWX7v3.css' with { type: 'file' };
 // @ts-ignore — type: 'file' is Bun ESM, not in lib.d.ts
@@ -19,7 +19,7 @@ export interface AdminAsset {
 }

 export const ADMIN_ASSETS: Record<string, AdminAsset> = {
-  "/admin/assets/index-BpDk4NI4.js": { path: A_0_assets_index_BpDk4NI4_js as unknown as string, mime: "application/javascript; charset=utf-8" },
+  "/admin/assets/index-CoGEje3-.js": { path: A_0_assets_index_CoGEje3__js as unknown as string, mime: "application/javascript; charset=utf-8" },
  "/admin/assets/index-GxkWX7v3.css": { path: A_1_assets_index_GxkWX7v3_css as unknown as string, mime: "text/css; charset=utf-8" },
  "/admin/index.html": { path: A_2_index_html as unknown as string, mime: "text/html; charset=utf-8" },
 };
@@ -354,6 +354,40 @@ export async function runApplyMigrations(args: string[]): Promise<void> {
    if (cli.forceAll) return; // both surfaces flushed
  }

+  const completed = loadCompletedMigrations();
+  const idx = indexCompleted(completed);
+  const plan = buildPlan(idx, installed, cli.specificMigration);
+
+  // Bug 3 — surface wedged migrations as a loud, actionable error.
+  if (plan.wedged.length > 0) {
+    for (const m of plan.wedged) {
+      console.error(
+        `\nMigration v${m.version} is WEDGED (${MAX_CONSECUTIVE_PARTIALS}+ consecutive partials with no completion). ` +
+        `Check ~/.gbrain/upgrade-errors.jsonl for the last failure reasons, fix the underlying issue, then run:\n` +
+        `  gbrain apply-migrations --force-retry ${m.version}\n` +
+        `Then re-run \`gbrain apply-migrations --yes\`.`,
+      );
+    }
+    // Don't exit — applied/partial/pending are still worth reporting and running.
+  }
+
+  if (cli.specificMigration && plan.applied.length + plan.partial.length + plan.pending.length + plan.skippedFuture.length === 0) {
+    console.error(`No migration registered with version "${cli.specificMigration}". Run \`gbrain apply-migrations --list\` to see registered versions.`);
+    process.exit(2);
+  }
+
+  // Read-only branches: --list and --dry-run print plan/state without
+  // touching anything. Skip the schema-drift pre-flight (which opens a DB
+  // connection) — its only purpose is to warn before APPLYING; for
+  // informational commands the connect+disconnect cycle is both wasted
+  // work and a portability hazard. On Windows the PGLite WASM teardown
+  // leaks worker handles in execFileSync contexts, surfacing as a spurious
+  // exit-1 to parent processes that shell out to `apply-migrations --list`
+  // (e.g. `skillpack-check`). The PGLite-specific skip below is preserved
+  // for non-read-only paths.
+  if (cli.list) { printList(plan, installed); process.exit(0); }
+  if (cli.dryRun) { printDryRun(plan, installed); process.exit(0); }
+
  // Pre-flight: warn if schema migrations (migrate.ts) are behind.
  // apply-migrations runs orchestrator migrations only; schema migrations
  // run via connectEngine() / initSchema(). Users often expect this CLI
@@ -392,31 +426,6 @@ export async function runApplyMigrations(args: string[]): Promise<void> {
    // run their filesystem-only phases.
  }

-  const completed = loadCompletedMigrations();
-  const idx = indexCompleted(completed);
-  const plan = buildPlan(idx, installed, cli.specificMigration);
-
-  // Bug 3 — surface wedged migrations as a loud, actionable error.
-  if (plan.wedged.length > 0) {
-    for (const m of plan.wedged) {
-      console.error(
-        `\nMigration v${m.version} is WEDGED (${MAX_CONSECUTIVE_PARTIALS}+ consecutive partials with no completion). ` +
-        `Check ~/.gbrain/upgrade-errors.jsonl for the last failure reasons, fix the underlying issue, then run:\n` +
-        `  gbrain apply-migrations --force-retry ${m.version}\n` +
-        `Then re-run \`gbrain apply-migrations --yes\`.`,
-      );
-    }
-    // Don't exit — applied/partial/pending are still worth reporting and running.
-  }
-
-  if (cli.specificMigration && plan.applied.length + plan.partial.length + plan.pending.length + plan.skippedFuture.length === 0) {
-    console.error(`No migration registered with version "${cli.specificMigration}". Run \`gbrain apply-migrations --list\` to see registered versions.`);
-    process.exit(2);
-  }
-
-  if (cli.list) { printList(plan, installed); process.exit(0); }
-  if (cli.dryRun) { printDryRun(plan, installed); process.exit(0); }
-
  const toRun: Migration[] = [...plan.partial, ...plan.pending];
  if (toRun.length === 0) {
    console.log('All migrations up to date.');
@@ -24,8 +24,6 @@ import { loadConfig, toEngineConfig } from '../core/config.ts';
 import { createEngine } from '../core/engine-factory.ts';
 import type { BrainEngine } from '../core/engine.ts';
 import { sqlQueryForEngine, executeRawJsonb, type SqlQuery } from '../core/sql-query.ts';
-import { pgArray } from '../core/oauth-provider.ts';
-import { assertValidSourceId } from '../core/source-id.ts';

 function hashToken(token: string): string {
  return createHash('sha256').update(token).digest('hex');
@@ -167,100 +165,6 @@ async function list() {
  });
 }

-/**
- * `gbrain auth list-clients [--json]` — read surface for OAuth 2.1 clients.
- *
- * The existing `gbrain auth list` shows LEGACY bearer tokens from
- * `access_tokens`; this is the parallel for v0.26+ OAuth clients. Separate
- * commands rather than merged output because the two models have different
- * field sets (legacy: lifecycle dates; OAuth: scopes + source_id +
- * federated_read).
- *
- * Human output is card-style (multi-line per client) instead of a fixed-
- * width table — federated_read can hold many ids per client and a wide
- * single-line layout truncates / wraps badly on terminals < 200 cols.
- * JSON output uses a `schema_version: 1` envelope; additive only.
- */
-async function listClients(args: string[]) {
-  const json = args.includes('--json');
-  const includeDeleted = args.includes('--include-deleted');
-  await withConfiguredSql(async (sql) => {
-    // Codex finding #2 (medium): default-hide soft-deleted clients so admin
-    // soft-deletes are honored by the CLI surface. Opt-in via flag.
-    const rows = includeDeleted
-      ? await sql`
-          SELECT client_id, client_name, scope, source_id, federated_read,
-                 grant_types, created_at, deleted_at
-          FROM oauth_clients
-          ORDER BY client_name
-        `
-      : await sql`
-          SELECT client_id, client_name, scope, source_id, federated_read,
-                 grant_types, created_at, deleted_at
-          FROM oauth_clients
-          WHERE deleted_at IS NULL
-          ORDER BY client_name
-        `;
-    if (json) {
-      const clients = rows.map((r) => ({
-        client_id: String(r.client_id),
-        client_name: String(r.client_name),
-        scope: r.scope == null ? null : String(r.scope),
-        source_id: r.source_id == null ? null : String(r.source_id),
-        federated_read: Array.isArray(r.federated_read)
-          ? (r.federated_read as string[]).map(String)
-          : [],
-        grant_types: Array.isArray(r.grant_types)
-          ? (r.grant_types as string[]).map(String)
-          : [],
-        created_at:
-          r.created_at instanceof Date
-            ? r.created_at.toISOString()
-            : r.created_at == null
-              ? null
-              : String(r.created_at),
-        deleted_at:
-          r.deleted_at instanceof Date
-            ? r.deleted_at.toISOString()
-            : r.deleted_at == null
-              ? null
-              : String(r.deleted_at),
-      }));
-      process.stdout.write(JSON.stringify({ schema_version: 1, clients }, null, 2) + '\n');
-      return;
-    }
-    if (rows.length === 0) {
-      console.log(
-        includeDeleted
-          ? 'No OAuth clients found (including deleted). Register one: gbrain auth register-client <name>'
-          : 'No active OAuth clients found. Register one: gbrain auth register-client <name>'
-            + '\n(Use --include-deleted to also show soft-deleted clients.)',
-      );
-      return;
-    }
-    for (let i = 0; i < rows.length; i++) {
-      const r = rows[i];
-      const fed = Array.isArray(r.federated_read)
-        ? (r.federated_read as string[]).map(String)
-        : [];
-      const grants = Array.isArray(r.grant_types)
-        ? (r.grant_types as string[]).map(String)
-        : [];
-      const deletedAt = r.deleted_at;
-      const status = deletedAt == null
-        ? ''
-        : ` [SOFT-DELETED ${deletedAt instanceof Date ? deletedAt.toISOString() : String(deletedAt)}]`;
-      console.log(`${sanitizeForTerminal(String(r.client_name))}${status}`);
-      console.log(`  client_id:    ${sanitizeForTerminal(String(r.client_id))}`);
-      console.log(`  scope:        ${r.scope == null ? '(none)' : sanitizeForTerminal(String(r.scope))}`);
-      console.log(`  grant types:  ${grants.length ? sanitizeForTerminal(grants.join(', ')) : '(none)'}`);
-      console.log(`  write source: ${r.source_id == null ? '(none)' : sanitizeForTerminal(String(r.source_id))}`);
-      console.log(`  federated:    ${fed.length ? sanitizeForTerminal(fed.join(', ')) : '(empty)'}`);
-      if (i < rows.length - 1) console.log('');
-    }
-  });
-}
-
 async function revoke(name: string) {
  if (!name) { console.error('Usage: auth revoke <name>'); process.exit(1); }
  await withConfiguredSql(async (sql) => {
@@ -397,475 +301,6 @@ async function test(url: string, token: string) {
  console.log(`\n🧠 Your brain is live! (${elapsed}s)`);
 }

-/**
- * Strip ANSI escapes + C0/C1 control characters from a string before
- * printing it to the operator's terminal. Defense for the
- * codex-flagged terminal-control-injection class: a client_name or
- * source_id registered via DCR with `\x1b[2J` (clear-screen) or
- * `\x1b]0;TITLE\x07` (OSC title-change) would poison
- * `gbrain auth list-clients` output otherwise.
- *
- * Replaces unsafe bytes with their `\xNN` hex escape so the operator
- * sees that something weird is in the field, instead of silent
- * mutilation. Tab and newline are preserved as-is so legitimate
- * multi-line values render.
- */
-export function sanitizeForTerminal(s: string): string {
-  // ALL C0/C1 controls + DEL get escaped. Codex re-review caught that
-  // preserving `\n` lets a DCR-registered client_name spoof additional
-  // human-output lines in list-clients (a real attack — newline in the
-  // name visually adds a fake row to the operator's terminal). Tab is
-  // also escaped for the same reason — field-separator spoofing.
-  // C0: 0x00-0x1F. DEL: 0x7F. C1: 0x80-0x9F.
-  return s.replace(/[\x00-\x1f\x7f-\x9f]/g, (ch) =>
-    `\\x${ch.charCodeAt(0).toString(16).padStart(2, '0')}`,
-  );
-}
-
-export interface ResolvedClient {
-  client_id: string;
-  client_name: string;
-  source_id: string | null;
-  federated_read: string[];
-  deleted_at: Date | string | null;
-}
-
-export type FederatedReadOutcome =
-  | { kind: 'noop'; reason: 'already-granted' | 'not-present' | 'same-list'; client: ResolvedClient; current: string[] }
-  | { kind: 'updated'; client: ResolvedClient; before: string[]; after: string[] };
-
-/**
- * Resolve an OAuth client by client_id (exact) or client_name (unique).
- * Errors on no-match and on ambiguous client_name (>1 row). client_id
- * takes precedence — if a long hash is passed and matches, returns
- * immediately without ever querying by name.
- *
- * Legacy bearer tokens in `access_tokens` are NOT searched. Federated read
- * scope is an OAuth-client concept (oauth_clients.federated_read column);
- * legacy bearers have no source scope.
- */
-/**
- * Resolve an OAuth client. Codex finding #2 (medium): default-hide
- * soft-deleted clients so admin-soft-deleted rows aren't mutated by the
- * CLI. The `includeDeleted` opt is reserved for future read-side surfaces;
- * grant/revoke/set ALWAYS filter active rows only.
- */
-export async function resolveClient(
-  sql: SqlQuery,
-  nameOrId: string,
-  opts: { includeDeleted?: boolean } = {},
-): Promise<ResolvedClient> {
-  const allowDeleted = opts.includeDeleted === true;
-  const byId = allowDeleted
-    ? await sql`
-        SELECT client_id, client_name, source_id, federated_read, deleted_at
-        FROM oauth_clients WHERE client_id = ${nameOrId} LIMIT 1
-      `
-    : await sql`
-        SELECT client_id, client_name, source_id, federated_read, deleted_at
-        FROM oauth_clients WHERE client_id = ${nameOrId} AND deleted_at IS NULL LIMIT 1
-      `;
-  if (byId.length === 1) return normalizeClientRow(byId[0]);
-  const byName = allowDeleted
-    ? await sql`
-        SELECT client_id, client_name, source_id, federated_read, deleted_at
-        FROM oauth_clients WHERE client_name = ${nameOrId}
-      `
-    : await sql`
-        SELECT client_id, client_name, source_id, federated_read, deleted_at
-        FROM oauth_clients WHERE client_name = ${nameOrId} AND deleted_at IS NULL
-      `;
-  if (byName.length === 0) {
-    throw new Error(
-      `No active OAuth client found with name or id "${nameOrId}". ` +
-        `Run \`gbrain auth register-client <name>\` to create one, ` +
-        `or \`gbrain auth list-clients\` to see what exists. ` +
-        `(Soft-deleted clients are hidden by default.)`,
-    );
-  }
-  if (byName.length > 1) {
-    const ids = byName.map((r) => `  ${String(r.client_id)}`).join('\n');
-    throw new Error(
-      `Multiple active OAuth clients named "${nameOrId}". Pass the full client_id instead:\n${ids}`,
-    );
-  }
-  return normalizeClientRow(byName[0]);
-}
-
-function normalizeClientRow(row: Record<string, unknown>): ResolvedClient {
-  const fed = row.federated_read;
-  return {
-    client_id: String(row.client_id),
-    client_name: String(row.client_name),
-    source_id: row.source_id == null ? null : String(row.source_id),
-    federated_read: Array.isArray(fed) ? (fed as string[]).map(String) : [],
-    deleted_at: row.deleted_at == null
-      ? null
-      : (row.deleted_at as Date | string),
-  };
-}
-
-/**
- * Validate the source_id shape AND DB existence. Codex finding #3 (medium):
- * a manually-INSERTed source row with weird chars (e.g. comma, quote)
- * would otherwise land in oauth_clients.federated_read as a never-deletable
- * malformed entry. Fail at the boundary before the existence query so
- * malformed input gets the validator's hint, not a "does not exist" hint
- * pointing at a non-creatable id.
- */
-export async function assertSourceExists(sql: SqlQuery, sourceId: string): Promise<void> {
-  assertValidSourceId(sourceId);
-  const rows = await sql`SELECT id FROM sources WHERE id = ${sourceId} LIMIT 1`;
-  if (rows.length === 0) {
-    throw new Error(
-      `Source "${sourceId}" does not exist. Run \`gbrain sources list\` to see registered sources, ` +
-        `or \`gbrain sources add ${sourceId}\` to create it.`,
-    );
-  }
-}
-
-/**
- * Atomic append: array_append + NOT-ANY guard so the row-lock fully
- * serializes concurrent grant/revoke against the same client. Codex
- * finding #1 (HIGH): the previous read-modify-write shape allowed a
- * concurrent revoke to be silently UNDONE by a racing grant.
- *
- * Returns the post-write federated_read array, or null when no rows
- * matched (already-granted, soft-deleted, or missing client). Callers
- * disambiguate via prior resolveClient + includes() check.
- *
- * `WHERE deleted_at IS NULL` is part of the atomic guard so a client
- * soft-deleted between resolveClient and the UPDATE can't be mutated.
- */
-async function appendFederatedReadAtomic(
-  sql: SqlQuery,
-  clientId: string,
-  sourceId: string,
-): Promise<string[] | null> {
-  const rows = await sql`
-    UPDATE oauth_clients
-    SET federated_read = array_append(federated_read, ${sourceId})
-    WHERE client_id = ${clientId}
-      AND deleted_at IS NULL
-      AND NOT (${sourceId} = ANY(federated_read))
-    RETURNING federated_read
-  `;
-  if (rows.length === 0) return null;
-  const fed = rows[0].federated_read;
-  return Array.isArray(fed) ? (fed as string[]).map(String) : [];
-}
-
-/**
- * Atomic remove: array_remove + ANY guard. Same race-correctness story
- * as appendFederatedReadAtomic. Returns post-write array or null.
- */
-async function removeFederatedReadAtomic(
-  sql: SqlQuery,
-  clientId: string,
-  sourceId: string,
-): Promise<string[] | null> {
-  const rows = await sql`
-    UPDATE oauth_clients
-    SET federated_read = array_remove(federated_read, ${sourceId})
-    WHERE client_id = ${clientId}
-      AND deleted_at IS NULL
-      AND ${sourceId} = ANY(federated_read)
-    RETURNING federated_read
-  `;
-  if (rows.length === 0) return null;
-  const fed = rows[0].federated_read;
-  return Array.isArray(fed) ? (fed as string[]).map(String) : [];
-}
-
-/**
- * Wholesale array overwrite for `set-federated-read`. Honors the
- * deleted_at filter. Last-writer-wins semantics under concurrent
- * `set` calls is acceptable — the user is asserting "this exact list"
- * intent; concurrent set+set just means whichever ran second wins.
- * Concurrent set+grant or set+revoke is also last-writer-wins, which
- * is the documented contract for `set`.
- */
-async function replaceFederatedReadAtomic(
-  sql: SqlQuery,
-  clientId: string,
-  next: string[],
-): Promise<string[] | null> {
-  // TEXT[] binding via pgArray() string-literal escaping (see helper
-  // for the security note). Our narrow SqlQuery surface
-  // (src/core/sql-query.ts) doesn't bind JS arrays directly.
-  const literal = pgArray(next);
-  const rows = await sql`
-    UPDATE oauth_clients
-    SET federated_read = ${literal}
-    WHERE client_id = ${clientId}
-      AND deleted_at IS NULL
-    RETURNING federated_read
-  `;
-  if (rows.length === 0) return null;
-  const fed = rows[0].federated_read;
-  return Array.isArray(fed) ? (fed as string[]).map(String) : [];
-}
-
-/**
- * Pure helper: dedupe a comma-separated source-id list while preserving
- * insertion order. Empty input → empty array. Exported so the CLI parser
- * and tests share one normalizer.
- */
-export function parseSourceCsv(csv: string): string[] {
-  const requested = csv.split(',').map((s) => s.trim()).filter(Boolean);
-  const seen = new Set<string>();
-  const out: string[] = [];
-  for (const s of requested) {
-    if (!seen.has(s)) {
-      seen.add(s);
-      out.push(s);
-    }
-  }
-  return out;
-}
-
-export interface FederatedReadOpts {
-  /** When true, compute the outcome but skip the persisting UPDATE. */
-  dryRun?: boolean;
-}
-
-/**
- * Core: append a source to the client's federated_read.
- *
- * Atomicity contract (Codex finding #1, HIGH):
- *   The actual write goes through `appendFederatedReadAtomic` which
- *   serializes at the row-lock so concurrent grant/revoke against the
- *   same client cannot lose updates. The race vector that previously
- *   silently restored revoked access is closed: under two operators
- *   racing `revoke-read sensitive` + `grant-read harmless`, postgres
- *   serializes the two UPDATEs and BOTH ops apply (sensitive removed,
- *   harmless added), instead of one clobbering the other.
- *
- * The reported `before` is the snapshot at resolveClient time, which
- * may be stale relative to a concurrent racer. The `after` reflects
- * the post-UPDATE state from RETURNING (always fresh).
- */
-export async function grantReadCore(
-  sql: SqlQuery,
-  nameOrId: string,
-  sourceId: string,
-  opts: FederatedReadOpts = {},
-): Promise<FederatedReadOutcome> {
-  const client = await resolveClient(sql, nameOrId);
-  await assertSourceExists(sql, sourceId);
-  if (client.federated_read.includes(sourceId)) {
-    return { kind: 'noop', reason: 'already-granted', client, current: client.federated_read };
-  }
-  if (opts.dryRun) {
-    // Compute the would-be result without touching the row. Last-known
-    // snapshot is best-effort under concurrent writes.
-    const projected = [...client.federated_read, sourceId];
-    return { kind: 'updated', client, before: client.federated_read, after: projected };
-  }
-  const after = await appendFederatedReadAtomic(sql, client.client_id, sourceId);
-  if (after === null) {
-    // Two equivalent failure modes: (a) racing grant-read already added
-    // the source and the NOT-ANY guard suppressed our UPDATE, or
-    // (b) the client was soft-deleted between resolveClient and UPDATE.
-    // (a) is the more common path. Re-resolve to confirm + report.
-    const reresolved = await resolveClient(sql, client.client_id, { includeDeleted: true });
-    if (reresolved.deleted_at != null) {
-      throw new Error(`Client "${client.client_name}" was soft-deleted before write could land.`);
-    }
-    return { kind: 'noop', reason: 'already-granted', client: reresolved, current: reresolved.federated_read };
-  }
-  return { kind: 'updated', client, before: client.federated_read, after };
-}
-
-/**
- * Core: remove a source from the client's federated_read. Atomic via
- * array_remove + ANY-guard. Same race-correctness rationale as
- * grantReadCore — concurrent ops serialize at the row lock.
- */
-export async function revokeReadCore(
-  sql: SqlQuery,
-  nameOrId: string,
-  sourceId: string,
-  opts: FederatedReadOpts = {},
-): Promise<FederatedReadOutcome> {
-  const client = await resolveClient(sql, nameOrId);
-  if (!client.federated_read.includes(sourceId)) {
-    return { kind: 'noop', reason: 'not-present', client, current: client.federated_read };
-  }
-  if (opts.dryRun) {
-    const projected = client.federated_read.filter((s) => s !== sourceId);
-    return { kind: 'updated', client, before: client.federated_read, after: projected };
-  }
-  const after = await removeFederatedReadAtomic(sql, client.client_id, sourceId);
-  if (after === null) {
-    // Same disambiguation as grant: either a concurrent revoke already
-    // removed the source (most common) or the client was soft-deleted.
-    const reresolved = await resolveClient(sql, client.client_id, { includeDeleted: true });
-    if (reresolved.deleted_at != null) {
-      throw new Error(`Client "${client.client_name}" was soft-deleted before write could land.`);
-    }
-    return { kind: 'noop', reason: 'not-present', client: reresolved, current: reresolved.federated_read };
-  }
-  return { kind: 'updated', client, before: client.federated_read, after };
-}
-
-/**
- * Core: replace the whole federated_read list. Idempotent on same list.
- *
- * Race semantics: wholesale-overwrite + deleted_at guard. Concurrent
- * set+set is last-writer-wins (documented contract for `set` — the
- * operator is asserting the exact list). Concurrent set+grant or
- * set+revoke is also last-writer-wins. If a strict-merge semantics is
- * needed, use grant-read / revoke-read individually.
- */
-export async function setFederatedReadCore(
-  sql: SqlQuery,
-  nameOrId: string,
-  sourceCsv: string,
-  opts: FederatedReadOpts = {},
-): Promise<FederatedReadOutcome> {
-  const next = parseSourceCsv(sourceCsv);
-  const client = await resolveClient(sql, nameOrId);
-  for (const s of next) {
-    await assertSourceExists(sql, s);
-  }
-  const prev = client.federated_read;
-  const same = prev.length === next.length && prev.every((v, i) => v === next[i]);
-  if (same) {
-    return { kind: 'noop', reason: 'same-list', client, current: prev };
-  }
-  if (opts.dryRun) {
-    return { kind: 'updated', client, before: prev, after: next };
-  }
-  const after = await replaceFederatedReadAtomic(sql, client.client_id, next);
-  if (after === null) {
-    throw new Error(`Client "${client.client_name}" was soft-deleted before write could land.`);
-  }
-  return { kind: 'updated', client, before: prev, after };
-}
-
-function printOutcome(
-  verb: 'grant' | 'revoke' | 'set',
-  sourceArg: string,
-  outcome: FederatedReadOutcome,
-  dryRun: boolean,
-): void {
-  // Terminal-injection defense (Codex finding #5, low): a client_name
-  // registered via DCR with ANSI escapes or control chars would
-  // otherwise poison this output. Sanitize ALL strings that round-trip
-  // from the DB before printing.
-  const s = sanitizeForTerminal;
-  const prefix = dryRun ? '[dry-run] ' : '';
-  if (outcome.kind === 'noop') {
-    const name = s(outcome.client.client_name);
-    if (outcome.reason === 'already-granted') {
-      console.log(`${prefix}No change: "${name}" already reads "${s(sourceArg)}".`);
-    } else if (outcome.reason === 'not-present') {
-      console.log(`${prefix}No change: "${name}" did not read "${s(sourceArg)}".`);
-    } else {
-      console.log(`${prefix}No change: "${name}" federated_read already matches.`);
-    }
-    console.log(`  federated_read: ${outcome.current.map(s).join(', ') || '(empty)'}`);
-    return;
-  }
-  const { client, before, after } = outcome;
-  const name = s(client.client_name);
-  const wouldOrDid = dryRun ? 'Would' : 'Did';
-  if (verb === 'grant') {
-    console.log(`${prefix}${wouldOrDid} grant: "${name}" can now read "${s(sourceArg)}".`);
-    console.log(`  federated_read: ${after.map(s).join(', ')}`);
-  } else if (verb === 'revoke') {
-    console.log(`${prefix}${wouldOrDid} revoke: "${name}" no longer reads "${s(sourceArg)}".`);
-    console.log(`  federated_read: ${after.map(s).join(', ') || '(empty — client has no federated reads)'}`);
-  } else {
-    console.log(`${prefix}${wouldOrDid} update "${name}" federated_read:`);
-    console.log(`  before: ${before.map(s).join(', ') || '(empty)'}`);
-    console.log(`  after:  ${after.map(s).join(', ') || '(empty)'}`);
-  }
-  if (after.length === 0) {
-    console.log(
-      'Warning: client now reads no sources via federation. Queries through this ' +
-        'client will only see content scoped explicitly via its write source.',
-    );
-  }
-}
-
-/**
- * Strip `--dry-run` from a positional-arg list. Returns the filtered list
- * plus the flag value. Kept positional-tolerant — the existing
- * `auth grant-read alice source` shape MUST keep working, AND
- * `auth grant-read alice source --dry-run` AND `auth grant-read --dry-run alice source`.
- */
-export function extractDryRun(args: string[]): { dryRun: boolean; rest: string[] } {
-  let dryRun = false;
-  const rest: string[] = [];
-  for (const a of args) {
-    if (a === '--dry-run') {
-      dryRun = true;
-      continue;
-    }
-    rest.push(a);
-  }
-  return { dryRun, rest };
-}
-
-async function grantRead(args: string[]): Promise<void> {
-  const { dryRun, rest } = extractDryRun(args);
-  const [nameOrId, sourceId] = rest;
-  if (!nameOrId || !sourceId) {
-    console.error('Usage: gbrain auth grant-read <client-name-or-id> <source-id> [--dry-run]');
-    process.exit(1);
-  }
-  try {
-    await withConfiguredSql(async (sql) => {
-      const outcome = await grantReadCore(sql, nameOrId, sourceId, { dryRun });
-      printOutcome('grant', sourceId, outcome, dryRun);
-    });
-  } catch (e: any) {
-    console.error('Error:', e.message);
-    process.exit(1);
-  }
-}
-
-async function revokeRead(args: string[]): Promise<void> {
-  const { dryRun, rest } = extractDryRun(args);
-  const [nameOrId, sourceId] = rest;
-  if (!nameOrId || !sourceId) {
-    console.error('Usage: gbrain auth revoke-read <client-name-or-id> <source-id> [--dry-run]');
-    process.exit(1);
-  }
-  try {
-    await withConfiguredSql(async (sql) => {
-      const outcome = await revokeReadCore(sql, nameOrId, sourceId, { dryRun });
-      printOutcome('revoke', sourceId, outcome, dryRun);
-    });
-  } catch (e: any) {
-    console.error('Error:', e.message);
-    process.exit(1);
-  }
-}
-
-async function setFederatedRead(args: string[]): Promise<void> {
-  const { dryRun, rest } = extractDryRun(args);
-  const [nameOrId, sourceCsv] = rest;
-  if (!nameOrId || sourceCsv === undefined) {
-    console.error(
-      'Usage: gbrain auth set-federated-read <client-name-or-id> <source-id1,source-id2,...> [--dry-run]',
-    );
-    console.error('Pass an empty string ("") to clear all federated reads.');
-    process.exit(1);
-  }
-  try {
-    await withConfiguredSql(async (sql) => {
-      const outcome = await setFederatedReadCore(sql, nameOrId, sourceCsv, { dryRun });
-      printOutcome('set', sourceCsv, outcome, dryRun);
-    });
-  } catch (e: any) {
-    console.error('Error:', e.message);
-    process.exit(1);
-  }
-}
-
 async function revokeClient(clientId: string) {
  if (!clientId) {
    console.error('Usage: auth revoke-client <client_id>');
@@ -884,7 +319,7 @@ async function revokeClient(clientId: string) {
        console.error(`No client found with id "${clientId}"`);
        process.exit(1);
      }
-      console.log(`OAuth client revoked: "${sanitizeForTerminal(String(rows[0].client_name))}" (${clientId})`);
+      console.log(`OAuth client revoked: "${rows[0].client_name}" (${clientId})`);
      console.log('Tokens and authorization codes purged via cascade.');
    });
  } catch (e: any) {
@@ -1005,15 +440,6 @@ export function parseRegisterClientArgs(args: string[]): RegisterClientArgs {
  if (!grantTypesSet && out.redirectUris.length > 0) {
    out.grantTypes = ['authorization_code', 'refresh_token'];
  }
-  // Codex re-review (medium): validate source_id shape at the CLI boundary
-  // so register-client can't seed malformed entries into source_id /
-  // federated_read that subsequent grant/revoke/set commands can't manage.
-  assertValidSourceId(out.sourceId);
-  if (out.federatedRead) {
-    for (const s of out.federatedRead) {
-      assertValidSourceId(s);
-    }
-  }
  return out;
 }

@@ -1131,10 +557,6 @@ export async function runAuth(args: string[]): Promise<void> {
    }
    case 'register-client': await registerClient(rest[0], rest.slice(1)); return;
    case 'revoke-client': await revokeClient(rest[0]); return;
-    case 'list-clients': await listClients(rest); return;
-    case 'grant-read': await grantRead(rest); return;
-    case 'revoke-read': await revokeRead(rest); return;
-    case 'set-federated-read': await setFederatedRead(rest); return;
    case 'test': {
      const tokenIdx = rest.indexOf('--token');
      const url = rest.find(a => !a.startsWith('--') && a !== rest[tokenIdx + 1]);
@@ -1172,13 +594,6 @@ Usage:
     --bound-max-concurrent <n>                            Bound submit_agent concurrency (default: 1)
     --budget-usd-per-day <usd>                            Bound submit_agent daily spend cap
  gbrain auth revoke-client <client_id>                   Hard-delete an OAuth 2.1 client (cascades to tokens + codes)
-  gbrain auth list-clients [--json]                       List OAuth 2.1 clients with scope + write source + federated_read.
-  gbrain auth grant-read <name|client_id> <source-id> [--dry-run]
-                                                          Add a source to the client's federated_read list (idempotent).
-  gbrain auth revoke-read <name|client_id> <source-id> [--dry-run]
-                                                          Remove a source from the client's federated_read list (idempotent).
-  gbrain auth set-federated-read <name|client_id> "<id1,id2,...>" [--dry-run]
-                                                          Replace the client's whole federated_read list. Pass "" to clear.
  gbrain auth test <url> --token <token>                  Smoke-test a remote MCP server
 `);
  }
@@ -474,7 +474,11 @@ export function extractTimelineFromContent(content: string, slug: string): Extra
  const entries: ExtractedTimelineEntry[] = [];

  // Format 1: Bullet — - **YYYY-MM-DD** | Source — Summary
-  const bulletPattern = /^-\s+\*\*(\d{4}-\d{2}-\d{2})\*\*\s*\|\s*(.+?)\s*[—–-]\s*(.+)$/gm;
+  // The separator is an em/en dash (optionally spaced, as before) OR a plain
+  // hyphen that MUST be surrounded by whitespace. A bare `-` with `\s*` on
+  // both sides split hyphenated slugs mid-word (`acme-consulting-group` →
+  // source "acme"), mangling timelines on every extract pass (#1341).
+  const bulletPattern = /^-\s+\*\*(\d{4}-\d{2}-\d{2})\*\*\s*\|\s*(.+?)(?:\s*[—–]\s*|\s+-\s+)(.+)$/gm;
  let match;
  while ((match = bulletPattern.exec(content)) !== null) {
    entries.push({ slug, date: match[1], source: match[2].trim(), summary: match[3].trim() });
@@ -68,6 +68,49 @@ const LLM_PREAMBLES = [
  /^Absolutely\.?\s*Here[^.\n]*\.?\s*\n*/gim,
 ];

+// ── Whole-page code-fence wrap (LLM artifact) ───────────────────────
+//
+// An LLM sometimes returns an ENTIRE page wrapped in a ```markdown fence.
+// Strip that wrap — but ONLY when the whole body is wrapped, never when a note
+// merely *contains* a ```markdown block mid-document (e.g. a Notion export that
+// fences a config snippet). The earlier code detected the wrap with /m regexes
+// (a fence anywhere) but stripped the closing fence with a string-anchored
+// regex, so a mid-document block lost only its trailing ``` and was left with
+// an open fence — re-corrupted on every autopilot lint cycle. Detection and fix
+// now share this single check so they can't drift apart again.
+
+function frontmatterLength(content: string): number {
+  const m = /^---\r?\n[\s\S]*?\r?\n---[ \t]*\r?\n?/.exec(content);
+  return m ? m[0].length : 0;
+}
+
+/**
+ * Treat a page as fence-wrapped only when the entire body (after any YAML
+ * frontmatter) is a single ```markdown fence: the first non-blank body line
+ * opens it, the last non-blank body line closes it, and no bare ``` appears
+ * between them (which would mean the fence closed early — not a whole-page
+ * wrap). Returns the unwrapped content (frontmatter preserved) when wrapped.
+ */
+function analyzeMarkdownWrap(content: string): { wrapped: boolean; unwrapped: string } {
+  const fmLen = frontmatterLength(content);
+  const head = content.slice(0, fmLen);
+  const lines = content.slice(fmLen).split('\n');
+
+  let first = 0;
+  while (first < lines.length && lines[first].trim() === '') first++;
+  let last = lines.length - 1;
+  while (last >= 0 && lines[last].trim() === '') last--;
+
+  if (first >= last) return { wrapped: false, unwrapped: content };
+  if (!/^```(?:markdown|md)\s*$/.test(lines[first].trim())) return { wrapped: false, unwrapped: content };
+  if (lines[last].trim() !== '```') return { wrapped: false, unwrapped: content };
+  for (let i = first + 1; i < last; i++) {
+    if (lines[i].trim().startsWith('```')) return { wrapped: false, unwrapped: content };
+  }
+
+  return { wrapped: true, unwrapped: head + lines.slice(first + 1, last).join('\n') };
+}
+
 // ── Rules ──────────────────────────────────────────────────────────

 /**
@@ -126,8 +169,10 @@ export function lintContent(content: string, filePath: string, opts: LintContent
    }
  }

-  // Rule: Wrapping code fences (```markdown ... ```)
-  if (content.match(/^```(?:markdown|md)\s*\n/m) && content.match(/\n```\s*$/m)) {
+  // Rule: Wrapping code fences — the WHOLE page body wrapped in ```markdown …
+  // ``` (an LLM artifact). A ```markdown block mid-document is legitimate and
+  // must NOT trigger this (see analyzeMarkdownWrap).
+  if (analyzeMarkdownWrap(content).wrapped) {
    issues.push({
      file: filePath, line: 1, rule: 'code-fence-wrap',
      message: 'Page wrapped in ```markdown code fences (LLM artifact)',
@@ -291,9 +336,10 @@ export function fixContent(content: string): string {
    fixed = fixed.replace(pattern, '');
  }

-  // Fix wrapping code fences
-  fixed = fixed.replace(/^```(?:markdown|md)\s*\n/, '');
-  fixed = fixed.replace(/\n```\s*$/, '');
+  // Fix wrapping code fences — only a genuine whole-page wrap (see
+  // analyzeMarkdownWrap); never strip the closing fence of a mid-note block.
+  const wrap = analyzeMarkdownWrap(fixed);
+  if (wrap.wrapped) fixed = wrap.unwrapped;

  // Clean up excessive blank lines left by fixes
  fixed = fixed.replace(/\n{3,}/g, '\n\n');
@@ -365,42 +365,6 @@ export interface AgentClientSpend {
  inflight_count: number;
 }

-/**
- * `/admin/api/sources` source list — the input rows for buildSyncStatusReport.
- *
- * Queries the JSONB config column directly (listSources doesn't carry it,
- * but buildSyncStatusReport needs syncEnabled / strategy fields).
- *
- * Deliberately does NOT filter on local_path: in a push-only deployment
- * (content arrives via MCP put_page / capture / ingest, not `gbrain sync`
- * of a server checkout) every source has a null local_path — filtering on
- * it would empty both the Sources tab AND the federation source-picker.
- * buildSyncStatusReport does no disk I/O, so null-local_path sources
- * report fine (pages/chunks from SQL, staleness 'unknown' / never-synced).
- */
-export async function queryAdminSources(engine: BrainEngine): Promise<
-  Array<{ id: string; name: string; local_path: string | null; config: Record<string, unknown> }>
-> {
-  const rows = await engine.executeRaw<{
-    id: string;
-    name: string;
-    local_path: string | null;
-    config: Record<string, unknown> | string | null;
-  }>(
-    `SELECT id, name, local_path, config FROM sources
-     WHERE archived IS NOT TRUE
-     ORDER BY id`,
-  );
-  return rows.map((r) => ({
-    id: r.id,
-    name: r.name,
-    local_path: r.local_path,
-    config: typeof r.config === 'string'
-      ? (JSON.parse(r.config) as Record<string, unknown>)
-      : (r.config ?? {}),
-  }));
-}
-
 export async function queryAgentClientSpend(engine: BrainEngine): Promise<AgentClientSpend[]> {
  const sql = sqlQueryForEngine(engine);
  const rows = await sql`
@@ -1547,111 +1511,6 @@ export async function runServeHttp(engine: BrainEngine, options: ServeHttpOption
    }
  });

-  // ---------------------------------------------------------------------------
-  // Sources tab — read-only view of registered sources with sync + embed
-  // coverage stats. Drives the admin SPA's `Sources` page.
-  //
-  // Returns the same shape `gbrain sources status --json` prints, so the
-  // SPA stays in lockstep with the CLI surface.
-  // ---------------------------------------------------------------------------
-  app.get('/admin/api/sources', requireAdmin, async (_req: Request, res: Response) => {
-    try {
-      const { buildSyncStatusReport } = await import('./sync.ts');
-      const report = await buildSyncStatusReport(engine, await queryAdminSources(engine));
-      res.json(report);
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      res.status(503).json({ error: 'service_unavailable', detail: msg });
-    }
-  });
-
-  // ---------------------------------------------------------------------------
-  // Federated-read management (admin-side counterparts of the CLI commands
-  // `gbrain auth grant-read / revoke-read / set-federated-read`). All three
-  // route through the same *Core helpers as the CLI so race-safety,
-  // soft-delete filter, and source-id shape validation apply uniformly.
-  //
-  // The admin SPA's `Agents` page renders "Manage reads" actions per
-  // client backed by these endpoints.
-  // ---------------------------------------------------------------------------
-  app.get('/admin/api/agents/federated-read', requireAdmin, async (_req: Request, res: Response) => {
-    try {
-      const rows = await sql`
-        SELECT client_id, client_name, source_id, federated_read
-        FROM oauth_clients
-        WHERE deleted_at IS NULL
-        ORDER BY client_name
-      `;
-      const clients = rows.map((r) => ({
-        client_id: String(r.client_id),
-        client_name: String(r.client_name),
-        source_id: r.source_id == null ? null : String(r.source_id),
-        federated_read: Array.isArray(r.federated_read)
-          ? (r.federated_read as string[]).map(String)
-          : [],
-      }));
-      res.json({ clients });
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      res.status(503).json({ error: 'service_unavailable', detail: msg });
-    }
-  });
-
-  app.post('/admin/api/agents/:clientId/grant-read', requireAdmin, express.json(), async (req: Request, res: Response) => {
-    const clientId = String(req.params.clientId ?? '');
-    const sourceId = String(req.body?.source_id ?? '').trim();
-    if (!clientId || !sourceId) {
-      res.status(400).json({ error: 'invalid_request', detail: 'clientId path param + source_id body required' });
-      return;
-    }
-    try {
-      const { grantReadCore } = await import('./auth.ts');
-      const outcome = await grantReadCore(sql, clientId, sourceId);
-      res.json({ outcome });
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      res.status(400).json({ error: 'mutation_failed', detail: msg });
-    }
-  });
-
-  app.post('/admin/api/agents/:clientId/revoke-read', requireAdmin, express.json(), async (req: Request, res: Response) => {
-    const clientId = String(req.params.clientId ?? '');
-    const sourceId = String(req.body?.source_id ?? '').trim();
-    if (!clientId || !sourceId) {
-      res.status(400).json({ error: 'invalid_request', detail: 'clientId path param + source_id body required' });
-      return;
-    }
-    try {
-      const { revokeReadCore } = await import('./auth.ts');
-      const outcome = await revokeReadCore(sql, clientId, sourceId);
-      res.json({ outcome });
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      res.status(400).json({ error: 'mutation_failed', detail: msg });
-    }
-  });
-
-  app.post('/admin/api/agents/:clientId/set-federated-read', requireAdmin, express.json(), async (req: Request, res: Response) => {
-    const clientId = String(req.params.clientId ?? '');
-    const rawIds = req.body?.source_ids;
-    if (!clientId || !Array.isArray(rawIds)) {
-      res.status(400).json({ error: 'invalid_request', detail: 'clientId path param + source_ids[] body required' });
-      return;
-    }
-    // Encode the array as CSV so the same setFederatedReadCore signature
-    // (string CSV input) the CLI uses applies here. Empty array → empty
-    // string → clears the list.
-    const csv = rawIds.map((s) => String(s).trim()).filter(Boolean).join(',');
-    try {
-      const { setFederatedReadCore } = await import('./auth.ts');
-      const outcome = await setFederatedReadCore(sql, clientId, csv);
-      res.json({ outcome });
-    } catch (e) {
-      const msg = e instanceof Error ? e.message : String(e);
-      res.status(400).json({ error: 'mutation_failed', detail: msg });
-    }
-  });
-
  // ---------------------------------------------------------------------------
  // SSE live activity feed
  // ---------------------------------------------------------------------------
@@ -29,6 +29,7 @@ import { runMigrateFence } from '../core/skillpack/migrate-fence.ts';
 import { runScrubLegacy } from '../core/skillpack/scrub-legacy.ts';
 import { runHarvest, HarvestError } from '../core/skillpack/harvest.ts';
 import { autoDetectSkillsDir } from '../core/repo-root.ts';
+import { extractFrontmatterBlock } from '../core/markdown.ts';
 import {
  RemoteSourceError,
  classifySpec,
@@ -222,9 +223,9 @@ async function cmdList(args: string[]): Promise<void> {
      let description: string | null = null;
      if (existsSync(skillMd)) {
        const body = readFileSync(skillMd, 'utf-8');
-        const fm = body.match(/^---\n([\s\S]*?)\n---/);
-        if (fm) {
-          const descMatch = fm[1].match(/^description:\s*["']?([^\n"']+)/m);
+        const fm = extractFrontmatterBlock(body);
+        if (fm !== null) {
+          const descMatch = fm.match(/^description:\s*["']?([^\n"']+)/m);
          if (descMatch) description = descMatch[1].trim();
        }
      }
@@ -1245,22 +1245,31 @@ async function writeSyncAnchor(
  // git-intrinsic committer time of the HEAD we just synced). `undefined` keeps
  // the legacy 2-column write; `null` clears the column (git unavailable).
  newestContentEpochMs?: number | null,
+  // #1430: when the upstream pull was attempted and FAILED this run, advance
+  // last_commit (the local import still converged) but do NOT stamp
+  // last_sync_at — doctor's sync_freshness must not read the source as
+  // "fresh" when we never observed remote state (network partition, revoked
+  // credentials, diverged remote). Operator-skipped offline modes (--no-pull,
+  // detached HEAD, no origin) are NOT failures and pass false.
+  pullFailed = false,
 ): Promise<void> {
  if (sourceId) {
    const col = which === 'repo_path' ? 'local_path' : 'last_commit';
-    // last_sync_at bookmarked on every last_commit advance.
+    // last_sync_at bookmarked on every last_commit advance — unless the pull
+    // failed this run (#1430).
    if (which === 'last_commit') {
+      const syncAt = pullFailed ? '' : ', last_sync_at = now()';
      if (newestContentEpochMs !== undefined) {
        const iso = newestContentEpochMs === null
          ? null
          : new Date(newestContentEpochMs).toISOString();
        await engine.executeRaw(
-          `UPDATE sources SET last_commit = $1, last_sync_at = now(), newest_content_at = $3 WHERE id = $2`,
+          `UPDATE sources SET last_commit = $1${syncAt}, newest_content_at = $3 WHERE id = $2`,
          [value, sourceId, iso],
        );
      } else {
        await engine.executeRaw(
-          `UPDATE sources SET last_commit = $1, last_sync_at = now() WHERE id = $2`,
+          `UPDATE sources SET last_commit = $1${syncAt} WHERE id = $2`,
          [value, sourceId],
        );
      }
@@ -1948,6 +1957,12 @@ async function performSyncInner(engine: BrainEngine, opts: SyncOpts): Promise<Sy
    });
  }

+  // #1430: distinguishes a true pull FAILURE (network/credentials/diverged)
+  // from operator-skipped offline modes. Only a real failure suppresses the
+  // last_sync_at freshness stamp on the anchor writes below; the pull_timeout
+  // path early-returns a partial before any anchor write.
+  let pullAttemptedAndFailed = false;
+
  if (!opts.noPull && !detachedHead && originRemotePresent) {
    const _t0 = Date.now();
    serr(`[gbrain phase] sync.git_pull start`);
@@ -1995,6 +2010,7 @@ async function performSyncInner(engine: BrainEngine, opts: SyncOpts): Promise<Sy
      } else {
        serr(`Warning: git pull failed: ${msg.slice(0, 100)}`);
      }
+      pullAttemptedAndFailed = true; // #1430: suppress last_sync_at below
    }
  }

@@ -2077,7 +2093,7 @@ async function performSyncInner(engine: BrainEngine, opts: SyncOpts): Promise<Sy
      // back to the authoritative full reconcile (which now also purges stale
      // pages for deleted files; see performFullSync's delete-reconcile pass).
      serr(`Sync anchor ${lastCommit.slice(0, 8)} object missing (gc'd after history rewrite). Running full reimport.`);
-      return performFullSync(engine, fullSyncRoots, headCommit, opts);
+      return performFullSync(engine, fullSyncRoots, headCommit, opts, pullAttemptedAndFailed);
    }

    // Observability only — NOT control flow. A non-ancestor bookmark is still
@@ -2100,7 +2116,7 @@ async function performSyncInner(engine: BrainEngine, opts: SyncOpts): Promise<Sy

  // First sync
  if (!lastCommit) {
-    return performFullSync(engine, fullSyncRoots, headCommit, opts);
+    return performFullSync(engine, fullSyncRoots, headCommit, opts, pullAttemptedAndFailed);
  }

  // v0.42.x (#1794): resumable incremental sync — resolve the PINNED target.
@@ -2170,7 +2186,10 @@ async function performSyncInner(engine: BrainEngine, opts: SyncOpts): Promise<Sy
    // reads it), separate from the import-converged bookmark. Without this,
    // a cron-driven `*/15 sync` over a quiet vault leaves last_sync_at pinned
    // to the last real commit, so doctor falsely flags the source as stale.
-    if (opts.sourceId) {
+    // #1430: suppress the heartbeat when the pull was attempted and FAILED —
+    // we never observed remote state, so stamping freshness would mask the
+    // failure. `!opts.dryRun`: a preview must never write.
+    if (opts.sourceId && !pullAttemptedAndFailed && !opts.dryRun) {
      await engine.executeRaw(
        `UPDATE sources SET last_sync_at = now() WHERE id = $1`,
        [opts.sourceId],
@@ -2192,7 +2211,7 @@ async function performSyncInner(engine: BrainEngine, opts: SyncOpts): Promise<Sy
      `[sync] chunker_version gate: stored=${storedVersion ?? 'unset'}, current=${currentVersion}. ` +
      `Forcing full re-chunk pass (git HEAD unchanged but pipeline version advanced).`,
    );
-    const result = await performFullSync(engine, fullSyncRoots, headCommit, opts);
+    const result = await performFullSync(engine, fullSyncRoots, headCommit, opts, pullAttemptedAndFailed);
    await writeChunkerVersion(engine, opts.sourceId, currentVersion);
    return result;
  }
@@ -2221,7 +2240,7 @@ async function performSyncInner(engine: BrainEngine, opts: SyncOpts): Promise<Sy
      `[sync] delta ${lastCommit.slice(0, 8)}..${pin.slice(0, 8)} unavailable ` +
      `(${delta.reason}) — falling back to full reconcile.`,
    );
-    return performFullSync(engine, fullSyncRoots, headCommit, opts);
+    return performFullSync(engine, fullSyncRoots, headCommit, opts, pullAttemptedAndFailed);
  }
  const manifest = delta.manifest;

@@ -2352,7 +2371,7 @@ async function performSyncInner(engine: BrainEngine, opts: SyncOpts): Promise<Sy
    // (#1794): advance to the PINNED target, and clear any checkpoint (a resume
    // whose remaining range turned out to have no syncable changes still
    // completes cleanly here).
-    await writeSyncAnchor(engine, opts.sourceId, 'last_commit', pin, commitTimeMs(gitContextRoot, pin));
+    await writeSyncAnchor(engine, opts.sourceId, 'last_commit', pin, commitTimeMs(gitContextRoot, pin), pullAttemptedAndFailed);
    await engine.setConfig('sync.last_run', new Date().toISOString());
    await writeChunkerVersion(engine, opts.sourceId, String(CHUNKER_VERSION));
    await clearOpCheckpoint(engine, ckpt.paths);
@@ -3175,7 +3194,7 @@ async function performSyncInner(engine: BrainEngine, opts: SyncOpts): Promise<Sy
    // "fresh". The checkpoint rows clear here — CONVERGENCE CONTRACT: sync
    // convergence == IMPORT convergence; downstream extract/facts/embed is
    // decoupled (its own resumable stale sweeps).
-    await writeSyncAnchor(engine, opts.sourceId, 'last_commit', pin, commitTimeMs(gitContextRoot, pin));
+    await writeSyncAnchor(engine, opts.sourceId, 'last_commit', pin, commitTimeMs(gitContextRoot, pin), pullAttemptedAndFailed);
    await engine.setConfig('sync.last_run', new Date().toISOString());
    await writeSyncAnchor(engine, opts.sourceId, 'repo_path', anchorPath);
    await writeChunkerVersion(engine, opts.sourceId, String(CHUNKER_VERSION));
@@ -3413,6 +3432,9 @@ async function performFullSync(
  roots: { gitContextRoot: string; syncScopeRoot: string; anchorPath: string },
  headCommit: string,
  opts: SyncOpts,
+  // #1430: a full reimport triggered after a failed pull still must not mark
+  // the source "fresh" — threaded into the last_commit anchor write.
+  pullFailed = false,
 ): Promise<SyncResult> {
  const { gitContextRoot, syncScopeRoot, anchorPath } = roots;
  // Scoped sync → slugs/source_path are git-root-relative (matches the
@@ -3500,7 +3522,7 @@ async function performFullSync(
  const advanceFull = async (): Promise<void> => {
    // Persist sync state so the next sync is incremental. Routed through
    // writeSyncAnchor so --source pins the right sources row.
-    await writeSyncAnchor(engine, opts.sourceId, 'last_commit', headCommit, newestCommitMs(gitContextRoot));
+    await writeSyncAnchor(engine, opts.sourceId, 'last_commit', headCommit, newestCommitMs(gitContextRoot), pullFailed);
    await engine.setConfig('sync.last_run', new Date().toISOString());
    await writeSyncAnchor(engine, opts.sourceId, 'repo_path', anchorPath);
    await writeChunkerVersion(engine, opts.sourceId, String(CHUNKER_VERSION));
@@ -12,6 +12,7 @@

 import { readFileSync, existsSync, readdirSync } from 'fs';
 import { join, relative } from 'path';
+import { extractFrontmatterBlock } from './markdown.ts';
 import { findResolverFile, findAllResolverFiles, RESOLVER_FILENAMES_LABEL } from './resolver-filenames.ts';
 import { loadOrDeriveManifest } from './skill-manifest.ts';
 import {
@@ -219,9 +220,8 @@ export function parseResolverEntries(resolverContent: string): ResolverEntry[] {

 /** Simple YAML frontmatter parser — extracts triggers array if present. */
 function extractTriggers(skillContent: string): string[] {
-  const fmMatch = skillContent.match(/^---\n([\s\S]*?)\n---/);
-  if (!fmMatch) return [];
-  const fm = fmMatch[1];
+  const fm = extractFrontmatterBlock(skillContent);
+  if (fm === null) return [];
  const triggersMatch = fm.match(/^triggers:\s*\n((?:\s+-\s+.+\n?)*)/m);
  if (!triggersMatch) return [];
  return triggersMatch[1]
@@ -1096,7 +1096,10 @@ export function configDir(): string {
    }
    return join(trimmed, '.gbrain');
  }
-  return join(homedir(), '.gbrain');
+  // Prefer $HOME over os.homedir(): Bun caches homedir()'s initial value and
+  // ignores later process.env.HOME mutations, which breaks test isolation and
+  // any workflow that runs against a specific $HOME (CI, scripted installs).
+  return join(process.env.HOME || homedir(), '.gbrain');
 }

 export function configPath(): string {
@@ -3,6 +3,24 @@ import { safeLoad as yamlSafeLoad } from 'js-yaml';
 import type { Page, PageType } from './types.ts';
 import { slugifyPath } from './sync.ts';

+/**
+ * Extract the raw YAML frontmatter body between leading `---` fences.
+ *
+ * Returns the body string (LF-normalized) or `null` when no frontmatter is
+ * present. Tolerant of CRLF line endings — input is normalized before
+ * matching so the same call works on files authored on Windows.
+ *
+ * Use this when you only need to run a few targeted regexes against the
+ * frontmatter (e.g. extracting `name:` or `triggers:`); prefer
+ * `parseMarkdown` when you need the full body + timeline split + gray-matter
+ * YAML parsing, and `parseSkillFrontmatter` for SKILL.md-specific fields.
+ */
+export function extractFrontmatterBlock(content: string): string | null {
+  const normalized = content.replace(/\r\n/g, '\n');
+  const match = normalized.match(/^---\n([\s\S]*?)\n---/);
+  return match ? match[1] : null;
+}
+
 export type ParseValidationCode =
  | 'MISSING_OPEN'
  | 'MISSING_CLOSE'
@@ -55,7 +55,7 @@ export interface AgentClientBindings {
 * `redirect_uri` containing `,`) would be parsed by Postgres as MULTIPLE
 * array elements, smuggling values past validation. See CSO finding #5.
 */
-export function pgArray(arr: string[]): string {
+function pgArray(arr: string[]): string {
  if (!arr || arr.length === 0) return '{}';
  const escaped = arr.map(s => `"${s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"`);
  return `{${escaped.join(',')}}`;
@@ -9,40 +9,22 @@
 */

 import { readFileSync, writeFileSync, renameSync, chmodSync, mkdtempSync, rmSync, existsSync, mkdirSync, appendFileSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-
-function home(): string {
-  // `os.homedir()` in Bun caches its initial value and ignores later
-  // `process.env.HOME` mutations, which breaks test isolation and any
-  // workflow that needs to run against a specific $HOME (CI, scripted installs).
-  // Prefer the env var; fall back to the cached OS value. Matches the existing
-  // `src/commands/upgrade.ts` pattern.
-  //
-  // NOTE: prefsDir() and migrationsDir() route through gbrainPath() (which
-  // honors GBRAIN_HOME), so this fallback is only used by code paths that
-  // want $HOME directly (none in this file as of v0.30.3).
-  return process.env.HOME || homedir();
-}
+import { join, dirname } from 'path';
+import { configDir } from './config.ts';

 /**
- * GBRAIN_HOME-aware override for the .gbrain directory. When the env var
- * is set, this returns it directly (so the directory is GBRAIN_HOME itself,
- * matching the convention `src/core/config.ts:gbrainPath` enforces).
- * When unset, falls back to `<home>/.gbrain` so legacy callers and the
- * doctor's filesystem-only checks keep working.
- *
- * Without this, `~/.gbrain/migrations/completed.jsonl` is the only path
- * doctor reads on filesystem checks — the test isolation contract that
- * `gbrainPath()` provides for everywhere else doesn't extend here.
+ * GBRAIN_HOME-aware override for the .gbrain directory. Delegates to
+ * `configDir()` so the GBRAIN_HOME contract is defined in exactly one
+ * place — pre-this-fix, this helper diverged from `configDir()` by
+ * returning `GBRAIN_HOME` directly instead of `GBRAIN_HOME/.gbrain`,
+ * which meant `~/.gbrain/migrations/completed.jsonl` (read by doctor)
+ * and `~/.gbrain/config.json` (read by loadConfig) lived in different
+ * directories whenever a test or operator set GBRAIN_HOME. The
+ * documented convention is "GBRAIN_HOME is a parent dir; we append
+ * `.gbrain`" — see configDir() docstring in src/core/config.ts.
 */
 function gbrainDir(): string {
-  const override = process.env.GBRAIN_HOME;
-  if (override) {
-    const trimmed = override.trim();
-    if (trimmed) return trimmed;
-  }
-  return join(home(), '.gbrain');
+  return configDir();
 }

 export type MinionMode = 'always' | 'pain_triggered' | 'off';
@@ -84,9 +66,38 @@ const VALID_MODES: ReadonlyArray<MinionMode> = ['always', 'pain_triggered', 'off
 // `$HOME/.gbrain` directly, which leaked the developer's local migration
 // ledger into E2E tests and CI runs even when GBRAIN_HOME was set.
 function prefsDir(): string { return gbrainDir(); }
-function prefsPath(): string { return join(prefsDir(), 'preferences.json'); }
+function prefsPath(): string {
+  const p = join(prefsDir(), 'preferences.json');
+  adoptLegacyFile(p, 'preferences.json');
+  return p;
+}
 function migrationsDir(): string { return join(gbrainDir(), 'migrations'); }
-function completedJsonlPath(): string { return join(migrationsDir(), 'completed.jsonl'); }
+function completedJsonlPath(): string {
+  const p = join(migrationsDir(), 'completed.jsonl');
+  adoptLegacyFile(p, 'migrations', 'completed.jsonl');
+  return p;
+}
+
+/**
+ * One-time legacy-path adoption. Before the gbrainDir()→configDir()
+ * unification, this module wrote preferences.json + migrations/completed.jsonl
+ * to `$GBRAIN_HOME/...` directly (no `.gbrain` suffix) whenever GBRAIN_HOME
+ * was set. Silently switching the read path would orphan an existing
+ * preferences file and — worse — an existing migration ledger, making every
+ * completed migration look pending again. So on first access after upgrade,
+ * move the legacy file into the new location. Best-effort: a failed move
+ * falls back to a fresh file (the pre-fix behavior for the new path).
+ */
+function adoptLegacyFile(newPath: string, ...legacySegments: string[]): void {
+  const override = process.env.GBRAIN_HOME?.trim();
+  if (!override) return; // GBRAIN_HOME unset → legacy and new paths were identical
+  const legacyPath = join(override, ...legacySegments);
+  if (legacyPath === newPath || existsSync(newPath) || !existsSync(legacyPath)) return;
+  try {
+    mkdirSync(dirname(newPath), { recursive: true });
+    renameSync(legacyPath, newPath);
+  } catch { /* best-effort */ }
+}

 /** Validate that a value is a recognized minion mode. Throws with the allowed list. */
 export function validateMinionMode(value: unknown): asserts value is MinionMode {
@@ -82,7 +82,13 @@ export interface ParsedFrontmatter {
 * `readFileSync(path, 'utf-8')` at the boundary.
 */
 export function parseSkillFrontmatter(content: string): ParsedFrontmatter | null {
-  const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+  // Normalize CRLF → LF before matching. The literal `\n` after the opening
+  // `---` fence cannot match `\r`, so a Windows-authored SKILL.md (CRLF)
+  // would fall through with raw=='' and silently lose every parsed field.
+  // Normalizing here also gives downstream value parsers an LF-only body so
+  // `[^"'\n]+?` character classes don't accidentally swallow a trailing `\r`.
+  const normalized = content.replace(/\r\n/g, '\n');
+  const fmMatch = normalized.match(/^---\n([\s\S]*?)\n---/);
  if (!fmMatch) return null;
  const raw = fmMatch[1];
  const out: ParsedFrontmatter = { raw };
@@ -27,6 +27,7 @@

 import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { join } from 'path';
+import { extractFrontmatterBlock } from './markdown.ts';

 export interface ManifestEntry {
  name: string;
@@ -47,9 +48,8 @@ export interface ManifestLoadResult {
 function parseSkillName(skillMdPath: string): string | null {
  try {
    const content = readFileSync(skillMdPath, 'utf-8');
-    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-    if (!fmMatch) return null;
-    const fm = fmMatch[1];
+    const fm = extractFrontmatterBlock(content);
+    if (fm === null) return null;
    // Match `name: foo` or `name: "foo"` or `name: 'foo'`
    const nameMatch = fm.match(/^name:\s*["']?([^"'\n]+?)["']?\s*$/m);
    if (!nameMatch) return null;
@@ -8,7 +8,7 @@
 */

 import { existsSync, readFileSync, statSync, readdirSync } from 'fs';
-import { join, dirname, isAbsolute, resolve } from 'path';
+import { join, dirname, isAbsolute, resolve, posix } from 'path';

 import { parseMarkdown } from '../markdown.ts';

@@ -142,9 +142,12 @@ function walkFiles(absDir: string, prefix: string, out: BundleEntry[], sharedDep
      continue;
    }
    if (stat.isDirectory()) {
-      walkFiles(abs, join(prefix, e), out, sharedDep);
+      // relTarget is a portable bundle path; always use forward-slash
+      // joining so Windows installs produce the same manifest shape as
+      // Linux/macOS (callers downstream string-match on `alpha/SKILL.md`).
+      walkFiles(abs, posix.join(prefix, e), out, sharedDep);
    } else if (stat.isFile()) {
-      out.push({ source: abs, relTarget: join(prefix, e), sharedDep });
+      out.push({ source: abs, relTarget: posix.join(prefix, e), sharedDep });
    }
  }
 }
@@ -1,82 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll, beforeEach } from 'bun:test';
-import { PGLiteEngine } from '../src/core/pglite-engine.ts';
-import { resetPgliteState } from './helpers/reset-pglite.ts';
-import { queryAdminSources } from '../src/commands/serve-http.ts';
-import { buildSyncStatusReport } from '../src/commands/sync.ts';
-
-/**
- * v0.41.29 Sources tab — `/admin/api/sources` endpoint SQL.
- *
- * The endpoint is a thin Express handler over `queryAdminSources` +
- * `buildSyncStatusReport`; the source-selection SQL is the load-bearing
- * surface (same pattern as test/admin-agents-spend.test.ts).
- *
- * Pinned behaviors:
- *   - Excludes archived sources
- *   - INCLUDES sources with null local_path (push-only brains: filtering
- *     on local_path emptied the Sources tab + federation source-picker)
- *   - JSONB config surfaces as an object, defaulting to {}
- *   - Deterministic ORDER BY id
- *   - buildSyncStatusReport accepts the rows (no disk I/O on null paths)
- */
-
-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('queryAdminSources (/admin/api/sources SQL)', () => {
-  it('includes push-only sources with null local_path', async () => {
-    await engine.executeRaw(
-      `INSERT INTO sources (id, name, local_path, config)
-       VALUES ('push-only', 'push-only', NULL, '{}'::jsonb)`,
-    );
-    const sources = await queryAdminSources(engine);
-    const ids = sources.map((s) => s.id);
-    expect(ids).toContain('push-only');
-    expect(sources.find((s) => s.id === 'push-only')!.local_path).toBe(null);
-  });
-
-  it('excludes archived sources', async () => {
-    await engine.executeRaw(
-      `INSERT INTO sources (id, name, archived) VALUES ('gone', 'gone', true)`,
-    );
-    const sources = await queryAdminSources(engine);
-    expect(sources.map((s) => s.id)).not.toContain('gone');
-  });
-
-  it('surfaces JSONB config as an object and orders by id', async () => {
-    await engine.executeRaw(
-      `INSERT INTO sources (id, name, config)
-       VALUES ('bbb', 'bbb', '{"syncEnabled": true}'::jsonb),
-              ('aaa', 'aaa', '{}'::jsonb)`,
-    );
-    const sources = await queryAdminSources(engine);
-    const ids = sources.map((s) => s.id);
-    expect(ids.indexOf('aaa')).toBeLessThan(ids.indexOf('bbb'));
-    expect(sources.find((s) => s.id === 'bbb')!.config).toEqual({ syncEnabled: true });
-    expect(sources.find((s) => s.id === 'aaa')!.config).toEqual({});
-  });
-
-  it('buildSyncStatusReport accepts the rows (null local_path does not throw)', async () => {
-    await engine.executeRaw(
-      `INSERT INTO sources (id, name, local_path, config)
-       VALUES ('push-only', 'push-only', NULL, '{}'::jsonb)`,
-    );
-    const report = await buildSyncStatusReport(engine, await queryAdminSources(engine));
-    expect(report.schema_version).toBe(1);
-    const row = report.sources.find((s) => s.source_id === 'push-only');
-    expect(row).toBeDefined();
-  });
-});
@@ -1,568 +0,0 @@
-/**
- * Tests for `gbrain auth grant-read|revoke-read|set-federated-read`.
- *
- * Pure helper: parseSourceCsv (no DB).
- * DB-coupled: resolveClient, assertSourceExists, *Core fns — exercised
- * against a real PGLite via the canonical block.
- */
-import { describe, expect, test, beforeAll, afterAll, beforeEach } from 'bun:test';
-import { PGLiteEngine } from '../src/core/pglite-engine.ts';
-import { resetPgliteState } from './helpers/reset-pglite.ts';
-import { sqlQueryForEngine } from '../src/core/sql-query.ts';
-import { pgArray } from '../src/core/oauth-provider.ts';
-import {
-  parseSourceCsv,
-  resolveClient,
-  assertSourceExists,
-  grantReadCore,
-  revokeReadCore,
-  setFederatedReadCore,
-  extractDryRun,
-  sanitizeForTerminal,
-} from '../src/commands/auth.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);
-});
-
-// ---------------------------------------------------------------------------
-// pure helpers
-// ---------------------------------------------------------------------------
-
-describe('parseSourceCsv', () => {
-  test('splits and trims', () => {
-    expect(parseSourceCsv('a,b,c')).toEqual(['a', 'b', 'c']);
-    expect(parseSourceCsv('  a  ,  b  ')).toEqual(['a', 'b']);
-  });
-
-  test('drops empty segments', () => {
-    expect(parseSourceCsv('a,,b,')).toEqual(['a', 'b']);
-    expect(parseSourceCsv(',,')).toEqual([]);
-    expect(parseSourceCsv('')).toEqual([]);
-  });
-
-  test('dedupes while preserving first-seen order', () => {
-    expect(parseSourceCsv('a,b,a,c,b')).toEqual(['a', 'b', 'c']);
-  });
-});
-
-describe('extractDryRun', () => {
-  test('absent flag → false', () => {
-    expect(extractDryRun(['alice', 'proj-x'])).toEqual({
-      dryRun: false,
-      rest: ['alice', 'proj-x'],
-    });
-  });
-
-  test('flag at end', () => {
-    expect(extractDryRun(['alice', 'proj-x', '--dry-run'])).toEqual({
-      dryRun: true,
-      rest: ['alice', 'proj-x'],
-    });
-  });
-
-  test('flag at start', () => {
-    expect(extractDryRun(['--dry-run', 'alice', 'proj-x'])).toEqual({
-      dryRun: true,
-      rest: ['alice', 'proj-x'],
-    });
-  });
-
-  test('flag in middle', () => {
-    expect(extractDryRun(['alice', '--dry-run', 'proj-x'])).toEqual({
-      dryRun: true,
-      rest: ['alice', 'proj-x'],
-    });
-  });
-
-  test('no args', () => {
-    expect(extractDryRun([])).toEqual({ dryRun: false, rest: [] });
-  });
-});
-
-// ---------------------------------------------------------------------------
-// DB-coupled
-// ---------------------------------------------------------------------------
-
-async function seedSource(id: string): Promise<void> {
-  const sql = sqlQueryForEngine(engine);
-  await sql`INSERT INTO sources (id, name) VALUES (${id}, ${id}) ON CONFLICT (id) DO NOTHING`;
-}
-
-async function seedClient(name: string, federated: string[] = []): Promise<string> {
-  // Ensure write source FK is satisfied — every seeded client points at 'default'.
-  await seedSource('default');
-  const sql = sqlQueryForEngine(engine);
-  const clientId = `gbrain_cl_test_${name}_${Date.now()}_${Math.random().toString(16).slice(2, 8)}`;
-  const fedLit = pgArray(federated);
-  await sql`
-    INSERT INTO oauth_clients (client_id, client_name, client_secret_hash,
-                               redirect_uris, grant_types, scope,
-                               client_id_issued_at, source_id, federated_read)
-    VALUES (${clientId}, ${name}, ${'dummy-hash'},
-            ${pgArray([])}, ${pgArray(['client_credentials'])}, ${'read'},
-            ${Date.now()}, ${'default'}, ${fedLit})
-  `;
-  return clientId;
-}
-
-async function readFederated(clientId: string): Promise<string[]> {
-  const sql = sqlQueryForEngine(engine);
-  const rows = await sql`SELECT federated_read FROM oauth_clients WHERE client_id = ${clientId}`;
-  const fed = rows[0]?.federated_read;
-  return Array.isArray(fed) ? (fed as string[]).map(String) : [];
-}
-
-describe('resolveClient', () => {
-  test('matches by client_id', async () => {
-    await seedSource('default');
-    const id = await seedClient('alice', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    const c = await resolveClient(sql, id);
-    expect(c.client_name).toBe('alice');
-    expect(c.federated_read).toEqual(['default']);
-  });
-
-  test('matches by client_name', async () => {
-    await seedSource('default');
-    await seedClient('alice', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    const c = await resolveClient(sql, 'alice');
-    expect(c.client_name).toBe('alice');
-  });
-
-  test('errors loudly on no-match', async () => {
-    const sql = sqlQueryForEngine(engine);
-    await expect(resolveClient(sql, 'nobody')).rejects.toThrow(/No active OAuth client found/);
-  });
-
-  test('errors loudly on ambiguous client_name', async () => {
-    await seedSource('default');
-    await seedClient('bob', ['default']);
-    await seedClient('bob', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    await expect(resolveClient(sql, 'bob')).rejects.toThrow(/Multiple active OAuth clients named/);
-  });
-
-  test('null source_id is preserved as null (legacy row tolerance)', async () => {
-    const sql = sqlQueryForEngine(engine);
-    const clientId = `gbrain_cl_test_null_${Date.now()}`;
-    await sql`
-      INSERT INTO oauth_clients (client_id, client_name, client_secret_hash,
-                                 redirect_uris, grant_types, scope,
-                                 client_id_issued_at, source_id, federated_read)
-      VALUES (${clientId}, ${'legacy'}, ${'dummy'},
-              ${pgArray([])}, ${pgArray(['client_credentials'])}, ${'read'},
-              ${Date.now()}, ${null}, ${pgArray([])})
-    `;
-    const c = await resolveClient(sql, clientId);
-    expect(c.source_id).toBeNull();
-    expect(c.federated_read).toEqual([]);
-  });
-});
-
-describe('assertSourceExists', () => {
-  test('passes when present', async () => {
-    await seedSource('proj-x');
-    const sql = sqlQueryForEngine(engine);
-    await expect(assertSourceExists(sql, 'proj-x')).resolves.toBeUndefined();
-  });
-
-  test('throws with paste-ready hint when missing', async () => {
-    const sql = sqlQueryForEngine(engine);
-    await expect(assertSourceExists(sql, 'ghost')).rejects.toThrow(
-      /Source "ghost" does not exist.*gbrain sources add ghost/s,
-    );
-  });
-});
-
-describe('grantReadCore', () => {
-  test('appends when not present and persists', async () => {
-    await seedSource('default');
-    await seedSource('proj-x');
-    const id = await seedClient('alice', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    const outcome = await grantReadCore(sql, 'alice', 'proj-x');
-    expect(outcome.kind).toBe('updated');
-    if (outcome.kind === 'updated') {
-      expect(outcome.before).toEqual(['default']);
-      expect(outcome.after).toEqual(['default', 'proj-x']);
-    }
-    expect(await readFederated(id)).toEqual(['default', 'proj-x']);
-  });
-
-  test('is idempotent — second call is a noop, list unchanged', async () => {
-    await seedSource('default');
-    await seedSource('proj-x');
-    const id = await seedClient('alice', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    await grantReadCore(sql, 'alice', 'proj-x');
-    const outcome = await grantReadCore(sql, 'alice', 'proj-x');
-    expect(outcome.kind).toBe('noop');
-    if (outcome.kind === 'noop') {
-      expect(outcome.reason).toBe('already-granted');
-    }
-    expect(await readFederated(id)).toEqual(['default', 'proj-x']);
-  });
-
-  test('refuses unknown source (fails BEFORE mutating)', async () => {
-    await seedSource('default');
-    const id = await seedClient('alice', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    await expect(grantReadCore(sql, 'alice', 'ghost')).rejects.toThrow(/does not exist/);
-    expect(await readFederated(id)).toEqual(['default']);
-  });
-
-  test('refuses unknown client', async () => {
-    const sql = sqlQueryForEngine(engine);
-    await expect(grantReadCore(sql, 'nobody', 'whatever')).rejects.toThrow(/No active OAuth client found/);
-  });
-
-  test('accepts client_id resolution too', async () => {
-    await seedSource('default');
-    await seedSource('proj-x');
-    const id = await seedClient('alice', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    await grantReadCore(sql, id, 'proj-x');
-    expect(await readFederated(id)).toEqual(['default', 'proj-x']);
-  });
-
-  test('rejects malformed source_id BEFORE existence check (Codex finding #3)', async () => {
-    await seedSource('default');
-    const id = await seedClient('alice', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    // Even with a row in `sources` having a weird id, the validator at the
-    // boundary refuses. Closes the "manual SQL plants a row, CLI lets it
-    // become unmanageable in federated_read" vector.
-    await sql`INSERT INTO sources (id, name) VALUES (${'has,"weird"-bits'}, ${'weird'})`;
-    await expect(grantReadCore(sql, 'alice', 'has,"weird"-bits')).rejects.toThrow(/Invalid source_id/);
-    // DB unchanged.
-    expect(await readFederated(id)).toEqual(['default']);
-  });
-});
-
-describe('revokeReadCore', () => {
-  test('removes when present', async () => {
-    await seedSource('default');
-    await seedSource('proj-x');
-    const id = await seedClient('alice', ['default', 'proj-x']);
-    const sql = sqlQueryForEngine(engine);
-    const outcome = await revokeReadCore(sql, 'alice', 'proj-x');
-    expect(outcome.kind).toBe('updated');
-    expect(await readFederated(id)).toEqual(['default']);
-  });
-
-  test('is idempotent — second call is a noop, list unchanged', async () => {
-    await seedSource('default');
-    const id = await seedClient('alice', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    const outcome = await revokeReadCore(sql, 'alice', 'ghost-source');
-    expect(outcome.kind).toBe('noop');
-    if (outcome.kind === 'noop') {
-      expect(outcome.reason).toBe('not-present');
-    }
-    expect(await readFederated(id)).toEqual(['default']);
-  });
-
-  test('allows clearing the list down to empty (no implicit guard)', async () => {
-    await seedSource('default');
-    const id = await seedClient('alice', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    await revokeReadCore(sql, 'alice', 'default');
-    expect(await readFederated(id)).toEqual([]);
-  });
-
-  test('does NOT validate the source exists — operator may revoke stale references', async () => {
-    await seedSource('default');
-    // federated_read carries 'proj-x' but the source row was deleted.
-    const id = await seedClient('alice', ['default', 'proj-x']);
-    const sql = sqlQueryForEngine(engine);
-    const outcome = await revokeReadCore(sql, 'alice', 'proj-x');
-    expect(outcome.kind).toBe('updated');
-    expect(await readFederated(id)).toEqual(['default']);
-  });
-});
-
-describe('setFederatedReadCore', () => {
-  test('replaces list wholesale', async () => {
-    await seedSource('a');
-    await seedSource('b');
-    await seedSource('c');
-    const id = await seedClient('alice', ['a']);
-    const sql = sqlQueryForEngine(engine);
-    const outcome = await setFederatedReadCore(sql, 'alice', 'b,c');
-    expect(outcome.kind).toBe('updated');
-    expect(await readFederated(id)).toEqual(['b', 'c']);
-  });
-
-  test('dedupes CSV input', async () => {
-    await seedSource('a');
-    await seedSource('b');
-    const id = await seedClient('alice', []);
-    const sql = sqlQueryForEngine(engine);
-    await setFederatedReadCore(sql, 'alice', 'a,b,a,b,a');
-    expect(await readFederated(id)).toEqual(['a', 'b']);
-  });
-
-  test('empty string clears the list', async () => {
-    await seedSource('a');
-    const id = await seedClient('alice', ['a']);
-    const sql = sqlQueryForEngine(engine);
-    await setFederatedReadCore(sql, 'alice', '');
-    expect(await readFederated(id)).toEqual([]);
-  });
-
-  test('noop when result equals current list', async () => {
-    await seedSource('a');
-    await seedSource('b');
-    const id = await seedClient('alice', ['a', 'b']);
-    const sql = sqlQueryForEngine(engine);
-    const outcome = await setFederatedReadCore(sql, 'alice', 'a,b');
-    expect(outcome.kind).toBe('noop');
-    if (outcome.kind === 'noop') {
-      expect(outcome.reason).toBe('same-list');
-    }
-    expect(await readFederated(id)).toEqual(['a', 'b']);
-  });
-
-  test('refuses unknown source (fails BEFORE mutating)', async () => {
-    await seedSource('a');
-    const id = await seedClient('alice', ['a']);
-    const sql = sqlQueryForEngine(engine);
-    await expect(setFederatedReadCore(sql, 'alice', 'a,ghost')).rejects.toThrow(/does not exist/);
-    // Original list preserved.
-    expect(await readFederated(id)).toEqual(['a']);
-  });
-
-  test('order in CSV is the order persisted', async () => {
-    await seedSource('a');
-    await seedSource('b');
-    await seedSource('c');
-    const id = await seedClient('alice', ['a']);
-    const sql = sqlQueryForEngine(engine);
-    await setFederatedReadCore(sql, 'alice', 'c,a,b');
-    expect(await readFederated(id)).toEqual(['c', 'a', 'b']);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// --dry-run semantics
-// ---------------------------------------------------------------------------
-
-// ---------------------------------------------------------------------------
-// Codex fixes: soft-delete filter, atomic-SQL race-safety, sanitizer
-// ---------------------------------------------------------------------------
-
-describe('sanitizeForTerminal', () => {
-  test('preserves printable ASCII unchanged', () => {
-    expect(sanitizeForTerminal('alice')).toBe('alice');
-    expect(sanitizeForTerminal('a b-c_d.e/f@g')).toBe('a b-c_d.e/f@g');
-  });
-
-  test('escapes ANSI escape sequences', () => {
-    expect(sanitizeForTerminal('\x1b[2J')).toBe('\\x1b[2J');
-    expect(sanitizeForTerminal('\x1b]0;TITLE\x07')).toBe('\\x1b]0;TITLE\\x07');
-  });
-
-  test('escapes ALL C0 controls including tab and newline', () => {
-    // Codex re-review: preserving \n lets a DCR-registered name spoof
-    // additional rows in list-clients output. Tab spoofs field separators.
-    // Both are now escaped.
-    expect(sanitizeForTerminal('\x00\x07\x08')).toBe('\\x00\\x07\\x08');
-    expect(sanitizeForTerminal('line1\nline2')).toBe('line1\\x0aline2');
-    expect(sanitizeForTerminal('col1\tcol2')).toBe('col1\\x09col2');
-  });
-
-  test('escapes DEL and C1 controls', () => {
-    expect(sanitizeForTerminal('\x7f')).toBe('\\x7f');
-    expect(sanitizeForTerminal('\x9b[31m')).toBe('\\x9b[31m');
-  });
-
-  test('passes through unicode', () => {
-    expect(sanitizeForTerminal('café')).toBe('café');
-    expect(sanitizeForTerminal('日本語')).toBe('日本語');
-  });
-});
-
-describe('soft-delete filter (Codex finding #2)', () => {
-  async function softDeleteClient(clientId: string): Promise<void> {
-    const sql = sqlQueryForEngine(engine);
-    await sql`UPDATE oauth_clients SET deleted_at = now() WHERE client_id = ${clientId}`;
-  }
-
-  test('resolveClient hides soft-deleted clients by default', async () => {
-    await seedSource('default');
-    const id = await seedClient('alice', ['default']);
-    await softDeleteClient(id);
-    const sql = sqlQueryForEngine(engine);
-    await expect(resolveClient(sql, 'alice')).rejects.toThrow(/No active OAuth client found/);
-    await expect(resolveClient(sql, id)).rejects.toThrow(/No active OAuth client found/);
-  });
-
-  test('resolveClient with includeDeleted finds soft-deleted clients', async () => {
-    await seedSource('default');
-    const id = await seedClient('alice', ['default']);
-    await softDeleteClient(id);
-    const sql = sqlQueryForEngine(engine);
-    const c = await resolveClient(sql, id, { includeDeleted: true });
-    expect(c.client_name).toBe('alice');
-    expect(c.deleted_at).not.toBeNull();
-  });
-
-  test('grantReadCore refuses to mutate soft-deleted clients', async () => {
-    await seedSource('default');
-    await seedSource('proj-x');
-    const id = await seedClient('alice', ['default']);
-    await softDeleteClient(id);
-    const sql = sqlQueryForEngine(engine);
-    await expect(grantReadCore(sql, 'alice', 'proj-x')).rejects.toThrow(/No active OAuth client found/);
-    expect(await readFederated(id)).toEqual(['default']);
-  });
-
-  test('revokeReadCore refuses to mutate soft-deleted clients', async () => {
-    await seedSource('default');
-    const id = await seedClient('alice', ['default']);
-    await softDeleteClient(id);
-    const sql = sqlQueryForEngine(engine);
-    await expect(revokeReadCore(sql, 'alice', 'default')).rejects.toThrow(/No active OAuth client found/);
-    expect(await readFederated(id)).toEqual(['default']);
-  });
-
-  test('two clients with same name but only one active resolves to the active one', async () => {
-    await seedSource('default');
-    // Seed two clients with the same name; soft-delete the older one.
-    const sql = sqlQueryForEngine(engine);
-    const oldId = await seedClient('alice', ['default']);
-    await softDeleteClient(oldId);
-    const newId = await seedClient('alice', ['default']);  // same name, new row
-    const c = await resolveClient(sql, 'alice');
-    expect(c.client_id).toBe(newId);  // active row wins; ambiguity error suppressed
-  });
-});
-
-describe('atomic SQL race-safety (Codex finding #1, HIGH)', () => {
-  test('grant+revoke serialize at row-lock — sensitive stays revoked', async () => {
-    await seedSource('default');
-    await seedSource('sensitive');
-    await seedSource('harmless');
-    const id = await seedClient('alice', ['default', 'sensitive']);
-    const sql = sqlQueryForEngine(engine);
-
-    // Simulate concurrent revoke(sensitive) + grant(harmless). Real concurrency
-    // would race at the JS event loop boundary; here we await sequentially but
-    // each call goes through the ATOMIC SQL path. The contract: regardless of
-    // ordering, the final state has sensitive REMOVED and harmless ADDED.
-    await revokeReadCore(sql, 'alice', 'sensitive');
-    await grantReadCore(sql, 'alice', 'harmless');
-    const final1 = await readFederated(id);
-    expect(final1.sort()).toEqual(['default', 'harmless']);
-
-    // Reverse order, same final state. The pre-fix read-modify-write shape
-    // would have produced ['default', 'sensitive', 'harmless'] here (the
-    // resurrection bug Codex caught).
-    const id2 = await seedClient('bob', ['default', 'sensitive']);
-    await grantReadCore(sql, 'bob', 'harmless');
-    await revokeReadCore(sql, 'bob', 'sensitive');
-    const final2 = await readFederated(id2);
-    expect(final2.sort()).toEqual(['default', 'harmless']);
-  });
-
-  test('grant uses RETURNING to surface the post-write state', async () => {
-    await seedSource('default');
-    await seedSource('proj-x');
-    await seedClient('alice', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    const outcome = await grantReadCore(sql, 'alice', 'proj-x');
-    expect(outcome.kind).toBe('updated');
-    if (outcome.kind === 'updated') {
-      // The `after` came from RETURNING, not from computing prev+sourceId
-      // in JS — proves the atomic path returned authoritative state.
-      expect(outcome.after).toEqual(['default', 'proj-x']);
-    }
-  });
-
-  test('grant noop path still survives without writing', async () => {
-    await seedSource('default');
-    const id = await seedClient('alice', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    const outcome = await grantReadCore(sql, 'alice', 'default');
-    expect(outcome.kind).toBe('noop');
-    if (outcome.kind === 'noop') expect(outcome.reason).toBe('already-granted');
-    expect(await readFederated(id)).toEqual(['default']);
-  });
-});
-
-describe('dryRun mode', () => {
-  test('grantReadCore returns "updated" outcome but skips the write', async () => {
-    await seedSource('default');
-    await seedSource('proj-x');
-    const id = await seedClient('alice', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    const outcome = await grantReadCore(sql, 'alice', 'proj-x', { dryRun: true });
-    expect(outcome.kind).toBe('updated');
-    if (outcome.kind === 'updated') {
-      expect(outcome.before).toEqual(['default']);
-      expect(outcome.after).toEqual(['default', 'proj-x']);
-    }
-    // Crucially: the DB row is UNCHANGED.
-    expect(await readFederated(id)).toEqual(['default']);
-  });
-
-  test('revokeReadCore returns "updated" outcome but skips the write', async () => {
-    await seedSource('default');
-    await seedSource('proj-x');
-    const id = await seedClient('alice', ['default', 'proj-x']);
-    const sql = sqlQueryForEngine(engine);
-    const outcome = await revokeReadCore(sql, 'alice', 'proj-x', { dryRun: true });
-    expect(outcome.kind).toBe('updated');
-    expect(await readFederated(id)).toEqual(['default', 'proj-x']);
-  });
-
-  test('setFederatedReadCore returns "updated" outcome but skips the write', async () => {
-    await seedSource('a');
-    await seedSource('b');
-    await seedSource('c');
-    const id = await seedClient('alice', ['a']);
-    const sql = sqlQueryForEngine(engine);
-    const outcome = await setFederatedReadCore(sql, 'alice', 'b,c', { dryRun: true });
-    expect(outcome.kind).toBe('updated');
-    expect(await readFederated(id)).toEqual(['a']);
-  });
-
-  test('noop outcomes are surfaced identically with or without dryRun', async () => {
-    await seedSource('default');
-    await seedSource('proj-x');
-    await seedClient('alice', ['default', 'proj-x']);
-    const sql = sqlQueryForEngine(engine);
-    const live = await grantReadCore(sql, 'alice', 'proj-x', { dryRun: false });
-    const dry = await grantReadCore(sql, 'alice', 'proj-x', { dryRun: true });
-    expect(live.kind).toBe('noop');
-    expect(dry.kind).toBe('noop');
-  });
-
-  test('errors still fire in dryRun (operator sees the problem before commit)', async () => {
-    await seedSource('default');
-    const id = await seedClient('alice', ['default']);
-    const sql = sqlQueryForEngine(engine);
-    await expect(
-      grantReadCore(sql, 'alice', 'ghost', { dryRun: true }),
-    ).rejects.toThrow(/does not exist/);
-    await expect(
-      grantReadCore(sql, 'nobody', 'default', { dryRun: true }),
-    ).rejects.toThrow(/No active OAuth client found/);
-    // DB unchanged.
-    expect(await readFederated(id)).toEqual(['default']);
-  });
-});
@@ -174,29 +174,6 @@ describe('parseRegisterClientArgs', () => {
  });

  describe('error cases', () => {
-    test('--source with malformed id throws (validates source_id shape — codex re-review)', () => {
-      // Defense for the "register-client seeds an unmanageable
-      // federated_read entry" vector. assertValidSourceId fires before the
-      // function returns so DB never sees a row with bad source scope.
-      expect(() => parseRegisterClientArgs(['--source', 'has,weird,bits'])).toThrow(/Invalid source_id/);
-      expect(() => parseRegisterClientArgs(['--source', 'UPPER'])).toThrow(/Invalid source_id/);
-      expect(() => parseRegisterClientArgs(['--source', ''])).toThrow(/Invalid source_id|requires a value/);
-    });
-
-    test('--federated-read with any malformed id throws', () => {
-      // Single-item bad.
-      expect(() => parseRegisterClientArgs(['--federated-read', 'bad,source!'])).toThrow(/Invalid source_id/);
-      // Mixed valid + invalid — fails on the first bad one.
-      expect(() => parseRegisterClientArgs(['--federated-read', 'good,bad source'])).toThrow(/Invalid source_id/);
-    });
-
-    test('--source default + --federated-read default,team passes (regression — common case)', () => {
-      // Sanity: the canonical real-world invocation still parses cleanly.
-      const out = parseRegisterClientArgs(['--source', 'default', '--federated-read', 'default,team']);
-      expect(out.sourceId).toBe('default');
-      expect(out.federatedRead).toEqual(['default', 'team']);
-    });
-
    test('--redirect-uri without value → throws', () => {
      expect(() => parseRegisterClientArgs(['--redirect-uri'])).toThrow(/requires a value/);
    });
@@ -410,6 +410,38 @@ describe("v0.22.4 regression — actual repo skills/ has 0 errors", () => {
  });
 });

+// ---------------------------------------------------------------------------
+// CRLF tolerance — Windows-authored SKILL.md must not cause mece_gap
+// false-positives. The frontmatter parser used to anchor on literal `\n`
+// after the leading `---`, which failed silently on `\r\n`-terminated files
+// and made every skill on Windows look like it was missing a triggers: array.
+// ---------------------------------------------------------------------------
+describe("checkResolvable — CRLF line endings", () => {
+  let dir: string;
+  afterEachCleanup(() => rmSync(dir, { recursive: true, force: true }));
+
+  test("does not flag mece_gap for skills with CRLF-terminated frontmatter", () => {
+    const lfBody = `---\nname: alpha\ndescription: alpha skill\ntriggers:\n  - "alpha trigger"\n---\n\n# Alpha\n`;
+    dir = mkdtempSync(join(tmpdir(), "gbrain-crlf-"));
+    writeFileSync(
+      join(dir, "RESOLVER.md"),
+      `## Test\n| Trigger | Skill |\n|-----|-----|\n| "alpha trigger" | \`skills/alpha/SKILL.md\` |\n`,
+    );
+    writeFileSync(
+      join(dir, "manifest.json"),
+      JSON.stringify({ skills: [{ name: "alpha", path: "alpha/SKILL.md" }] }, null, 2),
+    );
+    mkdirSync(join(dir, "alpha"), { recursive: true });
+    // Convert the otherwise-valid SKILL.md to CRLF — this is the actual
+    // on-disk shape produced by editors on Windows.
+    writeFileSync(join(dir, "alpha", "SKILL.md"), lfBody.replace(/\n/g, "\r\n"));
+
+    const report = checkResolvable(dir);
+    const gaps = report.issues.filter(i => i.type === "mece_gap");
+    expect(gaps).toEqual([]);
+  });
+});
+
 // bun:test has no beforeEach/afterEach at module scope cleanly interacting
 // with closures; a small helper keeps cleanup readable and per-test.
 function afterEachCleanup(fn: () => void) {
@@ -136,6 +136,50 @@ describe('extractTimelineFromContent', () => {
    expect(entries).toHaveLength(1);
  });

+  it('does not split a hyphenated word in the bullet body (bare-hyphen regression, #1341)', () => {
+    // A hyphen inside a slug/compound must not be read as the source/summary
+    // separator. Pre-fix this produced source "acme".
+    const content = `- **2025-05-13** | acme-consulting-group kickoff call`;
+    const entries = extractTimelineFromContent(content, 'test');
+    expect(entries.find((e) => e.source === 'acme')).toBeUndefined();
+  });
+
+  it('keeps hyphenated words intact in the summary when splitting on a spaced dash', () => {
+    const content = `- **2025-05-13** | Call — acme-consulting-group renewed`;
+    const entries = extractTimelineFromContent(content, 'test');
+    expect(entries).toHaveLength(1);
+    expect(entries[0].source).toBe('Call');
+    expect(entries[0].summary).toBe('acme-consulting-group renewed');
+  });
+
+  it('still splits on a spaced plain hyphen separator', () => {
+    // Bullets written as `Source - Summary` extracted fine pre-fix and must
+    // keep extracting (the #1341 PR's em/en-dash-only regex dropped them).
+    const content = `- **2025-05-13** | Standup - shipped the beta`;
+    const entries = extractTimelineFromContent(content, 'test');
+    expect(entries).toHaveLength(1);
+    expect(entries[0].source).toBe('Standup');
+    expect(entries[0].summary).toBe('shipped the beta');
+  });
+
+  it('still splits on an unspaced em dash separator', () => {
+    const content = `- **2025-05-13** | Call—renewed the contract`;
+    const entries = extractTimelineFromContent(content, 'test');
+    expect(entries).toHaveLength(1);
+    expect(entries[0].source).toBe('Call');
+    expect(entries[0].summary).toBe('renewed the contract');
+  });
+
+  it('long and parenthesized sources still extract', () => {
+    // The #1341 PR capped sources at 24 bracket-free chars, silently dropping
+    // previously-extracted bullets. No such cap here.
+    const content = `- **2025-05-13** | Quarterly business review (with acme-example team) — agreed on roadmap`;
+    const entries = extractTimelineFromContent(content, 'test');
+    expect(entries).toHaveLength(1);
+    expect(entries[0].source).toBe('Quarterly business review (with acme-example team)');
+    expect(entries[0].summary).toBe('agreed on roadmap');
+  });
+
  it('extracts inline citation format entries', () => {
    const content = `Closed the seed round with fund-a leading. [Source: board meeting notes, 2025-04-02]`;
    const entries = extractTimelineFromContent(content, 'deals/acme-seed');
@@ -32,6 +32,14 @@ describe('lintContent', () => {
    expect(issues.some(i => i.rule === 'code-fence-wrap')).toBe(true);
  });

+  test('does not flag a mid-document markdown code block as a page wrap', () => {
+    // Regression: a note that merely CONTAINS a ```markdown block (e.g. a
+    // Notion export fencing a config snippet) is not a whole-page wrap.
+    const content = '---\ntitle: Notes\ntype: note\ncreated: 2026-05-25\n---\n\nIntro paragraph.\n\n```markdown\nKEY=value\nPORT=3002\n```\n';
+    const issues = lintContent(content, 'test.md');
+    expect(issues.some(i => i.rule === 'code-fence-wrap')).toBe(false);
+  });
+
  test('detects placeholder dates', () => {
    const content = '---\ntitle: Test\ntype: person\ncreated: YYYY-MM-DD\n---\n\n# Test';
    const issues = lintContent(content, 'test.md');
@@ -97,6 +105,17 @@ describe('fixContent', () => {
    expect(fixed).toContain('# Title');
  });

+  test('leaves a mid-document markdown code block intact (keeps its closing fence)', () => {
+    // Regression for the autopilot churn: fixContent used to strip only the
+    // trailing ```, leaving the fence open and the note re-corrupted each cycle.
+    const input = '---\ntitle: Notes\ntype: note\ncreated: 2026-05-25\n---\n\nIntro paragraph.\n\n```markdown\nKEY=value\nPORT=3002\n```\n';
+    const fixed = fixContent(input);
+    const fenceLines = (fixed.match(/^```/gm) ?? []).length;
+    expect(fenceLines).toBe(2);
+    expect(fixed).toContain('```markdown');
+    expect(fixed.trimEnd().endsWith('```')).toBe(true);
+  });
+
  test('cleans up excessive blank lines after fix', () => {
    const input = 'Of course. Here is the brain page.\n\n\n\n# Title\n\nContent.';
    const fixed = fixContent(input);
@@ -21,12 +21,15 @@ beforeEach(() => {
  origHome = process.env.HOME;
  origGbrainHome = process.env.GBRAIN_HOME;
  tmp = mkdtempSync(join(tmpdir(), 'gbrain-prefs-test-'));
-  // preferences.ts's gbrainDir() returns `$HOME/.gbrain` when GBRAIN_HOME
-  // is unset. Test fixtures write to `$tmp/.gbrain/...`, so set HOME only
-  // and clear GBRAIN_HOME — setting GBRAIN_HOME would route prefs to $tmp
-  // directly (no .gbrain suffix), which doesn't match the fixture layout.
+  // Both gbrainDir() (preferences) and configDir() (config) now share the
+  // same contract via configDir(): GBRAIN_HOME is the parent dir, and they
+  // always append `.gbrain`. So setting GBRAIN_HOME=$tmp routes prefs to
+  // `$tmp/.gbrain/...`, matching the fixture layout used in this file.
+  //
+  // HOME alone is unreliable for isolation: os.homedir() reads USERPROFILE
+  // on Windows, ignoring HOME. GBRAIN_HOME is the platform-neutral hook.
  process.env.HOME = tmp;
-  delete process.env.GBRAIN_HOME;
+  process.env.GBRAIN_HOME = tmp;
 });

 afterEach(() => {
@@ -178,6 +181,40 @@ describe('appendCompletedMigration', () => {
  });
 });

+describe('legacy GBRAIN_HOME path adoption', () => {
+  // Before gbrainDir() delegated to configDir(), a set GBRAIN_HOME meant
+  // preferences.json + migrations/completed.jsonl lived at $GBRAIN_HOME/...
+  // directly (no `.gbrain` suffix). The unification must not orphan those
+  // files — first access moves them to $GBRAIN_HOME/.gbrain/... .
+  test('adopts a legacy preferences.json on load', () => {
+    writeFileSync(join(tmp, 'preferences.json'), JSON.stringify({ minion_mode: 'off' }));
+    expect(loadPreferences()).toEqual({ minion_mode: 'off' });
+    expect(existsSync(join(tmp, '.gbrain', 'preferences.json'))).toBe(true);
+    expect(existsSync(join(tmp, 'preferences.json'))).toBe(false);
+  });
+
+  test('adopts a legacy migrations/completed.jsonl on load', () => {
+    mkdirSync(join(tmp, 'migrations'), { recursive: true });
+    writeFileSync(
+      join(tmp, 'migrations', 'completed.jsonl'),
+      JSON.stringify({ version: '0.21.0', status: 'complete' }) + '\n',
+    );
+    const entries = loadCompletedMigrations();
+    expect(entries.length).toBe(1);
+    expect(entries[0].version).toBe('0.21.0');
+    expect(existsSync(join(tmp, '.gbrain', 'migrations', 'completed.jsonl'))).toBe(true);
+  });
+
+  test('new-path file wins over a stale legacy file', () => {
+    mkdirSync(join(tmp, '.gbrain'), { recursive: true });
+    writeFileSync(join(tmp, '.gbrain', 'preferences.json'), JSON.stringify({ minion_mode: 'always' }));
+    writeFileSync(join(tmp, 'preferences.json'), JSON.stringify({ minion_mode: 'off' }));
+    expect(loadPreferences()).toEqual({ minion_mode: 'always' });
+    // Legacy file left untouched — never clobber the adopted copy.
+    expect(existsSync(join(tmp, 'preferences.json'))).toBe(true);
+  });
+});
+
 describe('loadCompletedMigrations', () => {
  test('returns empty when file is missing', () => {
    expect(loadCompletedMigrations()).toEqual([]);
@@ -26,7 +26,11 @@ let tmp: string;
 let origHome: string | undefined;

 function run(args: string[]): { exitCode: number; stdout: string; stderr: string } {
-  const env = { ...process.env, HOME: tmp } as Record<string, string | undefined>;
+  // HOME alone doesn't redirect gbrain config on Windows: os.homedir() reads
+  // USERPROFILE on Win32. GBRAIN_HOME is the platform-neutral override that
+  // configDir() honors uniformly — set both so the test fixture isolates
+  // from the real user's `.gbrain/` directory on every platform.
+  const env = { ...process.env, HOME: tmp, GBRAIN_HOME: tmp } as Record<string, string | undefined>;
  delete env.DATABASE_URL;
  delete env.GBRAIN_DATABASE_URL;
  try {
@@ -56,6 +60,12 @@ afterEach(() => {
  try { rmSync(tmp, { recursive: true, force: true }); } catch { /* best-effort */ }
 });

+// Each test below spawns `bun run cli.ts skillpack-check`, which itself
+// spawns child `doctor` + `apply-migrations --list` processes. On Windows
+// subprocess cold-start is ~600ms each; the default 5s bun:test timeout
+// is too tight for the chained spawns. 30s leaves headroom for slower CI.
+const SUBPROCESS_TIMEOUT = 30_000;
+
 describe('gbrain skillpack-check', () => {
  test('healthy fresh install → exit 0, healthy:true, empty actions', () => {
    const result = run(['skillpack-check']);
@@ -66,7 +76,7 @@ describe('gbrain skillpack-check', () => {
    expect(report.summary).toBe('gbrain skillpack healthy');
    expect(report.version).toBeTruthy();
    expect(report.ts).toBeTruthy();
-  });
+  }, SUBPROCESS_TIMEOUT);

  test('half-migrated (partial completed.jsonl) → exit 1, apply-migrations in actions', () => {
    const migrationsDir = join(tmp, '.gbrain', 'migrations');
@@ -88,7 +98,7 @@ describe('gbrain skillpack-check', () => {
    const minions = doctorChecks.find(c => c.name === 'minions_migration');
    expect(minions).toBeDefined();
    expect(minions!.status).toBe('fail');
-  });
+  }, SUBPROCESS_TIMEOUT);

  test('--quiet → no stdout, same exit code', () => {
    // Healthy path quiet
@@ -106,7 +116,7 @@ describe('gbrain skillpack-check', () => {
    const broken = run(['skillpack-check', '--quiet']);
    expect(broken.exitCode).toBe(1);
    expect(broken.stdout).toBe('');
-  });
+  }, SUBPROCESS_TIMEOUT);

  test('--help → exit 0, prints usage', () => {
    const result = run(['skillpack-check', '--help']);
@@ -114,7 +124,7 @@ describe('gbrain skillpack-check', () => {
    expect(result.stdout).toContain('skillpack-check');
    expect(result.stdout).toContain('healthy');
    expect(result.stdout).toContain('Exit codes');
-  });
+  }, SUBPROCESS_TIMEOUT);

  test('summary includes top action when multiple present', () => {
    // Partial record creates apply-migrations action + the migrations count
@@ -130,5 +140,5 @@ describe('gbrain skillpack-check', () => {
    const report = JSON.parse(result.stdout);
    expect(report.summary).toMatch(/\d+ action\(s\)/);
    expect(report.summary).toContain(report.actions[0]);
-  });
+  }, SUBPROCESS_TIMEOUT);
 });
@@ -175,6 +175,17 @@ describe('enumerateBundle (D-CX-10 dependency closure)', () => {
    expect(targets.some(t => t.startsWith('alpha/'))).toBe(true);
    expect(targets.some(t => t.startsWith('beta/'))).toBe(true);
  });
+  it('emits forward-slash relTarget paths on every platform', () => {
+    // relTarget is a portable bundle key consumed by string-matching
+    // callers (managed-block writer, install-plan diffs); Windows-style
+    // backslashes silently break them. This test fails fast if anyone
+    // re-introduces `path.join` for relTarget construction.
+    const { gbrainRoot } = scratchGbrain();
+    const m = loadBundleManifest(gbrainRoot);
+    const entries = enumerateBundle({ gbrainRoot, manifest: m });
+    const offending = entries.filter(e => e.relTarget.includes('\\'));
+    expect(offending).toEqual([]);
+  });
 });

 describe('buildManagedBlock + updateManagedBlock', () => {
@@ -1004,3 +1004,117 @@ describe('v0.42.52.0: 0-changes sync bumps last_sync_at heartbeat (D4 invariant
    expect(lastCommitRows[0]?.last_commit).toEqual(lastCommit);
  });
 });
+
+describe('#1430: failed git pull suppresses last_sync_at freshness', () => {
+  let engine: PGLiteEngine;
+  const repos: string[] = [];
+
+  beforeAll(async () => {
+    engine = new PGLiteEngine();
+    await engine.connect({});
+    await engine.initSchema();
+  });
+
+  afterAll(async () => {
+    await engine.disconnect();
+  });
+
+  beforeEach(async () => {
+    await resetPgliteState(engine);
+  });
+
+  afterEach(() => {
+    while (repos.length) {
+      const d = repos.pop();
+      if (d) rmSync(d, { recursive: true, force: true });
+    }
+  });
+
+  function personMd(title: string, body: string): string {
+    return ['---', 'type: person', `title: ${title}`, '---', '', body].join('\n');
+  }
+
+  function mkRepo(files: Record<string, string>): string {
+    const dir = mkdtempSync(join(tmpdir(), 'gbrain-pullfail-'));
+    repos.push(dir);
+    execSync('git init', { cwd: dir, stdio: 'pipe' });
+    execSync('git config user.email "test@test.com"', { cwd: dir, stdio: 'pipe' });
+    execSync('git config user.name "Test"', { cwd: dir, stdio: 'pipe' });
+    for (const [rel, content] of Object.entries(files)) {
+      mkdirSync(join(dir, rel, '..'), { recursive: true });
+      writeFileSync(join(dir, rel), content);
+    }
+    execSync('git add -A && git commit -m "initial"', { cwd: dir, stdio: 'pipe' });
+    return dir;
+  }
+
+  const BASE_OPTS = { noEmbed: true, noExtract: true, sourceId: 'default' } as const;
+
+  async function sourceRow(): Promise<{ last_sync_at: string | null; last_commit: string | null }> {
+    const rows = await engine.executeRaw<{ last_sync_at: string | null; last_commit: string | null }>(
+      `SELECT last_sync_at, last_commit FROM sources WHERE id = 'default'`,
+    );
+    return rows[0] ?? { last_sync_at: null, last_commit: null };
+  }
+
+  test('up_to_date sync with a failed pull does NOT advance last_sync_at', async () => {
+    const { performSync } = await import('../src/commands/sync.ts');
+    const repo = mkRepo({ 'people/alice.md': personMd('Alice', 'Alice is a person.') });
+    // Origin points nowhere so a pull is ATTEMPTED and FAILS (non-timeout).
+    execSync('git remote add origin /nonexistent/repo.git', { cwd: repo, stdio: 'pipe' });
+
+    // Seed with --no-pull so the first sync succeeds and stamps freshness.
+    await performSync(engine, { repoPath: repo, ...BASE_OPTS, noPull: true });
+    const before = await sourceRow();
+    expect(before.last_sync_at).not.toBeNull();
+
+    await new Promise((r) => setTimeout(r, 1100));
+
+    // Pull attempted (no noPull) → fails → up_to_date heartbeat suppressed.
+    const result = await performSync(engine, { repoPath: repo, ...BASE_OPTS });
+    expect(result.status).toBe('up_to_date');
+    const after = await sourceRow();
+    expect(after.last_sync_at).toEqual(before.last_sync_at);
+  });
+
+  test('incremental sync with a failed pull advances last_commit but NOT last_sync_at', async () => {
+    const { performSync } = await import('../src/commands/sync.ts');
+    const repo = mkRepo({ 'people/alice.md': personMd('Alice', 'Alice is a person.') });
+    execSync('git remote add origin /nonexistent/repo.git', { cwd: repo, stdio: 'pipe' });
+
+    await performSync(engine, { repoPath: repo, ...BASE_OPTS, noPull: true });
+    const before = await sourceRow();
+    expect(before.last_sync_at).not.toBeNull();
+
+    // Local commit so the next sync takes the incremental import path.
+    writeFileSync(join(repo, 'people/bob.md'), personMd('Bob', 'Bob is a person.'));
+    execSync('git add -A && git commit -m "add bob"', { cwd: repo, stdio: 'pipe' });
+    const newHead = execSync('git rev-parse HEAD', { cwd: repo, encoding: 'utf-8' }).trim();
+
+    await new Promise((r) => setTimeout(r, 1100));
+
+    const result = await performSync(engine, { repoPath: repo, ...BASE_OPTS });
+    expect(result.status).toBe('synced');
+    const after = await sourceRow();
+    // Local import converged: bookmark advances. Remote never observed:
+    // freshness does not.
+    expect(after.last_commit).toBe(newHead);
+    expect(after.last_sync_at).toEqual(before.last_sync_at);
+  });
+
+  test('dry-run on an up-to-date source does NOT advance last_sync_at', async () => {
+    const { performSync } = await import('../src/commands/sync.ts');
+    const repo = mkRepo({ 'people/alice.md': personMd('Alice', 'Alice is a person.') });
+
+    await performSync(engine, { repoPath: repo, ...BASE_OPTS, noPull: true });
+    const before = await sourceRow();
+    expect(before.last_sync_at).not.toBeNull();
+
+    await new Promise((r) => setTimeout(r, 1100));
+
+    const result = await performSync(engine, { repoPath: repo, ...BASE_OPTS, noPull: true, dryRun: true });
+    expect(result.status).toBe('up_to_date');
+    const after = await sourceRow();
+    expect(after.last_sync_at).toEqual(before.last_sync_at);
+  });
+});
Author	SHA1	Message	Date
Garry TanandClaude Fable 5	980de2a424	fix(config): configDir honors $HOME over Bun's cached os.homedir() The gbrainDir()->configDir() unification dropped preferences.ts's process.env.HOME fallback; Bun caches homedir()'s initial value and ignores later HOME mutations, so per-test HOME isolation broke and test/migration-resume.test.ts leaked ledger entries across tests. Restore the env-first fallback in the one shared place. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-22 10:50:19 -07:00
Garry Tan rayers Claude Fable 5	a3864272a9	fix(sync): suppress last_sync_at when git pull failed (takeover of #1430 ) Part A of the PR (no-op heartbeat) already shipped in v0.42.52.0; this lands the still-missing part B rebased onto the refactored sync.ts: when the upstream pull is attempted and fails (network partition, revoked credentials, diverged remote), last_commit still advances for converged local imports, but last_sync_at is not stamped — on the anchor writes, the full-reimport path, AND the v0.42.52.0 up_to_date heartbeat (which otherwise still lied about freshness after a failed pull). The heartbeat is also now gated on --dry-run, which must stay side-effect free. Operator-skipped offline modes (--no-pull, detached HEAD, no origin) are not failures and advance normally. Co-authored-by: rayers <rayers@users.noreply.github.com> Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-21 14:47:21 -07:00
Garry Tan Chapwi Claude Fable 5	efb73858dd	fix(extract): don't split timeline bullets on bare hyphens (takeover of #1341 ) The bullet separator regex treated any [—–-] with optional whitespace as the Source/Summary split, so a hyphenated slug (acme-consulting-group) was split mid-word into source "acme" on every extract pass. The plain hyphen now requires surrounding whitespace; em/en dashes keep their old optional-space behavior, so spaced-hyphen, unspaced-em-dash, long, and parenthesized sources all keep extracting (the original PR's replacement dropped those). Co-authored-by: Chapwi <Chapwi@users.noreply.github.com> Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-21 14:44:14 -07:00
Garry Tan trinh-macbook Claude Fable 5	393369090b	fix(lint): only unwrap whole-page code fences, not mid-document blocks (takeover of #1417 ) Detection used /m regexes (a fence anywhere) while the fixer used string-anchored regexes, so a note that merely CONTAINS a ```markdown block lost only its closing fence and was re-corrupted every autopilot lint cycle. Detection and fix now share a single analyzeMarkdownWrap check: a page is wrapped only when the entire body (after frontmatter) is one fence. Salvaged from PR #1417 with the unrelated plugin.json + perplexity-research commits dropped (off-mission, reference a private external system). Co-authored-by: trinh-macbook <trinh-macbook@users.noreply.github.com> Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-21 14:43:11 -07:00
Garry Tan xwang4-svg Claude Fable 5	ed1563983f	fix: Windows compat — CRLF frontmatter, posix relTarget, read-only apply-migrations, gbrainDir contract (takeover of #1294 ) Four verified bugs from PR #1294, rebased onto master: - skill-frontmatter/CRLF: frontmatter regex anchored on literal \n could not match CRLF-terminated SKILL.md files; normalize before matching. Shared extractFrontmatterBlock helper replaces three hand-rolled copies. - skillpack bundle relTarget now posix.join'd (portable bundle key). - apply-migrations: --list/--dry-run are read-only and now skip the schema-drift preflight DB connect entirely. - preferences gbrainDir() now delegates to configDir() so GBRAIN_HOME means the same thing everywhere (parent dir + '.gbrain'). New on top of the PR: one-time legacy-path adoption — a brain that ran with GBRAIN_HOME set had preferences.json + migrations/completed.jsonl one directory above the new location; first access moves them so the migration ledger is not orphaned by the contract unification. Co-authored-by: xwang4-svg <xwang4-svg@users.noreply.github.com> Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>	2026-07-21 14:42:53 -07:00