killeros 2.0.18 → 2.0.20

package/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.0.20] - 2026-08-25
+
+### Changed
+
+- Added a typescript-eslint type-checked lint gate (`npm run lint`) alongside `tsc --noEmit`, and cleaned up the dead imports and untyped boundaries it surfaced.
+
+### Fixed
+
+- Treated Pi's exact `Nothing to compact (session too small)` rejection as an expected automatic-compaction skip: no failure notification, silent retry on the next eligible turn, and active goals resume through a dedicated skip recovery instead of pausing for `/goal resume`.
+- Made `/handoff` resilient to an unreadable `killeros.json`: explicit `KillerosOptions` budgets bypass the file, while other summaries fall back to the default budget with a visible warning.
+- Named `/handoff` output truncation instead of reporting "did not finish", raised the default summary budget to 8192 tokens for reasoning models, and made the budget configurable through `KillerosOptions` or the `killeros.json` `handoffMaxTokens` key.
+
+## [2.0.19] - 2026-08-24
+
+### Changed
+
+- Hardened JSON and caught-error boundaries, made goal and `/init` target states constructive, added exhaustive outcome handling, and replaced unsafe test doubles with checked adapters.
+- Deprecated positional `executeHook` arguments in favor of object options; the compatibility adapter will be removed in the next major release.
+
+### Fixed
+
+- Paused active goals during automatic compaction and resumed the exact paused revision once after compaction and turn settlement succeed.
+- Restored active goals saved by v2.0.18 shutdown checkpoints that omitted their stopped clock timestamp.
+
 ## [2.0.18] - 2026-08-24
 
 ### Added

package/Killeros.ts

@@ -30,6 +30,8 @@ export { buildInitEvidence, listInitEvidence, readInitEvidence } from "./killero
 export { captureInitTargetBaseline, installInitAgentsFile, validateGeneratedGuidance, writeInitAgentsFile } from "./killeros/init-target.ts";
 export interface KillerosOptions {
   completionNotifications?: CompletionNotificationDependencies;
+  /** Output-token budget for /handoff summaries; invalid values fall back to killeros.json, then the default. */
+  handoffMaxTokens?: number;
 }
 
 export default function Killeros(pi: ExtensionAPI, options: KillerosOptions = {}): void {
@@ -41,7 +43,7 @@ export default function Killeros(pi: ExtensionAPI, options: KillerosOptions = {}
   registerPersonalInstructions(pi, initRuntime);
   registerQuestionTool(pi);
   registerAliases(pi);
-  registerHandoff(pi, goalRuntime);
+  registerHandoff(pi, goalRuntime, options.handoffMaxTokens);
   registerSlashAutocomplete(pi, commandResolver);
   registerFooter(pi, goalRuntime);
   registerVariants(pi);

package/README.md

@@ -34,7 +34,7 @@ Or from GitHub:
 pi install git:github.com/KyrosHendrix/pi-KillerOS
 ```
 
-Pin a release by appending its tag, for example `@v2.0.18`. Add `-l` to install only for the current project. Restart Pi after installing.
+Pin a release by appending its tag, for example `@v2.0.20`. Add `-l` to install only for the current project. Restart Pi after installing.
 
 ## Commands
 
@@ -67,10 +67,13 @@ The packaged `killeros` theme activates on TUI start. Compaction triggers by def
   "autoCompaction": {
     "enabled": true,
     "percentRemaining": 15
-  }
+  },
+  "handoffMaxTokens": 8192
 }
 ```
 
+`handoffMaxTokens` caps the `/handoff` summary output at 8192 tokens by default; raise it when long sessions truncate the summary.
+
 Completion sounds are off by default; change with `/notification` in TUI mode. The tab-title indicator requires a Nerd Font.
 
 ## Development

package/killeros/activity.ts

@@ -52,6 +52,10 @@ export function formatActivityMessage(message: ActivityMessage, theme: Theme): s
           detail = `using ${safeToolName(message.toolName)}`;
       }
       break;
+    default: {
+      const exhaustive: never = message;
+      return exhaustive;
+    }
   }
 
   return `${theme.fg("accent", verb)} ${theme.fg("dim", `(${theme.bold("esc")} to interrupt · ${detail})`)}`;

package/killeros/auto-compaction.ts

@@ -12,6 +12,8 @@ import { createKillerosSettingsStore } from "./settings.ts";
 export const DEFAULT_AUTO_COMPACTION_PERCENT_REMAINING = 15;
 export const AUTO_COMPACTION_MESSAGE_TYPE = "killeros-auto-compaction";
 export const AUTO_COMPACTION_MESSAGE = "Continue the interrupted task from the compacted context.";
+/** Pi's exact rejection when a session has no eligible history to summarize; an expected skip, not a failure. */
+export const SESSION_TOO_SMALL_COMPACTION_ERROR = "Nothing to compact (session too small)";
 
 export interface AutoCompactionPreference {
   enabled: boolean;
@@ -23,6 +25,8 @@ export interface AutoCompactionGoalHandlers {
   onRequested(): void;
   onCompleted(ctx: ExtensionContext): void;
   onFailed(ctx: ExtensionContext, error: unknown): void;
+  /** Recovers the goal paused for a request Pi rejected as session-too-small, without claiming success. */
+  onSkipped(ctx: ExtensionContext): void;
 }
 
 export interface AutoCompactionDependencies {
@@ -72,6 +76,11 @@ function reserveTokens(settings: Pick<CompactionSettings, "reserveTokens">): num
     : 0;
 }
 
+/** Matches only Pi's exact rejection text on a real Error; near-matches and stringified values stay failures. */
+export function isSessionTooSmallCompactionError(error: unknown): boolean {
+  return error instanceof Error && error.message === SESSION_TOO_SMALL_COMPACTION_ERROR;
+}
+
 /** Triggers at the stricter of the user's percentage and Pi's token reserve. */
 export function shouldTriggerAutoCompaction(
   usage: Pick<ContextUsage, "tokens" | "contextWindow"> | undefined,
@@ -116,13 +125,7 @@ export function registerAutoCompaction(
     ctx.ui.notify(`Automatic compaction failed: ${errorMessage(error)}`, "error");
   };
 
-  const finishFailure = (
-    ctx: ExtensionContext,
-    token: symbol,
-    goal: boolean,
-    error: unknown,
-  ): void => {
-    if (!request || request.token !== token) return;
+  const finishFailure = (ctx: ExtensionContext, goal: boolean, error: unknown): void => {
     request = undefined;
     if (goal && dependencies.goal) {
       try {
@@ -135,6 +138,33 @@ export function registerAutoCompaction(
     notifyFailure(ctx, error);
   };
 
+  /** Ends a request with Pi's expected eligibility rejection: silent, rearmed, and never a failure. */
+  const finishSkip = (ctx: ExtensionContext, goal: boolean): void => {
+    request = undefined;
+    armed = true;
+    if (!goal) return;
+    try {
+      dependencies.goal?.onSkipped(ctx);
+    } catch (callbackError) {
+      notifyFailure(ctx, callbackError);
+    }
+  };
+
+  /** Single entry point for rejected requests: classifies before any sanitization, stale tokens stay inert. */
+  const finishRequestError = (
+    ctx: ExtensionContext,
+    token: symbol,
+    goal: boolean,
+    error: unknown,
+  ): void => {
+    if (!request || request.token !== token) return;
+    if (isSessionTooSmallCompactionError(error)) {
+      finishSkip(ctx, goal);
+      return;
+    }
+    finishFailure(ctx, goal, error);
+  };
+
   pi.on("turn_end", (_event, ctx) => {
     if (!supportedMode(ctx) || request) return;
 
@@ -179,7 +209,7 @@ export function registerAutoCompaction(
       try {
         dependencies.goal.onRequested();
       } catch (error) {
-        finishFailure(ctx, token, true, error);
+        finishFailure(ctx, true, error);
         return;
       }
     }
@@ -207,10 +237,10 @@ export function registerAutoCompaction(
             notifyFailure(ctx, error);
           }
         },
-        onError: (error) => finishFailure(ctx, token, goal, error),
+        onError: (error) => finishRequestError(ctx, token, goal, error),
       });
     } catch (error) {
-      finishFailure(ctx, token, goal, error);
+      finishRequestError(ctx, token, goal, error);
     }
   });
 

package/killeros/codex-fast-state.ts

@@ -5,10 +5,9 @@ interface CodexFastState {
   listeners: Set<CodexFastStateListener>;
 }
 
-const GLOBAL_STATE_KEY = "__killerosCodexFastState";
-type GlobalWithCodexFastState = typeof globalThis & {
-  [GLOBAL_STATE_KEY]?: unknown;
-};
+declare global {
+  var __killerosCodexFastState: unknown;
+}
 
 // Accepts process-global state only when it is safe to reuse across extension versions.
 function isCodexFastState(value: unknown): value is CodexFastState {
@@ -18,14 +17,13 @@ function isCodexFastState(value: unknown): value is CodexFastState {
     && [...value.listeners].every((listener) => typeof listener === "function");
 }
 
-const globalState = globalThis as GlobalWithCodexFastState;
-const savedState = globalState[GLOBAL_STATE_KEY];
+const savedState = globalThis.__killerosCodexFastState;
 const state: CodexFastState = isCodexFastState(savedState) ? savedState : {
   enabled: typeof savedState === "object" && savedState !== null
     && "enabled" in savedState && savedState.enabled === true,
   listeners: new Set<CodexFastStateListener>(),
 };
-globalState[GLOBAL_STATE_KEY] = state;
+globalThis.__killerosCodexFastState = state;
 
 export function isCodexFastEnabled(): boolean {
   return state.enabled;

package/killeros/commands.ts

@@ -234,9 +234,11 @@ export function registerSlashAutocomplete(
         };
       },
       applyCompletion(lines, cursorLine, cursorCol, item, prefix) {
-        const tagged = item as TaggedAutocompleteItem;
-        if (!tagged.killerosCommand) return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
-        usage.set(tagged.killerosCommand, (usage.get(tagged.killerosCommand) ?? 0) + 1);
+        const commandName = "killerosCommand" in item && typeof item.killerosCommand === "string"
+          ? item.killerosCommand
+          : undefined;
+        if (!commandName) return current.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+        usage.set(commandName, (usage.get(commandName) ?? 0) + 1);
         const line = lines[cursorLine] ?? "";
         const beforeCursor = line.slice(0, cursorCol);
         const afterCursor = line.slice(cursorCol);

package/killeros/errors.ts

@@ -1,6 +1,14 @@
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { safeTerminalText } from "./safe-terminal-text.ts";
 
+/** Checks a caught value for one exact string error code. */
+export function hasErrorCode(error: unknown, code: string): boolean {
+  return typeof error === "object"
+    && error !== null
+    && "code" in error
+    && error.code === code;
+}
+
 /** Converts unknown caught values into text suitable for user-facing errors. */
 export function errorMessage(error: unknown): string {
   return safeTerminalText(error instanceof Error ? error.message : String(error));

package/killeros/footer.ts

@@ -1,5 +1,5 @@
-import { DynamicBorder, type ExtensionAPI, type ExtensionContext, type Theme, type ThemeColor } from "@earendil-works/pi-coding-agent";
-import { Container, Text, truncateToWidth, visibleWidth, type TUI } from "@earendil-works/pi-tui";
+import { type ExtensionAPI, type ExtensionContext, type Theme, type ThemeColor } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth, type TUI } from "@earendil-works/pi-tui";
 import { isCodexFastEnabled, subscribeCodexFast } from "./codex-fast-state.ts";
 import { formatCwd, formatTime, formatTokens, padRight } from "./display.ts";
 import { goalElapsedMilliseconds } from "./goals.ts";
@@ -196,7 +196,7 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
     unsubscribeCodexFast = subscribeCodexFast(() => activeTui?.requestRender());
     const sessionStart = Date.now();
     currentModel = ctx.model;
-    thinkingLevel = pi.getThinkingLevel() as ThinkingLevel;
+    thinkingLevel = pi.getThinkingLevel();
     const cwd = formatCwd(ctx.cwd);
 
     ctx.ui.setFooter((tui, theme, footerData) => {