@ilya-lesikov/pi-pi 0.7.0 → 0.9.0

package/extensions/orchestrator/config.test.ts

@@ -122,10 +122,16 @@ describe("validateConfig", () => {
     );
   });
 
+  it("throws for invalid injectAgentsMd value", () => {
+    expect(() => validateConfig({ general: { injectAgentsMd: "yes" } })).toThrow(
+      "config.general.injectAgentsMd",
+    );
+  });
+
   it("accepts valid partial config", () => {
     expect(() =>
       validateConfig({
-        general: { autoCommit: false },
+        general: { autoCommit: false, injectAgentsMd: false },
         commands: {
           afterEdit: { fmt: { run: "npm run fmt", globs: ["**/*.ts"] } },
           afterImplement: { test: { run: "npm test" } },
@@ -192,6 +198,39 @@ describe("loadConfig", () => {
     expect(config.performance.commands.afterEdit).toBe(1234);
     expect(config.performance.commands.afterImplement).toBe(300000);
     expect(config.general.autoCommit).toBe(false);
+    expect(config.general.injectAgentsMd).toBe(true);
+  });
+
+  it("defaults injectAgentsMd to true and honors an explicit override", () => {
+    const cwd = makeTempDir();
+    const defaults = loadConfig(cwd, "/nonexistent/global/config.json");
+    expect(defaults.general.injectAgentsMd).toBe(true);
+
+    const cwd2 = makeTempDir();
+    const ppDir = join(cwd2, ".pp");
+    mkdirSync(ppDir, { recursive: true });
+    writeFileSync(join(ppDir, "config.json"), JSON.stringify({ general: { injectAgentsMd: false } }), "utf-8");
+    const overridden = loadConfig(cwd2, "/nonexistent/global/config.json");
+    expect(overridden.general.injectAgentsMd).toBe(false);
+  });
+
+  it("defaults mainTurnStale to 10m and normalizes an override to ms", () => {
+    const cwd = makeTempDir();
+    const defaults = loadConfig(cwd, "/nonexistent/global/config.json");
+    expect(defaults.performance.internals.mainTurnStale).toBe(600000);
+
+    const cwd2 = makeTempDir();
+    const ppDir = join(cwd2, ".pp");
+    mkdirSync(ppDir, { recursive: true });
+    writeFileSync(join(ppDir, "config.json"), JSON.stringify({ performance: { internals: { mainTurnStale: "90s" } } }), "utf-8");
+    const overridden = loadConfig(cwd2, "/nonexistent/global/config.json");
+    expect(overridden.performance.internals.mainTurnStale).toBe(90000);
+  });
+
+  it("rejects an invalid mainTurnStale duration", () => {
+    expect(() => validateConfig({ performance: { internals: { mainTurnStale: "soon" } } })).toThrow(
+      "config.performance.internals.mainTurnStale",
+    );
   });
 
   it("creates default config when config.json does not exist", () => {

package/extensions/orchestrator/config.ts

@@ -7,7 +7,7 @@ import { isValidLogLevel, getLogger, type LogLevel } from "./log.js";
 
 export type DurationValue = string | number;
 export type OrchestratorRole = "implement" | "plan" | "debug" | "brainstorm" | "review" | "quick";
-export type SimpleSubagentRole = "explore" | "librarian" | "task";
+export type SimpleSubagentRole = "explore" | "librarian" | "task" | "advisor" | "deep-debugger" | "reviewer";
 export type PresetGroupKey = "planners" | "codeReviewers" | "planReviewers" | "brainstormReviewers";
 
 export interface AgentConfig {
@@ -43,6 +43,7 @@ export interface AfterImplementCommandConfig {
 export interface PiPiConfig {
   general: {
     autoCommit: boolean;
+    injectAgentsMd: boolean;
     loadExtraRepoConfigs: boolean;
     logLevel: LogLevel;
     tracing: boolean;
@@ -65,6 +66,7 @@ export interface PiPiConfig {
     };
     internals: {
       subagentStale: DurationValue;
+      mainTurnStale: DurationValue;
       taskLockStale: DurationValue;
       taskLockRefresh: DurationValue;
     };
@@ -79,6 +81,7 @@ export interface NormalizedPiPiConfig extends PiPiConfig {
     };
     internals: {
       subagentStale: number;
+      mainTurnStale: number;
       taskLockStale: number;
       taskLockRefresh: number;
     };
@@ -92,11 +95,12 @@ export type TimeoutConfig = NormalizedPiPiConfig["performance"]["internals"];
 export const PRESET_GROUPS = ["planners", "codeReviewers", "planReviewers", "brainstormReviewers"] as const;
 
 const ORCHESTRATOR_ROLES: OrchestratorRole[] = ["implement", "plan", "debug", "brainstorm", "review", "quick"];
-const SIMPLE_SUBAGENT_ROLES: SimpleSubagentRole[] = ["explore", "librarian", "task"];
+const SIMPLE_SUBAGENT_ROLES: SimpleSubagentRole[] = ["explore", "librarian", "task", "advisor", "deep-debugger", "reviewer"];
 
 const DEFAULT_CONFIG: PiPiConfig = {
   general: {
     autoCommit: true,
+    injectAgentsMd: true,
     loadExtraRepoConfigs: true,
     logLevel: "info",
     tracing: false,
@@ -115,6 +119,9 @@ const DEFAULT_CONFIG: PiPiConfig = {
         explore: { model: "google/gemini-flash-latest", thinking: "low" },
         librarian: { model: "google/gemini-flash-latest", thinking: "medium" },
         task: { model: "anthropic/claude-opus-latest", thinking: "medium" },
+        advisor: { model: "openai/gpt-latest", thinking: "high" },
+        "deep-debugger": { model: "openai/gpt-latest", thinking: "high" },
+        reviewer: { model: "openai/gpt-latest", thinking: "high" },
       },
       presetGroups: {
         planners: {
@@ -200,6 +207,7 @@ const DEFAULT_CONFIG: PiPiConfig = {
     },
     internals: {
       subagentStale: "5m",
+      mainTurnStale: "10m",
       taskLockStale: "1m",
       taskLockRefresh: "30s",
     },
@@ -344,6 +352,7 @@ export function validateConfig(config: Record<string, any>): void {
   if (config.general !== undefined) {
     const general = requireObject(config.general, "config.general");
     ensureBool(general.autoCommit, "config.general.autoCommit");
+    ensureBool(general.injectAgentsMd, "config.general.injectAgentsMd");
     ensureBool(general.loadExtraRepoConfigs, "config.general.loadExtraRepoConfigs");
     ensureBool(general.tracing, "config.general.tracing");
     if (general.logLevel !== undefined && !isValidLogLevel(general.logLevel)) {
@@ -414,6 +423,7 @@ export function validateConfig(config: Record<string, any>): void {
     if (performance.internals !== undefined) {
       const internals = requireObject(performance.internals, "config.performance.internals");
       ensureDuration(internals.subagentStale, "config.performance.internals.subagentStale");
+      ensureDuration(internals.mainTurnStale, "config.performance.internals.mainTurnStale");
       ensureDuration(internals.taskLockStale, "config.performance.internals.taskLockStale");
       ensureDuration(internals.taskLockRefresh, "config.performance.internals.taskLockRefresh");
     }
@@ -523,6 +533,9 @@ export function validateMergedConfig(config: Record<string, any>): void {
   if (parseDuration(typed.performance.internals.subagentStale) === null) {
     throw new Error("config.performance.internals.subagentStale must be a valid duration");
   }
+  if (parseDuration(typed.performance.internals.mainTurnStale) === null) {
+    throw new Error("config.performance.internals.mainTurnStale must be a valid duration");
+  }
   if (parseDuration(typed.performance.internals.taskLockStale) === null) {
     throw new Error("config.performance.internals.taskLockStale must be a valid duration");
   }
@@ -537,6 +550,7 @@ export function normalizeConfigDurations(config: PiPiConfig): NormalizedPiPiConf
   const afterEdit = parseDuration(next.performance.commands.afterEdit);
   const afterImplement = parseDuration(next.performance.commands.afterImplement);
   const subagentStale = parseDuration(next.performance.internals.subagentStale);
+  const mainTurnStale = parseDuration(next.performance.internals.mainTurnStale);
   const taskLockStale = parseDuration(next.performance.internals.taskLockStale);
   const taskLockRefresh = parseDuration(next.performance.internals.taskLockRefresh);
 
@@ -544,6 +558,7 @@ export function normalizeConfigDurations(config: PiPiConfig): NormalizedPiPiConf
     afterEdit === null ||
     afterImplement === null ||
     subagentStale === null ||
+    mainTurnStale === null ||
     taskLockStale === null ||
     taskLockRefresh === null
   ) {
@@ -553,6 +568,7 @@ export function normalizeConfigDurations(config: PiPiConfig): NormalizedPiPiConf
   next.performance.commands.afterEdit = afterEdit;
   next.performance.commands.afterImplement = afterImplement;
   next.performance.internals.subagentStale = subagentStale;
+  next.performance.internals.mainTurnStale = mainTurnStale;
   next.performance.internals.taskLockStale = taskLockStale;
   next.performance.internals.taskLockRefresh = taskLockRefresh;
   return next;

package/extensions/orchestrator/context.test.ts

@@ -14,6 +14,8 @@ vi.mock("@earendil-works/pi-coding-agent", () => ({
 import {
   getContextDirs,
   getLatestSynthesizedPlan,
+  getArtifactManifest,
+  formatManifestBlock,
   getPhaseArtifacts,
   loadAllContextFiles,
   loadContextFiles,
@@ -377,6 +379,58 @@ describe("getLatestSynthesizedPlan", () => {
   });
 });
 
+describe("getArtifactManifest", () => {
+  it("returns empty when no artifacts or plan exist", () => {
+    const taskDir = makeTempDir();
+    expect(getArtifactManifest(taskDir)).toEqual([]);
+  });
+
+  it("extracts titles from artifact headings with a filename fallback", () => {
+    const taskDir = makeTempDir();
+    const artifactsDir = join(taskDir, "artifacts");
+    mkdirSync(artifactsDir, { recursive: true });
+    writeFileSync(join(artifactsDir, "design.md"), "# My Design\n\nbody", "utf-8");
+    writeFileSync(join(artifactsDir, "notitle.md"), "no heading here", "utf-8");
+
+    const manifest = getArtifactManifest(taskDir);
+    expect(manifest).toEqual([
+      { title: "My Design", path: join(artifactsDir, "design.md") },
+      { title: "artifacts/notitle.md", path: join(artifactsDir, "notitle.md") },
+    ]);
+  });
+
+  it("includes the latest synthesized plan with its REAL path, regardless of phase", () => {
+    const taskDir = makeTempDir();
+    const plansDir = join(taskDir, "plans");
+    mkdirSync(plansDir, { recursive: true });
+    writeFileSync(join(plansDir, "001_synthesized.md"), "old", "utf-8");
+    writeFileSync(join(plansDir, "010_synthesized.md"), "new", "utf-8");
+
+    const manifest = getArtifactManifest(taskDir);
+    expect(manifest).toEqual([
+      { title: "Synthesized implementation plan", path: join(plansDir, "010_synthesized.md") },
+    ]);
+  });
+});
+
+describe("formatManifestBlock", () => {
+  it("emits the do-not-re-read line only when the manifest is empty", () => {
+    const block = formatManifestBlock([]);
+    expect(block).toContain("Do NOT re-read them from disk");
+    expect(block).not.toContain("read them from disk with the read tool");
+  });
+
+  it("lists each manifest entry's path and title for on-demand reading", () => {
+    const block = formatManifestBlock([
+      { title: "Design", path: "/t/artifacts/design.md" },
+      { title: "Synthesized implementation plan", path: "/t/plans/1_synthesized.md" },
+    ]);
+    expect(block).toContain("do NOT re-read them from disk");
+    expect(block).toContain("- /t/artifacts/design.md  — Design");
+    expect(block).toContain("- /t/plans/1_synthesized.md  — Synthesized implementation plan");
+  });
+});
+
 describe("context regressions", () => {
   it("parses bracket array values without truncation when closing bracket is missing", () => {
     const cwd = makeTempDir();

package/extensions/orchestrator/context.ts

@@ -5,7 +5,7 @@ import type { RepoInfo } from "./repo-utils.js";
 import type { Phase } from "./state.js";
 import { getLogger } from "./log.js";
 
-type AgentType = "main" | "explore" | "librarian" | "planner" | "planReviewer" | "task" | "codeReviewer" | "brainstormReviewer";
+type AgentType = "main" | "explore" | "librarian" | "planner" | "planReviewer" | "task" | "codeReviewer" | "brainstormReviewer" | "advisor" | "deep-debugger" | "reviewer";
 type AgentGroup = "all" | "subagents";
 type InjectMode = "system" | "context";
 type PhaseFilter = "brainstorm" | "debug" | "plan" | "implement" | "review";
@@ -30,7 +30,7 @@ interface Frontmatter {
 }
 
 const VALID_INJECT_MODES: readonly string[] = ["system", "context"];
-const VALID_AGENTS: readonly string[] = ["main", "explore", "librarian", "planner", "planReviewer", "task", "codeReviewer", "brainstormReviewer"];
+const VALID_AGENTS: readonly string[] = ["main", "explore", "librarian", "planner", "planReviewer", "task", "codeReviewer", "brainstormReviewer", "advisor", "deep-debugger", "reviewer"];
 const VALID_AGENT_GROUPS: readonly string[] = ["all", "subagents"];
 const VALID_PHASES: readonly string[] = ["brainstorm", "debug", "plan", "implement", "review"];
 const VALID_VENDORS: readonly string[] = ["anthropic", "openai", "google", "unknown"];
@@ -279,6 +279,85 @@ export function getLatestSynthesizedPlan(taskDir: string): string | null {
   return readFileSync(join(plansDir, synthFiles[synthFiles.length - 1]), "utf-8");
 }
 
+// True when the newest `code-reviews/*_final_pass-*.md` exists and carries an
+// `ANCHORS:` block. Shared by publishGuard (Publish menu) and the review-phase
+// completion gates so a review cannot finish without the deliverable Publish
+// consumes. A zero-findings `ANCHORS: (none)` still satisfies this (the line exists).
+export function hasFinalPassAnchors(taskDir: string): boolean {
+  const reviewsDir = join(taskDir, "code-reviews");
+  if (!existsSync(reviewsDir)) return false;
+  const finalPassFiles = readdirSync(reviewsDir)
+    .filter((f) => f.endsWith(".md") && f.includes("_final_pass-"))
+    .sort();
+  if (finalPassFiles.length === 0) return false;
+  const latest = finalPassFiles[finalPassFiles.length - 1];
+  const content = readFileSync(join(reviewsDir, latest), "utf8");
+  return /^ANCHORS:/m.test(content);
+}
+
+function getLatestSynthesizedPlanPath(taskDir: string): string | null {
+  const plansDir = join(taskDir, "plans");
+  if (!existsSync(plansDir)) return null;
+
+  const synthFiles = readdirSync(plansDir)
+    .filter((f) => f.includes("synthesized"))
+    .sort(sortByTimestampPrefix);
+  if (synthFiles.length === 0) return null;
+
+  return join(plansDir, synthFiles[synthFiles.length - 1]);
+}
+
+function extractTitle(path: string, fallback: string): string {
+  try {
+    const content = readFileSync(path, "utf-8");
+    for (const line of content.split("\n")) {
+      const m = line.match(/^#\s+(.+?)\s*$/);
+      if (m) return m[1];
+    }
+  } catch {
+    // fall through to filename fallback
+  }
+  return fallback;
+}
+
+// Path-aware manifest of on-demand task documents (artifacts/*.md + the synthesized
+// plan when present) — each entry carries a REAL filesystem path an agent can read.
+// Unlike getPhaseArtifacts, the plan is included whenever it exists (not phase-gated),
+// so a reviewer spawned in the review phase still gets the plan path.
+export function getArtifactManifest(taskDir: string): { title: string; path: string }[] {
+  const manifest: { title: string; path: string }[] = [];
+
+  const artifactsDir = join(taskDir, "artifacts");
+  if (existsSync(artifactsDir)) {
+    for (const file of readdirSync(artifactsDir).filter((f) => f.endsWith(".md")).sort()) {
+      const path = join(artifactsDir, file);
+      manifest.push({ title: extractTitle(path, `artifacts/${file}`), path });
+    }
+  }
+
+  const planPath = getLatestSynthesizedPlanPath(taskDir);
+  if (planPath) {
+    manifest.push({ title: "Synthesized implementation plan", path: planPath });
+  }
+
+  return manifest;
+}
+
+// Renders a manifest into the trailing prompt block shared by phased panels.
+// Replaces the old "Do NOT re-read them from disk" line: USER_REQUEST/RESEARCH
+// (and the inlined plan) stay in context, while additional artifacts are offered
+// for on-demand reading from disk.
+export function formatManifestBlock(manifest: { title: string; path: string }[]): string {
+  if (manifest.length === 0) {
+    return "The USER REQUEST and RESEARCH above are already in your context. Do NOT re-read them from disk.";
+  }
+  return [
+    "The USER REQUEST and RESEARCH above are already in your context — do NOT re-read them from disk.",
+    "Additional analysis artifacts and the plan are listed below; read them from disk with the read tool if relevant:",
+    ...manifest.map((m) => `- ${m.path}  — ${m.title}`),
+  ].join("\n");
+}
+
 export function loadBrainstormReviewOutputs(taskDir: string, pass: number): { name: string; content: string }[] {
   const dir = join(taskDir, "brainstorm-reviews");
   if (!existsSync(dir)) return [];

package/extensions/orchestrator/custom-footer.test.ts

@@ -0,0 +1,91 @@
+import { describe, expect, it, beforeEach } from "vitest";
+import { createCustomFooter, setFooterContext, setFooterTracker, setFooterOrchestrator } from "./custom-footer.js";
+
+const theme = { fg: (_color: string, text: string) => text } as any;
+const footerData = { getGitBranch: () => "main" } as any;
+
+function render(width = 200): string[] {
+  const footer = createCustomFooter({} as any, theme, footerData);
+  return footer.render(width);
+}
+
+function makeCtx(usage?: { tokens: number | null; contextWindow: number; percent: number | null }): any {
+  return {
+    cwd: "/tmp/project",
+    model: { id: "test-model", provider: "test" },
+    sessionManager: { getSessionName: () => undefined, getEntries: () => [] },
+    getContextUsage: () => usage,
+  };
+}
+
+describe("createCustomFooter", () => {
+  beforeEach(() => {
+    setFooterTracker(undefined as any);
+    setFooterOrchestrator(undefined as any);
+  });
+
+  it("renders exactly two lines (no status/LSP line)", () => {
+    setFooterContext(makeCtx());
+    const lines = render();
+    expect(lines).toHaveLength(2);
+  });
+
+  it("line 1 shows task/phase/mode when a task is active", () => {
+    setFooterContext(makeCtx());
+    setFooterOrchestrator({
+      active: { type: "implement", state: { phase: "plan", mode: "autonomous" } },
+    } as any);
+    const [line1] = render();
+    expect(line1).toContain("task: implement");
+    expect(line1).toContain("phase: plan");
+    expect(line1).toContain("mode: autonomous");
+  });
+
+  it("line 1 shows autonomous mode in a read-only phase for an autonomous task", () => {
+    setFooterContext(makeCtx());
+    setFooterOrchestrator({
+      active: { type: "implement", state: { phase: "brainstorm", mode: "autonomous" } },
+    } as any);
+    const [line1] = render();
+    expect(line1).toContain("phase: brainstorm");
+    expect(line1).toContain("mode: autonomous");
+  });
+
+  it("line 1 shows guided mode for a guided task", () => {
+    setFooterContext(makeCtx());
+    setFooterOrchestrator({
+      active: { type: "implement", state: { phase: "implement", mode: "guided" } },
+    } as any);
+    const [line1] = render();
+    expect(line1).toContain("mode: guided");
+  });
+
+  it("line 1 omits the mode segment for a quick task", () => {
+    setFooterContext(makeCtx());
+    setFooterOrchestrator({
+      active: { type: "quick", state: { phase: "quick", mode: "autonomous" } },
+    } as any);
+    const [line1] = render();
+    expect(line1).toContain("task: quick");
+    expect(line1).not.toContain("mode:");
+  });
+
+  it("line 1 omits task metadata when no task is active", () => {
+    setFooterContext(makeCtx());
+    const [line1] = render();
+    expect(line1).not.toContain("task:");
+    expect(line1).toContain("main");
+  });
+
+  it("context indicator shows percent/used/max", () => {
+    setFooterContext(makeCtx({ tokens: 38000, contextWindow: 1000000, percent: 3.8 }));
+    const [, line2] = render();
+    expect(line2).toContain("3.8%/38k/1.0M (auto)");
+  });
+
+  it("context indicator degrades gracefully when tokens are null", () => {
+    setFooterContext(makeCtx({ tokens: null, contextWindow: 1000000, percent: null }));
+    const [, line2] = render();
+    expect(line2).toContain("?%/?/1.0M (auto)");
+  });
+});

package/extensions/orchestrator/custom-footer.ts

@@ -2,9 +2,12 @@ import { homedir } from "node:os";
 import type { ExtensionContext, ReadonlyFooterDataProvider, Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth, type Component, type TUI } from "@earendil-works/pi-tui";
 import type { UsageTracker } from "./usage-tracker.js";
+import type { Orchestrator } from "./orchestrator.js";
+import { formatModeIndicator } from "./state.js";
 
 let footerCtx: ExtensionContext | undefined;
 let footerTracker: UsageTracker | undefined;
+let footerOrchestrator: Orchestrator | undefined;
 
 export function setFooterContext(ctx: ExtensionContext): void {
   footerCtx = ctx;
@@ -14,6 +17,10 @@ export function setFooterTracker(tracker: UsageTracker): void {
   footerTracker = tracker;
 }
 
+export function setFooterOrchestrator(orchestrator: Orchestrator): void {
+  footerOrchestrator = orchestrator;
+}
+
 function formatTokens(count: number): string {
   if (count < 1000) return count.toString();
   if (count < 10000) return `${(count / 1000).toFixed(1)}k`;
@@ -22,10 +29,6 @@ function formatTokens(count: number): string {
   return `${Math.round(count / 1000000)}M`;
 }
 
-function sanitizeStatusText(text: string): string {
-  return text.replace(/[\r\n\t]/g, " ").replace(/ +/g, " ").trim();
-}
-
 function formatPath(cwd: string): string {
   const home = homedir();
   return cwd.startsWith(home) ? `~${cwd.slice(home.length)}` : cwd;
@@ -47,8 +50,10 @@ function toContextUsagePart(ctx: ExtensionContext | undefined, theme: Theme): st
   const usage = ctx?.getContextUsage();
   const contextWindow = usage?.contextWindow ?? 0;
   const percentValue = usage?.percent ?? null;
+  const tokensValue = usage?.tokens ?? null;
   const percentText = percentValue === null ? "?" : percentValue.toFixed(1);
-  const display = `${percentText}%/${formatTokens(contextWindow)} (auto)`;
+  const tokensText = tokensValue === null ? "?" : formatTokens(tokensValue);
+  const display = `${percentText}%/${tokensText}/${formatTokens(contextWindow)} (auto)`;
   if (percentValue !== null && percentValue > 90) return theme.fg("error", display);
   if (percentValue !== null && percentValue > 70) return theme.fg("warning", display);
   return display;
@@ -115,23 +120,19 @@ function renderPathLine(width: number, theme: Theme, footerData: ReadonlyFooterD
   const ctx = footerCtx;
   const path = formatPath(ctx?.cwd ?? process.cwd());
   const branch = footerData.getGitBranch();
-  const sessionName = ctx?.sessionManager.getSessionName();
 
   let line = path;
   if (branch) line += ` (${branch})`;
-  if (sessionName) line += ` • ${sessionName}`;
-
-  return truncateToWidth(theme.fg("dim", line), width, theme.fg("dim", "..."));
-}
-
-function renderStatusLine(width: number, theme: Theme, footerData: ReadonlyFooterDataProvider): string | undefined {
-  const statuses = footerData.getExtensionStatuses();
-  if (statuses.size === 0) return undefined;
 
-  const line = Array.from(statuses.entries())
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([, text]) => sanitizeStatusText(text))
-    .join(" ");
+  const task = footerOrchestrator?.active;
+  if (task && task.state.phase !== "done") {
+    line += ` • task: ${task.type} • phase: ${task.state.phase}`;
+    const mode = formatModeIndicator(task.state, task.type);
+    if (mode) line += ` • mode: ${mode}`;
+  } else {
+    const sessionName = ctx?.sessionManager.getSessionName();
+    if (sessionName) line += ` • ${sessionName}`;
+  }
 
   return truncateToWidth(theme.fg("dim", line), width, theme.fg("dim", "..."));
 }
@@ -141,8 +142,7 @@ export function createCustomFooter(_tui: TUI, theme: Theme, footerData: Readonly
     render(width: number): string[] {
       const line1 = renderPathLine(width, theme, footerData);
       const line2 = renderStatsLine(width, theme);
-      const line3 = renderStatusLine(width, theme, footerData) ?? theme.fg("dim", "");
-      return [line1, line2, line3];
+      return [line1, line2];
     },
     invalidate(): void {},
     dispose(): void {},