killeros 2.0.9 → 2.0.11

package/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.0.11] - 2026-08-17
+
+### Fixed
+
+- Made automated npm publication and GitHub release recovery idempotent, aligned the documented and tested Pi floor, and made machine-identifier casing locale-independent.
+- Extended strict type checking to release scripts and typed test suites, while correctly identifying JavaScript-only suites as `.js`.
+
+### Removed
+
+- Removed the decision-gated workflow subsystem, its skill-specific policy, public extension interface, and YAML dependency. Skills now remain instruction-only.
+
+## [2.0.10] - 2026-08-16
+
+### Added
+
+- Added proactive turn-boundary compaction with Pi-owned settings and safe continuation for ordinary prompts and active goals.
+- Added reusable multi-activation decision-gated workflow registrations while preserving exact-match behavior.
+
 ## [2.0.9] - 2026-08-15
 
 ### Added

package/Killeros.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerRequestActivity } from "./killeros/activity.ts";
+import { registerAutoCompaction } from "./killeros/auto-compaction.ts";
 import {
   createSlashCommandResolver,
   registerAliases,
@@ -14,33 +15,19 @@ import {
   type CompletionNotificationDependencies,
 } from "./killeros/notifications.ts";
 import { registerPersonalInstructions } from "./killeros/personal-instructions.ts";
-import { registerQuestionTool, type QuestionRunner } from "./killeros/question.ts";
-import { createDecisionGatedWorkflowAdapter } from "./killeros/decision-gated-workflow.ts";
+import { registerQuestionTool } from "./killeros/question.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 { 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 {
@@ -50,19 +37,15 @@ export default function Killeros(pi: ExtensionAPI, options: KillerosOptions = {}
   registerShellUi(pi, commandResolver);
   registerGoal(pi, goalRuntime, initRuntime);
   registerPersonalInstructions(pi, initRuntime);
-  const questionRunner: QuestionRunner = registerQuestionTool(pi);
-  registerWorkflowGate(
-    pi,
-    questionRunner,
-    options.decisionGatedWorkflows ?? [createDecisionGatedWorkflowAdapter()],
-  );
+  registerQuestionTool(pi);
   registerAliases(pi);
   registerSlashAutocomplete(pi, commandResolver);
   registerFooter(pi, goalRuntime);
   registerVariants(pi);
   registerInitCommand(pi, initRuntime, goalRuntime);
   registerLifecycleHooks(pi);
-  registerGoalSettlement(pi, goalRuntime, initRuntime);
+  const goalCompaction = registerGoalSettlement(pi, goalRuntime, initRuntime);
+  registerAutoCompaction(pi, { goal: goalCompaction });
   registerInitSettlement(pi, initRuntime);
   registerRequestActivity(pi);
   registerCompletionNotifications(pi, options.completionNotifications);

package/README.md

@@ -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.9
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.11
 ```
 
 Add `-l` to either command for a project-only install. Restart Pi after installing.
@@ -44,12 +44,11 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 - 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
+- Proactive turn-boundary context compaction in TUI and RPC modes, with ordinary prompts and active goals continuing safely after a successful summary
 - 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`
-- 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.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
@@ -79,10 +78,6 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 
 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
 
 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.
@@ -97,9 +92,22 @@ KillerOS activates its packaged `killeros` theme when a TUI session starts. Tool
 
 The completion sound is a global user preference stored in Pi's agent directory and is off by default. Run `/notification` in TUI mode to enable or disable it; enabling does not play a preview. Enabled TUI tabs append `󰂚`, which requires a Nerd Font in the terminal tab UI. An unsupported font may show a box without affecting sound. KillerOS uses the terminal's audible bell and cannot produce sound when the terminal disables it.
 
+Automatic compaction is enabled by default when Pi's effective `compaction.enabled` setting is true. After each completed assistant turn, including its tool execution, KillerOS reads the active model's current context usage and triggers the public Pi compaction API when `remainingTokens <= max(contextWindow * percentRemaining / 100, reserveTokens)`. The default `percentRemaining` is `15`; `reserveTokens` and `keepRecentTokens` remain Pi-owned. KillerOS reads those effective settings with Pi's public `SettingsManager` using `getAgentDir()` and the current project trust state. The KillerOS-only preference lives in the same global `killeros.json` file:
+
+```json
+{
+  "autoCompaction": {
+    "enabled": true,
+    "percentRemaining": 15
+  }
+}
+```
+
+Missing context readings skip the check. Successful ordinary-prompt compaction queues one hidden continuation; active `/goal` runs use the existing session-compaction and goal-continuation path. A failed compaction does not automatically retry. Manual `/compact` behavior is unchanged.
+
 KillerOS displays session costs in USD. The footer uses Pi's human-readable model name when available, keeps the provider visually secondary, and renders context as `percent left (tokens)` without a progress bar. An active goal replaces the right-side path with warning-yellow `/goal is active (...)` and keeps exact seconds in minute and hour formats. Paused and blocked goals retain their existing placement; completed goals remain in transcript history and `/goal` status rather than the footer. At narrow widths, context pressure and actionable goal state take priority.
 
-Pi decides when compaction runs and Pi writes the summary, applies manual focus instructions, tracks files, retries summarization, and handles overflow recovery. KillerOS does not add a second threshold or replace Pi's summary. Active `/goal` work continues from Pi's settled boundary, after Pi finishes retries, compaction, and queued work.
+Pi writes the summary, applies manual focus instructions, tracks files, retries summarization, and handles overflow recovery. KillerOS owns only the proactive turn-boundary trigger and does not replace Pi's compaction implementation. Active `/goal` work continues from the settled compaction boundary, after Pi finishes retries, compaction, and queued work.
 
 Manual `/compact` aborts the current goal turn before summarization, so KillerOS records an honest temporary pause for that exact goal revision. After Pi saves the manual summary, KillerOS resumes that revision automatically. A failed or cancelled manual compaction stays paused; run `/goal pause` during the pause to cancel automatic recovery.
 
@@ -111,9 +119,9 @@ 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 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 |
+| TUI | All features are available, including proactive compaction, the completion sound, and the tab-title indicator |
+| RPC | Proactive compaction and 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`, `/init`, and proactive compaction are disabled; completion sounds and the title indicator are disabled |
 
 ## Validation
 
@@ -131,16 +139,9 @@ The package manifest lists Pi’s built-in modules as peer dependencies, so npm
 
 ## Publish
 
-To create a GitHub release, update the version in `package.json` and `package-lock.json`, add the matching `CHANGELOG.md` section, and push the release commit to `main`. After the full CI workflow passes, the release workflow creates the matching tag and GitHub release from that verified commit.
-
-Do not manually tag a normal release. If automation must recover a missing GitHub release, push the matching version tag; the same workflow validates the tag against the package and changelog before creating the release.
-
-The [`pi-package`](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/packages.md) keyword makes a published npm release visible in Pi’s package catalog. GitHub release automation does not publish to npm. Publish there separately after validation:
+To release KillerOS, update the version in `package.json` and `package-lock.json`, add the matching `CHANGELOG.md` section, and push the release commit to `main`. After the full CI workflow passes, the release workflow publishes the package to npm through trusted publishing, then creates the matching tag and GitHub release from that verified commit. The [`pi-package`](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/packages.md) keyword makes the npm release visible in Pi’s package catalog.
 
-```bash
-npm login
-npm publish
-```
+Do not manually tag a normal release. If automation must recover a missing GitHub release, push the matching version tag. The workflow validates the tag against the package and changelog, skips npm publication when that version already exists, and creates only the missing release.
 
 ## Security
 

package/killeros/activity.ts

@@ -30,7 +30,7 @@ export function formatActivityMessage(message: ActivityMessage, theme: Theme): s
       detail = "assembling the answer";
       break;
     case "tool":
-      switch (message.toolName.trim().toLocaleLowerCase()) {
+      switch (message.toolName.trim().toLowerCase()) {
         case "read":
         case "grep":
         case "find":

package/killeros/auto-compaction.ts

@@ -0,0 +1,224 @@
+import {
+  getAgentDir,
+  SettingsManager,
+  type CompactionSettings,
+  type ContextUsage,
+  type ExtensionAPI,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+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.";
+
+export interface AutoCompactionPreference {
+  enabled: boolean;
+  percentRemaining: number;
+}
+
+export interface AutoCompactionGoalHandlers {
+  isActive(ctx: ExtensionContext): boolean;
+  onRequested(): void;
+  onCompleted(ctx: ExtensionContext): void;
+  onFailed(ctx: ExtensionContext, error: unknown): void;
+}
+
+export interface AutoCompactionDependencies {
+  loadPreference?: (ctx: ExtensionContext) => AutoCompactionPreference;
+  getCompactionSettings?: (ctx: ExtensionContext) => CompactionSettings;
+  goal?: AutoCompactionGoalHandlers;
+}
+
+interface AutoCompactionRequest {
+  goal: boolean;
+  token: symbol;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export function readAutoCompactionPreference(
+  settings: Readonly<Record<string, unknown>>,
+): AutoCompactionPreference {
+  const raw = isRecord(settings.autoCompaction) ? settings.autoCompaction : {};
+  const percentRemaining = typeof raw.percentRemaining === "number"
+    && Number.isFinite(raw.percentRemaining)
+    && raw.percentRemaining >= 0
+    && raw.percentRemaining <= 100
+    ? raw.percentRemaining
+    : DEFAULT_AUTO_COMPACTION_PERCENT_REMAINING;
+  return {
+    enabled: typeof raw.enabled === "boolean" ? raw.enabled : true,
+    percentRemaining,
+  };
+}
+
+function defaultPreference(): AutoCompactionPreference {
+  return readAutoCompactionPreference(createKillerosSettingsStore().load());
+}
+
+function defaultCompactionSettings(ctx: ExtensionContext): CompactionSettings {
+  return SettingsManager.create(ctx.cwd, getAgentDir(), {
+    projectTrusted: ctx.isProjectTrusted(),
+  }).getCompactionSettings();
+}
+
+function reserveTokens(settings: Pick<CompactionSettings, "reserveTokens">): number {
+  return typeof settings.reserveTokens === "number" && Number.isFinite(settings.reserveTokens)
+    ? Math.max(0, settings.reserveTokens)
+    : 0;
+}
+
+export function shouldTriggerAutoCompaction(
+  usage: Pick<ContextUsage, "tokens" | "contextWindow"> | undefined,
+  preference: AutoCompactionPreference,
+  compactionSettings: Pick<CompactionSettings, "enabled" | "reserveTokens">,
+): boolean {
+  if (!preference.enabled || !compactionSettings.enabled || usage?.tokens === undefined || usage.tokens === null) {
+    return false;
+  }
+  if (!Number.isFinite(usage.tokens) || !Number.isFinite(usage.contextWindow) || usage.contextWindow <= 0) {
+    return false;
+  }
+  const remainingTokens = usage.contextWindow - usage.tokens;
+  const threshold = Math.max(
+    usage.contextWindow * preference.percentRemaining / 100,
+    reserveTokens(compactionSettings),
+  );
+  return remainingTokens <= threshold;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function supportedMode(ctx: ExtensionContext): boolean {
+  return ctx.mode === "tui" || ctx.mode === "rpc";
+}
+
+export function registerAutoCompaction(
+  pi: ExtensionAPI,
+  dependencies: AutoCompactionDependencies = {},
+): void {
+  const loadPreference = dependencies.loadPreference ?? (() => defaultPreference());
+  const getCompactionSettings = dependencies.getCompactionSettings ?? defaultCompactionSettings;
+  let request: AutoCompactionRequest | undefined;
+  let armed = true;
+  let settingsErrorReported = false;
+
+  const resetForLifecycle = (): void => {
+    request = undefined;
+    armed = true;
+    settingsErrorReported = false;
+  };
+
+  const notifyFailure = (ctx: ExtensionContext, error: unknown): void => {
+    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;
+    request = undefined;
+    if (goal && dependencies.goal) {
+      try {
+        dependencies.goal.onFailed(ctx, error);
+      } catch (callbackError) {
+        notifyFailure(ctx, callbackError);
+      }
+      return;
+    }
+    notifyFailure(ctx, error);
+  };
+
+  pi.on("turn_end", (_event, ctx) => {
+    if (!supportedMode(ctx) || request) return;
+
+    let preference: AutoCompactionPreference;
+    let compactionSettings: CompactionSettings;
+    let usage: ContextUsage | undefined;
+    try {
+      preference = loadPreference(ctx);
+      compactionSettings = getCompactionSettings(ctx);
+    } catch (error) {
+      if (!settingsErrorReported) {
+        settingsErrorReported = true;
+        ctx.ui.notify(`Automatic compaction settings could not be read: ${errorMessage(error)}`, "error");
+      }
+      return;
+    }
+    try {
+      usage = ctx.getContextUsage();
+    } catch {
+      return;
+    }
+    if (!usage) return;
+    if (usage.tokens !== null && usage.tokens !== undefined && Number.isFinite(usage.tokens)
+      && Number.isFinite(usage.contextWindow) && usage.contextWindow > 0) {
+      const remainingTokens = usage.contextWindow - usage.tokens;
+      const threshold = Math.max(
+        usage.contextWindow * preference.percentRemaining / 100,
+        reserveTokens(compactionSettings),
+      );
+      if (remainingTokens > threshold) {
+        armed = true;
+      }
+    }
+    if (!armed) return;
+    if (!shouldTriggerAutoCompaction(usage, preference, compactionSettings)) return;
+
+    armed = false;
+    const token = Symbol();
+    const goal = dependencies.goal?.isActive(ctx) === true;
+    request = { goal, token };
+    if (goal && dependencies.goal) {
+      try {
+        dependencies.goal.onRequested();
+      } catch (error) {
+        finishFailure(ctx, token, true, error);
+        return;
+      }
+    }
+
+    try {
+      ctx.compact({
+        onComplete: () => {
+          if (!request || request.token !== token) return;
+          request = undefined;
+          if (goal && dependencies.goal) {
+            try {
+              dependencies.goal.onCompleted(ctx);
+            } catch (error) {
+              notifyFailure(ctx, error);
+            }
+            return;
+          }
+          try {
+            pi.sendMessage({
+              customType: AUTO_COMPACTION_MESSAGE_TYPE,
+              content: AUTO_COMPACTION_MESSAGE,
+              display: false,
+            }, { triggerTurn: true, deliverAs: "followUp" });
+          } catch (error) {
+            notifyFailure(ctx, error);
+          }
+        },
+        onError: (error) => finishFailure(ctx, token, goal, error),
+      });
+    } catch (error) {
+      finishFailure(ctx, token, goal, error);
+    }
+  });
+
+  pi.on("session_start", resetForLifecycle);
+  pi.on("session_shutdown", resetForLifecycle);
+  pi.on("session_tree", resetForLifecycle);
+  pi.on("session_before_switch", resetForLifecycle);
+  pi.on("session_before_fork", resetForLifecycle);
+}

package/killeros/commands.ts

@@ -166,8 +166,8 @@ export function createSlashCommandResolver(
 
 function scoreCommandMatch(name: string, prefix: string): number {
   if (!prefix) return 1;
-  const normalizedName = name.toLocaleLowerCase();
-  const normalizedPrefix = prefix.toLocaleLowerCase();
+  const normalizedName = name.toLowerCase();
+  const normalizedPrefix = prefix.toLowerCase();
   if (normalizedName.startsWith(normalizedPrefix)) return 100;
   if (normalizedName.split(/[:\-_]/).some((token) => token.startsWith(normalizedPrefix))) return 80;
   if (normalizedName.includes(normalizedPrefix)) return 50;
@@ -190,7 +190,7 @@ export function registerSlashAutocomplete(
         const prefixMatch = getSlashCommandPrefix(beforeCursor);
         if (!prefixMatch) return current.getSuggestions(lines, cursorLine, cursorCol, options);
 
-        const prefix = prefixMatch.prefix.toLocaleLowerCase();
+        const prefix = prefixMatch.prefix.toLowerCase();
         const baseSuggestions = await current.getSuggestions(lines, cursorLine, cursorCol, options);
         resolver.updateFallbackCommands(baseSuggestions?.items ?? []);
         const commands = resolver.getCommandCatalog(baseSuggestions?.items ?? []);

package/killeros/display.ts

@@ -6,8 +6,8 @@ export function formatCwd(cwd: string): string {
   if (!home) return cwd;
   const normalizedHome = home.replace(/[\\/]+$/, "");
   const normalizedCwd = cwd.replace(/[\\/]+$/, "");
-  const comparedHome = process.platform === "win32" ? normalizedHome.toLocaleLowerCase() : normalizedHome;
-  const comparedCwd = process.platform === "win32" ? normalizedCwd.toLocaleLowerCase() : normalizedCwd;
+  const comparedHome = process.platform === "win32" ? normalizedHome.toLowerCase() : normalizedHome;
+  const comparedCwd = process.platform === "win32" ? normalizedCwd.toLowerCase() : normalizedCwd;
   if (comparedCwd === comparedHome) return "~";
   const separator = normalizedCwd.slice(normalizedHome.length, normalizedHome.length + 1);
   return comparedCwd.startsWith(comparedHome) && (separator === "/" || separator === "\\")

package/killeros/footer.ts

@@ -75,12 +75,12 @@ const PROVIDER_WORDS: Readonly<Record<string, string>> = {
 
 function formatProviderName(provider: string): string {
   const normalized = provider.trim();
-  const known = PROVIDER_LABELS[normalized.toLocaleLowerCase()];
+  const known = PROVIDER_LABELS[normalized.toLowerCase()];
   if (known) return known;
   return normalized
     .split(/[-_]+/u)
     .filter(Boolean)
-    .map((word) => PROVIDER_WORDS[word.toLocaleLowerCase()] ?? `${word.charAt(0).toLocaleUpperCase()}${word.slice(1)}`)
+    .map((word) => PROVIDER_WORDS[word.toLowerCase()] ?? `${word.charAt(0).toUpperCase()}${word.slice(1)}`)
     .join(" ") || "Unknown provider";
 }
 

package/killeros/goals.ts

@@ -264,7 +264,10 @@ function transitionGoal(
     resumeAfterManualCompaction: options.resumeAfterManualCompaction,
   };
   persistGoalState(pi, runtime, event, next);
-  if (status !== "active") runtime.continuationScheduled = false;
+  if (status !== "active") {
+    runtime.continuationScheduled = false;
+    runtime.automaticCompaction = undefined;
+  }
   return next;
 }
 
@@ -272,6 +275,7 @@ function clearGoalExecutionFlags(runtime: GoalRuntime): void {
   runtime.continuationScheduled = false;
   runtime.goalTurnInFlight = false;
   runtime.agentEndObserved = false;
+  runtime.automaticCompaction = undefined;
   runtime.lastStopReason = undefined;
   runtime.lastError = undefined;
 }
@@ -287,7 +291,7 @@ async function stopGoalRun(runtime: GoalRuntime, ctx: ExtensionCommandContext, s
 }
 
 function goalStatusLabel(status: GoalStatus): string {
-  return `${status.charAt(0).toLocaleUpperCase()}${status.slice(1)}`;
+  return `${status.charAt(0).toUpperCase()}${status.slice(1)}`;
 }
 
 function goalPanelActions(status: GoalStatus): Array<{ label: string; control: "pause" | "resume" | "edit" | "clear" }> {
@@ -305,7 +309,7 @@ function goalPanelActions(status: GoalStatus): Array<{ label: string; control: "
 function goalStatusSummary(state: GoalState, ctx: ExtensionContext): string {
   const usedTokens = Math.max(0, sumGoalTokens(ctx) - state.baselineTokens);
   const lines = [
-    `Goal ${goalStatusLabel(state.status).toLocaleLowerCase()} · ${state.turns} turn${state.turns === 1 ? "" : "s"} · ${formatTime(goalElapsedMilliseconds(state))} · ${formatTokens(usedTokens)} tokens`,
+    `Goal ${goalStatusLabel(state.status).toLowerCase()} · ${state.turns} turn${state.turns === 1 ? "" : "s"} · ${formatTime(goalElapsedMilliseconds(state))} · ${formatTokens(usedTokens)} tokens`,
     state.objective,
   ];
   if (state.result) lines.push(state.result);
@@ -333,6 +337,7 @@ export function pauseGoalAfterFailure(
     syncGoalUpdateTool(pi, runtime);
     runtime.persistenceRetryNeeded = true;
     runtime.continuationScheduled = false;
+    runtime.automaticCompaction = undefined;
     runtime.requestRender?.();
   }
   if (notify) ctx.ui.notify(`Goal paused: ${reason}\n${recoveryInstruction}`, "error");
@@ -359,6 +364,7 @@ function pauseGoalForPossibleManualCompaction(
     syncGoalUpdateTool(pi, runtime);
     runtime.persistenceRetryNeeded = true;
     runtime.continuationScheduled = false;
+    runtime.automaticCompaction = undefined;
     runtime.requestRender?.();
   }
   ctx.ui.notify(
@@ -384,6 +390,7 @@ function recoverGoalAfterManualCompaction(
     return false;
   }
   runtime.continuationScheduled = false;
+  runtime.automaticCompaction = undefined;
   ctx.ui.notify("Manual compaction complete. Goal resumed.", "info");
   setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
   return true;
@@ -450,6 +457,42 @@ function scheduleGoalContinuation(
   }
 }
 
+function completeAutomaticCompaction(
+  pi: ExtensionAPI,
+  runtime: GoalRuntime,
+  initState: InitRuntime,
+  ctx: ExtensionContext,
+): void {
+  if (runtime.automaticCompaction === undefined) return;
+  if (runtime.state?.status !== "active" || initState.active) {
+    runtime.automaticCompaction = undefined;
+    return;
+  }
+  runtime.automaticCompaction = "completed";
+  if (runtime.goalTurnInFlight || !ctx.isIdle()) return;
+  runtime.automaticCompaction = undefined;
+  setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
+}
+
+function failAutomaticCompaction(
+  pi: ExtensionAPI,
+  runtime: GoalRuntime,
+  ctx: ExtensionContext,
+  error: unknown,
+): void {
+  if (runtime.automaticCompaction === undefined) return;
+  runtime.automaticCompaction = undefined;
+  if (runtime.state?.status !== "active") return;
+  const reason = error instanceof Error ? error.message : String(error);
+  pauseGoalAfterFailure(
+    pi,
+    runtime,
+    ctx,
+    `automatic compaction failed: ${reason}`,
+    "Automatic continuation is stopped. Run /goal resume after resolving the compaction problem.",
+  );
+}
+
 function goalInstructions(state: GoalState, heading: string): string {
   return [
     `# ${heading}`,
@@ -598,6 +641,7 @@ export function registerGoal(
     runtime.continuationHeld = false;
     runtime.goalTurnInFlight = false;
     runtime.agentEndObserved = false;
+    runtime.automaticCompaction = undefined;
     runtime.persistenceRetryNeeded = false;
     runtime.lastStopReason = undefined;
     runtime.lastError = undefined;
@@ -630,6 +674,7 @@ export function registerGoal(
     runtime.continuationHeld = false;
     runtime.goalTurnInFlight = false;
     runtime.agentEndObserved = false;
+    runtime.automaticCompaction = undefined;
     runtime.persistenceRetryNeeded = false;
     runtime.lastStopReason = undefined;
     runtime.lastError = undefined;
@@ -663,7 +708,7 @@ export function registerGoal(
         return;
       }
       const input = args.trim();
-      const control = input.toLocaleLowerCase();
+      const control = input.toLowerCase();
       const isControl = control === "clear" || control === "edit" || control === "pause" || control === "resume";
 
       if (!input) {
@@ -963,7 +1008,7 @@ export function registerGoal(
   pi.registerCommand("goal", {
     description: "Set or view the goal for a long-running task",
     getArgumentCompletions: (prefix) => {
-      const normalized = prefix.trimStart().toLocaleLowerCase();
+      const normalized = prefix.trimStart().toLowerCase();
       if (normalized.includes(" ")) return null;
       const actions = [
         { value: "clear", description: "Remove the current goal" },
@@ -983,7 +1028,12 @@ export function registerGoalSettlement(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
   initState: InitRuntime,
-): void {
+): {
+  isActive(ctx: ExtensionContext): boolean;
+  onRequested(): void;
+  onCompleted(ctx: ExtensionContext): void;
+  onFailed(ctx: ExtensionContext, error: unknown): void;
+} {
   pi.on("agent_settled", (_event, ctx) => {
     const wasGoalTurn = runtime.goalTurnInFlight;
     const continuationWasScheduled = runtime.continuationScheduled;
@@ -1000,6 +1050,7 @@ export function registerGoalSettlement(
       return;
     }
     if (!agentEndObserved) {
+      if (runtime.automaticCompaction !== undefined) return;
       pauseGoalAfterFailure(pi, runtime, ctx, "the goal turn ended without an agent result");
       return;
     }
@@ -1007,6 +1058,12 @@ export function registerGoalSettlement(
       const reason = runtime.lastError || "the agent turn was aborted";
       runtime.lastStopReason = undefined;
       runtime.lastError = undefined;
+      if (runtime.automaticCompaction !== undefined) {
+        if (runtime.automaticCompaction === "completed") {
+          completeAutomaticCompaction(pi, runtime, initState, ctx);
+        }
+        return;
+      }
       pauseGoalForPossibleManualCompaction(pi, runtime, ctx, reason);
       return;
     }
@@ -1023,7 +1080,23 @@ export function registerGoalSettlement(
   });
 
   pi.on("session_compact", (event, ctx) => {
+    if (runtime.automaticCompaction !== undefined) {
+      completeAutomaticCompaction(pi, runtime, initState, ctx);
+      return;
+    }
     if (event.reason !== "manual") return;
     recoverGoalAfterManualCompaction(pi, runtime, initState, ctx);
   });
+
+  return {
+    isActive: (ctx: ExtensionContext): boolean => isGoalModeSupported(ctx)
+      && isSavedSession(ctx)
+      && runtime.state?.status === "active"
+      && !initState.active,
+    onRequested: (): void => {
+      if (runtime.state?.status === "active") runtime.automaticCompaction = "pending";
+    },
+    onCompleted: (ctx: ExtensionContext): void => completeAutomaticCompaction(pi, runtime, initState, ctx),
+    onFailed: (ctx: ExtensionContext, error: unknown): void => failAutomaticCompaction(pi, runtime, ctx, error),
+  };
 }