@selesai/code 0.8.3 → 0.8.4

package/dist/extensions/pi-powerline-footer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-powerline-footer",
-  "version": "0.12.3",
+  "version": "0.13.0",
   "description": "Powerline-style status bar extension for pi coding agent",
   "type": "module",
   "files": [

package/dist/extensions/pi-powerline-footer/powerline-config.ts

@@ -17,7 +17,6 @@ export interface PowerlineConfig {
   invalidPlacement: string | null;
   welcome: boolean;
   stashSharpSShortcut: boolean;
-  queue: { captureSigil: string | false };
 }
 
 function isRecord(value: unknown): value is Record<string, unknown> {
@@ -89,12 +88,6 @@ function normalizeCustomPrefix(value: unknown): string | undefined {
   return normalized ? normalized : undefined;
 }
 
-function normalizeCaptureSigil(value: unknown): string | false {
-  if (value === false) return false;
-  if (typeof value !== "string") return "#";
-  const normalized = value.trim();
-  return normalized && !/\s/.test(normalized) ? normalized : "#";
-}
 
 function normalizeCustomStatusItem(raw: unknown, idOverride?: string): CustomStatusItem | null {
   if (!isRecord(raw)) return null;
@@ -314,7 +307,6 @@ export function parsePowerlineConfig(value: unknown, presets: readonly StatusLin
     invalidPlacement: null,
     welcome: true,
     stashSharpSShortcut: false,
-    queue: { captureSigil: "#" },
   };
 
   const directPreset = normalizePreset(value, presets);
@@ -326,9 +318,6 @@ export function parsePowerlineConfig(value: unknown, presets: readonly StatusLin
   const { disabledSegments, invalidDisabledSegments } = normalizeDisabledSegments(value.disabledSegments, customItems);
   const { layout, invalidLayoutSegments } = normalizeLayout(value.layout, customItems);
   const { placement, invalidPlacement } = normalizePlacement(value.placement);
-  const queue = isRecord(value.queue)
-    ? { captureSigil: normalizeCaptureSigil(value.queue.captureSigil) }
-    : defaultConfig.queue;
 
   return {
     preset: normalizePreset(value.preset, presets) ?? defaultConfig.preset,
@@ -344,7 +333,6 @@ export function parsePowerlineConfig(value: unknown, presets: readonly StatusLin
     invalidPlacement,
     welcome: value.welcome !== false,
     stashSharpSShortcut: value.stashSharpSShortcut === true,
-    queue,
   };
 }
 

package/dist/extensions/pi-powerline-footer/queue/store.ts

@@ -46,7 +46,7 @@ function normalizeTarget(value: unknown): QueueTarget | null {
 }
 
 function normalizeIntent(value: unknown): QueueIntent | null {
-  return value === "steer" || value === "follow-up" || value === "post-compact" || value === "idea"
+  return value === "steer" || value === "follow-up" || value === "post-compact"
     ? value
     : null;
 }
@@ -189,23 +189,18 @@ export class PowerlineQueueStore {
   }
 
   queuedDeliveryItems(context: QueueContext, intent?: QueueIntent): PowerlineQueueItem[] {
-    return this.activeItems(context).filter((item) => {
-      if (item.status !== "queued") return false;
-      if (item.intent === "idea") return false;
-      return intent ? item.intent === intent : true;
-    });
+    return this.activeItems(context).filter((item) => (
+      item.status === "queued" && (intent ? item.intent === intent : true)
+    ));
   }
 
   summarize(context: QueueContext, compacting: boolean): QueueSummary {
-    const active = this.activeItems(context);
-    const queueItems = active.filter((item) => item.intent !== "idea");
-    const ideaItems = active.filter((item) => item.intent === "idea");
-    const blockedItems = active.filter((item) => item.status === "blocked" || item.status === "failed");
-    const leading = [...blockedItems, ...queueItems, ...ideaItems][0] ?? null;
+    const queueItems = this.activeItems(context);
+    const blockedItems = queueItems.filter((item) => item.status === "blocked" || item.status === "failed");
+    const leading = [...blockedItems, ...queueItems][0] ?? null;
 
     return {
       queueCount: queueItems.length,
-      ideaCount: ideaItems.length,
       blockedCount: blockedItems.length,
       compacting,
       leadingText: leading?.text ?? null,
@@ -304,51 +299,8 @@ export function isActiveForContext(item: PowerlineQueueItem, context: QueueConte
   return item.source.cwd === currentCwd;
 }
 
-export function targetForIdea(rawTarget: string | null, store: PowerlineQueueStore, cwd: string): QueueTarget {
-  if (!rawTarget) return { kind: "project", cwd: normalizeCwd(cwd) };
-  if (rawTarget === "current") return { kind: "current-session" };
-  if (rawTarget === "global") return { kind: "global" };
-
-  const aliasCwd = store.resolveAlias(rawTarget);
-  if (!aliasCwd) {
-    throw new Error(`Unknown project alias @${rawTarget}. Use /queue alias ${rawTarget} <path> first.`);
-  }
-  return { kind: "project", cwd: aliasCwd, alias: rawTarget };
-}
-
-export function parseTargetPrefix(text: string): { target: string | null; text: string } {
-  const trimmed = text.trim();
-  const match = /^@([a-zA-Z0-9_-]+)(?:\s+|$)/.exec(trimmed);
-  if (!match) return { target: null, text: trimmed };
-  return { target: match[1], text: trimmed.slice(match[0].length).trim() };
-}
-
-export function parseSigilIdeaCapture(text: string, sigil: string | false): { target: string | null; text: string } | null {
-  if (sigil === false) return null;
-  const normalizedSigil = sigil.trim();
-  if (!normalizedSigil) return null;
-
-  const trimmed = text.trim();
-  if (!trimmed.startsWith(normalizedSigil)) return null;
-
-  const afterSigil = trimmed.slice(normalizedSigil.length);
-  if (!/^\s/.test(afterSigil)) return null;
-
-  const parsed = parseTargetPrefix(afterSigil.trim());
-  return parsed.text ? parsed : null;
-}
-
 export function formatQueueDeliveryText(item: PowerlineQueueItem): string {
-  if (item.intent !== "idea") return item.text;
-  return `[powerline idea ${item.id}, captured ${new Date(item.createdAt).toISOString()} from ${item.source.cwd}]\n${item.text}`;
-}
-
-export function formatIdeaIssuePrompt(item: PowerlineQueueItem): string {
-  const target = item.target.kind === "project"
-    ? `project ${item.target.alias ? `@${item.target.alias} ` : ""}${item.target.cwd}`
-    : item.target.kind;
-
-  return `Please process this saved Powerline idea as a GitHub issue candidate.\n\n${formatQueueDeliveryText(item)}\n\nIssue filing rules:\n- If subagents are available, spawn one low-budget issue-filing lane for this idea; otherwise do the same checks directly.\n- First identify the target repository from the idea target (${target}), source cwd (${item.source.cwd}), and current session context.\n- If the target repository is unclear or is not owned/controlled by the user, ask before filing anything.\n- If the target repository is clear and owned/controlled by the user, dedupe against existing open issues first.\n- If a matching open issue already exists, report it and do not create another issue.\n- If no matching issue exists, create one self-contained GitHub issue in that repository with a clear title, context, acceptance criteria, and the Powerline idea provenance above.\n- Use explicit repository targeting for GitHub commands and do not change source files for this handoff.`;
+  return item.text;
 }
 
 export function parseCompactQueuedPrompt(text: string): string | null {

package/dist/extensions/pi-powerline-footer/queue/types.ts

@@ -1,4 +1,4 @@
-export type QueueIntent = "steer" | "follow-up" | "post-compact" | "idea";
+export type QueueIntent = "steer" | "follow-up" | "post-compact";
 export type QueueStatus = "queued" | "blocked" | "delivering" | "sent" | "failed";
 
 export type QueueTarget =
@@ -29,7 +29,6 @@ export interface QueueAliasMap {
 
 export interface QueueSummary {
   queueCount: number;
-  ideaCount: number;
   blockedCount: number;
   compacting: boolean;
   leadingText: string | null;

package/dist/extensions/pi-powerline-footer/segments.ts

@@ -257,9 +257,6 @@ const queueSegment: StatusLineSegment = {
       parts.push(`q ${summary.queueCount}`);
     }
 
-    if (summary.ideaCount > 0) {
-      parts.push(`ideas ${summary.ideaCount}`);
-    }
 
     if (summary.blockedCount > 0) {
       parts.push(`blocked ${summary.blockedCount}`);

package/dist/extensions/pi-powerline-footer/tests/bash-mode.test.ts

@@ -865,6 +865,9 @@ test("bash editor refreshGhostSuggestion reuses the ghost scheduling path", asyn
     let scheduled = false;
 
     getMethod(BashModeEditor.prototype, "refreshGhostSuggestion").call({
+      areCompletionsEnabled() {
+        return true;
+      },
       scheduleGhostUpdate() {
         scheduled = true;
       },
@@ -876,6 +879,232 @@ test("bash editor refreshGhostSuggestion reuses the ghost scheduling path", asyn
   }
 });
 
+test("bash editor refreshGhostSuggestion clears ghosts when completions are disabled", async () => {
+  const links = ensureEditorModuleLinks();
+
+  try {
+    const { BashModeEditor } = await import("../bash-mode/editor.ts");
+    let cleared = false;
+    let scheduled = false;
+
+    getMethod(BashModeEditor.prototype, "refreshGhostSuggestion").call({
+      areCompletionsEnabled() {
+        return false;
+      },
+      clearGhostSuggestion() {
+        cleared = true;
+      },
+      scheduleGhostUpdate() {
+        scheduled = true;
+      },
+    });
+
+    assert.equal(cleared, true);
+    assert.equal(scheduled, false);
+  } finally {
+    links.cleanup();
+  }
+});
+
+test("bash editor hot path avoids full expansion and coalesces ghost work", async () => {
+  const links = ensureEditorModuleLinks();
+
+  try {
+    const { BashModeEditor } = await import("../bash-mode/editor.ts");
+    const { KeybindingsManager } = await import(new URL("../node_modules/@earendil-works/pi-coding-agent/dist/core/keybindings.js", import.meta.url).href);
+    const keybindings = KeybindingsManager.create();
+    const resolved: string[] = [];
+    let bashModeActive = false;
+    const editor = new BashModeEditor(
+      { requestRender() {}, terminal: { columns: 80, rows: 24 } },
+      { borderColor: (text: string) => text },
+      keybindings,
+      {
+        keybindings,
+        isBashModeActive: () => bashModeActive,
+        isShellRunning: () => false,
+        onExitBashMode() {},
+        onSubmitCommand() {},
+        onInterrupt() {},
+        onNotify() {},
+        getHistoryEntries: () => [],
+        resolveGhostSuggestion: async (text) => {
+          resolved.push(text);
+          return null;
+        },
+      },
+    );
+
+    (editor as { getExpandedText(): string }).getExpandedText = () => {
+      throw new Error("expanded text should not be read while typing");
+    };
+    const insertCharacter = Reflect.get(editor, "insertCharacter").bind(editor);
+    let fastInserts = 0;
+    Reflect.set(editor, "insertCharacter", (character: string) => {
+      fastInserts += 1;
+      insertCharacter(character);
+    });
+
+    for (const character of ["a", "A", ".", "漢", "🙂"]) editor.handleInput(character);
+    assert.equal(editor.getText(), "aA.漢🙂");
+    assert.equal(fastInserts, 5);
+    editor.onExtensionShortcut = (data) => data === "b";
+    editor.handleInput("b");
+    assert.equal(editor.getText(), "aA.漢🙂");
+    assert.equal(fastInserts, 5);
+    editor.onExtensionShortcut = undefined;
+    editor.render(80);
+
+    bashModeActive = true;
+    editor.setText("");
+    editor.handleInput("g");
+    editor.handleInput("i");
+    editor.handleInput("t");
+    assert.deepEqual(resolved, []);
+    await new Promise((resolve) => setTimeout(resolve, 75));
+    assert.deepEqual(resolved, ["git"]);
+    editor.clearGhostSuggestion();
+
+  } finally {
+    links.cleanup();
+  }
+});
+
+test("bash editor long ASCII backspace keeps undo without scanning the full line", async () => {
+  const links = ensureEditorModuleLinks();
+
+  try {
+    const { BashModeEditor } = await import("../bash-mode/editor.ts");
+    const { KeybindingsManager } = await import(new URL("../node_modules/@earendil-works/pi-coding-agent/dist/core/keybindings.js", import.meta.url).href);
+    const keybindings = KeybindingsManager.create();
+    const editor = new BashModeEditor(
+      { requestRender() {}, terminal: { columns: 80, rows: 24 } },
+      { borderColor: (text: string) => text },
+      keybindings,
+      {
+        keybindings,
+        isBashModeActive: () => false,
+        isShellRunning: () => false,
+        onExitBashMode() {},
+        onSubmitCommand() {},
+        onInterrupt() {},
+        onNotify() {},
+        getHistoryEntries: () => [],
+        resolveGhostSuggestion: async () => null,
+      },
+    );
+    const original = "x".repeat(5000);
+    editor.setText(original);
+    Reflect.get(editor, "undoStack").clear();
+    const segment = Reflect.get(editor, "segment").bind(editor);
+    Reflect.set(editor, "segment", () => {
+      throw new Error("long ASCII backspace must not segment the full line");
+    });
+
+    editor.handleInput("\x7f");
+    assert.equal(editor.getText(), original.slice(0, -1));
+
+    editor.handleInput("\x1b[122;9u");
+    assert.equal(editor.getText(), original);
+
+    Reflect.set(editor, "segment", segment);
+    editor.setText(`${"x".repeat(4998)}\u0600a`);
+    editor.handleInput("\x7f");
+    assert.equal(editor.getText(), "x".repeat(4998));
+  } finally {
+    links.cleanup();
+  }
+});
+
+test("bash editor long ASCII backspace preserves custom app bindings by input sequence", async () => {
+  const links = ensureEditorModuleLinks();
+
+  try {
+    const { BashModeEditor } = await import("../bash-mode/editor.ts");
+    const { KeybindingsManager } = await import(new URL("../node_modules/@earendil-works/pi-coding-agent/dist/core/keybindings.js", import.meta.url).href);
+    const keybindings = new KeybindingsManager({ "app.clear": "ctrl+h" });
+    const editor = new BashModeEditor(
+      { requestRender() {}, terminal: { columns: 80, rows: 24 } },
+      { borderColor: (text: string) => text },
+      keybindings,
+      {
+        keybindings,
+        isBashModeActive: () => false,
+        isShellRunning: () => false,
+        onExitBashMode() {},
+        onSubmitCommand() {},
+        onInterrupt() {},
+        onNotify() {},
+        getHistoryEntries: () => [],
+        resolveGhostSuggestion: async () => null,
+      },
+    );
+    let cleared = false;
+    editor.onAction("app.clear", () => {
+      cleared = true;
+    });
+    const original = "x".repeat(5000);
+    editor.setText(original);
+
+    editor.handleInput("\x7f");
+    assert.equal(editor.getText(), original.slice(0, -1));
+    assert.equal(cleared, false);
+
+    editor.handleInput("\x08");
+    assert.equal(cleared, true);
+    assert.equal(editor.getText(), original.slice(0, -1));
+  } finally {
+    links.cleanup();
+  }
+});
+
+test("bash editor fast path preserves plain custom keybindings", async () => {
+  const links = ensureEditorModuleLinks();
+
+  try {
+    const { BashModeEditor } = await import("../bash-mode/editor.ts");
+    const { KeybindingsManager } = await import(new URL("../node_modules/@earendil-works/pi-coding-agent/dist/core/keybindings.js", import.meta.url).href);
+    const { getKeybindings, setKeybindings } = await import(new URL("../node_modules/@earendil-works/pi-tui/dist/index.js", import.meta.url).href);
+    const previousKeybindings = getKeybindings();
+    const keybindings = new KeybindingsManager({ "tui.editor.cursorLeft": "a" });
+
+    try {
+      setKeybindings(keybindings);
+      const editor = new BashModeEditor(
+        { requestRender() {}, terminal: { columns: 80, rows: 24 } },
+        { borderColor: (text: string) => text },
+        keybindings,
+        {
+          keybindings,
+          isBashModeActive: () => false,
+          isShellRunning: () => false,
+          onExitBashMode() {},
+          onSubmitCommand() {},
+          onInterrupt() {},
+          onNotify() {},
+          getHistoryEntries: () => [],
+          resolveGhostSuggestion: async () => null,
+        },
+      );
+
+      editor.setText("x");
+      editor.handleInput("a");
+      assert.equal(editor.getText(), "x");
+      assert.deepEqual(editor.getCursor(), { line: 0, col: 0 });
+
+      keybindings.setUserBindings({ "tui.editor.cursorLeft": "shift+a" });
+      Reflect.set(editor, "plainBoundInputs", null);
+      editor.handleInput("A");
+      assert.equal(editor.getText(), "x");
+      assert.deepEqual(editor.getCursor(), { line: 0, col: 0 });
+    } finally {
+      setKeybindings(previousKeybindings);
+    }
+  } finally {
+    links.cleanup();
+  }
+});
+
 test("bash editor dismiss clears autocomplete when mode turns off", async () => {
   const links = ensureEditorModuleLinks();
 
@@ -1332,6 +1561,7 @@ test("bash editor command-z resets shell history and updates ghost state", async
     Reflect.set(shellEditor, "shellHistoryItems", ["git status"]);
     Reflect.set(shellEditor, "shellHistoryDraft", "git");
     shellEditor.handleInput("\x1b[122;9u");
+    await new Promise((resolve) => setTimeout(resolve, 75));
 
     assert.equal(shellEditor.getText(), "a");
     assert.equal(Reflect.get(shellEditor, "shellHistoryIndex"), -1);
@@ -1602,7 +1832,7 @@ test("bash editor does not accept a hidden ghost suggestion when the cursor is n
     const { BashModeEditor } = await import("../bash-mode/editor.ts");
     const accepted = getMethod(BashModeEditor.prototype, "acceptGhostSuggestion").call({
       ghost: { value: "git status", source: "project-history" },
-      getExpandedText() {
+      getText() {
         return "git st";
       },
       getCursor() {

package/dist/extensions/pi-powerline-footer/tests/custom-items.test.ts

@@ -35,7 +35,6 @@ test("parsePowerlineConfig supports object config with custom items", () => {
   assert.equal(config.invalidPlacement, null);
   assert.equal(config.welcome, true);
   assert.equal(config.stashSharpSShortcut, false);
-  assert.deepEqual(config.queue, { captureSigil: "#" });
 });
 
 test("parsePowerlineConfig supports disabled segments", () => {
@@ -156,31 +155,18 @@ test("parsePowerlineConfig validates primary powerline placement", () => {
 
 
 
-test("parsePowerlineConfig supports welcome, legacy sharp-S, and queue capture settings", () => {
-  const disabled = parsePowerlineConfig(
-    { preset: "compact", welcome: false, stashSharpSShortcut: true, queue: { captureSigil: false } },
-    ["default", "compact"],
-  );
-  const customSigil = parsePowerlineConfig(
-    { preset: "compact", queue: { captureSigil: "//" } },
-    ["default", "compact"],
-  );
-  const invalidSigil = parsePowerlineConfig(
-    { preset: "compact", queue: { captureSigil: "# note" } },
+test("parsePowerlineConfig supports welcome and legacy sharp-S settings", () => {
+  const config = parsePowerlineConfig(
+    { preset: "compact", welcome: false, stashSharpSShortcut: true },
     ["default", "compact"],
   );
   const shorthand = parsePowerlineConfig("compact", ["default", "compact"]);
 
-  assert.equal(disabled.welcome, false);
-  assert.equal(disabled.stashSharpSShortcut, true);
-  assert.deepEqual(disabled.queue, { captureSigil: false });
-  assert.deepEqual(customSigil.queue, { captureSigil: "//" });
-  assert.deepEqual(invalidSigil.queue, { captureSigil: "#" });
+  assert.equal(config.welcome, false);
+  assert.equal(config.stashSharpSShortcut, true);
   assert.equal(shorthand.welcome, true);
   assert.equal(shorthand.stashSharpSShortcut, false);
-  assert.deepEqual(shorthand.queue, { captureSigil: "#" });
 });
-
 test("parsePowerlineConfig extracts supported segment options", () => {
   const config = parsePowerlineConfig(
     {

package/dist/extensions/pi-powerline-footer/tests/editor-performance.test.ts

@@ -0,0 +1,43 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EditorPerfProfiler, readEditorPerfOptions } from "../editor-performance.ts";
+
+test("editor profiling and A/B switches are opt-in", () => {
+  assert.deepEqual(readEditorPerfOptions({}), {
+    enabled: false,
+    fastRender: true,
+    editorChrome: true,
+    widgets: true,
+    bashWidgets: true,
+    lastPrompt: true,
+  });
+
+  assert.deepEqual(readEditorPerfOptions({
+    POWERLINE_DEBUG_PERF: "1",
+    POWERLINE_PERF_FAST_RENDER: "0",
+    POWERLINE_PERF_EDITOR_CHROME: "0",
+    POWERLINE_PERF_WIDGETS: "0",
+    POWERLINE_PERF_BASH_WIDGETS: "0",
+    POWERLINE_PERF_LAST_PROMPT: "0",
+  }), {
+    enabled: true,
+    fastRender: false,
+    editorChrome: false,
+    widgets: false,
+    bashWidgets: false,
+    lastPrompt: false,
+  });
+});
+
+test("editor profiler reports timings, counts, and draft size", () => {
+  const profiler = new EditorPerfProfiler(readEditorPerfOptions({ POWERLINE_DEBUG_PERF: "1" }));
+
+  profiler.measure("input.total", () => 42);
+  profiler.count("editor.render.fast-hit");
+  profiler.observeDraft(["hello", "world"]);
+
+  const report = profiler.report();
+  assert.match(report, /inputs=1, editor-renders=0, renders\/input=0\.00, max-draft=11/);
+  assert.match(report, /editor\.render\.fast-hit: n=1/);
+  assert.match(report, /input\.total: n=1, avg=/);
+});

package/dist/extensions/pi-powerline-footer/tests/git-optional-locks.test.ts

@@ -0,0 +1,64 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { readOnlyGitEnv } from "../git-status.ts";
+
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+// Background fetches spawn git with up to 500ms timeouts; give them room.
+const FETCH_SETTLE_MS = 1200;
+
+test("read-only git commands opt out of git's optional index lock", () => {
+  const env = readOnlyGitEnv({ PATH: "/usr/bin" });
+  assert.equal(env.GIT_OPTIONAL_LOCKS, "0");
+  assert.equal(env.PATH, "/usr/bin", "must extend the ambient environment, not replace it");
+});
+
+test("readOnlyGitEnv overrides an inherited GIT_OPTIONAL_LOCKS=1", () => {
+  assert.equal(readOnlyGitEnv({ GIT_OPTIONAL_LOCKS: "1" }).GIT_OPTIONAL_LOCKS, "0");
+});
+
+// Guards the regression end to end, via a `git` shim on PATH: the footer polls
+// every repo the user visits, so it must never take `.git/index.lock`.
+test("the git process the footer spawns receives GIT_OPTIONAL_LOCKS=0", { skip: process.platform === "win32" ? "POSIX shim" : false }, async () => {
+  const dir = mkdtempSync(join(tmpdir(), "powerline-git-locks-"));
+  const bin = join(dir, "bin");
+  mkdirSync(bin);
+  const log = join(dir, "calls.log");
+
+  writeFileSync(
+    join(bin, "git"),
+    `#!/bin/sh\necho "GIT_OPTIONAL_LOCKS=\${GIT_OPTIONAL_LOCKS-unset} ARGS=$*" >> ${JSON.stringify(log)}\nexit 0\n`,
+    { mode: 0o755 },
+  );
+
+  const originalPath = process.env.PATH;
+  const originalOptionalLocks = process.env.GIT_OPTIONAL_LOCKS;
+  process.env.PATH = `${bin}:${originalPath ?? ""}`;
+  // Some environments export GIT_OPTIONAL_LOCKS=0 as a machine-wide workaround
+  // for this bug; force the opposite so we can't inherit a false pass.
+  process.env.GIT_OPTIONAL_LOCKS = "1";
+  try {
+    // Imported here so the module reads the shimmed PATH when it spawns.
+    const { getGitStatus, invalidateGitStatus, invalidateGitBranch } = await import("../git-status.ts");
+    invalidateGitStatus();
+    invalidateGitBranch();
+    getGitStatus("main");
+    await sleep(FETCH_SETTLE_MS);
+  } finally {
+    process.env.PATH = originalPath;
+    if (originalOptionalLocks === undefined) delete process.env.GIT_OPTIONAL_LOCKS;
+    else process.env.GIT_OPTIONAL_LOCKS = originalOptionalLocks;
+  }
+
+  assert.ok(existsSync(log), "expected the footer to spawn git");
+  const calls = readFileSync(log, "utf8").trim().split("\n");
+  const status = calls.filter((line) => line.includes("ARGS=status --porcelain"));
+  assert.ok(status.length > 0, `expected a status call, got:\n${calls.join("\n")}`);
+  for (const call of calls) {
+    assert.match(call, /GIT_OPTIONAL_LOCKS=0/, `git spawned without the lock opt-out: ${call}`);
+  }
+});