killeros 2.1.27 → 2.1.29

package/CHANGELOG.md

@@ -4,6 +4,38 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.1.29] - 2026-09-19
+
+### Added
+
+- Added `/auto-compact [status|on|off|<percent>]` to inspect and update the global automatic compaction preference without restarting Pi.
+
+### Fixed
+
+- Kept normalized CRLF checkouts clean in passive Git scans while respecting text attributes and binary files without running filters.
+- Detected same-size tracked-file rewrites even when tools restore the indexed modification time.
+- Resolved change-receipt repository ownership at the start of every response so nested or replaced repositories cannot reuse a stale monitor.
+- Kept the 100% automatic-compaction threshold active for later user requests and goal turns without compacting the generated ordinary continuation.
+- Prevented automatic footer and change-receipt scans from starting clean or process filters, including filters added and removed while a scan is running.
+
+## [2.1.28] - 2026-09-15
+
+### Changed
+
+- Simplified goal presentation without changing goal behavior: transcript history shows one iconless event row per lifecycle change (`Goal started`, `Goal replaced`, `Goal paused`, `Goal resumed`, `Goal cleared`), progress and blocker outcomes render once through the goal tool result, the footer shows compact `/goal active · 1/20 · 10s` status, the `/goal` panel leads with status then objective then `Pause goal` / `Resume goal` / `Clear goal` actions, and duplicate TUI success notifications are suppressed while RPC confirmations remain. Active-goal labels use muted teal `#6FAEB2` through the packaged theme's extension-label role.
+- Removed the legacy `✻` marker from version-1 `Worked for …` transcript rows; stored entries are unchanged and remain readable.
+
+### Added
+
+- Appended the selected model ID as a gray `· <model-id>` suffix to every TUI activity working message, retained for the full request cycle and falling back to `unknown model` when no usable ID exists.
+
+### Fixed
+
+- Kept resumed blocked goals and goals paused by truncated provider errors readable after reload.
+- Made goal continuation explicit: each settled turn now needs one accepted `continue`, `complete`, or blocker decision. Missing decisions, repeated continuation reports, unavailable goal tools, and runtime failures pause without scheduling another turn; compaction recovery resumes the same logical turn.
+- Preserved accepted goal decisions across automatic compaction: a `continue` or blocker audit recorded before compaction now authorizes exactly one next turn instead of being discarded and re-decided. Duplicate compaction and settlement callbacks cannot start a second turn.
+- Scoped goal pause reasons to the current paused state: resume and manual pause no longer surface an earlier automatic reason, terminal states keep no pause reason, and contradictory persisted states fail closed instead of starting automatic work.
+
 ## [2.1.27] - 2026-09-12
 
 ### Added

package/README.md

@@ -5,10 +5,10 @@ A TypeScript extension for the [Pi coding agent](https://github.com/earendil-wor
 ## What you get
 
 - A custom TUI: startup masthead with versions, model, working directory, and Git branch; a dark theme with coral accents; a multiline editor with slash-command completion; a footer that tracks model, context, and goal state; settled task receipts with duration and token usage.
-- `/goal`: set an objective and Pi keeps working toward it across turns, compaction, reloads, and branch navigation. New goals pause after 20 turns; `/goal resume` grants another 20.
+- `/goal`: set an objective and Pi keeps working toward it across turns, compaction, reloads, and branch navigation. Each turn must record `continue` with evidence and one next action, `complete`, or the existing blocker decision; otherwise the goal pauses. New goals pause after 20 turns; `/goal resume` grants another 20.
 - `/codex-fast`: toggles the `priority` service tier on Codex requests or reports its status.
 - `/handoff`: starts a fresh linked session carrying visible continuation context.
-- Automatic context compaction when remaining tokens drop below 15% of the window (configurable).
+- `/auto-compact`: reports, enables, disables, or tunes automatic context compaction.
 - A `question` tool with single-select and multi-select modes.
 - Lifecycle hooks (`tool_call`, `tool_result`, `agent_settled`) from `.pi/killeros-hooks.json`, plus `AGENTS.local.md` loading for trusted projects.
 - Optional completion sounds for settled requests.
@@ -32,7 +32,7 @@ Or from GitHub:
 pi install git:github.com/KyrosHendrix/pi-KillerOS
 ```
 
-Pin a release by appending its tag, for example `@v2.1.27`. Add `-l` to install only for the current project. Restart Pi after installing.
+Pin a release by appending its tag, for example `@v2.1.29`. Add `-l` to install only for the current project. Restart Pi after installing.
 
 ## Commands
 
@@ -43,6 +43,8 @@ Pin a release by appending its tag, for example `@v2.1.27`. Add `-l` to install
 /goal resume              Resume automatic continuation
 /goal clear               Remove the current goal
 /codex-fast [status]      Toggle or report Codex fast mode
+/auto-compact [status|on|off|<percent>]
+                          Inspect or change automatic compaction
 /notification             Configure the completion sound
 /handoff [focus]          Fresh session with continuation context
 /clear                    New session after confirmation
@@ -71,6 +73,8 @@ The packaged `killeros` theme activates on TUI start. Compaction triggers by def
 }
 ```
 
+Use `/auto-compact status` to inspect the effective KillerOS preference, `/auto-compact on` or `/auto-compact off` to toggle it, and `/auto-compact <percent>` to set an integer threshold from 0 through 100. A threshold of 0 does not disable Pi's own token reserve.
+
 `handoffMaxTokens` caps the `/handoff` summary output at 8192 tokens by default; raise it when long sessions truncate the summary.
 
 State proof in the objective so the agent can verify it with its normal tools:
@@ -85,7 +89,7 @@ A direct quoted file target binds silent file proof:
 /goal Fix `killeros/footer.ts`, verified by npm test
 ```
 
-KillerOS captures the file baseline at goal start and only completes when the file is created or changed. New goals pause after 20 turns without warning. An explicit `/goal resume` on an exhausted goal grants another 20 turns; compaction recovery never grants turns. Restored goals keep their persisted limit.
+KillerOS captures the file baseline at goal start and only completes when the file is created or changed. A normal response never continues a goal by itself: the agent must record `continue`, `complete`, or a blocker decision through `killeros_goal_update`. Repeated continuation reports and unavailable goal tools pause the goal. New goals pause after 20 turns without warning. An explicit `/goal resume` on an exhausted goal grants another 20 turns; compaction recovery never grants turns. Restored goals keep their persisted limit.
 
 Completion sounds are off by default; change with `/notification` in TUI mode. The tab-title indicator requires a Nerd Font.
 

package/killeros/activity.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
+import { modelDisplayName } from "./display.ts";
 
 export type ActivityMessage =
   | { kind: "prompt" }
@@ -12,7 +13,7 @@ function safeToolName(toolName: string): string {
   return truncateToWidth(normalized || "tool", 32, "…");
 }
 
-export function formatActivityMessage(message: ActivityMessage, theme: Theme): string {
+export function formatActivityMessage(message: ActivityMessage, theme: Theme, modelId?: string): string {
   let verb: string;
   let detail: string;
 
@@ -58,38 +59,46 @@ export function formatActivityMessage(message: ActivityMessage, theme: Theme): s
     }
   }
 
-  return `${theme.fg("accent", verb)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · ${detail})`)}`;
+  const suffix = modelDisplayName({ id: modelId }) || "unknown model";
+  return `${theme.fg("accent", verb)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · ${detail})`)}${theme.fg("dim", ` · ${suffix}`)}`;
 }
 
 export function registerRequestActivity(pi: ExtensionAPI): void {
   let active = false;
+  let activeModel: string | undefined;
+
+  const render = (message: ActivityMessage, ctx: ExtensionContext): void => {
+    ctx.ui.setWorkingMessage(formatActivityMessage(message, ctx.ui.theme, activeModel));
+  };
 
   const clear = (ctx?: ExtensionContext): void => {
+    active = false;
+    activeModel = undefined;
     if (ctx?.mode === "tui") {
       ctx.ui.setWorkingMessage();
     }
-    active = false;
   };
 
   pi.on("agent_start", (_event, ctx) => {
     if (ctx.mode !== "tui") return;
+    if (!active) activeModel = ctx.model?.id;
     active = true;
-    ctx.ui.setWorkingMessage(formatActivityMessage({ kind: "prompt" }, ctx.ui.theme));
+    render({ kind: "prompt" }, ctx);
   });
 
   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));
+    render({ kind: "tool", toolName: event.toolName }, ctx);
   });
 
   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));
+    render({ kind: "tool-result", failed: event.isError }, ctx);
   });
 
   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));
+    render({ kind: "responding" }, ctx);
   });
 
   pi.on("agent_settled", (_event, ctx) => {

package/killeros/auto-compaction.ts

@@ -7,7 +7,8 @@ import {
   type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { errorMessage } from "./errors.ts";
-import { createKillerosSettingsStore } from "./settings.ts";
+import { GOAL_CONTINUATION_TYPE } from "./goal-runtime.ts";
+import { createKillerosSettingsStore, type KillerosSettingsStore } from "./settings.ts";
 
 export const DEFAULT_AUTO_COMPACTION_PERCENT_REMAINING = 15;
 export const AUTO_COMPACTION_MESSAGE_TYPE = "killeros-auto-compaction";
@@ -32,6 +33,7 @@ export interface AutoCompactionGoalHandlers {
 export interface AutoCompactionDependencies {
   loadPreference?: (ctx: ExtensionContext) => AutoCompactionPreference;
   getCompactionSettings?: (ctx: ExtensionContext) => CompactionSettings;
+  settingsStore?: KillerosSettingsStore;
   goal?: AutoCompactionGoalHandlers;
 }
 
@@ -66,8 +68,8 @@ export function readAutoCompactionPreference(
   };
 }
 
-function defaultPreference(): AutoCompactionPreference {
-  return readAutoCompactionPreference(createKillerosSettingsStore().load());
+function defaultPreference(store: KillerosSettingsStore): AutoCompactionPreference {
+  return readAutoCompactionPreference(store.load());
 }
 
 function defaultCompactionSettings(ctx: ExtensionContext): CompactionSettings {
@@ -115,18 +117,60 @@ export function registerAutoCompaction(
   pi: ExtensionAPI,
   dependencies: AutoCompactionDependencies = {},
 ): void {
-  const loadPreference = dependencies.loadPreference ?? (() => defaultPreference());
+  const settingsStore = dependencies.settingsStore ?? createKillerosSettingsStore();
+  const loadPreference = dependencies.loadPreference ?? (() => defaultPreference(settingsStore));
   const getCompactionSettings = dependencies.getCompactionSettings ?? defaultCompactionSettings;
   let request: AutoCompactionRequest | undefined;
   let armed = true;
+  let rearmOnNextLogicalRequest = false;
   let settingsErrorReported = false;
 
   const resetForLifecycle = (): void => {
     request = undefined;
     armed = true;
+    rearmOnNextLogicalRequest = false;
     settingsErrorReported = false;
   };
 
+  pi.registerCommand("auto-compact", {
+    description: "Inspect or change automatic compaction",
+    handler: async (args, ctx) => {
+      const argument = args.trim();
+      if (!argument || argument === "status") {
+        try {
+          const preference = readAutoCompactionPreference(settingsStore.load());
+          ctx.ui.notify(preference.enabled
+            ? `Automatic compaction: on at ${preference.percentRemaining}% remaining`
+            : `Automatic compaction: off (threshold ${preference.percentRemaining}%)`, "info");
+        } catch (error) {
+          ctx.ui.notify(`Automatic compaction setting could not be read: ${errorMessage(error)}`, "error");
+        }
+        return;
+      }
+
+      const percent = /^\d+$/u.test(argument) ? Number(argument) : undefined;
+      if (argument !== "on" && argument !== "off" && (percent === undefined || percent > 100)) {
+        ctx.ui.notify("Usage: /auto-compact [status|on|off|<percent 0-100>]", "error");
+        return;
+      }
+
+      try {
+        const preference = readAutoCompactionPreference(settingsStore.load());
+        const updated = percent === undefined
+          ? { ...preference, enabled: argument === "on" }
+          : { ...preference, percentRemaining: percent };
+        settingsStore.update({ autoCompaction: updated });
+        ctx.ui.notify(percent === undefined
+          ? updated.enabled
+            ? `Automatic compaction: on at ${updated.percentRemaining}% remaining`
+            : `Automatic compaction: off (threshold ${updated.percentRemaining}%)`
+          : `Automatic compaction threshold: ${percent}% remaining (${updated.enabled ? "on" : "off"})`, "info");
+      } catch (error) {
+        ctx.ui.notify(`Automatic compaction setting could not be saved: ${errorMessage(error)}`, "error");
+      }
+    },
+  });
+
   const notifyFailure = (ctx: ExtensionContext, error: unknown): void => {
     ctx.ui.notify(`Automatic compaction failed: ${errorMessage(error)}`, "error");
   };
@@ -250,6 +294,7 @@ export function registerAutoCompaction(
       ctx.compact({
         onComplete: () => {
           if (request?.phase !== "compacting" || request.token !== token) return;
+          rearmOnNextLogicalRequest = preference.percentRemaining === 100;
           if (goal && dependencies.goal) {
             request = undefined;
             try {
@@ -280,9 +325,15 @@ export function registerAutoCompaction(
     finalizeOrdinaryContinuation(ctx, request.token);
   });
   pi.on("message_start", (event) => {
-    if (request?.phase === "continuation-dispatched"
-      && event.message.role === "custom"
-      && event.message.customType === AUTO_COMPACTION_MESSAGE_TYPE) request = undefined;
+    const isOrdinaryContinuation = event.message.role === "custom"
+      && event.message.customType === AUTO_COMPACTION_MESSAGE_TYPE;
+    if (request?.phase === "continuation-dispatched" && isOrdinaryContinuation) request = undefined;
+    const startsNewLogicalRequest = event.message.role === "user"
+      || (event.message.role === "custom" && event.message.customType === GOAL_CONTINUATION_TYPE);
+    if (rearmOnNextLogicalRequest && startsNewLogicalRequest) {
+      armed = true;
+      rearmOnNextLogicalRequest = false;
+    }
   });
 
   pi.on("session_start", resetForLifecycle);

package/killeros/change-receipt.ts

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { createReadStream, watch } from "node:fs";
-import { PASSIVE_GIT_CONFIG_ARGS, passiveGitCommand, passiveGitEnv, passiveStatusSafetyArgs, samePassiveFilters } from "./passive-git-status.ts";
+import { inspectWorktreeWithoutFilters, passiveGitCommand, passiveGitEnv, type PassiveWorktreeFile as DirtyFile } from "./passive-git-status.ts";
 import { lstat, open, readlink } from "node:fs/promises";
 import path from "node:path";
 import { createInflate } from "node:zlib";
@@ -140,44 +140,22 @@ type Repository = {
   blobCache: Map<string, Buffer>;
   blobCacheBytes: number;
 };
-const repositoryCache = new Map<string, Promise<Repository>>();
-
 async function repository(cwd: string): Promise<Repository> {
-  const cached = repositoryCache.get(cwd);
-  if (cached) return cached;
-  const pending = (async () => {
-    const result = decode(await runGit(cwd, ["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-dir", "--git-common-dir"])).trimEnd().split(/\r?\n/u);
-    const [root, gitDirectory, commonDirectory] = result;
-    if (!root || !gitDirectory || !commonDirectory) throw new GitFailure("error");
-    return {
-      root,
-      gitDirectory,
-      commonDirectory,
-      objectDirectory: path.join(commonDirectory, "objects"),
-      blobCache: new Map(),
-      blobCacheBytes: 0,
-    };
-  })();
-  repositoryCache.set(cwd, pending);
-  try {
-    return await pending;
-  } catch (error) {
-    repositoryCache.delete(cwd);
-    throw error;
-  }
+  const result = decode(await runGit(cwd, [
+    "rev-parse", "--path-format=absolute", "--show-toplevel", "--git-dir", "--git-common-dir", "--git-path", "objects",
+  ])).trimEnd().split(/\r?\n/u);
+  const [root, gitDirectory, commonDirectory, objectDirectory] = result;
+  if (!root || !gitDirectory || !commonDirectory || !objectDirectory) throw new GitFailure("error");
+  return {
+    root,
+    gitDirectory,
+    commonDirectory,
+    objectDirectory,
+    blobCache: new Map(),
+    blobCacheBytes: 0,
+  };
 }
 
-type DirtyFile = {
-  path: string;
-  headMode?: string;
-  headObjectId?: string;
-  indexMode?: string;
-  indexObjectId?: string;
-  mode?: string;
-  content?: Buffer;
-  contentObjectId?: string;
-};
-
 async function readBoundedFile(filePath: string, limit: number): Promise<Buffer> {
   const handle = await open(filePath, "r");
   try {
@@ -198,47 +176,6 @@ async function readBoundedFile(filePath: string, limit: number): Promise<Buffer>
   }
 }
 
-async function readSnapshotFiles(repo: Repository, files: Map<string, DirtyFile>): Promise<void> {
-  const pending = [...files.values()].filter((file) => file.mode && !file.contentObjectId);
-  let totalBytes = 0;
-  let nextIndex = 0;
-  const readNext = async (): Promise<void> => {
-    while (nextIndex < pending.length) {
-      const file = pending[nextIndex];
-      nextIndex += 1;
-      if (!file?.mode) continue;
-      const absolutePath = path.join(repo.root, ...file.path.split("/"));
-      if (file.mode === "120000") {
-        const content = Buffer.from(await readlink(absolutePath));
-        totalBytes += content.length;
-        if (totalBytes > SNAPSHOT_CONTENT_LIMIT) throw new GitFailure("too-large");
-        file.content = content;
-        continue;
-      }
-      const handle = await open(absolutePath, "r");
-      try {
-        const stats = await handle.stat();
-        if (!stats.isFile()) throw new GitFailure("error");
-        totalBytes += stats.size;
-        if (totalBytes > SNAPSHOT_CONTENT_LIMIT) throw new GitFailure("too-large");
-        const content = Buffer.alloc(stats.size + 1);
-        let length = 0;
-        while (length < content.length) {
-          const { bytesRead } = await handle.read(content, length, content.length - length, length);
-          if (bytesRead === 0) break;
-          length += bytesRead;
-        }
-        if (length > stats.size) throw new GitFailure("error");
-        totalBytes -= stats.size - length;
-        file.content = content.subarray(0, length);
-      } finally {
-        await handle.close();
-      }
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(8, pending.length) }, readNext));
-}
-
 type Snapshot = { head: string; files: Map<string, DirtyFile> };
 type RepositoryMonitor = {
   changedPaths: Set<string>;
@@ -253,59 +190,23 @@ const repositoryMonitors = new Map<string, RepositoryMonitor>();
 
 function discardMonitor(monitor: RepositoryMonitor): void {
   for (const watcher of monitor.watchers) watcher.close();
-  repositoryMonitors.delete(monitor.repo.root);
+  if (repositoryMonitors.get(monitor.repo.root) === monitor) repositoryMonitors.delete(monitor.repo.root);
 }
 
-async function snapshot(repo: Repository, paths?: readonly string[]): Promise<Snapshot> {
-  const config = decode(await runGit(repo.root, PASSIVE_GIT_CONFIG_ARGS));
-  const safetyArgs = passiveStatusSafetyArgs(config);
-  if (!safetyArgs) throw new GitFailure("error");
-  const output = decode(await runGit(repo.root, [
-    ...safetyArgs,
-    "status", "--porcelain=v2", "--branch", "--no-ahead-behind", "-z", "--no-renames", "--untracked-files=all", "--ignore-submodules=all",
-    ...(paths ? ["--", ...paths] : []),
-  ]));
-  if (!samePassiveFilters(config, decode(await runGit(repo.root, PASSIVE_GIT_CONFIG_ARGS)))) throw new GitFailure("error");
-  const records = output.split("\0").filter(Boolean);
-  const headRecord = records.find((record) => record.startsWith("# branch.oid "));
-  if (!headRecord) throw new Error("missing HEAD state");
-  const files = new Map<string, DirtyFile>();
-  for (const record of records) {
-    if (record.startsWith("# ")) continue;
-    if (record.startsWith("u ")) throw new Error("unmerged index");
-    if (record.startsWith("? ")) {
-      const filePath = record.slice(2);
-      if (!filePath || filePath.endsWith("/")) continue;
-      const stats = await lstat(path.join(repo.root, ...filePath.split("/")));
-      files.set(filePath, {
-        ...files.get(filePath),
-        path: filePath,
-        indexMode: undefined,
-        indexObjectId: undefined,
-        mode: stats.isSymbolicLink() ? "120000" : stats.mode & 0o111 ? "100755" : "100644",
-        contentObjectId: undefined,
-      });
-      continue;
-    }
-    const match = /^1 (\S{2}) \S+ ([0-7]{6}) ([0-7]{6}) ([0-7]{6}) ([0-9a-f]+) ([0-9a-f]+) (.*)$/su.exec(record);
-    if (!match) throw new Error("invalid status record");
-    const [, status, headMode, indexMode, worktreeMode, headObjectId, indexObjectId, filePath] = match;
-    if (!status || !headMode || !indexMode || !worktreeMode || !headObjectId || !indexObjectId || !filePath) throw new Error("incomplete status record");
-    const worktreeChanged = status[1] !== ".";
-    const selectedMode = worktreeChanged ? worktreeMode : indexMode;
-    files.set(filePath, {
-      ...files.get(filePath),
-      path: filePath,
-      headMode: headMode === "000000" ? undefined : headMode,
-      headObjectId: /^0+$/u.test(headObjectId) ? undefined : headObjectId,
-      indexMode: indexMode === "000000" ? undefined : indexMode,
-      indexObjectId: /^0+$/u.test(indexObjectId) ? undefined : indexObjectId,
-      mode: selectedMode === "000000" ? undefined : selectedMode,
-      contentObjectId: worktreeChanged || /^0+$/u.test(indexObjectId) ? undefined : indexObjectId,
-    });
+function sameRepository(left: Repository, right: Repository): boolean {
+  return left.root === right.root
+    && left.gitDirectory === right.gitDirectory
+    && left.commonDirectory === right.commonDirectory
+    && left.objectDirectory === right.objectDirectory;
+}
+
+async function snapshot(repo: Repository): Promise<Snapshot> {
+  try {
+    return await inspectWorktreeWithoutFilters(repo.root, (args) => runGit(repo.root, args));
+  } catch (error) {
+    if (error instanceof Error && error.message === "worktree content limit exceeded") throw new GitFailure("too-large");
+    throw error;
   }
-  await readSnapshotFiles(repo, files);
-  return { head: headRecord.slice("# branch.oid ".length), files };
 }
 
 async function snapshotKnownPaths(repo: Repository, baseline: Snapshot, paths: readonly string[]): Promise<Snapshot | undefined> {
@@ -360,7 +261,8 @@ function observes(filePath: string, observedPaths: readonly string[]): boolean {
 async function refreshSnapshot(monitor: RepositoryMonitor, observedPaths: readonly string[], current = monitor.snapshot): Promise<Snapshot> {
   if (monitor.watchFailed || observedPaths.length > 200) return snapshot(monitor.repo);
   if (observedPaths.length === 0) return current;
-  const scoped = await snapshotKnownPaths(monitor.repo, current, observedPaths) ?? await snapshot(monitor.repo, observedPaths);
+  const scoped = await snapshotKnownPaths(monitor.repo, current, observedPaths);
+  if (!scoped) return snapshot(monitor.repo);
   const files = new Map(current.files);
   for (const filePath of files.keys()) {
     if (observes(filePath, observedPaths)) files.delete(filePath);
@@ -714,11 +616,17 @@ export async function beginChangeReceipt(cwd: string, trusted = true): Promise<C
     };
   }
   try {
-    const repo = await repository(cwd);
+    let repo = await repository(cwd);
     let monitor = repositoryMonitors.get(repo.root);
+    if (monitor && !sameRepository(monitor.repo, repo)) {
+      discardMonitor(monitor);
+      monitor = undefined;
+    }
     if (!monitor) {
       monitor = createMonitor(repo, await snapshot(repo));
       repositoryMonitors.set(repo.root, monitor);
+    } else {
+      repo = monitor.repo;
     }
     if (monitor.inUse) throw new Error("change collection already active");
     const idleChanges = [...monitor.changedPaths];
@@ -771,5 +679,4 @@ export async function beginChangeReceipt(cwd: string, trusted = true): Promise<C
 export function disposeChangeReceipts(): void {
   for (const monitor of repositoryMonitors.values()) discardMonitor(monitor);
   repositoryMonitors.clear();
-  repositoryCache.clear();
 }

package/killeros/commands.ts

@@ -70,6 +70,7 @@ const BUILTIN_COMMANDS: ReadonlyArray<{ name: string; description: string }> = [
 ];
 
 const COMMAND_SYNTAX_HINTS: Readonly<Record<string, string>> = {
+  "auto-compact": "/auto-compact [status|on|off|<percent>]",
   goal: "/goal [objective|pause|resume|clear]",
   handoff: "/handoff [next-session focus]",
   model: "/model [provider/model]",