fix(memory-ingest): stop silently ingesting 0 pages — include gitignored staging, reconcile counts

Pages stage into ~/.gstack/.staging-ingest-*/ inside a repo whose .gitignore
is `*`, and gbrain import honours .gitignore — so it collected 0 files,
imported nothing, and the ingest still reported "written: N" from the STAGED
count while advancing state, meaning no future run ever retried. Three
layers now: (1) pass --include-gitignored (root cause); (2) if the installed
gbrain predates the flag, retry without it (subcommand --help is generic, so
the attempt is the only probe) with an upgrade pointer; (3) reconcile
gbrain's imported+unchanged accounting against the staged count and REFUSE
to advance state on a shortfall, naming the gitignore collision.

Fixes #2144, #2104.

Contributed by @gawievanblerk (PR #2560) and @Charles-Grant (PR #2486).

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

test/gstack-memory-ingest.test.ts

@@ -330,7 +330,7 @@ describe("gstack-memory-ingest --limit", () => {
  */
 function installFakeGbrain(
   home: string,
-  opts: { failingPaths?: string[] } = {},
+  opts: { failingPaths?: string[]; collectNothing?: boolean } = {},
 ): { binDir: string; logFile: string; argsFile: string; stagingListFile: string } {
   const binDir = join(home, "fake-bin");
   mkdirSync(binDir, { recursive: true });
@@ -392,6 +392,13 @@ EOF
     else
       TOTAL=0
     fi
+    # collectNothing: simulate gbrain walking the staging dir and finding
+    # nothing — the real-world shape when .gitignore hides every staged file
+    # from collect_files. Crucially this writes NO sync-failures.jsonl entry,
+    # because there is no per-file failure: gbrain never saw the files.
+    if [ "${opts.collectNothing ? "1" : "0"}" = "1" ]; then
+      TOTAL=0
+    fi
     ERRORS=0
     if [ -n "\$FAILING_LIST" ]; then
       ERRORS=\$(echo "\$FAILING_LIST" | tr '|' '\\n' | wc -l | tr -d ' ')
@@ -470,6 +477,51 @@ describe("gstack-memory-ingest writer (gbrain v0.20+ batch `import` interface)",
     expect(stagedList).toMatch(/^\.\/transcripts\/claude-code\/.+\.md$/m);
   });
 
+  // Silent-data-loss regression: gbrain accepts the import call, exits 0, and
+  // reports imported=0 because collect_files found nothing in the staging dir
+  // (real-world cause: gstack-artifacts-init writes `.gitignore = "*"` into
+  // $GSTACK_HOME, and `gbrain import` honours .gitignore, so every file staged
+  // under $GSTACK_HOME is invisible to it).
+  //
+  // No per-file failure is written to sync-failures.jsonl — gbrain never SAW
+  // the files — so readNewFailures returns empty. Before the reconciliation
+  // check, that made a total loss indistinguishable from success: every
+  // prepared file got state-recorded as ingested and the pass reported
+  // "N written". State then said "done", so no later run ever retried.
+  it("refuses to advance state when gbrain imports fewer pages than were staged", () => {
+    const home = makeTestHome();
+    const gstackHome = join(home, ".gstack");
+    mkdirSync(gstackHome, { recursive: true });
+    const { binDir, logFile } = installFakeGbrain(home, { collectNothing: true });
+
+    const session =
+      `{"type":"user","message":{"role":"user","content":"hi"},"timestamp":"2026-05-01T00:00:00Z","cwd":"/tmp/foo"}\n` +
+      `{"type":"assistant","message":{"role":"assistant","content":"hello"},"timestamp":"2026-05-01T00:00:01Z"}\n`;
+    writeClaudeCodeSession(home, "tmp-foo", "abc123", session);
+
+    const r = runScript(["--bulk", "--include-unattributed", "--quiet"], {
+      HOME: home,
+      GSTACK_HOME: gstackHome,
+      PATH: `${binDir}:${process.env.PATH || ""}`,
+    });
+
+    // gbrain WAS called — this is not a "gbrain missing" path.
+    expect(existsSync(logFile)).toBe(true);
+
+    // The pass must not claim success.
+    expect(r.stderr).toMatch(/\[memory-ingest\] ERR:.*accounted for 0 of 1 staged page/);
+    expect(r.stderr).toMatch(/Refusing to advance state/);
+    expect(r.stdout).not.toMatch(/written:\s+1/);
+
+    // The critical assertion: state must NOT mark the session ingested, or the
+    // next run skips it forever and the transcript is lost silently.
+    const statePath = join(gstackHome, ".transcript-ingest-state.json");
+    if (existsSync(statePath)) {
+      const state = JSON.parse(readFileSync(statePath, "utf-8"));
+      expect(Object.keys(state.sessions || {}).length).toBe(0);
+    }
+  });
+
   // Originally landed in v1.32.0.0 (PR #1411) on the per-file `gbrain put`
   // path. Postgres rejects 0x00 in UTF-8 text columns. Some Claude Code
   // transcripts contain NUL inside user-pasted content or tool output. The

test/memory-ingest-include-gitignored.test.ts

@@ -0,0 +1,79 @@
+/**
+ * Regression pin: `gstack-memory-ingest` must pass `--include-gitignored` to
+ * `gbrain import`.
+ *
+ * gstack-artifacts-init writes an ignore-everything `.gitignore` (a bare `*`,
+ * headed "Do not edit") at the root of `~/.gstack`. The memory ingest stages
+ * pages into `~/.gstack/.staging-ingest-<pid>-<ts>/`, which is INSIDE that
+ * repo, and gbrain's markdown collector honours .gitignore. So the collector
+ * walks the staging dir, matches every file against `*`, and collects zero.
+ *
+ * The failure is silent: `gbrain import` exits 0 having imported nothing,
+ * while the ingest still prints `written: N` from the STAGED count rather
+ * than the imported count. A run that indexes nothing is indistinguishable
+ * from a healthy one, and the memory corpus quietly stops growing.
+ *
+ * Two tests here:
+ *  1. Source pin (same shape as memory-ingest-no-put_page.test.ts): the flag
+ *     is present in active code, so removing it trips the build.
+ *  2. Behavioural proof of the underlying collision, using git's own ignore
+ *     machinery. No gbrain and no network required.
+ */
+
+import { describe, it, expect } from "bun:test";
+import { execFileSync } from "child_process";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { readFileSync } from "fs";
+
+const SOURCE_PATH = join(import.meta.dir, "..", "bin", "gstack-memory-ingest.ts");
+
+/** Strip comments so the pin only inspects executable code. */
+function stripComments(src: string): string {
+  const noBlock = src.replace(/\/\*[\s\S]*?\*\//g, "");
+  return noBlock.replace(/\/\/[^\n]*/g, "");
+}
+
+describe("gstack-memory-ingest: gbrain import must not be filtered by .gitignore", () => {
+  it("passes --include-gitignored in active code", () => {
+    const stripped = stripComments(readFileSync(SOURCE_PATH, "utf-8"));
+    expect(stripped).toContain("--include-gitignored");
+  });
+
+  it("keeps the flag on the same import invocation as the staging dir", () => {
+    const stripped = stripComments(readFileSync(SOURCE_PATH, "utf-8"));
+    // Match the spawn call's argument array and assert both the subcommand
+    // and the flag live in it, so the flag can't drift onto another call.
+    const call = stripped.match(/spawnGbrainAsync\(\s*\[[^\]]*"import"[^\]]*\]/s);
+    expect(call).not.toBeNull();
+    expect(call![0]).toContain("--include-gitignored");
+  });
+
+  it("demonstrates the collision: an ignore-everything root hides staged pages", () => {
+    const dir = mkdtempSync(join(tmpdir(), "gstack-ingest-gitignore-"));
+    try {
+      const git = (...args: string[]) =>
+        execFileSync("git", args, { cwd: dir, encoding: "utf-8" });
+      git("init", "-q", ".");
+
+      const staging = join(dir, ".staging-ingest-12345-1700000000000", "learnings");
+      mkdirSync(staging, { recursive: true });
+      writeFileSync(join(staging, "page.md"), "# a staged page\n", "utf-8");
+
+      // Exactly what gstack-artifacts-init writes at the root of ~/.gstack.
+      writeFileSync(join(dir, ".gitignore"), "*\n", "utf-8");
+
+      // `git ls-files --others --exclude-standard` is the same view a
+      // gitignore-honouring collector takes: untracked and not ignored.
+      const collectable = git("ls-files", "--others", "--exclude-standard")
+        .split("\n")
+        .filter(Boolean);
+
+      // The staged page is invisible. This is the silent data loss.
+      expect(collectable).toHaveLength(0);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});