pi-fovea 0.6.0 → 0.7.0

package/README.md

@@ -129,7 +129,7 @@ Files over the size cap and extraction failures remain visible in `/fovea status
 
 Continuous sync is on by default. Before an agent starts, Fovea establishes its baseline or injects any out-of-band drift before the first model call. After every assistant turn it compares extracted symbols, calls, imports, literals, and anchors again. Content hashes keep the unchanged fast path cheap, while comment- and formatting-only edits do not wake the model.
 
-A meaningful change found before agent start is injected directly into that run. A post-turn route or dependency change is sent with `deliverAs: "steer"`; if the agent would otherwise settle, `triggerTurn` starts the continuation automatically. The compact update names directly changed files, route deltas, newly relevant files, causal channels such as calls, imports, shared literals, tests, or co-change history, and a suggested next focus probe so the update continues graph navigation. Clean turns remain silent unless `sync.ackClean` is enabled.
+A meaningful change found before agent start is injected directly into that run. A post-turn route or dependency change is sent with `deliverAs: "steer"`; if the agent would otherwise settle, `triggerTurn` starts the continuation automatically. The compact update names directly changed files, route deltas, newly relevant files, causal channels such as calls, imports, shared literals, tests, or co-change history, and—by default—the top drift target's refreshed focus context embedded inline (push). With `sync.pushFocus` off, the update ends in a suggested next focus probe instead (pull). Clean turns remain silent unless `sync.ackClean` is enabled.
 
 Runtime controls:
 
@@ -154,6 +154,7 @@ Global settings live in `~/.pi/agent/fovea.json`. A trusted repo-level override
 | `sync.budget` | `1024` | token cap for proactive steering context |
 | `sync.ackClean` | `false` | toast after clean structural turns |
 | `sync.warmFileThreshold` | `2` | newly relevant files that justify proactive model steering |
+| `sync.pushFocus` | `true` | embed a budgeted focus preview of the top drift target in red syncs |
 | `tools.defaultBudget` | `2000` | fallback maxTokens for the fovea_* tools |
 | `tools.replaceGrep` | `true` | install hybrid native-text / bare-query graph grep |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fovea",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Token-budgeted repo mapping for agent sessions: foveated heat diffusion over a cross-language code graph, with progressive disclosure.",
   "type": "module",
   "license": "MIT",
@@ -50,20 +50,19 @@
   "bin": {
     "fovea": "cli.ts"
   },
-  "dependencies": {
-    "typebox": "^1.0.76"
-  },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.83.0",
-    "@earendil-works/pi-tui": "0.83.0",
+    "@earendil-works/pi-coding-agent": "0.84.0",
+    "@earendil-works/pi-tui": "0.84.0",
     "@types/node": "^22.0.0",
     "tsx": "^4.19.0",
+    "typebox": "^1.3.10",
     "typescript": "^5.6.0",
     "vitest": "^3.0.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.80.6",
-    "@earendil-works/pi-tui": ">=0.80.6"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   },
   "scripts": {
     "typecheck": "tsc --noEmit",

package/src/core/config.ts

@@ -1,11 +1,11 @@
 // pi-fovea configuration. Mirrors pi-fabric's two-scope model: a global file
-// under the pi agent dir (~/.pi/agent/fovea.json) and a project override at
-// <repo>/.pi/fovea.json when the project is trusted. Settings merge over
+// under the pi agent dir and a trusted project override beneath pi's
+// configurable project resource directory. Settings merge over
 // defaults; the FOVEA_TURN_SYNC=off environment variable always wins, the
 // same way PI_FABRIC_* overrides win over stored fabric config.
 
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 
 interface FoveaSyncConfig {
@@ -17,6 +17,9 @@ interface FoveaSyncConfig {
   ackClean: boolean;
   /** Number of newly relevant files that justifies proactive steering on its own. */
   warmFileThreshold: number;
+  /** Push (default): red syncs embed a budgeted focus preview of the top drift
+   * target. Pull: the update ends in a Next: advisory the model may follow. */
+  pushFocus: boolean;
 }
 
 interface FoveaToolsConfig {
@@ -37,6 +40,7 @@ export const DEFAULT_FOVEA_CONFIG: FoveaConfig = {
     budget: 1024,
     ackClean: false,
     warmFileThreshold: 2,
+    pushFocus: true,
   },
   tools: {
     defaultBudget: 2000,
@@ -59,7 +63,7 @@ export interface FoveaConfigScopes {
 }
 
 export const globalFoveaConfigPath = (agentDir: string): string => path.join(agentDir, "fovea.json");
-export const projectFoveaConfigPath = (cwd: string): string => path.join(cwd, ".pi", "fovea.json");
+export const projectFoveaConfigPath = (cwd: string): string => path.join(cwd, CONFIG_DIR_NAME, "fovea.json");
 
 const BOUNDS: Record<string, [number, number]> = {
   "sync.budget": [128, 8192],
@@ -89,6 +93,7 @@ const applyPartial = (base: FoveaConfig, partial: unknown): FoveaConfig => {
       budget: intValue("sync.budget", sync.budget, base.sync.budget),
       ackClean: boolValue(sync.ackClean, base.sync.ackClean),
       warmFileThreshold: intValue("sync.warmFileThreshold", sync.warmFileThreshold, base.sync.warmFileThreshold),
+      pushFocus: boolValue(sync.pushFocus, base.sync.pushFocus),
     },
     tools: {
       defaultBudget: intValue("tools.defaultBudget", tools.defaultBudget, base.tools.defaultBudget),
@@ -151,8 +156,6 @@ export const saveFoveaConfig = (
   return { scope, path: targetPath };
 };
 
-export const defaultAgentDir = (): string => path.join(os.homedir(), ".pi", "agent");
-
 /** Dotted-id helper used by the settings UI -> saveFoveaConfig partials. */
 export const buildPartialFromId = (id: string, value: unknown): Record<string, unknown> => {
   const segments = id.split(".");

package/src/core/ops.ts

@@ -5,7 +5,7 @@
 
 import { createHash } from "node:crypto";
 import { stat } from "node:fs/promises";
-import { posix } from "node:path";
+import { join, posix } from "node:path";
 import { hasAstGrepAsync } from "./astgrep.js";
 import {
   assembleGraphWithIndex,
@@ -55,6 +55,11 @@ export interface RepoState {
   probedAt: number;
   walkedAt: number;
   sweptAt: number;
+  /** Porcelain-dirty paths at last probe. Porcelain diffs the worktree against
+   * HEAD, but facts track the last seen worktree: a file reverting to
+   * porcelain-clean with unmoved HEAD would otherwise keep serving its dirty
+   * facts until the next edit. */
+  dirty: Set<string>;
 }
 
 // State lifecycle: background builds, probe-gated refreshes, LRU eviction.
@@ -126,6 +131,7 @@ const assembleState = async (
   extraction: ExtractionReport,
   gitKind: "git" | "plain",
   head: string | undefined,
+  dirty: Set<string>,
 ): Promise<RepoState> => {
   // Snapshot the generation: refresh replaces fact records wholesale, so the
   // Record view stays a stable witness for baselines (sync).
@@ -148,7 +154,7 @@ const assembleState = async (
     list.sort((a, b) => Number(a.kind === "contains") - Number(b.kind === "contains") || b.w - a.w || a.to - b.to);
   }
   const stamp = Date.now();
-  return { root, version, graph, csr, joinIndex, facts, extraction, adjacency, store, files, gitKind, head, probedAt: stamp, walkedAt: stamp, sweptAt: stamp };
+  return { root, version, graph, csr, joinIndex, facts, extraction, adjacency, store, files, gitKind, head, dirty, probedAt: stamp, walkedAt: stamp, sweptAt: stamp };
 };
 
 const buildState = async (root: string): Promise<RepoState> => {
@@ -163,7 +169,8 @@ const buildState = async (root: string): Promise<RepoState> => {
   const gitKind: RepoState["gitKind"] = probe ? "git" : "plain";
   const files = await listFiles(root, routeRes);
   const { store, report } = await factPass(() => loadFacts(root, files));
-  return assembleState(root, files, store, report, gitKind, probe?.head);
+  return assembleState(root, files, store, report, gitKind, probe?.head,
+    new Set(probe ? probe.changes.map((c) => c.path).filter((p) => p && !p.endsWith("/")) : []));
 };
 
 const refreshState = async (state: RepoState, hints: string[] = [], force = false): Promise<RepoState> => {
@@ -205,6 +212,25 @@ const refreshState = async (state: RepoState, hints: string[] = [], force = fals
           }
         }
       }
+      const nowDirty = new Set(
+        probe.changes.map((c) => c.path).filter((p) => p && !p.endsWith("/")),
+      );
+      if (!headMoved && !needsList) {
+        // Porcelain-clean with unmoved HEAD hides reverts: a previously dirty
+        // file vanishes from the probe while its captured facts stay dirty.
+        // Resurrect it once so the snapshot follows the worktree (covers
+        // checkout/restore and untracked files that disappear).
+        for (const p of state.dirty) {
+          if (nowDirty.has(p)) continue;
+          // stat is the arbiter: a restored file whose facts were dropped
+          // with the deletion must come back through changed, not sit
+          // deleted until its next porcelain-visible edit.
+          const onDisk = await stat(join(state.root, p)).then((s) => s.isFile(), () => false);
+          if (onDisk) changed.push(p);
+          else if (store.facts.has(p) || store.failedSha.has(p)) deleted.push(p);
+        }
+      }
+      state.dirty = nowDirty;
     } else {
       // .git vanished (moved/renamed out from under us): degrade to plain.
       state.gitKind = "plain";
@@ -237,7 +263,7 @@ const refreshState = async (state: RepoState, hints: string[] = [], force = fals
     state.files = files;
     return state;
   }
-  const fresh = await assembleState(state.root, files, store, report, state.gitKind, state.head);
+  const fresh = await assembleState(state.root, files, store, report, state.gitKind, state.head, state.dirty);
   states.set(state.root, fresh);
   return fresh;
 };

package/src/core/sync.ts

@@ -12,7 +12,7 @@
 // and /fovea reset alongside focus sessions.
 
 import { ROOT_CACHE_LIMIT, forEachChunked } from "./asyncutil.js";
-import { ensureState, ensureStateBackground, getInflight, getState, impact, isTestScope } from "./ops.js";
+import { ensureState, ensureStateBackground, focus, getInflight, getState, impact, isTestScope } from "./ops.js";
 import type { RepoState } from "./ops.js";
 import { getSession } from "./session.js";
 
@@ -25,6 +25,8 @@ interface SyncBaseline {
   semantics: Map<string, string>;
   /** Previously reported undisclosed warmth, for delta delivery. */
   warmed?: Set<string>;
+  /** Drift targets already push-embedded in this baseline chain (embed-once). */
+  pushed?: Set<string>;
 }
 
 const baselines = new Map<string, SyncBaseline>();
@@ -50,6 +52,8 @@ export interface SyncParams {
   files?: string[];
   budget: number;
   warmFileThreshold: number;
+  /** Push vs pull (default push): embed the top file target's focus context. */
+  pushFocus?: boolean;
 }
 
 export interface SyncOutcome {
@@ -168,7 +172,8 @@ export const sync = async (
       : [...warmNow].filter((file) => !prev.warmed!.has(file));
   }
 
-  setBaseline(root, { ...(await snapshot(state)), warmed: warmNow });
+  const pushed = new Set(prev.pushed ?? []);
+  setBaseline(root, { ...(await snapshot(state)), warmed: warmNow, pushed });
 
   // Extraction failures leave fact gaps that look like anchor *removals* —
   // never escalate red on removals while degraded; the degraded note is
@@ -196,34 +201,59 @@ export const sync = async (
   const changedSummary = files.length
     ? `${files.slice(0, 4).join(", ")}${files.length > 4 ? ` (+${files.length - 4} more)` : ""}`
     : deleted.length
-      ? `${deleted.length} deleted file${deleted.length === 1 ? "" : "s"}`
+      ? `deleted ${deleted.slice(0, 4).join(", ")}${deleted.length > 4 ? ` (+${deleted.length - 4} more)` : ""}`
       : "route structure";
   const orderedWarm = [...warmNew].sort((a, b) =>
     Number(isTestScope(a)) - Number(isTestScope(b)) || a.localeCompare(b));
   const lines: string[] = [
-    "Fovea continuous update — repository structure changed.",
+    "Repository structure changed.",
     `Changed: ${changedSummary}`,
   ];
   for (const id of added.filter((anchor) => !newlyImplicit.includes(anchor)).slice(0, 6)) {
     lines.push(`Route added: ${id}`);
   }
-  for (const id of removed.slice(0, 6)) lines.push(`Route removed: ${id}`);
+  // Degraded removals are suspect (extraction gaps look like removals); the
+  // escalation gate already distrusts them, so the message does too.
+  if (!degraded) for (const id of removed.slice(0, 6)) lines.push(`Route removed: ${id}`);
   if (orderedWarm.length) {
     lines.push("Newly relevant files:");
     for (const file of orderedWarm.slice(0, 8)) {
       lines.push(`  ${file} — ${(warmReasons[file] ?? ["graph path"]).join(", ")}`);
     }
   }
-  // Hand the model a next probe, not just a verdict: point focus at the
-  // most consequential consequence of the drift (new route > changed file >
-  // newly warm file), so the update continues graph navigation.
+  // Push vs pull on the consequence probe. A file target gets its refreshed
+  // focus context embedded inline (the embed discloses it, so any follow-up
+  // probe is a session delta and nearly free); each target embeds at most
+  // once per baseline chain. Route targets keep the advisory pending route
+  // fuzzy-match quality, and the no-target case stays verdict-only. Pull
+  // mode renders the advisory unconditionally.
   const focusTarget = added.find((id) => !newlyImplicit.includes(id))?.replace(/^\w+\s+(?=\/)/, "")
     ?? files[0]
     ?? orderedWarm[0];
-  lines.push(focusTarget
-    ? `Next: fovea_focus ${JSON.stringify(focusTarget)} to see what it now connects to.`
-    : "Next: fovea_sketch for the updated silhouette.");
-  lines.push("Steer: account for this update before continuing; inspect only the files relevant to the current task.");
+  const pushFocus = params.pushFocus !== false;
+  const steerLine = "Steer: account for this update before continuing.";
+  let embedded = false;
+  if (pushFocus && focusTarget && focusTarget in state.facts && !pushed.has(focusTarget)) {
+    const detailBudget = params.budget - Math.ceil([...lines, steerLine].join("\n").length / 4);
+    if (detailBudget >= 128) {
+      try {
+        const detail = await focus(root, focusTarget, detailBudget);
+        if (detail.text.trim()) {
+          lines.push(...detail.text.split("\n"));
+          pushed.add(focusTarget);
+          embedded = true;
+        }
+      } catch {
+        // Focus is best-effort context; fall through to the advisory.
+      }
+    }
+  }
+  if (!embedded && (!pushFocus || focusTarget)) {
+    lines.push(focusTarget
+      ? `Next: fovea_focus ${JSON.stringify(focusTarget)} to see what it now connects to.`
+      : "Next: fovea_sketch for the updated silhouette.");
+  }
+  lines.push(steerLine);
   while (lines.length > 3 && Math.ceil(lines.join("\n").length / 4) > params.budget) {
     lines.splice(lines.length - 2, 1);
   }
@@ -239,6 +269,7 @@ export const sync = async (
       warmNew: orderedWarm,
       warmReasons,
       deletedFiles: deleted,
+      ...(embedded ? { pushedFocus: focusTarget } : {}),
       ...(degraded ? { extractionDegraded: true } : {}),
     },
   };

package/src/index.ts

@@ -4,9 +4,9 @@
 // incremental across sessions.
 
 import { readFileSync } from "node:fs";
-import { createGrepTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { createGrepTool, getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
-import { defaultAgentDir, loadFoveaConfig, type FoveaConfig } from "./core/config.js";
+import { loadFoveaConfig, type FoveaConfig } from "./core/config.js";
 import { hasAstGrep } from "./core/astgrep.js";
 import { ROOT_CACHE_LIMIT } from "./core/asyncutil.js";
 import { dwell, ensureStateBackground, focus, impact, sketch } from "./core/ops.js";
@@ -78,7 +78,7 @@ export default function fovea(pi: ExtensionAPI) {
       configs.set(root, hit);
       return hit;
     }
-    const cfg = loadFoveaConfig({ cwd: root, agentDir: agentDir ?? defaultAgentDir(), projectTrusted: trusted });
+    const cfg = loadFoveaConfig({ cwd: root, agentDir: agentDir ?? getAgentDir(), projectTrusted: trusted });
     configs.set(root, cfg);
     while (configs.size > ROOT_CACHE_LIMIT) configs.delete(configs.keys().next().value!);
     return cfg;
@@ -104,6 +104,7 @@ export default function fovea(pi: ExtensionAPI) {
     throw error instanceof Error ? error : new Error(String(error));
   };
 
+  let lifecycleEpoch = 0;
   let grepOverrideRegistered = false;
   const registerGrepOverride = (): void => {
     if (grepOverrideRegistered) return;
@@ -152,11 +153,13 @@ export default function fovea(pi: ExtensionAPI) {
     });
   };
 
-  pi.on("session_start", async (event, ctx) => {
-    if (event.reason === "new" || event.reason === "fork") {
-      resetSessions();
-      resetSyncBaselines();
-    }
+  pi.on("session_start", async (_event, ctx) => {
+    const epoch = ++lifecycleEpoch;
+    // pi 0.84 replaces extension runtimes on resume/fork/new/reload. Core
+    // module caches may outlive one factory instance, but disclosure and sync
+    // baselines are session-local and must never cross that boundary.
+    resetSessions();
+    resetSyncBaselines();
     if (configFor(ctx.cwd, ctx.isProjectTrusted()).tools.replaceGrep) registerGrepOverride();
     // Kick indexing in the background — the very first prompt must never
     // wait on hashing/ast-grep. Slow cold builds surface a ready notice so
@@ -168,14 +171,16 @@ export default function fovea(pi: ExtensionAPI) {
       // unhandled rejection when ast-grep is unavailable.
       void kick.promise.then(
         (st) => {
+          if (epoch !== lifecycleEpoch) return;
           const ms = Date.now() - t0;
           if (kick.started && ctx.hasUI && ms > 4000) {
-            ctx.ui.notify(`Fovea index ready — ${st.graph.files.length} files (${(ms / 1000).toFixed(1)}s)`, "info");
+            ctx.ui.notify(`Index ready — ${st.graph.files.length} files (${(ms / 1000).toFixed(1)}s)`, "info");
           }
         },
         (error) => {
+          if (epoch !== lifecycleEpoch) return;
           if (kick.started && ctx.hasUI) {
-            ctx.ui.notify(`Fovea index failed: ${error instanceof Error ? error.message : error}`, "warning");
+            ctx.ui.notify(`Index failed: ${error instanceof Error ? error.message : error}`, "warning");
           }
         },
       );
@@ -190,6 +195,13 @@ export default function fovea(pi: ExtensionAPI) {
   // conversation turns exit at zero cost through the version fast path.
   let turnFiles: string[] = [];
   let lastSyncError: string | undefined;
+  pi.on("session_shutdown", () => {
+    lifecycleEpoch++;
+    turnFiles = [];
+    lastSyncError = undefined;
+    resetSessions();
+    resetSyncBaselines();
+  });
   pi.on("turn_start", () => {
     turnFiles = [];
   });
@@ -204,7 +216,7 @@ export default function fovea(pi: ExtensionAPI) {
       if (!cfg.sync.enabled) return;
       const outcome = await sync(
         ctx.cwd,
-        { files: [], budget: cfg.sync.budget, warmFileThreshold: cfg.sync.warmFileThreshold },
+        { files: [], budget: cfg.sync.budget, warmFileThreshold: cfg.sync.warmFileThreshold, pushFocus: cfg.sync.pushFocus },
         undefined,
         { probe: "cheap" },
       );
@@ -220,11 +232,11 @@ export default function fovea(pi: ExtensionAPI) {
         };
       }
       if (outcome.structural && !outcome.details.baseline && cfg.sync.ackClean && ctx.hasUI) {
-        ctx.ui.notify("Fovea checked repository changes; no new action is needed.", "info");
+        ctx.ui.notify("Checked repository changes; no new action is needed.", "info");
       }
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
-      if (ctx.hasUI && message !== lastSyncError) ctx.ui.notify(`Fovea sync paused: ${message}`, "warning");
+      if (ctx.hasUI && message !== lastSyncError) ctx.ui.notify(`Sync paused: ${message}`, "warning");
       lastSyncError = message;
     }
   });
@@ -239,7 +251,7 @@ export default function fovea(pi: ExtensionAPI) {
       if (!cfg.sync.enabled) return;
       const outcome = await sync(
         ctx.cwd,
-        { files: rels, budget: cfg.sync.budget, warmFileThreshold: cfg.sync.warmFileThreshold },
+        { files: rels, budget: cfg.sync.budget, warmFileThreshold: cfg.sync.warmFileThreshold, pushFocus: cfg.sync.pushFocus },
         undefined,
         { probe: "cheap" },
       );
@@ -255,13 +267,13 @@ export default function fovea(pi: ExtensionAPI) {
           details: outcome.details,
         }, { deliverAs: "steer", triggerTurn: true });
       } else if (!outcome.details.baseline && cfg.sync.ackClean && ctx.hasUI) {
-        ctx.ui.notify("Fovea checked repository changes; no new action is needed.", "info");
+        ctx.ui.notify("Checked repository changes; no new action is needed.", "info");
       }
     } catch (error) {
       // Turn-sync stays nonfatal, but a persistent index failure must not look
       // like a clean repository. Notify once until a successful sync clears it.
       const message = error instanceof Error ? error.message : String(error);
-      if (ctx.hasUI && message !== lastSyncError) ctx.ui.notify(`Fovea sync paused: ${message}`, "warning");
+      if (ctx.hasUI && message !== lastSyncError) ctx.ui.notify(`Sync paused: ${message}`, "warning");
       lastSyncError = message;
     }
   });

package/src/ui/settings.ts

@@ -2,10 +2,11 @@
 // settings component structure (SettingsList in a bordered Container,
 // SelectList submenus, dotted-id coercion) so both extensions feel like one
 // settings surface. Persistence: fovea.json under the pi agent dir, with a
-// project override at <repo>/.pi/fovea.json for trusted projects; Ctrl+G in
-// the overlay toggles which scope the next change saves to.
+// project override beneath pi's configured project resource directory; the
+// external-editor keybinding toggles which scope the next change saves to.
 
 import {
+  CONFIG_DIR_NAME,
   DynamicBorder,
   getAgentDir,
   type ExtensionContext,
@@ -14,8 +15,7 @@ import {
 import {
   Container,
   type Component,
-  Key,
-  matchesKey,
+  type KeybindingsManager,
   SelectList,
   type SelectItem,
   type SelectListLayoutOptions,
@@ -43,7 +43,6 @@ const SELECT_LAYOUT: SelectListLayoutOptions = {
   maxPrimaryColumnWidth: 32,
 };
 
-const SAVE_SCOPE_SHORTCUT = Key.ctrl("g");
 
 type SettingsSubmenu = (currentValue: string, done: (selectedValue?: string) => void) => Component;
 
@@ -123,7 +122,13 @@ const numericSubmenu = (
   );
 };
 
+const formatKey = (key: string): string => key
+  .split("+")
+  .map((part) => part === "ctrl" ? "Ctrl" : part === "alt" ? "Alt" : part === "shift" ? "Shift" : part.toUpperCase())
+  .join("+");
+
 export interface FoveaSettingsComponentOptions {
+  keybindings?: Pick<KeybindingsManager, "matches" | "getKeys">;
   initialSaveScope?: FoveaConfigScope;
   projectScopeAvailable?: boolean;
   onSaveScopeChange?: (scope: FoveaConfigScope) => void;
@@ -132,6 +137,7 @@ export interface FoveaSettingsComponentOptions {
 export class FoveaSettingsComponent extends Container {
   readonly settingsList: SettingsList;
   private readonly theme: Theme;
+  private readonly keybindings: Pick<KeybindingsManager, "matches" | "getKeys"> | undefined;
   private readonly saveScopeText: Text;
   private readonly projectScopeAvailable: boolean;
   private readonly onSaveScopeChange: (scope: FoveaConfigScope) => void;
@@ -146,6 +152,7 @@ export class FoveaSettingsComponent extends Container {
   ) {
     super();
     this.theme = theme;
+    this.keybindings = options.keybindings;
     this.projectScopeAvailable = options.projectScopeAvailable ?? true;
     this.saveScope = options.initialSaveScope === "global" || !this.projectScopeAvailable
       ? "global"
@@ -164,7 +171,7 @@ export class FoveaSettingsComponent extends Container {
   }
 
   handleInput(data: string): void {
-    if (matchesKey(data, SAVE_SCOPE_SHORTCUT)) {
+    if (this.keybindings?.matches(data, "app.editor.external")) {
       if (!this.projectScopeAvailable) return;
       this.saveScope = this.saveScope === "project" ? "global" : "project";
       this.updateSaveScopeText();
@@ -174,12 +181,19 @@ export class FoveaSettingsComponent extends Container {
     this.settingsList.handleInput(data);
   }
 
+  override invalidate(): void {
+    super.invalidate();
+    this.updateSaveScopeText();
+  }
+
   private updateSaveScopeText(): void {
     const destination = this.saveScope === "project"
-      ? "Project (.pi/fovea.json)"
-      : "Global (~/.pi/agent/fovea.json)";
+      ? `Project (${CONFIG_DIR_NAME}/fovea.json)`
+      : `Global (~/${CONFIG_DIR_NAME}/agent/fovea.json)`;
+    const keys = this.keybindings?.getKeys("app.editor.external") ?? [];
+    const shortcut = keys.map(formatKey).join("/");
     const hint = this.projectScopeAvailable
-      ? " · Ctrl+G toggles save scope"
+      ? shortcut ? ` · ${shortcut} toggles save scope` : " · scope toggle key unavailable"
       : " · project scope unavailable for untrusted projects";
     this.saveScopeText.setText(
       this.theme.fg("muted", "Save scope: ") +
@@ -240,6 +254,11 @@ const buildItems = (
       "How many newly relevant files justify steering the model. Higher means fewer continuations; route changes always steer.",
     submenu: numericSubmenu(theme, THRESHOLDS, "Relevance threshold", "Newly relevant file count that steers the model."),
   }),
+  setting("sync.pushFocus", "Push focus detail", config.sync.pushFocus ? "true" : "false", {
+    description:
+      "Embed a budgeted focus preview of the top drift target in red sync messages so no extra probe turn is needed. Off keeps the Next: advisory. Default on.",
+    values: BOOLEANS,
+  }),
   setting("tools.replaceGrep", "Hybrid grep", config.tools.replaceGrep ? "true" : "false", {
     description:
       "Preserve native grep for scoped/regex/text searches and use Fovea only for bare symbol queries. Default on; changing it reloads extensions.",
@@ -294,7 +313,7 @@ export const openFoveaSettings = async (
     deps.onConfigApplied?.();
   };
 
-  await context.ui.custom<void>((tui, theme, _keybindings, done) => {
+  await context.ui.custom<void>((tui, theme, keybindings, done) => {
     const items = buildItems(theme, config);
     return new FoveaSettingsComponent(
       theme,
@@ -302,6 +321,7 @@ export const openFoveaSettings = async (
       (id, newValue) => apply(id, coerceValue(id, newValue, config)),
       () => done(),
       {
+        keybindings,
         initialSaveScope: saveScope,
         projectScopeAvailable: scopes.projectTrusted,
         onSaveScopeChange: (scope) => {