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/sync.ts

@@ -197,7 +197,7 @@ export interface SyncResult {
   /** Pages re-embedded during this sync's auto-embed step. 0 if --no-embed or skipped. */
   embedded: number;
   pagesAffected: string[];
-  failedFiles?: number; // count of per-file import/sync failures (Bug 9)
+  failedFiles?: number; // count of parse failures (Bug 9)
   /**
    * v0.41.13.0 partial-sync fields (only set when status === 'partial').
    *
@@ -3183,7 +3183,7 @@ async function performSyncInner(engine: BrainEngine, opts: SyncOpts): Promise<Sy
     await clearOpCheckpoint(engine, ckpt.target);
   };
 
-  // issue #1939 adversarial finding #1: a file that failed to import (open ledger
+  // issue #1939 adversarial finding #1: a file that failed to parse (open ledger
   // row) and is then deleted/renamed-away never re-enters failedFiles and never
   // imports, so its row would never clear and would age doctor to a permanent
   // FAIL. Treat removed paths as resolved so the ledger self-heals.
@@ -3215,9 +3215,9 @@ async function performSyncInner(engine: BrainEngine, opts: SyncOpts): Promise<Sy
     } else {
       const fileFailCount = failedFiles.filter(f => isSkippablePath(f.path)).length;
       serr(
-        `\nSync blocked: ${fileFailCount} file(s) failed to import:\n` +
+        `\nSync blocked: ${fileFailCount} file(s) failed to parse:\n` +
         `${codeBreakdown}\n\n` +
-        `Fix the listed file errors and re-run, or use 'gbrain sync --skip-failed' to ` +
+        `Fix the frontmatter and re-run, or use 'gbrain sync --skip-failed' to ` +
         `acknowledge and move on. A file that keeps failing auto-skips after ` +
         `${resolveAutoSkipThreshold()} consecutive syncs.`,
       );
@@ -5355,7 +5355,7 @@ function printSyncResult(result: SyncResult, sink: NodeJS.WriteStream = process.
     case 'dry_run':
       break; // already printed in performSync
     case 'blocked_by_failures':
-      write(`Sync BLOCKED at ${result.toCommit.slice(0, 8)}: ${result.failedFiles ?? 0} file(s) failed to import.`);
+      write(`Sync BLOCKED at ${result.toCommit.slice(0, 8)}: ${result.failedFiles ?? 0} file(s) failed to parse.`);
       write(`  See ~/.gbrain/sync-failures.jsonl for details, or run 'gbrain doctor'.`);
       write(`  Fix the files then re-run 'gbrain sync', or 'gbrain sync --skip-failed' to move on.`);
       break;

src/core/pglite-engine.ts

@@ -1058,16 +1058,6 @@ export class PGLiteEngine implements BrainEngine {
        RETURNING id, source_id, slug, type, title, compiled_truth, timeline, frontmatter, content_hash, created_at, updated_at, effective_date, effective_date_source, import_filename, source_kind, source_uri, ingested_via, ingested_at`,
       [sourceId, slug, page.type, pageKind, page.title, page.compiled_truth, page.timeline || '', JSON.stringify(frontmatter), hash, effectiveDate, effectiveDateSource, importFilename, chunkerVersion, sourcePath, sourceKind, sourceUri, ingestedVia, ingestedAt]
     );
-    // #2189: an INSERT … ON CONFLICT DO UPDATE … RETURNING that yields 0 rows
-    // (e.g. a BEFORE trigger suppressing the write) previously crashed in
-    // rowToPage with an opaque "undefined is not an object (row.deleted_at)".
-    // Throw a diagnosable error naming the row instead. Mirrors postgres-engine.ts.
-    if (!rows[0]) {
-      throw new Error(
-        `putPage: INSERT … RETURNING produced no row for slug='${slug}' source_id='${sourceId}'. ` +
-        `A trigger or rule on the pages table may be suppressing the write.`
-      );
-    }
     return rowToPage(rows[0] as Record<string, unknown>);
   }
 

src/core/postgres-engine.ts

@@ -1119,16 +1119,6 @@ export class PostgresEngine implements BrainEngine {
         ingested_at           = COALESCE(EXCLUDED.ingested_at,           pages.ingested_at)
       RETURNING id, source_id, slug, type, title, compiled_truth, timeline, frontmatter, content_hash, created_at, updated_at, effective_date, effective_date_source, import_filename, source_kind, source_uri, ingested_via, ingested_at
     `;
-    // #2189: an INSERT … ON CONFLICT DO UPDATE … RETURNING that yields 0 rows
-    // (e.g. a BEFORE trigger suppressing the write) previously crashed in
-    // rowToPage with an opaque "undefined is not an object (row.deleted_at)".
-    // Throw a diagnosable error naming the row instead. Mirrors pglite-engine.ts.
-    if (!rows[0]) {
-      throw new Error(
-        `putPage: INSERT … RETURNING produced no row for slug='${slug}' source_id='${sourceId}'. ` +
-        `A trigger or rule on the pages table may be suppressing the write.`
-      );
-    }
     return rowToPage(rows[0]);
   }
 

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/putpage-returning-guard.test.ts

@@ -1,74 +0,0 @@
-// #2189 regression guard: putPage's INSERT … ON CONFLICT DO UPDATE … RETURNING
-// can yield 0 rows when brain-local DB state (e.g. a BEFORE INSERT trigger)
-// suppresses the write. Pre-fix, rowToPage(rows[0]) crashed with the opaque
-// "undefined is not an object (evaluating 'row.deleted_at')" that failed
-// ~all files of a code sync. Post-fix, putPage throws a descriptive error
-// naming the slug + source_id so the failure is diagnosable per-file.
-//
-// Same guard lands in postgres-engine.ts (engine-parity invariant); this test
-// exercises the PGLite side, where the issue was reported.
-
-import { describe, expect, test, beforeAll, afterAll } from 'bun:test';
-import { PGLiteEngine } from '../src/core/pglite-engine.ts';
-
-let engine: PGLiteEngine;
-
-beforeAll(async () => {
-  engine = new PGLiteEngine();
-  await engine.connect({});
-  await engine.initSchema();
-  // Simulate the reporter's state-dependent failure: a trigger that
-  // suppresses inserts for one slug, making RETURNING produce no row.
-  await engine.executeRaw(`
-    CREATE OR REPLACE FUNCTION suppress_pages_insert() RETURNS trigger AS $$
-    BEGIN
-      IF NEW.slug = 'suppressed-page' THEN RETURN NULL; END IF;
-      RETURN NEW;
-    END;
-    $$ LANGUAGE plpgsql;
-  `);
-  await engine.executeRaw(`
-    CREATE TRIGGER suppress_pages_insert_trg
-    BEFORE INSERT ON pages
-    FOR EACH ROW EXECUTE FUNCTION suppress_pages_insert();
-  `);
-});
-
-afterAll(async () => {
-  await engine.executeRaw('DROP TRIGGER IF EXISTS suppress_pages_insert_trg ON pages');
-  await engine.executeRaw('DROP FUNCTION IF EXISTS suppress_pages_insert');
-  await engine.disconnect();
-});
-
-describe('putPage RETURNING guard (#2189)', () => {
-  test('0-row RETURNING throws a descriptive error, not row.deleted_at TypeError', async () => {
-    let err: Error | undefined;
-    try {
-      await engine.putPage('suppressed-page', {
-        type: 'code',
-        title: 'Suppressed',
-        compiled_truth: 'x',
-        timeline: '',
-      });
-    } catch (e) {
-      err = e as Error;
-    }
-    expect(err).toBeDefined();
-    expect(err!.message).toContain('putPage');
-    expect(err!.message).toContain("slug='suppressed-page'");
-    expect(err!.message).toContain("source_id='default'");
-    // The pre-fix crash signature must be gone.
-    expect(err!.message).not.toContain('deleted_at');
-  });
-
-  test('unsuppressed slugs still upsert normally with the trigger installed', async () => {
-    const page = await engine.putPage('normal-page', {
-      type: 'concept',
-      title: 'Normal',
-      compiled_truth: 'y',
-      timeline: '',
-    });
-    expect(page.slug).toBe('normal-page');
-    expect(page.source_id).toBe('default');
-  });
-});

test/sync.test.ts

@@ -375,31 +375,6 @@ describe('performSync dry-run never writes', () => {
     expect(messages.some(m => m.includes('git pull failed'))).toBe(false);
   });
 
-  test('first PGLite code sync imports code files without runtime failures', async () => {
-    const { performSync } = await import('../src/commands/sync.ts');
-    mkdirSync(join(repoPath, 'src'), { recursive: true });
-    writeFileSync(
-      join(repoPath, 'src/example.ts'),
-      'export function add(left: number, right: number) { return left + right; }\n',
-    );
-    execSync('git add -A && git commit -m "add code file"', { cwd: repoPath, stdio: 'pipe' });
-
-    const result = await performSync(engine, {
-      repoPath,
-      noPull: true,
-      noEmbed: true,
-      noExtract: true,
-      strategy: 'code',
-    });
-
-    expect(result.status).toBe('first_sync');
-    expect(result.added).toBe(1);
-    expect(result.failedFiles ?? 0).toBe(0);
-    const page = await engine.getPage('src-example-ts');
-    expect(page?.type).toBe('code');
-    expect(page?.frontmatter).toMatchObject({ file: 'src/example.ts', language: 'typescript' });
-  });
-
   test('incremental dry-run does NOT write to DB or advance the bookmark', async () => {
     const { performSync } = await import('../src/commands/sync.ts');
     // First do a real sync to seed the bookmark.