killeros 2.0.6 → 2.0.8

package/CHANGELOG.md

@@ -4,6 +4,44 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.0.8] - 2026-08-15
+
+### Added
+
+- Added a reusable, opt-in pre-turn gate for explicitly activated decision-gated workflows. It opens the shared structured question UI before skill expansion, keeps the selected policy active, blocks unknown and disallowed tools, and clears safely across lifecycle boundaries.
+- Added a disposable decision-gated workflow fixture and focused coverage for activation ordering, pending safety, policy allowlists, lifecycle cleanup, adapter reuse, and Pi 0.84.2 compatibility.
+
+### Removed
+
+- Removed KillerOS's always-on concise response policy and provider-specific concise defaults; Pi now owns response-style guidance.
+
+### Changed
+
+- Raised the locked direct Pi development packages to 0.84.2 while keeping the peer dependency floor at 0.84.1.
+
+## [2.0.7] - 2026-08-13
+
+### Changed
+
+- Raised the supported and locked Pi baseline from 0.82.1 to the current matched 0.84.1 AI, coding-agent, and TUI packages.
+- Added a compact two-deck footer beneath the prompt and removed the work-trail widget.
+- Replaced the framed prompt and shuffled activity verbs with a focus-aware single-arrow editor and event-derived working copy.
+- Made settled timing entries report `Done`, `Stopped`, or `Failed` while keeping existing `Worked for` history readable.
+
+### Fixed
+
+- Separated response output from the prompt editor while keeping footer telemetry close beneath a quiet muted divider.
+- Kept `/variants` within the active terminal height, preserved the focused reasoning level across resizes, and initially focused the current level.
+- Rendered `/variants` controls from the same Pi keybinding manager that handles input, including installations with separate package module instances.
+- Rendered active, paused, and blocked `/goal` status text consistently in the footer's far-right slot.
+- Kept the private goal-update tool inactive outside active `/goal` runs and rendered its real execution errors instead of malformed blocker-audit fields.
+- Verified exact persisted paths for clearly declared file-deliverable goals before completion, while preserving model-reported completion for general objectives.
+- Accepted explicit `1`/`1` bounds for single-select questions and applied the same bounds validation before rendering and execution.
+- Prevented reload and branch navigation from preserving or reconstructing stale manual-compaction recovery eligibility; only Pi's live event in the current session can resume the interrupted goal safely.
+- Restricted goal deliverable verification to explicit destination phrases so source and reference paths cannot be reported as completed output.
+- Kept saved goals fully inactive in print and JSON modes, including the private update tool and shutdown checkpoints.
+- Rejected concurrent `/init` starts during preflight, cancelled pending preflight work on shutdown, and settled active `/init` command handlers when their session closes.
+
 ## [2.0.6] - 2026-08-11
 
 ### Added

package/Killeros.ts

@@ -1,6 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerRequestActivity } from "./killeros/activity.ts";
 import { registerAliases, registerSlashAutocomplete } from "./killeros/commands.ts";
-import { registerConcisePrompt } from "./killeros/concise.ts";
 import { registerFooter } from "./killeros/footer.ts";
 import { registerGoal, registerGoalSettlement } from "./killeros/goals.ts";
 import { registerLifecycleHooks } from "./killeros/hooks.ts";
@@ -10,31 +10,47 @@ import {
   type CompletionNotificationDependencies,
 } from "./killeros/notifications.ts";
 import { registerPersonalInstructions } from "./killeros/personal-instructions.ts";
-import { registerQuestionTool } from "./killeros/question.ts";
+import { registerQuestionTool, type QuestionRunner } from "./killeros/question.ts";
+import { createDecisionGatedWorkflowAdapter } from "./killeros/decision-gated-workflow.ts";
 import { createGoalRuntime, createInitRuntime } from "./killeros/runtime.ts";
 import { registerShellUi } from "./killeros/shell-ui.ts";
 import { registerVariants } from "./killeros/variants.ts";
 import { registerWorkedFor } from "./killeros/worked-for.ts";
+import { registerWorkflowGate, type WorkflowAdapter } from "./killeros/workflow-gate.ts";
 
-export { CONCISE_SYSTEM_PROMPT, isConciseEnabled, isConcisedEnabled } from "./killeros/concise.ts";
 export { contextPercentRemaining, formatCost, formatContextProgress } from "./killeros/footer.ts";
 export { executeHook } from "./killeros/hooks.ts";
 export { INIT_WORKFLOW_PROMPT } from "./killeros/init.ts";
 export { buildInitEvidence, listInitEvidence, readInitEvidence } from "./killeros/init-evidence.ts";
 export { captureInitTargetBaseline, installInitAgentsFile, validateGeneratedGuidance, writeInitAgentsFile } from "./killeros/init-target.ts";
+export { createDecisionGatedWorkflowAdapter } from "./killeros/decision-gated-workflow.ts";
+export { explicitSkillActivation, registerWorkflowGate } from "./killeros/workflow-gate.ts";
+export type {
+  WorkflowAdapter,
+  WorkflowGateController,
+  WorkflowGateState,
+  WorkflowPolicy,
+  WorkflowTerminalReason,
+  WorkflowToolAuthorization,
+} from "./killeros/workflow-gate.ts";
 
 export interface KillerosOptions {
   completionNotifications?: CompletionNotificationDependencies;
+  decisionGatedWorkflows?: readonly WorkflowAdapter[];
 }
 
 export default function Killeros(pi: ExtensionAPI, options: KillerosOptions = {}): void {
   const initRuntime = createInitRuntime();
   const goalRuntime = createGoalRuntime();
   registerShellUi(pi);
-  registerConcisePrompt(pi);
   registerGoal(pi, goalRuntime, initRuntime);
   registerPersonalInstructions(pi, initRuntime);
-  registerQuestionTool(pi);
+  const questionRunner: QuestionRunner = registerQuestionTool(pi);
+  registerWorkflowGate(
+    pi,
+    questionRunner,
+    options.decisionGatedWorkflows ?? [createDecisionGatedWorkflowAdapter()],
+  );
   registerAliases(pi);
   registerSlashAutocomplete(pi);
   registerFooter(pi, goalRuntime);
@@ -43,6 +59,7 @@ export default function Killeros(pi: ExtensionAPI, options: KillerosOptions = {}
   registerLifecycleHooks(pi);
   registerGoalSettlement(pi, goalRuntime, initRuntime);
   registerInitSettlement(pi, initRuntime);
+  registerRequestActivity(pi);
   registerCompletionNotifications(pi, options.completionNotifications);
   registerWorkedFor(pi);
 }

package/README.md

@@ -1,11 +1,11 @@
 # KillerOS
 
-A production-hardened Pi extension that combines a custom TUI, repository initialization, long-running goals, reasoning controls, interactive questions, command aliases, and concise-response guidance.
+A production-hardened Pi extension that combines a custom TUI, repository initialization, long-running goals, reasoning controls, interactive questions, and command aliases.
 
 ## Requirements
 
 - Node.js `22.19.0` or later
-- Pi `0.82.1` or later
+- Pi `0.84.2` or later
 - Interactive TUI mode for the custom header, editor, footer, `question` tool, and `/init`
 
 The extension is strict TypeScript. Pi provides the runtime modules.
@@ -31,7 +31,7 @@ pi install git:github.com/KyrosHendrix/pi-KillerOS
 Pin an install to a release:
 
 ```bash
-pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.6
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.8
 ```
 
 Add `-l` to either command for a project-only install. Restart Pi after installing.
@@ -40,18 +40,19 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 
 - 52-column Compact startup card with inline version, polished model/provider identity, adjacent `/model`, directory, conditional Git branch, and a shuffled session-stable tip
 - Cohesive dark theme with coral accents and neutral tool-call containers across pending, success, and error states
-- Animated orange 12-frame activity glyph loop at 120 ms per frame, with orange shuffled Claude-adjacent verbs changing every 2.5 seconds, a gray `(esc to interrupt · thinking)` status with bold `esc`, and a quiet hidden-thinking label
-- Full-width framed multiline editor with a shuffled session-stable empty-state suggestion, Shift+Enter support, and slash-command autocomplete; KillerOS preserves an editor factory configured by another extension
-- Responsive footer with polished model/provider identity, plain-language context, and active goal state remaining; reasoning, Git branch, elapsed time, cost, and path cut down by available width
+- Animated orange 12-frame activity glyph loop at 120 ms per frame with contextual copy derived from request, tool, result, and response events, plus a quiet hidden-thinking label
+- Frameless multiline editor with one focus-aware `❯`, a shuffled session-stable empty-state suggestion, overflow-only scroll indicators, Shift+Enter support, and slash-command autocomplete; KillerOS preserves an editor factory configured by another extension
+- One compact TUI transcript line reporting truthful `Done`, `Stopped`, or `Failed` settlement with elapsed time while preserving older `✻ Worked for …` entries
+- Compact two-deck footer with session state above workspace state; model, context, and active goals stay prioritized as reasoning, time, cost, branch, and path reduce by available width
 - Pi-owned context compaction with active goals continuing from Pi's settled boundary after manual, threshold, and overflow compaction
 - Optional completion sounds after successful or failed settled requests, excluding manual aborts
 - `/variants` selector and direct reasoning-level arguments
 - Codex-style `/goal` with an interactive status/action panel, durable objectives, immediate pause and clear cancellation, automatic continuation, explicit completion, and durable blocker audits
-- Automatic `/init` guideline synthesis with a frozen safe evidence map, protected existing policy, and the four packaged behavioral sections adapted from `writing-great-guidelines`
+- Automatic `/init` guideline synthesis with a frozen safe evidence map, protected existing policy, and the four packaged behavioral sections adapted from `writing-great-guidelines`
+- Opt-in decision-gated workflows that ask a structured policy question before explicit skill expansion, preserve the selected allowlist, and fail closed across tool and session boundaries
 - `question` tool with single-select and opt-in bounded multi-select, height-bounded option windows, configured Pi keybindings, live option/input progress, proposal previews, custom answers, history, cancellation, and compact expandable transcript rendering
-- Mid-prompt slash completion with current Pi `0.82.1` commands, extensions, prompts, and skills; paths, URLs, and invalid commands remain plain text
+- Mid-prompt slash completion with current Pi `0.84.2` commands, extensions, prompts, and skills; paths, URLs, and invalid commands remain plain text
 - Goal-aware `/clear` that confirms, aborts active work, waits for settlement, and starts a new session, plus `/exit` for graceful shutdown
-- Concise system-prompt guidance and supported native concise defaults that preserve explicit provider settings
 
 ## Commands
 
@@ -70,17 +71,21 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 /exit                     Quit Pi gracefully
 ```
 
-`/goal` requires a saved session in TUI or RPC mode. Goal state is stored in versioned session entries on the active branch and restored after reload, resume, fork, or tree navigation. Active goals inject their unchanged objective every turn and continue one settled turn at a time. The model must use KillerOS’s private goal tool to mark verified completion. Blocking requires one stable lowercase blocker key recorded on three consecutive goal turns; a changed key, skipped turn, resume, or edit resets the streak. Final prose alone does not end the loop.
+`/goal` requires a saved session in TUI or RPC mode. Goal state is stored in versioned session entries on the active branch and restored after reload, resume, fork, or tree navigation. Active goals inject their unchanged objective every turn and continue one settled turn at a time. The model must use KillerOS’s private goal tool to report completion. For an objective that clearly asks to create, write, save, or generate a named file-like deliverable at one quoted absolute path, KillerOS saves that exact path with the goal and verifies that a regular file exists there before accepting completion. Other objectives retain model-reported completion. Blocking requires one stable lowercase blocker key recorded on three consecutive goal turns; a changed key, skipped turn, resume, or edit resets the streak. Final prose alone does not end the loop.
 
 `/goal pause` and `/goal clear` save paused or cleared state before aborting current goal work, so settlement cannot restart it. Aborted turns, provider failures, and continuation failures otherwise pause safely. Failed edit and replacement writes dispatch no edited objective; an active prior objective pauses fail-closed, while inactive durable state remains unchanged. Replacing unfinished work requires confirmation, and `/goal edit` requires TUI mode.
 
 `/init` freezes a safe project-file map and exposes only dedicated read and list operations while it generates root `AGENTS.md`. Git-ignored files, known secret paths, private-key formats, other guidance, dependencies, links, non-regular files, and files outside that map are unavailable. Existing root `AGENTS.md` is separate protected policy: compatible rules are preserved, a real policy conflict leaves it unchanged with a reason, and any concurrent target change aborts installation without replacing the newer file.
 
-The generated file uses the four behavioral sections adapted from `writing-great-guidelines`; no external skill installation is required. `/init` asks no setup questions, starts no second model process, writes no other file, and reloads Pi resources only after a successful write.
+The generated file uses the four behavioral sections adapted from `writing-great-guidelines`; no external skill installation is required. `/init` asks no setup questions, starts no second model process, writes no other file, and reloads Pi resources only after a successful write.
+
+### Decision-gated workflows
+
+Explicit `/skill:decision-gated-workflow` activation opens the shared question UI before Pi expands the skill. `Normal` allows only interview and read-only tools; `With docs` additionally permits agreed glossary, context-map, and ADR paths. The selected policy remains active until the workflow is explicitly finished or cancelled, and lifecycle changes clear it safely. Extensions can supply additional adapters through `KillerosOptions.decisionGatedWorkflows`.
+
+### Interactive questions
 
-### Interactive questions
-
-Single-select remains the default. An agent opts into multi-select with `mode: "multiple"` and may set `minSelections` and `maxSelections`; the custom answer counts as one selection.
+Single-select remains the default. Explicit `minSelections: 1` and `maxSelections: 1` are equivalent to omitting both bounds; other single-select bounds are rejected. An agent opts into multi-select with `mode: "multiple"` and may set `minSelections` and `maxSelections`; the custom answer counts as one selection.
 
 In multi-select, use Space or a visible number to toggle an option, `/` to filter, and Enter to submit. The filter accepts spaces; Enter applies it and Escape returns to the choices. Checked options remain selected when the filter changes. Select **Type a custom answer** with Enter to add or edit one custom item alongside checked options.
 
@@ -107,8 +112,8 @@ Lifecycle hooks are loaded from `.pi/killeros-hooks.json` at session start. Supp
 | Mode | Behavior |
 |---|---|
 | TUI | All features are available, including the completion sound and tab-title indicator |
-| RPC | Goal set/view/pause/resume/clear and concise prompt guidance work; TUI components, `/goal edit`, `/init`, completion sounds, and the title indicator are disabled |
-| Print/JSON | Concise prompt guidance works; interactive questions, `/goal`, and `/init` fail explicitly; completion sounds and the title indicator are disabled |
+| RPC | Goal set/view/pause/resume/clear work; TUI components, `/goal edit`, `/init`, completion sounds, and the title indicator are disabled |
+| Print/JSON | Interactive questions, `/goal`, and `/init` fail explicitly; completion sounds and the title indicator are disabled |
 
 ## Validation
 

package/killeros/activity.ts

@@ -0,0 +1,97 @@
+import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+
+export type ActivityMessage =
+  | { kind: "prompt" }
+  | { kind: "tool"; toolName: string }
+  | { kind: "tool-result"; failed: boolean }
+  | { kind: "responding" };
+
+function safeToolName(toolName: string): string {
+  const normalized = toolName.replace(/[\u0000-\u001F\u007F]+/gu, " ").replace(/\s+/gu, " ").trim();
+  return truncateToWidth(normalized || "tool", 32, "…");
+}
+
+export function formatActivityMessage(message: ActivityMessage, theme: Theme): string {
+  let verb: string;
+  let detail: string;
+
+  switch (message.kind) {
+    case "prompt":
+      verb = "Mapping…";
+      detail = "understanding request";
+      break;
+    case "tool-result":
+      verb = message.failed ? "Recovering…" : "Reviewing…";
+      detail = message.failed ? "tool failed" : "reading the result";
+      break;
+    case "responding":
+      verb = "Responding…";
+      detail = "assembling the answer";
+      break;
+    case "tool":
+      switch (message.toolName.trim().toLocaleLowerCase()) {
+        case "read":
+        case "grep":
+        case "find":
+        case "ls":
+          verb = "Inspecting…";
+          detail = "reading relevant code";
+          break;
+        case "edit":
+        case "write":
+          verb = "Changing…";
+          detail = "editing";
+          break;
+        case "bash":
+          verb = "Running…";
+          detail = "command";
+          break;
+        default:
+          verb = "Working…";
+          detail = `using ${safeToolName(message.toolName)}`;
+      }
+      break;
+  }
+
+  return `${theme.fg("accent", verb)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · ${detail})`)}`;
+}
+
+export function registerRequestActivity(pi: ExtensionAPI): void {
+  let active = false;
+
+  const clear = (ctx?: ExtensionContext): void => {
+    if (ctx?.mode === "tui") {
+      ctx.ui.setWorkingMessage();
+    }
+    active = false;
+  };
+
+  pi.on("agent_start", (_event, ctx) => {
+    if (ctx.mode !== "tui") return;
+    active = true;
+    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "prompt" }, ctx.ui.theme));
+  });
+
+  pi.on("tool_execution_start", (event, ctx) => {
+    if (ctx.mode !== "tui" || !active) return;
+    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "tool", toolName: event.toolName }, ctx.ui.theme));
+  });
+
+  pi.on("tool_execution_end", (event, ctx) => {
+    if (ctx.mode !== "tui" || !active) return;
+    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "tool-result", failed: event.isError }, ctx.ui.theme));
+  });
+
+  pi.on("message_update", (event, ctx) => {
+    if (ctx.mode !== "tui" || !active || event.assistantMessageEvent.type !== "text_start") return;
+    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "responding" }, ctx.ui.theme));
+  });
+
+  pi.on("agent_settled", (_event, ctx) => {
+    if (ctx.mode !== "tui" || !active || !ctx.isIdle?.() || ctx.hasPendingMessages?.()) return;
+    clear(ctx);
+  });
+
+  pi.on("session_shutdown", (_event, ctx) => clear(ctx));
+}

package/killeros/decision-gated-workflow.ts

@@ -0,0 +1,76 @@
+import path from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { QuestionDetails } from "./question.ts";
+import type { WorkflowAdapter, WorkflowPolicy, WorkflowToolAuthorization } from "./workflow-gate.ts";
+
+const READ_ONLY_TOOLS = ["read", "grep", "find", "ls", "question"] as const;
+
+const DOCUMENTATION_PATHS: readonly RegExp[] = [
+  /^(?:docs\/)?(?:glossary|context-map)(?:\.md|\/|$)/u,
+  /^docs\/adr\/[^/]+\.md$/u,
+];
+
+function relativePath(input: Readonly<Record<string, unknown>>, ctx: ExtensionContext): string | undefined {
+  if (typeof input.path !== "string" || input.path.trim().length === 0) return;
+  const absolute = path.resolve(ctx.cwd, input.path);
+  const relative = path.relative(ctx.cwd, absolute);
+  if (!relative || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return;
+  return relative.replaceAll(path.sep, "/").toLocaleLowerCase();
+}
+
+function authorizeDocumentationTool(
+  toolName: string,
+  input: Readonly<Record<string, unknown>>,
+  ctx: ExtensionContext,
+): WorkflowToolAuthorization {
+  if (toolName !== "edit" && toolName !== "write") return true;
+  const target = relativePath(input, ctx);
+  if (target && DOCUMENTATION_PATHS.some((pattern) => pattern.test(target))) return true;
+  return "With docs policy permits writes only to the agreed glossary, context-map, and ADR paths";
+}
+
+const NORMAL_POLICY: WorkflowPolicy = {
+  id: "normal",
+  allowedTools: READ_ONLY_TOOLS,
+};
+
+const WITH_DOCS_POLICY: WorkflowPolicy = {
+  id: "with-docs",
+  allowedTools: [...READ_ONLY_TOOLS, "edit", "write"],
+  authorizeTool: authorizeDocumentationTool,
+};
+
+const POLICIES = [NORMAL_POLICY, WITH_DOCS_POLICY] as const;
+
+function selectedAnswer(details: QuestionDetails): string | undefined {
+  if (!("answer" in details) || details.answer === null) return;
+  return details.answer;
+}
+
+export function createDecisionGatedWorkflowAdapter(): WorkflowAdapter {
+  return {
+    id: "decision-gated-workflow",
+    activation: "decision-gated-workflow",
+    question: {
+      question: "Choose the policy for this workflow before the model starts",
+      options: [
+        {
+          label: "Normal",
+          description: "Interview and read-only work; implementation files stay protected.",
+        },
+        {
+          label: "With docs",
+          description: "Allow only agreed glossary, context-map, or ADR documentation writes.",
+        },
+      ],
+    },
+    policies: POLICIES,
+    selectPolicy(details) {
+      switch (selectedAnswer(details)) {
+        case "Normal": return NORMAL_POLICY;
+        case "With docs": return WITH_DOCS_POLICY;
+        default: return undefined;
+      }
+    },
+  };
+}

package/killeros/footer.ts

@@ -125,6 +125,10 @@ function renderFooterRow(left: string, right: string, width: number): string {
   return ` ${clippedLeft}${gap}${clippedRight} `;
 }
 
+function renderFooter(rows: string[], width: number, theme: Theme): string[] {
+  return [theme.fg("borderMuted", "─".repeat(width)), ...rows];
+}
+
 function formatGoalElapsed(milliseconds: number): string {
   const totalSeconds = Number.isFinite(milliseconds) ? Math.max(0, Math.floor(milliseconds / 1_000)) : 0;
   if (totalSeconds < 60) return `${totalSeconds}s`;
@@ -138,15 +142,13 @@ function formatGoalElapsed(milliseconds: number): string {
   return `${hours}h ${minutes.toString().padStart(2, "0")}m ${seconds.toString().padStart(2, "0")}s`;
 }
 
-function formatActiveGoalFooter(state: GoalState | undefined, theme: Theme): string {
-  if (state?.status !== "active") return "";
-  return theme.fg("warning", `/goal is active (${formatGoalElapsed(goalElapsedMilliseconds(state))})`);
-}
-
 function formatGoalFooter(state: GoalState | undefined, theme: Theme): string {
   if (!state) return "";
-  if (state.status === "paused") return theme.fg("warning", "Ⅱ goal paused");
-  if (state.status === "blocked") return theme.fg("error", "! goal blocked");
+  if (state.status === "active") {
+    return theme.fg("warning", `/goal is active (${formatGoalElapsed(goalElapsedMilliseconds(state))})`);
+  }
+  if (state.status === "paused") return theme.fg("warning", "/goal is paused");
+  if (state.status === "blocked") return theme.fg("error", "/goal is blocked");
   return "";
 }
 
@@ -211,52 +213,36 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
           const signature = formatModel(model, theme);
           const fullDirectory = theme.fg("dim", cwd);
           const focusedDirectory = theme.fg("dim", compactDirectory(cwd));
-          const activeGoal = formatActiveGoalFooter(goalRuntime.state, theme);
           const goal = formatGoalFooter(goalRuntime.state, theme);
-          const rich = joinFooterParts([
+          const primary = joinFooterParts([
             signature,
             level,
             context,
-            goal,
-            branch ? theme.fg("dim", branch) : "",
+          ], theme);
+          const primaryFocused = joinFooterParts([signature, context], theme);
+          const session = joinFooterParts([
             theme.fg("dim", formatTime(Date.now() - sessionStart)),
             theme.fg("dim", formatCost(getSessionCost(ctx))),
           ], theme);
-          const focused = joinFooterParts([signature, context, goal], theme);
-
-          if (activeGoal) {
-            if (footerRowFits(rich, activeGoal, width)) {
-              return [renderFooterRow(rich, activeGoal, width)];
-            }
-            if (footerRowFits(focused, activeGoal, width)) {
-              return [renderFooterRow(focused, activeGoal, width)];
-            }
-            if (footerRowFits(context, activeGoal, width)) {
-              return [renderFooterRow(context, activeGoal, width)];
-            }
-            return [renderFooterRow("", activeGoal, width)];
-          }
-
-          if (footerRowFits(rich, fullDirectory, width)) {
-            return [renderFooterRow(rich, fullDirectory, width)];
-          }
-          if (footerRowFits(rich, focusedDirectory, width)) {
-            return [renderFooterRow(rich, focusedDirectory, width)];
-          }
-          if (footerRowFits(focused, focusedDirectory, width)) {
-            return [renderFooterRow(focused, focusedDirectory, width)];
-          }
-          if (footerRowFits(focused, "", width)) {
-            return [renderFooterRow(focused, "", width)];
-          }
-          if (goal) {
-            const essentialGoal = joinFooterParts([context, goal], theme);
-            if (footerRowFits(essentialGoal, "", width)) return [renderFooterRow(essentialGoal, "", width)];
-            return [renderFooterRow(goal, context, width)];
-          }
-
           const essentialModel = formatModel(model, theme, false);
-          return [renderFooterRow(essentialModel, context, width)];
+          const primaryRow = footerRowFits(primary, session, width)
+            ? renderFooterRow(primary, session, width)
+            : footerRowFits(primary, "", width)
+              ? renderFooterRow(primary, "", width)
+              : footerRowFits(primaryFocused, "", width)
+                ? renderFooterRow(primaryFocused, "", width)
+                : renderFooterRow(essentialModel, context, width);
+          const branchLabel = branch ? theme.fg("dim", branch) : "";
+          const workspaceRight = goal || fullDirectory;
+          const secondaryRow = footerRowFits(branchLabel, workspaceRight, width)
+            ? renderFooterRow(branchLabel, workspaceRight, width)
+            : goal
+              ? renderFooterRow("", goal, width)
+              : footerRowFits(branchLabel, focusedDirectory, width)
+                ? renderFooterRow(branchLabel, focusedDirectory, width)
+                : renderFooterRow(branchLabel, "", width);
+
+          return renderFooter([primaryRow, secondaryRow], width, theme);
         },
       };
     });