fix(autopilot): add --target to value-flag set so install targets survive positional translation

Review finding on #3103: --target is installDaemon's value flag
(macos | linux-systemd | ephemeral-container | linux-cron). The
translator only knew --repo/--interval, so `gbrain autopilot
--install --target linux-cron` misread the target value as an
unknown positional subcommand and exited 2 before installDaemon ran.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

src/commands/autopilot.ts

@@ -151,6 +151,100 @@ export function shouldSpawnAutopilotWorker(args: string[]): boolean {
   return !args.includes('--no-worker');
 }
 
+/**
+ * #1525 — positional subcommand translation.
+ *
+ * Pre-fix, `gbrain autopilot status` silently fell through to "start daemon"
+ * because `runAutopilot()` only branched on flag forms (`--status`, etc.).
+ * `status` was treated as a stray positional and ignored.
+ *
+ * This translator maps known positional subcommands to their flag form so
+ * `autopilot status` is equivalent to `autopilot --status`, then rejects
+ * any unrecognized positional with a fail-loud error before any side
+ * effect (lockfile, daemon spawn, sync dispatch) runs.
+ *
+ * Scope decisions:
+ *   - Known aliases: `status` → `--status`, `install` → `--install`,
+ *     `uninstall` → `--uninstall`, `start` → (drop; default daemon launch).
+ *   - `stop` is intentionally NOT aliased here. Stopping a running daemon
+ *     is a new behavior (read PID from lock, SIGTERM, drain) that deserves
+ *     its own design and PR. Users typing `gbrain autopilot stop` today get
+ *     the unknown-positional error with the canonical alternatives.
+ *   - At most one positional allowed; multiple positionals fail loud.
+ */
+// Every flag that consumes the NEXT argv token. Missing one here makes the
+// translator misread the flag's value as a positional subcommand and exit 2
+// (e.g. `--install --target linux-cron`). Keep in sync with parseArg call sites.
+const AUTOPILOT_VALUE_FLAGS = new Set(['--repo', '--interval', '--target']);
+const AUTOPILOT_POSITIONAL_ALIASES: Record<string, string | null> = {
+  status: '--status',
+  install: '--install',
+  uninstall: '--uninstall',
+  start: null, // drop the positional; default behavior is daemon launch
+};
+
+export type PositionalTranslation =
+  | { ok: true; args: string[] }
+  | {
+      ok: false;
+      reason: 'unknown_subcommand' | 'multiple_subcommands';
+      message: string;
+    };
+
+export function translatePositionalSubcommands(args: string[]): PositionalTranslation {
+  const out: string[] = [];
+  let positionalSeen = false;
+  let i = 0;
+  while (i < args.length) {
+    const a = args[i];
+    if (AUTOPILOT_VALUE_FLAGS.has(a)) {
+      // Pass through the flag and its value untouched. If the value is
+      // missing at end-of-argv, fall through so the existing parseArg
+      // path can report the broken usage.
+      out.push(a);
+      if (i + 1 < args.length) {
+        out.push(args[i + 1]);
+        i += 2;
+      } else {
+        i += 1;
+      }
+      continue;
+    }
+    if (a.startsWith('-')) {
+      out.push(a);
+      i += 1;
+      continue;
+    }
+    // Positional subcommand.
+    if (positionalSeen) {
+      const known = Object.keys(AUTOPILOT_POSITIONAL_ALIASES).join(', ');
+      return {
+        ok: false,
+        reason: 'multiple_subcommands',
+        message: `Multiple subcommands given. Use only one of: ${known}.`,
+      };
+    }
+    positionalSeen = true;
+    if (a in AUTOPILOT_POSITIONAL_ALIASES) {
+      const alias = AUTOPILOT_POSITIONAL_ALIASES[a];
+      if (alias) out.push(alias);
+      i += 1;
+      continue;
+    }
+    const known = Object.keys(AUTOPILOT_POSITIONAL_ALIASES).join(', ');
+    return {
+      ok: false,
+      reason: 'unknown_subcommand',
+      message:
+        `Unknown subcommand: \`${a}\`.\n` +
+        `Allowed subcommands: ${known}.\n` +
+        `Or use the flag form: --status, --install, --uninstall.\n` +
+        `Run \`gbrain autopilot --help\` for full usage.`,
+    };
+  }
+  return { ok: true, args: out };
+}
+
 export function isPidAlive(pid: number): boolean {
   if (!Number.isFinite(pid) || pid <= 0) return false;
   try {
@@ -363,6 +457,11 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
       '       gbrain autopilot --install [--repo <path>]\n' +
       '       gbrain autopilot --uninstall\n' +
       '       gbrain autopilot --status [--json]\n\n' +
+      'Subcommand aliases:\n' +
+      '       gbrain autopilot status     → --status\n' +
+      '       gbrain autopilot install    → --install\n' +
+      '       gbrain autopilot uninstall  → --uninstall\n' +
+      '       gbrain autopilot start      → (default daemon launch)\n\n' +
       'Self-maintaining brain daemon. Runs the full maintenance cycle\n' +
       '(lint + backlinks + sync + extract + embed + orphans) on an interval.\n\n' +
       'For a one-shot cron-triggered cycle, see `gbrain dream`.',
@@ -370,6 +469,16 @@ export async function runAutopilot(engine: BrainEngine, args: string[]) {
     return;
   }
 
+  // #1525: translate positional subcommands to their flag form BEFORE any
+  // side effect (lockfile, daemon spawn, sync dispatch). Unknown positionals
+  // fail loud here rather than silently starting the daemon.
+  const translated = translatePositionalSubcommands(args);
+  if (!translated.ok) {
+    console.error(translated.message);
+    process.exit(2);
+  }
+  args = translated.args;
+
   if (args.includes('--install')) {
     await installDaemon(engine, args);
     return;

src/commands/extract.ts

@@ -433,10 +433,7 @@ export async function extractLinksFromFile(
       async resolve(name: string, dirHint?: string | string[]): Promise<string | null> {
         if (!name) return null;
         const trimmed = name.trim();
-        // Same broadened slug-shape as makeResolver step 1: accepts
-        // digit-leading folders (`90-people/nicolai`) and nested paths.
-        // Exact Set membership guards it — no false positives.
-        if (/\//.test(trimmed) && /^[a-z0-9][a-z0-9/_-]*$/.test(trimmed) && allSlugs.has(trimmed)) {
+        if (/^[a-z][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/.test(trimmed) && allSlugs.has(trimmed)) {
           return trimmed;
         }
         const hints = Array.isArray(dirHint) ? dirHint : (dirHint ? [dirHint] : []);
@@ -585,17 +582,6 @@ export interface ExtractOpts {
    * before (single-'default'-source brains unaffected).
    */
   sourceId?: string;
-  /**
-   * v0.42 — also extract frontmatter links on the incremental (slugs) path.
-   * `extractForSlugs` extracts BODY links only by default; set this true to also
-   * parse each changed page's frontmatter so `sources:`/`related:` edges stay fresh
-   * when YAML is edited externally and synced in. Applied PER changed page, so the
-   * incremental walk stays bounded (no switch to a full DB scan). Only honored on
-   * the incremental path (`slugs` defined); the full-walk path already covers
-   * frontmatter via its own dispatch. Gated upstream by the config key
-   * `autopilot.incremental_extract_include_frontmatter` (default off).
-   */
-  includeFrontmatter?: boolean;
 }
 
 /**
@@ -634,7 +620,7 @@ export async function runExtractCore(engine: BrainEngine, opts: ExtractOpts): Pr
       // Nothing changed — skip entirely.
       return result;
     }
-    const r = await extractForSlugs(engine, opts.dir, opts.slugs, opts.mode, dryRun, jsonMode, workers, opts.signal, opts.sourceId, opts.includeFrontmatter);
+    const r = await extractForSlugs(engine, opts.dir, opts.slugs, opts.mode, dryRun, jsonMode, workers, opts.signal, opts.sourceId);
     result.links_created = r.links_created;
     result.timeline_entries_created = r.timeline_created;
     result.pages_processed = r.pages;
@@ -1025,11 +1011,6 @@ async function extractForSlugs(
   signal?: AbortSignal,
   // #1747/#1503: stamp resolved brain source id on batch rows (see ExtractOpts.sourceId).
   sourceId?: string,
-  // v0.42: when true, also extract frontmatter links per changed page so
-  // externally-edited YAML (`sources:`/`related:`) stays fresh on the cycle.
-  // Default false preserves the body-only incremental behavior. Gated upstream
-  // by `autopilot.incremental_extract_include_frontmatter`.
-  includeFrontmatter: boolean = false,
 ): Promise<{ links_created: number; timeline_created: number; pages: number }> {
   // Build the full slug set for link resolution (fast: just readdir, no file reads)
   const allFiles = walkMarkdownFiles(brainDir);
@@ -1104,7 +1085,7 @@ async function extractForSlugs(
         const content = readFileSync(fullPath, 'utf-8');
 
         if (doLinks) {
-          const links = await extractLinksFromFile(content, relPath, allSlugs, { globalBasename, includeFrontmatter });
+          const links = await extractLinksFromFile(content, relPath, allSlugs, { globalBasename });
           for (const link of links) {
             if (dryRun) {
               if (!jsonMode) console.log(`  ${link.from_slug} → ${link.to_slug} (${link.link_type})`);

src/core/config.ts

@@ -121,18 +121,6 @@ export interface GBrainConfig {
       /** Daily spend cap (USD); bounds drains/day = floor(cap / ~$0.30). Default 2.0. */
       max_usd_per_day?: number;
     };
-    /**
-     * v0.42 — keep frontmatter links fresh on the incremental cycle. The cycle's
-     * extract phase re-extracts only the slugs a sync changed, but `extractForSlugs`
-     * extracts BODY links only — frontmatter (`sources:`/`related:` etc.) link edges
-     * silently drift stale when a page's YAML is edited externally and synced in.
-     * Set true to also extract frontmatter links per changed page each cycle, keeping
-     * externally-edited YAML edges fresh without a full rescan. Default false
-     * (preserves current behavior). Read via the file/env/DB plane in the cycle's
-     * extract dispatch. Disable/enable with
-     * `gbrain config set autopilot.incremental_extract_include_frontmatter <bool>`.
-     */
-    incremental_extract_include_frontmatter?: boolean;
   };
   eval?: {
     /** false disables capture entirely. Defaults to true. */

src/core/cycle.ts

@@ -996,21 +996,6 @@ async function runPhaseExtract(
 ): Promise<PhaseResult> {
   try {
     const { runExtractCore } = await import('../commands/extract.ts');
-    const { loadConfig } = await import('./config.ts');
-    // Default off: the incremental cycle extracts body links only unless the
-    // operator opts in to keeping externally-edited frontmatter links fresh too.
-    // Both planes, file wins (env > file > DB precedence, per loadConfigWithEngine):
-    // `gbrain config set autopilot.incremental_extract_include_frontmatter true`
-    // writes the DB plane (engine.setConfig), so a file-plane-only read here
-    // would make the documented enable command a silent no-op (#2120 class).
-    const fileVal = loadConfig()?.autopilot?.incremental_extract_include_frontmatter;
-    let includeFrontmatter = fileVal === true;
-    if (fileVal === undefined) {
-      try {
-        includeFrontmatter =
-          (await engine.getConfig('autopilot.incremental_extract_include_frontmatter')) === 'true';
-      } catch { /* config table unreadable → default off */ }
-    }
     // Extract is read-mostly against the filesystem + write to links table.
     // Honor dryRun by skipping with a 'skipped' entry: extract doesn't have
     // a clean dry-run mode today and runCycle should be honest about it.
@@ -1031,7 +1016,6 @@ async function runPhaseExtract(
       slugs: changedSlugs,  // undefined = full walk (first run / manual)
       signal,
       sourceId,
-      includeFrontmatter,  // honored on the incremental (slugs) path only
     });
     const linksCreated = result?.links_created ?? 0;
     const timelineCreated = result?.timeline_entries_created ?? 0;

src/core/link-extraction.ts

@@ -942,17 +942,8 @@ export function makeResolver(
 
       const hints = Array.isArray(dirHint) ? dirHint : (dirHint ? [dirHint] : []);
 
-      // Step 1: already a slug? Try an exact page lookup for any slug-shaped
-      // value (contains '/', slug charset). Broadened beyond the original
-      // single-segment lowercase-leading form (`^[a-z][a-z0-9-]*\/[a-z0-9]...`)
-      // to also accept digit-leading folders (`90-people/nicolai`,
-      // `01-trading/...`) and nested paths (`a/b/c`) — common in PARA-numbered
-      // vaults. This is an EXACT getPage match only — no fuzzy — so it never
-      // produces a false positive; a non-existent slug just falls through to
-      // the steps below. Fixes frontmatter `related: [[dir/slug]]` values
-      // (unwrapped by unwrapWikilink) that name a real page the strict regex
-      // could not reach and whose full-path fuzzy score is below threshold.
-      if (/\//.test(trimmed) && /^[a-z0-9][a-z0-9/_-]*$/.test(trimmed)) {
+      // Step 1: already a slug? (dir/name shape, lowercase, hyphenated)
+      if (/^[a-z][a-z0-9-]*\/[a-z0-9][a-z0-9-]*$/.test(trimmed)) {
         const page = await engine.getPage(trimmed);
         if (page) {
           cache.set(cacheKey, trimmed);
@@ -1012,25 +1003,6 @@ export function makeResolver(
 
 // ─── Frontmatter extractor ──────────────────────────────────────
 
-/**
- * Unwrap an Obsidian `[[wikilink]]` frontmatter value to its bare link
- * target so the resolver (which expects bare titles / dir slugs) can match
- * it. Mainstream Obsidian authors frontmatter links as `related: ["[[Page]]"]`;
- * without this, the resolver treats the brackets as part of the value and a
- * `[[90-people/nicolai]]` is normalized into `90peoplenicolai`, so it never
- * resolves. Strips a trailing `|alias`, `#heading`, or `^block` suffix — the
- * link target only. The regex is anchored to a wholly-wrapped value
- * (`^\s*\[\[…\]\]\s*$`), so bare titles and any value not fully wrapped pass
- * through unchanged and existing behavior is preserved exactly.
- */
-export function unwrapWikilink(value: string): string {
-  const match = /^\s*\[\[(.+?)\]\]\s*$/.exec(value);
-  if (!match) return value;
-  // Take the link target: drop |alias, then #heading / ^block suffixes.
-  const target = match[1].split('|')[0].split('#')[0].split('^')[0];
-  return target.trim();
-}
-
 export interface UnresolvedFrontmatterRef {
   /** The frontmatter field name. */
   field: string;
@@ -1088,12 +1060,7 @@ export async function extractFrontmatterLinks(
         }
         if (!name) continue;   // skip numbers, nulls, malformed objects
 
-        // Accept Obsidian `[[wikilink]]` values in frontmatter link fields by
-        // unwrapping to the bare target before resolution. Bare titles pass
-        // through unchanged; the original `name` is preserved for the
-        // unresolved report and edge context.
-        const linkTarget = unwrapWikilink(name);
-        const resolved = await resolver.resolve(linkTarget, mapping.dirHint);
+        const resolved = await resolver.resolve(name, mapping.dirHint);
         if (!resolved) {
           unresolved.push({ field, name });
           continue;

test/autopilot-positional-subcommands.test.ts

@@ -0,0 +1,197 @@
+/**
+ * Tests for translatePositionalSubcommands() — the v0.41.x #1525 fix that
+ * prevents `gbrain autopilot status` from silently starting the daemon.
+ *
+ * IRON RULE regression guard: the exact ticket repro (`gbrain autopilot
+ * status`) MUST translate to `--status`, not fall through to the default
+ * daemon launch. Verified by the "ticket-exact repro" case below.
+ */
+
+import { describe, test, expect } from 'bun:test';
+import { translatePositionalSubcommands } from '../src/commands/autopilot.ts';
+
+describe('translatePositionalSubcommands — known aliases', () => {
+  test('IRON RULE — `autopilot status` translates to `--status` (ticket #1525 repro)', () => {
+    const r = translatePositionalSubcommands(['status']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['--status']);
+  });
+
+  test('`install` translates to `--install`', () => {
+    const r = translatePositionalSubcommands(['install']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['--install']);
+  });
+
+  test('`uninstall` translates to `--uninstall`', () => {
+    const r = translatePositionalSubcommands(['uninstall']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['--uninstall']);
+  });
+
+  test('`start` drops the positional (default daemon launch)', () => {
+    const r = translatePositionalSubcommands(['start']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual([]);
+  });
+
+  test('`start --json` drops only the positional, keeps the flag', () => {
+    const r = translatePositionalSubcommands(['start', '--json']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['--json']);
+  });
+});
+
+describe('translatePositionalSubcommands — flag/positional interleaving', () => {
+  test('`status --json` preserves the trailing flag', () => {
+    const r = translatePositionalSubcommands(['status', '--json']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['--status', '--json']);
+  });
+
+  test('`--json status` preserves the leading flag', () => {
+    const r = translatePositionalSubcommands(['--json', 'status']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['--json', '--status']);
+  });
+
+  test('`--repo /foo status` does not mis-classify the path as positional', () => {
+    const r = translatePositionalSubcommands(['--repo', '/foo', 'status']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['--repo', '/foo', '--status']);
+  });
+
+  test('`--interval 300 install` does not mis-classify the number as positional', () => {
+    const r = translatePositionalSubcommands(['--interval', '300', 'install']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['--interval', '300', '--install']);
+  });
+
+  test('`--install --target linux-cron` does not mis-classify the target as positional', () => {
+    // --target is installDaemon's value flag; its value must never be read
+    // as a positional subcommand (regression guard for the review fix).
+    const r = translatePositionalSubcommands(['--install', '--target', 'linux-cron']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['--install', '--target', 'linux-cron']);
+  });
+
+  test('`install --target macos` keeps the alias translation and the target value', () => {
+    const r = translatePositionalSubcommands(['install', '--target', 'macos']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['--install', '--target', 'macos']);
+  });
+
+  test('value-flag at end of argv with missing value passes through (so parseArg can report it)', () => {
+    const r = translatePositionalSubcommands(['--repo']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['--repo']);
+  });
+
+  test('value-flag whose value looks like an alias is NOT translated', () => {
+    // `--repo status` means "use repo path 'status'", not "show status".
+    // Translator must not destructure the value of --repo.
+    const r = translatePositionalSubcommands(['--repo', 'status']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['--repo', 'status']);
+  });
+});
+
+describe('translatePositionalSubcommands — pass-through cases', () => {
+  test('empty args returns empty args', () => {
+    const r = translatePositionalSubcommands([]);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual([]);
+  });
+
+  test('flag-only invocation passes through unchanged', () => {
+    const r = translatePositionalSubcommands(['--status', '--json']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['--status', '--json']);
+  });
+
+  test('short flag `-h` passes through unchanged', () => {
+    const r = translatePositionalSubcommands(['-h']);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(['-h']);
+  });
+
+  test('all known bare flags pass through unchanged', () => {
+    const flags = ['--help', '--install', '--uninstall', '--status', '--json', '--inline', '--no-worker'];
+    const r = translatePositionalSubcommands(flags);
+    expect(r.ok).toBe(true);
+    if (r.ok) expect(r.args).toEqual(flags);
+  });
+});
+
+describe('translatePositionalSubcommands — rejection of unknown positionals', () => {
+  test('unknown positional `foo` fails with reason=unknown_subcommand + structured message', () => {
+    const r = translatePositionalSubcommands(['foo']);
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      expect(r.reason).toBe('unknown_subcommand');
+      expect(r.message).toContain('Unknown subcommand: `foo`');
+      expect(r.message).toContain('status');
+      expect(r.message).toContain('install');
+      expect(r.message).toContain('uninstall');
+      expect(r.message).toContain('--help');
+    }
+  });
+
+  test('unknown positional `stop` fails with reason=unknown_subcommand (NOT silently aliased)', () => {
+    // Stop is mentioned in the ticket but deliberately NOT aliased in this
+    // PR — stopping a running daemon is a new behavior, not just an alias.
+    // Until that feature lands separately, `stop` must fail loud rather
+    // than starting the daemon (the bug we're fixing).
+    const r = translatePositionalSubcommands(['stop']);
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      expect(r.reason).toBe('unknown_subcommand');
+      expect(r.message).toContain('Unknown subcommand: `stop`');
+    }
+  });
+
+  test('unknown positional `status-detail` (close-but-not-matching) fails', () => {
+    const r = translatePositionalSubcommands(['status-detail']);
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      expect(r.reason).toBe('unknown_subcommand');
+      expect(r.message).toContain('Unknown subcommand: `status-detail`');
+    }
+  });
+
+  test('multiple positionals fail with reason=multiple_subcommands (`start install`)', () => {
+    const r = translatePositionalSubcommands(['start', 'install']);
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      expect(r.reason).toBe('multiple_subcommands');
+      expect(r.message).toContain('Multiple subcommands');
+    }
+  });
+
+  test('multiple positionals fail even when both are known aliases (`status install`)', () => {
+    const r = translatePositionalSubcommands(['status', 'install']);
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      expect(r.reason).toBe('multiple_subcommands');
+      expect(r.message).toContain('Multiple subcommands');
+    }
+  });
+
+  test('known-then-unknown rejects with multiple_subcommands (first-positional-wins)', () => {
+    // First positional is known, second is not. Rejection comes from the
+    // multiple-positional rule, which fires before the unknown check; the
+    // intent is "only one subcommand allowed."
+    const r = translatePositionalSubcommands(['status', 'garbage']);
+    expect(r.ok).toBe(false);
+    if (!r.ok) expect(r.reason).toBe('multiple_subcommands');
+  });
+
+  test('unknown-then-known rejects on the unknown (unknown fires before second-positional check)', () => {
+    const r = translatePositionalSubcommands(['garbage', 'status']);
+    expect(r.ok).toBe(false);
+    if (!r.ok) {
+      expect(r.reason).toBe('unknown_subcommand');
+      expect(r.message).toContain('garbage');
+    }
+  });
+});

test/extract-incremental.test.ts

@@ -191,37 +191,3 @@ describe('runExtractCore — incremental cycle path (#417)', () => {
     expect(result.links_created).toBeGreaterThan(0);
   });
 });
-describe('runExtractCore — incremental frontmatter gate (includeFrontmatter)', () => {
-  // alice has a `source:` frontmatter edge but NO body links. The incremental
-  // path extracts body links only by default, so the frontmatter edge is the
-  // sole signal that distinguishes the gate off vs on.
-  const aliceFm = '---\nsource: companies/acme-example\n---\n# alice';
-
-  test('9. default (flag omitted) does NOT extract frontmatter links on the incremental path', async () => {
-    await seedPage('companies/acme-example', '# acme');
-    await seedPage('people/alice-example', aliceFm);
-    const result = await runExtractCore(engine as unknown as BrainEngine, {
-      mode: 'all',
-      dir: tempDir,
-      slugs: ['people/alice-example'],
-    });
-    // alice's only potential edge is her frontmatter `source:`; with the gate off
-    // it must not be extracted (preserves the body-only incremental behavior).
-    expect(result.pages_processed).toBe(1);
-    expect(result.links_created).toBe(0);
-  });
-
-  test('10. includeFrontmatter: true extracts the frontmatter link on the incremental path', async () => {
-    await seedPage('companies/acme-example', '# acme');
-    await seedPage('people/alice-example', aliceFm);
-    const result = await runExtractCore(engine as unknown as BrainEngine, {
-      mode: 'all',
-      dir: tempDir,
-      slugs: ['people/alice-example'],
-      includeFrontmatter: true,
-    });
-    // Same page, gate on → the `source:` frontmatter edge is now extracted.
-    expect(result.pages_processed).toBe(1);
-    expect(result.links_created).toBeGreaterThan(0);
-  });
-});

test/extract.test.ts

@@ -76,18 +76,6 @@ describe('extractLinksFromFile', () => {
     }
   });
 
-  it('resolves wrapped [[wikilink]] digit-leading slug-path in frontmatter (fs resolver, broadened step 1)', async () => {
-    // Same bug class as makeResolver step 1 (#1983): the fs resolver's strict
-    // `^[a-z]…` slug regex rejected digit-leading / nested paths, so a PARA-vault
-    // `related: "[[90-people/nicolai]]"` never resolved even though the page exists.
-    const content = '---\nrelated: "[[90-people/nicolai]]"\ntype: concept\n---\nContent.';
-    const allSlugs = new Set(['wiki/note', '90-people/nicolai']);
-    const links = await extractLinksFromFile(content, 'wiki/note.md', allSlugs, { includeFrontmatter: true });
-    const related = links.filter(l => l.link_type === 'related_to');
-    expect(related).toHaveLength(1);
-    expect(related[0].to_slug).toBe('90-people/nicolai');
-  });
-
   it('frontmatter extraction is default OFF (back-compat)', async () => {
     // Without includeFrontmatter, fs-source no longer auto-extracts frontmatter.
     // Matches db-source behavior. User opts in with --include-frontmatter flag.

test/link-extraction.test.ts

@@ -9,7 +9,6 @@ import {
   parseTimelineEntries,
   isAutoLinkEnabled,
   FRONTMATTER_LINK_MAP,
-  unwrapWikilink,
   type SlugResolver,
 } from '../src/core/link-extraction.ts';
 import type { BrainEngine } from '../src/core/engine.ts';
@@ -1292,175 +1291,3 @@ describe('parseTimelineEntries — Format 3: inline [Source: ..., YYYY-MM-DD] ci
     expect(parseTimelineEntries('[Source: import batch, 2025-07-01]')).toHaveLength(0);
   });
 });
-// ─── Frontmatter [[wikilink]] + slug-path resolution ──────────────────────
-// Mainstream Obsidian authors frontmatter links as `related: ["[[Page]]"]`,
-// and PARA-numbered vaults use digit-leading / nested slug paths like
-// `[[90-people/nicolai]]`. Both were silently dropped: brackets were treated
-// as part of the value and the step-1 slug regex (`^[a-z]…`) rejected
-// digit-leading / nested paths, while full-path fuzzy scored below threshold.
-// Fix: unwrapWikilink() before resolution + an exact getPage() for any
-// slug-shaped value (exact-match only → no false positives).
-
-describe('unwrapWikilink', () => {
-  test('wrapped title → bare title', () => {
-    expect(unwrapWikilink('[[Monday Range]]')).toBe('Monday Range');
-  });
-  test('wrapped slug-path (digit-leading folder) → bare slug', () => {
-    expect(unwrapWikilink('[[90-people/nicolai]]')).toBe('90-people/nicolai');
-  });
-  test('wrapped nested slug-path → bare slug', () => {
-    expect(unwrapWikilink('[[01-trading/wiki/strategies/opening-range-breakout]]'))
-      .toBe('01-trading/wiki/strategies/opening-range-breakout');
-  });
-  test('strips |alias', () => {
-    expect(unwrapWikilink('[[90-people/nicolai|Nicolai]]')).toBe('90-people/nicolai');
-  });
-  test('strips #heading', () => {
-    expect(unwrapWikilink('[[Page#Section]]')).toBe('Page');
-  });
-  test('strips ^block', () => {
-    expect(unwrapWikilink('[[Page^abc123]]')).toBe('Page');
-  });
-  test('surrounding whitespace tolerated', () => {
-    expect(unwrapWikilink('  [[Page]]  ')).toBe('Page');
-  });
-  test('bare title passes through unchanged', () => {
-    expect(unwrapWikilink('Monday Range')).toBe('Monday Range');
-  });
-  test('bare slug passes through unchanged', () => {
-    expect(unwrapWikilink('90-people/nicolai')).toBe('90-people/nicolai');
-  });
-  test('partially-wrapped value is NOT unwrapped (anchored)', () => {
-    // Not a wholly-wrapped value → left intact so existing behavior is exact.
-    expect(unwrapWikilink('see [[Page]] for detail')).toBe('see [[Page]] for detail');
-  });
-});
-
-describe('makeResolver — slug-path exact getPage (step 1 broadened)', () => {
-  function fakeEngine(
-    slugs: string[],
-    fuzzyMap: Map<string, { slug: string; similarity: number }> = new Map(),
-  ): BrainEngine {
-    const lookup = new Set(slugs);
-    return {
-      async getPage(slug: string) { return lookup.has(slug) ? { slug } as any : null; },
-      async findByTitleFuzzy(name: string) { return fuzzyMap.get(name) ?? null; },
-      async searchKeyword() { return []; },
-    } as unknown as BrainEngine;
-  }
-
-  test('digit-leading folder slug resolves via exact getPage', async () => {
-    const r = makeResolver(fakeEngine(['90-people/nicolai']));
-    expect(await r.resolve('90-people/nicolai')).toBe('90-people/nicolai');
-  });
-
-  test('nested (>2 segment) slug resolves via exact getPage', async () => {
-    const r = makeResolver(fakeEngine(['01-trading/wiki/strategies/opening-range-breakout']));
-    expect(await r.resolve('01-trading/wiki/strategies/opening-range-breakout'))
-      .toBe('01-trading/wiki/strategies/opening-range-breakout');
-  });
-
-  test('regression: single-segment lowercase slug still resolves', async () => {
-    const r = makeResolver(fakeEngine(['people/pedro']));
-    expect(await r.resolve('people/pedro')).toBe('people/pedro');
-  });
-
-  test('exact-only: slug-shaped value with no matching page falls through (no false positive)', async () => {
-    // `90-people/ghost` is slug-shaped but absent → step-1 getPage misses,
-    // no fuzzy hit → null. Never invents an edge.
-    const r = makeResolver(fakeEngine(['90-people/nicolai']));
-    expect(await r.resolve('90-people/ghost')).toBeNull();
-  });
-
-  test('non-slug value still routes to fuzzy', async () => {
-    const r = makeResolver(fakeEngine(
-      ['01-trading/monday-range'],
-      new Map([['Monday Range', { slug: '01-trading/monday-range', similarity: 1 }]]),
-    ));
-    expect(await r.resolve('Monday Range')).toBe('01-trading/monday-range');
-  });
-});
-
-describe('extractFrontmatterLinks — [[wikilink]] related: values (end-to-end)', () => {
-  function fakeEngine(
-    slugs: string[],
-    fuzzyMap: Map<string, { slug: string; similarity: number }> = new Map(),
-  ): BrainEngine {
-    const lookup = new Set(slugs);
-    return {
-      async getPage(slug: string) { return lookup.has(slug) ? { slug } as any : null; },
-      async findByTitleFuzzy(name: string) { return fuzzyMap.get(name) ?? null; },
-      async searchKeyword() { return []; },
-    } as unknown as BrainEngine;
-  }
-
-  test('wrapped slug-path related: resolves (the core win)', async () => {
-    const resolver = makeResolver(fakeEngine(['90-people/nicolai']));
-    const { candidates, unresolved } = await extractFrontmatterLinks(
-      'wiki/originals/ideas/note', 'note' as never,
-      { related: '[[90-people/nicolai]]' }, resolver,
-    );
-    expect(unresolved).toHaveLength(0);
-    expect(candidates).toHaveLength(1);
-    expect(candidates[0]).toMatchObject({
-      fromSlug: 'wiki/originals/ideas/note',
-      targetSlug: '90-people/nicolai',
-      linkType: 'related_to',
-      linkSource: 'frontmatter',
-    });
-  });
-
-  test('wrapped nested slug-path related: resolves', async () => {
-    const resolver = makeResolver(fakeEngine(['01-trading/wiki/strategies/opening-range-breakout']));
-    const { candidates } = await extractFrontmatterLinks(
-      'wiki/note', 'note' as never,
-      { related: ['[[01-trading/wiki/strategies/opening-range-breakout]]'] }, resolver,
-    );
-    expect(candidates).toHaveLength(1);
-    expect(candidates[0].targetSlug).toBe('01-trading/wiki/strategies/opening-range-breakout');
-  });
-
-  test('wrapped value with |alias resolves to the target', async () => {
-    const resolver = makeResolver(fakeEngine(['90-people/nicolai']));
-    const { candidates } = await extractFrontmatterLinks(
-      'wiki/note', 'note' as never,
-      { related: '[[90-people/nicolai|Nicolai]]' }, resolver,
-    );
-    expect(candidates).toHaveLength(1);
-    expect(candidates[0].targetSlug).toBe('90-people/nicolai');
-  });
-
-  test('regression: bare slug related: still resolves', async () => {
-    const resolver = makeResolver(fakeEngine(['90-people/nicolai']));
-    const { candidates } = await extractFrontmatterLinks(
-      'wiki/note', 'note' as never,
-      { related: '90-people/nicolai' }, resolver,
-    );
-    expect(candidates).toHaveLength(1);
-    expect(candidates[0].targetSlug).toBe('90-people/nicolai');
-  });
-
-  test('regression: wrapped title resolves via fuzzy (brackets harmless)', async () => {
-    const resolver = makeResolver(fakeEngine(
-      ['01-trading/monday-range'],
-      new Map([['Monday Range', { slug: '01-trading/monday-range', similarity: 1 }]]),
-    ));
-    const { candidates } = await extractFrontmatterLinks(
-      'wiki/note', 'note' as never,
-      { related: '[[Monday Range]]' }, resolver,
-    );
-    expect(candidates).toHaveLength(1);
-    expect(candidates[0].targetSlug).toBe('01-trading/monday-range');
-  });
-
-  test('unknown wrapped slug → unresolved (no crash), original value preserved', async () => {
-    const resolver = makeResolver(fakeEngine(['90-people/nicolai']));
-    const { candidates, unresolved } = await extractFrontmatterLinks(
-      'wiki/note', 'note' as never,
-      { related: '[[99-archive/does-not-exist]]' }, resolver,
-    );
-    expect(candidates).toHaveLength(0);
-    expect(unresolved).toHaveLength(1);
-    expect(unresolved[0]).toEqual({ field: 'related', name: '[[99-archive/does-not-exist]]' });
-  });
-});