@mediadatafusion/pi-workflow-suite 0.0.16 → 0.0.18

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 All notable public releases will be documented in this file.
 
+## [0.0.18] - 2026-06-10
+
+### Improved
+
+- Improved package metadata and compaction settings documentation.
+- Refined compaction safeguards for default and custom configuration flows.
+
+## [0.0.17] - 2026-06-10
+
+### Improved
+
+- Improved package metadata to better reflect the suite's workflow modes, configuration surfaces, and orchestration features.
+
 ## [0.0.16] - 2026-06-09
 
 ### Fixed

package/README.md

@@ -4,7 +4,7 @@
 
 [![Install](https://cdn.jsdelivr.net/npm/@mediadatafusion/pi-workflow-suite@0.0.12/docs/assets/readme-link-install.svg)](#installation) [![Quick Start](https://cdn.jsdelivr.net/npm/@mediadatafusion/pi-workflow-suite@0.0.12/docs/assets/readme-link-quick-start.svg)](#quick-start) [![Commands](https://cdn.jsdelivr.net/npm/@mediadatafusion/pi-workflow-suite@0.0.12/docs/assets/readme-link-commands.svg)](#core-commands) [![Settings](https://cdn.jsdelivr.net/npm/@mediadatafusion/pi-workflow-suite@0.0.12/docs/assets/readme-link-settings.svg)](#settings-reference)
 
-**Workflow Suite Version:** `v0.0.16`
+**Workflow Suite Version:** `v0.0.18`
 
 ## Overview
 
@@ -118,7 +118,7 @@ Pi Workflow Suite turns Pi into a guided workflow environment:
 | Interactive Diagrams | `workflow_diagram` Mermaid support with terminal preview, SVG-first clickable artifacts, PNG/runtime rendering support, dark-mode-friendly styling, and runtime artifact storage. |
 | Web Research & Browser Verification | First-party `workflow_web_search`, `workflow_web_fetch`, and `workflow_browser_check` tools. Search and fetch for public web evidence with source URLs, blocked local/private/internal hosts, and time/size limits. Headless browser verification for runtime web app validation with interactive UI actions (click, type, read, screenshot, evaluate). |
 | Repo Lock | Project-scoped Global Safety control that constrains normal file tools, bash path checks, and sub-agents to the active repository, with protected configuration paths and clear non-sandbox caveats. |
-| Compaction | Pi default, custom model, or disabled Workflow Suite compaction so context summarization can use its own provider/model, proactive threshold checks, idle-boundary execution, custom token tuning, adaptive fitting, status reporting, and safe fallback. |
+| Compaction | Shared compaction controls for Pi default or custom summary model selection, Pi default or custom trigger thresholds, idle-boundary proactive checks, custom token tuning, adaptive fitting, status reporting, and safe fallback. |
 | Token Budgets | Optional per-mode token and runtime caps (`maxTokens`, `maxRuntimeHours`) for Plan, Mission, and Standard Mode. Off by default (unlimited). When enabled, Workflow Suite tracks cumulative usage and blocks further agent turns when the budget is exceeded. |
 | Workflow Roles | Planner, Executor, Reviewer, Validator, Mission, and compaction responsibilities are separated by phase so each job has clear boundaries and can be matched to the right model. |
 | Model Selection | Configure which provider/model and thinking level powers each workflow role, with shared defaults plus Standard-specific and Mission-specific overrides for simpler or higher-rigor setups. |
@@ -799,27 +799,34 @@ Compaction settings are available through:
 /workflow settings Shared Compaction
 ```
 
-Supported modes:
+The grouped Shared Compaction menu separates trigger behavior from summary model selection. The trigger can use Pi default behavior or an explicit Workflow Suite threshold, while the compaction provider/model controls which model writes compaction summaries when configured.
 
-- **Pi default** — preserve Pi built-in compaction.
-- **Custom model** — route compaction summaries through a configured provider/model when available.
-- **Disabled** — disables Workflow Suite custom compaction and leaves Pi fallback behavior.
-- **Custom agent** — planned-only/backward-compatible mode; current releases keep Pi default fallback behavior instead of running agent-routed compaction.
+Workflow Suite can request proactive compaction when context usage reaches the configured threshold. Actual proactive compaction runs only at a safe after-turn idle agent boundary, so it does not interrupt arbitrary tool execution or queued workflow handoffs. Pi default auto-compaction remains available as a safety fallback near the model limit.
 
-Workflow Suite can request proactive compaction when context usage reaches the configured threshold. For Custom model mode, a configured compaction provider/model with custom compaction enabled arms the threshold trigger even when generic auto-trigger behavior is otherwise off. This lets compaction use a different model than planning, execution, review, or validation, which is useful when context summarization has a different cost, speed, or context-window requirement than active workflow work. Actual proactive compaction runs only at a safe after-turn idle agent boundary, so it does not interrupt arbitrary tool execution or queued workflow handoffs. Pi default auto-compaction remains available as a safety fallback near the model limit.
+The menu controls provider/model preference, auto-trigger behavior, trigger threshold, cooldown, reserve tokens, and keep-recent tokens:
 
-The grouped Shared Compaction menu controls auto-compaction, trigger threshold, cooldown, reserve tokens, keep-recent tokens, and custom compaction model behavior.
+```text
+Shared Compaction Settings
+
+Compaction Provider
+Compaction Model
+Workflow Auto Trigger Enabled
+Workflow Trigger Percent
+Workflow Trigger Cooldown
+Custom Reserve Tokens
+Custom Keep Recent Tokens
+List Current Settings
+Back
+```
+
+Each configurable compaction setting includes a Pi default option. Provider and model choices do not change the trigger threshold. The trigger reports `Pi default` when the native Pi threshold formula is in control and reports `custom, <percent>%` only when an explicit Workflow Suite trigger override is set.
 
 Important behavior:
 
 - **Safe boundary**: proactive compaction runs at a safe after-turn idle agent boundary only.
 - **Cooldown**: the cooldown is the minimum wait between proactive attempts; it is not a delay before compaction starts and does not block manual compaction.
-- **Adaptive fit**: Custom model preparation is fit to the selected compaction model context window using configured reserve and keep-recent token settings.
-- **Fallback**: Custom model compaction falls back to Pi default behavior if required settings are missing, the model cannot be found, authentication or API key checks fail, preparation cannot fit, or the compaction call errors.
-- **Status**: `/workflow settings Show Current Settings` reports the effective trigger state, runtime status, selected custom model, reserve/keep-recent token settings, latest check decision, and `Last Custom Compaction Status`.
-
-The legacy `workflowCompactionCheckMode` setting may still exist for compatibility, but the primary release behavior is safe after-turn idle-boundary compaction. It is not permission to compact in the middle of arbitrary tool execution.
-
+- **Adaptive fit**: Custom summary model preparation is fit to the selected model context window using configured reserve and keep-recent token settings.
+- **Fallback**: Custom summary model compaction falls back to Pi default behavior if required settings are missing, the model cannot be found, authentication or API key checks fail, preparation cannot fit, or the compaction call errors.
 ## Diagram Support
 
 Workflow Suite includes a `workflow_diagram` tool for Mermaid diagrams in workflow explanations, architecture notes, state transitions, data flows, export/share flows, and dependency maps. It is available to Workflow Suite execution and validation surfaces through the shared workflow tool set.
@@ -1007,8 +1014,8 @@ pi install -l npm:@mediadatafusion/pi-workflow-suite
 ### Installing specific versions
 
 ```bash
-pi install npm:@mediadatafusion/pi-workflow-suite@0.0.16
-pi install -l npm:@mediadatafusion/pi-workflow-suite@0.0.16
+pi install npm:@mediadatafusion/pi-workflow-suite@0.0.18
+pi install -l npm:@mediadatafusion/pi-workflow-suite@0.0.18
 ```
 
 An unversioned install follows normal update behavior: `pi update` and `pi update --extensions` will pick up new package releases. A versioned install pins the package to that version. Pinned package specs are intentionally skipped by Pi's normal package update commands. To move a pinned install to a newer version, reinstall with the desired version. To switch back to latest tracking, use the unversioned install command without `@<version>`.
@@ -1124,7 +1131,7 @@ Primary settings areas:
 - `standard` — Standard Mode enablement, dynamic To Do tracking, configurable clarification, widgets, model role, Standard sub-agent orchestration, and shared model selection.
 - `missions` — Mission Mode autonomy, runtime, checkpoints, validation, repair, and mission-specific model selection.
 - `subagents` — workflow phase policies, worker targets, activity indicator, parallelism preferences, and edit-concurrency guidance. These settings do not edit arbitrary sub-agent tool permissions.
-- `context` — compaction mode, custom compaction provider/model, proactive trigger percentage, check mode, cooldown, and fallback status.
+- `context` — compaction provider/model, auto-trigger behavior, trigger percentage, cooldown, reserve tokens, and keep-recent tokens.
 - `ui` — widgets, shortcuts, Workflow Suite theme selection, startup visuals, startup logo text styling, footer/status hints, and optional themed input borders.
 - `safety` — bash/tool guard settings.
 
@@ -1207,17 +1214,17 @@ See `docs/TROUBLESHOOTING.md` for detailed diagnostics.
 
 ## Operational Notes
 
-- Use Custom model mode for active custom compaction today. Custom agent mode is reserved for agent-routed compaction and keeps Pi fallback behavior in current releases.
+- Configure a compaction provider/model when summaries should use a custom model; trigger behavior remains separate and can stay on Pi default behavior.
 - Mission checkpoints are created at workflow gates and progress saves. The checkpoint interval setting records the preferred cadence for future timed checkpoint automation.
 - Watchdog status can report stale mission activity when enabled. Recovery remains user-supervised so Mission Mode does not resume or mutate work unexpectedly.
 - Parallel file edits are governed separately from parallel sub-agent work. Scoped parallel edit mode requires conflict protection; otherwise the main workflow keeps writes serialized for safety.
 
 ## Versioning
 
-The current preparation version is `v0.0.16`. Version information is intentionally aligned across:
+The current preparation version is `v0.0.18`. Version information is intentionally aligned across:
 
-- `VERSION` (`v0.0.16`),
-- `package.json` (`0.0.16`),
+- `VERSION` (`v0.0.18`),
+- `package.json` (`0.0.18`),
 - `package-lock.json`,
 - this README,
 - Workflow Suite settings/about output.

package/VERSION

@@ -1 +1 @@
-v0.0.16
+v0.0.18

package/extensions/workflow-model-router.ts

@@ -1434,14 +1434,8 @@ export function workflowSettingsConsistencyDiagnostics(settings: WorkflowSetting
   if (settings.missions.finalValidationEnabled === true && (!settings.models.validator.enabled || !roleIsConfigured(settings.models.validator))) {
     diagnostics.push("mission final validation is enabled but the shared validator model is disabled or unconfigured");
   }
-  if (settings.context.compactionMode === "custom_model" && (!settings.context.compactionModelProvider || !settings.context.compactionModel)) {
-    diagnostics.push("custom compaction model mode is selected but compaction provider/model is incomplete");
-  }
-  if (settings.context.compactionMode === "custom_model" && settings.context.customCompactionEnabled !== true) {
-    diagnostics.push("custom compaction mode is selected but customCompactionEnabled is not set — custom compaction will not activate");
-  }
-  if (settings.context.customCompactionEnabled === true && settings.context.compactionMode !== "custom_model") {
-    diagnostics.push(`customCompactionEnabled=true but compactionMode=${settings.context.compactionMode}`);
+  if ((settings.context.compactionModelProvider || settings.context.compactionModel) && (!settings.context.compactionModelProvider || !settings.context.compactionModel)) {
+    diagnostics.push("custom compaction summary model preference is incomplete");
   }
   if (settings.missions.autoRepairReviewFailures !== false && settings.missions.reviewRetryMode === "off") {
     diagnostics.push("mission review auto-repair is enabled but reviewRetryMode is off — override to safe_only will be applied at runtime; set reviewRetryMode explicitly to avoid confusion");

package/extensions/workflow-modes.ts

@@ -206,6 +206,15 @@ type PiSessionEntry = SessionEntry;
 const DEFAULT_PI_COMPACTION_RESERVE_TOKENS = 16_384;
 const DEFAULT_PI_COMPACTION_KEEP_RECENT_TOKENS = 20_000;
 const CUSTOM_COMPACTION_PROMPT_OVERHEAD_TOKENS = 8_192;
+const PI_SETTINGS_FILE = join(AGENT_DIR, "settings.json");
+
+type PiNativeCompactionSettings = {
+  enabled: boolean;
+  reserveTokens: number;
+  keepRecentTokens: number;
+  source: "default" | "global" | "project";
+  file?: string;
+};
 
 function loadPiCompactionApi(): PiCompactionApi {
   return {
@@ -215,6 +224,85 @@ function loadPiCompactionApi(): PiCompactionApi {
   };
 }
 
+function readJsonObject(path: string): Record<string, unknown> | undefined {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8")) as unknown;
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed as Record<string, unknown> : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+function findProjectPiSettings(cwd: string): string | undefined {
+  let dir = cwd;
+  for (let i = 0; i < 40; i += 1) {
+    const candidate = join(dir, ".pi", "settings.json");
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return undefined;
+}
+
+function coercePiCompactionSettings(raw: unknown): Partial<PiNativeCompactionSettings> | undefined {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return undefined;
+  const compaction = raw as Record<string, unknown>;
+  const settings: Partial<PiNativeCompactionSettings> = {};
+  if (typeof compaction.enabled === "boolean") settings.enabled = compaction.enabled;
+  const reserveTokens = Number(compaction.reserveTokens);
+  if (Number.isFinite(reserveTokens) && reserveTokens > 0) settings.reserveTokens = Math.round(reserveTokens);
+  const keepRecentTokens = Number(compaction.keepRecentTokens);
+  if (Number.isFinite(keepRecentTokens) && keepRecentTokens > 0) settings.keepRecentTokens = Math.round(keepRecentTokens);
+  return settings;
+}
+
+function loadPiNativeCompactionSettings(cwd?: string): PiNativeCompactionSettings {
+  let settings: PiNativeCompactionSettings = {
+    enabled: true,
+    reserveTokens: DEFAULT_PI_COMPACTION_RESERVE_TOKENS,
+    keepRecentTokens: DEFAULT_PI_COMPACTION_KEEP_RECENT_TOKENS,
+    source: "default",
+  };
+  const globalSettings = existsSync(PI_SETTINGS_FILE) ? coercePiCompactionSettings(readJsonObject(PI_SETTINGS_FILE)?.compaction) : undefined;
+  if (globalSettings) settings = { ...settings, ...globalSettings, source: "global", file: PI_SETTINGS_FILE };
+
+  const projectFile = cwd ? findProjectPiSettings(cwd) : undefined;
+  const projectSettings = projectFile ? coercePiCompactionSettings(readJsonObject(projectFile)?.compaction) : undefined;
+  if (projectSettings) settings = { ...settings, ...projectSettings, source: "project", file: projectFile };
+  return settings;
+}
+
+function contextWindowFrom(ctx?: ExtensionContext, usage?: { contextWindow?: number }): number | undefined {
+  const contextWindow = Number(usage?.contextWindow ?? ctx?.getContextUsage?.()?.contextWindow ?? ctx?.model?.contextWindow);
+  return Number.isFinite(contextWindow) && contextWindow > 0 ? contextWindow : undefined;
+}
+
+function piNativeCompactionThreshold(cwd: string | undefined, contextWindow: number | undefined): { settings: PiNativeCompactionSettings; triggerTokens?: number; triggerPercent?: number } {
+  const settings = loadPiNativeCompactionSettings(cwd);
+  if (!settings.enabled || !contextWindow) return { settings };
+  const threshold = compactionThresholdForReserve(contextWindow, settings.reserveTokens);
+  return { settings, ...threshold };
+}
+
+function compactionThresholdForReserve(contextWindow: number, reserveTokens: number): { triggerTokens: number; triggerPercent: number } {
+  const triggerTokens = Math.max(0, contextWindow - reserveTokens);
+  return { triggerTokens, triggerPercent: (triggerTokens / contextWindow) * 100 };
+}
+
+function formatPiNativeCompactionThreshold(cwd: string | undefined, contextWindow: number | undefined): string {
+  const threshold = piNativeCompactionThreshold(cwd, contextWindow);
+  if (!threshold.settings.enabled) return "disabled";
+  return "Pi default";
+}
+
+function formatSharedCompactionTrigger(settings: ReturnType<typeof loadWorkflowSettings>, ctx?: ExtensionContext): string {
+  if (settings.context.compactionMode === "disabled" || settings.context.autoCompactionEnabled === false) return "disabled";
+  const override = compactionTriggerPercentOverride(settings);
+  if (override != null) return `custom, ${override}%`;
+  return formatPiNativeCompactionThreshold(ctx?.cwd, contextWindowFrom(ctx));
+}
+
 function createWorkflowCompactionFileOps(): FileOperations {
   return { read: new Set<string>(), written: new Set<string>(), edited: new Set<string>() };
 }
@@ -2675,15 +2763,15 @@ Mission Mode settings:
 
 Compaction:
 - /workflow-settings configure compaction opens the selectable compaction menu
-- Compaction Provider and Compaction Model use the model registry provider/model picker
-- /workflow-settings set context compactionMode pi_default|custom_model|disabled (custom_agent remains backward-compatible but hidden until implemented)
-- /workflow-settings set context customCompactionEnabled true|false
-- /workflow-settings set context autoCompactionEnabled true|false
+- Compaction Provider and Compaction Model select the summary model preference
+- /workflow-settings set context autoCompactionEnabled true|false|default
 - /workflow-settings set context compactionTriggerPercent 50-95|default|reset
-- /workflow-settings set context compactionCooldownMinutes 0-240
+- /workflow-settings set context compactionCooldownMinutes 0-240|default|reset
 - /workflow-settings set context customCompactionReserveTokens 4096-65536|default|reset
 - /workflow-settings set context customCompactionKeepRecentTokens 1000-200000|default|reset
 - /workflow-settings set context workflowCompactionCheckMode boundary|in_session (legacy/backward-compatible; primary UI uses safe after-turn compaction)
+- /workflow-settings set context compactionMode pi_default|custom_model|disabled (legacy/backward-compatible; primary UI uses trigger/provider/model controls)
+- /workflow-settings set context customCompactionEnabled true|false (legacy/backward-compatible; no longer required for summary model routing)
 - /workflow-settings set context compactionModelProvider <provider> (advanced/manual fallback)
 - /workflow-settings set context compactionModel <model> (advanced/manual fallback)
 - /workflow-settings set context compactionAgent <agent> (legacy/backward-compatible; custom agent is planned only)
@@ -3172,40 +3260,34 @@ function workflowCompactionCheckRuntimeStatus(): string {
   return `Last Check: ${workflowLastCompactionCheckAt}\nLast Decision: ${workflowLastCompactionDecision}`;
 }
 
-function customModelCompactionConfigured(settings: ReturnType<typeof loadWorkflowSettings>): boolean {
-  return settings.context.customCompactionEnabled === true
-    && settings.context.compactionMode === "custom_model"
-    && Boolean(settings.context.compactionModelProvider)
+function summaryModelConfigured(settings: ReturnType<typeof loadWorkflowSettings>): boolean {
+  return Boolean(settings.context.compactionModelProvider)
     && Boolean(settings.context.compactionModel);
 }
 
+function customModelCompactionConfigured(settings: ReturnType<typeof loadWorkflowSettings>): boolean {
+  return settings.context.compactionMode !== "disabled" && summaryModelConfigured(settings);
+}
+
 function workflowProactiveCompactionEffective(settings: ReturnType<typeof loadWorkflowSettings>): boolean {
   if (settings.context.compactionMode === "disabled") return false;
   return settings.context.autoCompactionEnabled === true;
 }
 
 function compactionIntegrationStatus(settings: ReturnType<typeof loadWorkflowSettings>): string {
-  if (!settings.context.customCompactionEnabled || settings.context.compactionMode === "pi_default") return "Pi default behavior is active";
-  if (settings.context.compactionMode === "custom_model") {
-    if (!settings.context.compactionModelProvider || !settings.context.compactionModel) return "Custom model selected but provider/model is missing. Fallback: Pi default compaction.";
-    return `Custom model active through Pi's session_before_compact hook using ${settings.context.compactionModelProvider}/${settings.context.compactionModel}. Fallback: Pi default if custom compaction cannot run or fails.`;
-  }
+  if (settings.context.compactionMode === "disabled") return "Workflow compaction disabled";
+  if (summaryModelConfigured(settings)) return `Custom summary model configured through Pi's session_before_compact hook using ${settings.context.compactionModelProvider}/${settings.context.compactionModel}. Fallback: Pi default if custom compaction cannot run or fails.`;
   if (settings.context.compactionMode === "custom_agent") return "Custom agent compaction is planned only. Fallback: Pi default compaction.";
-  return "Workflow custom compaction disabled; Pi default behavior applies";
-}
-
-function defaultCompactionTriggerPercent(): number {
-  return 50;
+  return "Pi default summary model is active";
 }
 
-function compactionTriggerPercent(settings: ReturnType<typeof loadWorkflowSettings>): number {
-  const fallback = defaultCompactionTriggerPercent();
-  const value = Number(settings.context.compactionTriggerPercent ?? fallback);
-  return Number.isFinite(value) && value >= 50 && value <= 95 ? Math.round(value) : fallback;
+function compactionTriggerPercentOverride(settings: ReturnType<typeof loadWorkflowSettings>): number | undefined {
+  const value = Number(settings.context.compactionTriggerPercent);
+  return Number.isFinite(value) && value >= 50 && value <= 95 ? Math.round(value) : undefined;
 }
 
 function compactionTriggerOverrideLabel(settings: ReturnType<typeof loadWorkflowSettings>): string {
-  const value = settings.context.compactionTriggerPercent;
+  const value = compactionTriggerPercentOverride(settings);
   return typeof value === "number" ? `${value}%` : "none";
 }
 
@@ -3220,18 +3302,9 @@ function resetCompactionContextToPiDefault(context: ReturnType<typeof loadWorkfl
 }
 
 function effectiveWorkflowCompactionTriggerPercent(settings: ReturnType<typeof loadWorkflowSettings>, ctx: ExtensionContext, usage: { contextWindow?: number }): number {
-  const configured = compactionTriggerPercent(settings);
-  if (!customModelCompactionConfigured(settings)) return configured;
-  const contextWindow = Number(usage.contextWindow);
-  if (!Number.isFinite(contextWindow) || contextWindow <= 0) return configured;
-  const model = ctx.modelRegistry.find(settings.context.compactionModelProvider, settings.context.compactionModel);
-  if (!model) return configured;
-  const safeInputTokens = customCompactionSafeInputTokens(model);
-  if (!safeInputTokens) return configured;
-  const safeTotalBeforeCompaction = safeInputTokens + DEFAULT_PI_COMPACTION_KEEP_RECENT_TOKENS;
-  const modelSafePercent = Math.floor((safeTotalBeforeCompaction / contextWindow) * 100);
-  if (!Number.isFinite(modelSafePercent) || modelSafePercent <= 0) return configured;
-  return Math.max(10, Math.min(configured, modelSafePercent));
+  const contextWindow = contextWindowFrom(ctx, usage);
+  const nativeThreshold = piNativeCompactionThreshold(ctx.cwd, contextWindow);
+  return compactionTriggerPercentOverride(settings) ?? nativeThreshold.triggerPercent ?? NaN;
 }
 
 function compactionCooldownMinutes(settings: ReturnType<typeof loadWorkflowSettings>): number {
@@ -3239,6 +3312,16 @@ function compactionCooldownMinutes(settings: ReturnType<typeof loadWorkflowSetti
   return Number.isFinite(value) && value >= 0 && value <= 240 ? Math.round(value) : 5;
 }
 
+function compactionCooldownLabel(settings: ReturnType<typeof loadWorkflowSettings>): string {
+  const value = compactionCooldownMinutes(settings);
+  return value === 5 ? "Pi default" : `${value} min`;
+}
+
+function workflowAutoTriggerLabel(settings: ReturnType<typeof loadWorkflowSettings>): string {
+  if (settings.context.compactionMode === "disabled" || settings.context.autoCompactionEnabled === false) return "disabled";
+  return settings.context.autoCompactionEnabled === true ? "enabled" : "Pi default";
+}
+
 function customCompactionReserveTokens(settings: ReturnType<typeof loadWorkflowSettings>): number {
   const value = Number(settings.context.customCompactionReserveTokens ?? DEFAULT_PI_COMPACTION_RESERVE_TOKENS);
   return Number.isFinite(value) && value >= 4096 && value <= 65536 ? Math.round(value) : DEFAULT_PI_COMPACTION_RESERVE_TOKENS;
@@ -3249,6 +3332,16 @@ function customCompactionKeepRecentTokens(settings: ReturnType<typeof loadWorkfl
   return Number.isFinite(value) && value >= 1000 && value <= 200000 ? Math.round(value) : DEFAULT_PI_COMPACTION_KEEP_RECENT_TOKENS;
 }
 
+function compactionReserveTokensLabel(settings: ReturnType<typeof loadWorkflowSettings>): string {
+  const value = customCompactionReserveTokens(settings);
+  return value === DEFAULT_PI_COMPACTION_RESERVE_TOKENS ? "Pi default" : value.toLocaleString();
+}
+
+function compactionKeepRecentTokensLabel(settings: ReturnType<typeof loadWorkflowSettings>): string {
+  const value = customCompactionKeepRecentTokens(settings);
+  return value === DEFAULT_PI_COMPACTION_KEEP_RECENT_TOKENS ? "Pi default" : value.toLocaleString();
+}
+
 function customCompactionPreparationSettings(settings: ReturnType<typeof loadWorkflowSettings>, fallback: PiCompactionPreparation["settings"]): PiCompactionPreparation["settings"] {
   return {
     ...fallback,
@@ -3261,14 +3354,15 @@ function compactionTriggerStatus(settings: ReturnType<typeof loadWorkflowSetting
   if (settings.context.compactionMode === "disabled") return "Workflow compaction disabled";
   const cooldown = `${compactionCooldownMinutes(settings)} minute cooldown`;
   const safeBoundary = "safe after-turn idle boundary only";
-  if (customModelCompactionConfigured(settings) && settings.context.autoCompactionEnabled === true) return `Armed at ${compactionTriggerPercent(settings)}%; ${cooldown}; Compaction runs at ${safeBoundary}; Custom Model: ${settings.context.compactionModelProvider}/${settings.context.compactionModel}; Custom Prep: keep ${customCompactionKeepRecentTokens(settings).toLocaleString()} recent tokens, reserve ${customCompactionReserveTokens(settings).toLocaleString()} tokens`;
-  if (customModelCompactionConfigured(settings)) return `Custom compaction model configured for Pi session_before_compact only: ${settings.context.compactionModelProvider}/${settings.context.compactionModel}. Workflow proactive trigger is not enabled.`;
+  const override = compactionTriggerPercentOverride(settings);
+  if (workflowProactiveCompactionEffective(settings)) return `Armed at ${override == null ? "Pi default formula" : `${override}%`}; ${cooldown}; Compaction runs at ${safeBoundary}`;
+  if (summaryModelConfigured(settings)) return `Custom summary model configured for Pi session_before_compact: ${settings.context.compactionModelProvider}/${settings.context.compactionModel}. Workflow proactive trigger is not enabled.`;
   if (settings.context.autoCompactionEnabled !== true) return "Workflow proactive compaction disabled; Pi default auto-compaction still applies";
-  return `Armed at ${compactionTriggerPercent(settings)}%; ${cooldown}; Compaction runs at ${safeBoundary}; Pi default fallback enabled`;
+  return "Pi default auto-compaction applies";
 }
 
 function missionCheckpointModelLabel(settings: ReturnType<typeof loadWorkflowSettings>): string {
-  if (settings.context.customCompactionEnabled && settings.context.compactionMode === "custom_model" && settings.context.compactionModelProvider && settings.context.compactionModel) {
+  if (customModelCompactionConfigured(settings)) {
     return `concise checkpoint summaries; Pi session compaction uses configured compaction model when active (currently ${settings.context.compactionModelProvider}/${settings.context.compactionModel})`;
   }
   return "concise checkpoint summaries; Pi session compaction uses configured compaction model when active";
@@ -3294,7 +3388,7 @@ Mission Checkpoint Model: ${missionCheckpointModelLabel(settings)}`;
 function renderPlanModelSettings(settings: ReturnType<typeof loadWorkflowSettings>): string {
   return `Plan Model Source: shared workflow role models
 ${renderWorkflowModels(settings)}
-Compaction Model: ${settings.context.compactionMode === "custom_model" && settings.context.compactionModelProvider && settings.context.compactionModel ? `${settings.context.compactionModelProvider}/${settings.context.compactionModel}` : "Pi default / not configured"}`;
+Compaction Model: ${settings.context.compactionModelProvider && settings.context.compactionModel ? `${settings.context.compactionModelProvider}/${settings.context.compactionModel}` : "Pi default"}`;
 }
 
 function renderPlanSubagentWorkerSettings(settings: ReturnType<typeof loadWorkflowSettings>): string {
@@ -3393,8 +3487,10 @@ function renderWorkflowSettingsHealth(settings: ReturnType<typeof loadWorkflowSe
     `Validator: ${configuredLabel(settings.models.validator)}`,
     "",
     "## Compaction",
-    `Mode: ${compactionModeLabel(settings.context.compactionMode)}`,
-    `Workflow Auto Trigger: ${workflowProactiveCompactionEffective(settings) ? "armed" : "inactive"}`,
+    `Provider: ${settings.context.compactionModelProvider || "Pi default"}`,
+    `Model: ${settings.context.compactionModel || "Pi default"}`,
+    `Workflow Auto Trigger: ${workflowAutoTriggerLabel(settings)}`,
+    `Trigger: ${formatSharedCompactionTrigger(settings)}`,
     "Runtime: safe after-turn compaction",
     "",
     "## Capability Matrix Summary",
@@ -3652,18 +3748,16 @@ Note: Parallel File Edits controls simultaneous file writes only. It must not di
 ${renderSafetySettings(settings)}
 
 ## Compaction
-Compaction Mode: ${compactionModeLabel(settings.context.compactionMode)}
-Custom Compaction Enabled: ${settings.context.customCompactionEnabled ? "enabled" : "disabled"}
-Compaction Model Provider: ${settings.context.compactionModelProvider || "(not set)"}
-Compaction Model: ${settings.context.compactionModel || "(not set)"}
-${compactionAgentLine(settings)}${compactionAgentLine(settings) ? "\n" : ""}Workflow Auto Compaction Trigger Setting: ${settings.context.autoCompactionEnabled === true ? "enabled" : "disabled"}
+Compaction Provider: ${settings.context.compactionModelProvider || "Pi default"}
+Compaction Model: ${settings.context.compactionModel || "Pi default"}
+${compactionAgentLine(settings)}${compactionAgentLine(settings) ? "\n" : ""}Workflow Auto Compaction Trigger Setting: ${workflowAutoTriggerLabel(settings)}
 Effective Workflow Compaction Trigger: ${workflowProactiveCompactionEffective(settings) ? "armed" : "inactive"}
 Compaction Runtime: safe after-turn idle boundary only
 Workflow Compaction Trigger Override: ${compactionTriggerOverrideLabel(settings)}
-Effective Workflow Compaction Trigger Percent: ${compactionTriggerPercent(settings)}%
+Trigger: ${formatSharedCompactionTrigger(settings)}
 Workflow Compaction Cooldown: ${compactionCooldownMinutes(settings)} minute(s)
-Custom Compaction Reserve Tokens: ${customCompactionReserveTokens(settings)}
-Custom Compaction Keep Recent Tokens: ${customCompactionKeepRecentTokens(settings)}
+Compaction Reserve Tokens: ${compactionReserveTokensLabel(settings)}
+Compaction Keep Recent Tokens: ${compactionKeepRecentTokensLabel(settings)}
 Compaction Integration Status: ${compactionIntegrationStatus(settings)}
 Compaction Trigger Status: ${compactionTriggerStatus(settings)}
 ${workflowCompactionCheckRuntimeStatus()}
@@ -14651,33 +14745,62 @@ ${renderMissionStatus(activeMission ?? paused)}`);
     return { provider: providerChoice, model: modelChoice.replace(`${providerChoice}/`, "") };
   }
 
-  async function selectCompactionModel(ctx: ExtensionContext) {
-    const selected = await selectProviderAndModel(ctx, "Compaction model");
-    if (!selected) return;
+  async function chooseCompactionProvider(ctx: ExtensionContext): Promise<string | undefined> {
+    const models = ctx.modelRegistry.getAll();
+    const providers = [...new Set(models.map((m) => m.provider))].sort();
+    const providerChoice = await ctx.ui.select("Compaction Provider", ["Pi default", "Custom provider", "Back"]);
+    if (!providerChoice || providerChoice === "Back") return undefined;
+    if (providerChoice === "Pi default") return "";
+    const choice = await ctx.ui.select("Custom provider", [...providers, "Custom provider name", "Back"]);
+    if (!choice || choice === "Back") return undefined;
+    if (choice === "Custom provider name") return (await ctx.ui.input("Custom compaction provider:", "provider-name"))?.trim();
+    return choice;
+  }
+
+  async function selectCompactionProvider(ctx: ExtensionContext) {
+    const provider = await chooseCompactionProvider(ctx);
+    if (provider === undefined) return;
     const result = updateSettings(ctx.cwd, undefined, (s) => {
-      s.context.compactionMode = "custom_model";
-      s.context.compactionModelProvider = selected.provider;
-      s.context.compactionModel = selected.model;
-      s.context.customCompactionEnabled = true;
+      s.context.compactionModelProvider = provider;
+      s.context.compactionModel = "";
     });
-    ctx.ui.notify(`Compaction model stored as ${selected.provider}/${selected.model} in ${result.file}. It will be used by session_before_compact when available, with Pi default fallback on failure.`, "info");
+    ctx.ui.notify(provider ? `Compaction provider preference stored as ${provider} in ${result.file}. Trigger behavior was not changed.` : `Compaction provider reset to Pi default in ${result.file}. Trigger behavior was not changed.`, "info");
   }
 
-  async function selectCompactionModelForCurrentProvider(ctx: ExtensionContext) {
+  async function selectCompactionModel(ctx: ExtensionContext) {
     const settings = loadWorkflowSettings(ctx.cwd);
     const provider = settings.context.compactionModelProvider;
-    if (!provider) return selectCompactionModel(ctx);
-    const providerModels = ctx.modelRegistry.getAll().filter((m) => m.provider === provider).map((m) => m.id).sort();
-    if (providerModels.length === 0) return selectCompactionModel(ctx);
-    const modelChoice = await ctx.ui.select(`Compaction model for ${provider}:`, providerModels.map((model) => `${provider}/${model}`));
-    if (!modelChoice) return;
-    const model = modelChoice.replace(`${provider}/`, "");
+    const mode = await ctx.ui.select("Compaction Model", ["Pi default", "Custom model", "Back"]);
+    if (!mode || mode === "Back") return;
+    if (mode === "Pi default") {
+      const result = updateSettings(ctx.cwd, undefined, (s) => {
+        s.context.compactionModelProvider = "";
+        s.context.compactionModel = "";
+      });
+      ctx.ui.notify(`Compaction summary model reset to Pi default in ${result.file}. Trigger behavior was not changed.`, "info");
+      return;
+    }
+
+    let selectedProvider = provider;
+    if (!selectedProvider) {
+      const chosen = await chooseCompactionProvider(ctx);
+      if (chosen === undefined) return;
+      selectedProvider = chosen;
+    }
+    if (!selectedProvider) {
+      ctx.ui.notify("Select a custom compaction provider before selecting a custom model.", "warning");
+      return;
+    }
+    const providerModels = ctx.modelRegistry.getAll().filter((m) => m.provider === selectedProvider).map((m) => m.id).sort();
+    const modelChoice = await ctx.ui.select(`Custom model for ${selectedProvider}:`, [...providerModels.map((model) => `${selectedProvider}/${model}`), "Custom model name", "Back"]);
+    if (!modelChoice || modelChoice === "Back") return;
+    const model = modelChoice === "Custom model name" ? (await ctx.ui.input("Custom compaction model:", "model-name"))?.trim() : modelChoice.replace(`${selectedProvider}/`, "");
+    if (!model) return;
     const result = updateSettings(ctx.cwd, undefined, (s) => {
-      s.context.compactionMode = "custom_model";
+      s.context.compactionModelProvider = selectedProvider;
       s.context.compactionModel = model;
-      s.context.customCompactionEnabled = true;
     });
-    ctx.ui.notify(`Compaction model stored as ${provider}/${model} in ${result.file}. It will be used by session_before_compact when available, with Pi default fallback on failure.`, "info");
+    ctx.ui.notify(`Compaction model preference stored as ${selectedProvider}/${model} in ${result.file}. Trigger behavior was not changed.`, "info");
   }
 
   async function selectCompactionAgent(ctx: ExtensionContext) {
@@ -14697,60 +14820,70 @@ ${renderMissionStatus(activeMission ?? paused)}`);
   async function showCompactionSettingsMenu(ctx: ExtensionContext) {
     if (!ctx.hasUI) return show(pi, renderFullWorkflowSettings(loadWorkflowSettings(ctx.cwd)));
     while (ctx.hasUI) {
-      const choice = await ctx.ui.select("Shared Compaction Settings", ["Compaction Mode", "Compaction Provider", "Compaction Model", "Custom Compaction Enabled", "Workflow Auto Trigger Enabled", "Workflow Trigger Percent", "Workflow Trigger Cooldown", "Custom Reserve Tokens", "Custom Keep Recent Tokens", "List Current Settings", "Back"]);
+      const choice = await ctx.ui.select("Shared Compaction Settings", ["Compaction Provider", "Compaction Model", "Workflow Auto Trigger Enabled", "Workflow Trigger Percent", "Workflow Trigger Cooldown", "Custom Reserve Tokens", "Custom Keep Recent Tokens", "List Current Settings", "Back"]);
       if (!choice || choice === "Back") return;
-      if (choice === "Compaction Mode") {
-        const mode = parseCompactionMode((await ctx.ui.select("Compaction mode", ["Pi default", "Custom model", "Disabled"])) ?? "");
-        if (!mode) continue;
-        if (mode === "custom_model") { await selectCompactionModel(ctx); continue; }
-        const r = updateSettings(ctx.cwd, undefined, (s) => {
-          if (mode === "pi_default") resetCompactionContextToPiDefault(s.context);
-          else {
-            s.context.compactionMode = mode;
-            s.context.customCompactionEnabled = false;
-          }
-        });
-        ctx.ui.notify(`Compaction mode set to ${compactionModeLabel(mode)} in ${r.file}${mode === "pi_default" ? "; custom compaction overrides reset, selected provider/model preserved" : ""}.`, "info");
-      } else if (choice === "Compaction Provider") {
-        await selectCompactionModel(ctx);
+      if (choice === "Compaction Provider") {
+        await selectCompactionProvider(ctx);
       } else if (choice === "Compaction Model") {
-        await selectCompactionModelForCurrentProvider(ctx);
-      } else if (choice === "Custom Compaction Enabled") {
-        const enabled = await chooseBool(ctx, "Custom compaction enabled?");
-        if (enabled !== undefined) { const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.customCompactionEnabled = enabled; }); ctx.ui.notify(`Custom compaction set to ${enabled ? "enabled" : "disabled"} in ${r.file}. Custom model routing uses the session compaction hook when configured; Pi default fallback remains enabled.`, "info"); }
+        await selectCompactionModel(ctx);
       } else if (choice === "Workflow Auto Trigger Enabled") {
-        const enabled = await chooseBool(ctx, "Workflow proactive auto-compaction trigger enabled?");
-        if (enabled !== undefined) { const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.autoCompactionEnabled = enabled; }); ctx.ui.notify(`Workflow auto trigger set to ${enabled ? "enabled" : "disabled"} in ${r.file}. Pi default auto-compaction remains available as fallback.`, "info"); }
+        const trigger = await ctx.ui.select("Workflow Auto Trigger Enabled", ["Pi default", "Enabled", "Disabled", "Back"]);
+        if (!trigger || trigger === "Back") continue;
+        const r = updateSettings(ctx.cwd, undefined, (s) => {
+          if (trigger === "Pi default") delete s.context.autoCompactionEnabled;
+          else s.context.autoCompactionEnabled = trigger === "Enabled";
+        });
+        ctx.ui.notify(`Workflow auto trigger set to ${trigger.toLowerCase()} in ${r.file}.`, "info");
       } else if (choice === "Workflow Trigger Percent") {
-        const current = loadWorkflowSettings(ctx.cwd).context.compactionTriggerPercent;
-        const raw = String((await ctx.ui.input("Workflow compaction trigger percent (50-95, default, or reset)", current == null ? "Pi default" : String(compactionTriggerPercent(loadWorkflowSettings(ctx.cwd)))) ?? "")).trim().toLowerCase();
-        if (raw === "default" || raw === "reset") {
+        const mode = await ctx.ui.select("Workflow Trigger Percent", ["Pi default", "Custom percent", "Back"]);
+        if (!mode || mode === "Back") continue;
+        if (mode === "Pi default") {
           const r = updateSettings(ctx.cwd, undefined, (s) => { delete s.context.compactionTriggerPercent; });
-          ctx.ui.notify(`Workflow compaction trigger percent override removed in ${r.file}; Pi default compaction behavior remains in control.`, "info");
+          ctx.ui.notify(`Workflow compaction trigger percent override removed in ${r.file}; Pi native trigger formula remains in control.`, "info");
         } else {
+          const raw = String((await ctx.ui.input("Workflow compaction trigger percent (50-95)", String(compactionTriggerPercentOverride(loadWorkflowSettings(ctx.cwd)) ?? 85))) ?? "").trim();
           const count = Number(raw);
           if (Number.isInteger(count) && count >= 50 && count <= 95) { const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.compactionTriggerPercent = count; }); ctx.ui.notify(`Workflow compaction trigger percent set to ${count}% in ${r.file}`, "info"); }
-          else ctx.ui.notify("Trigger percent must be an integer from 50 to 95, default, or reset.", "error");
+          else ctx.ui.notify("Trigger percent must be an integer from 50 to 95.", "error");
         }
       } else if (choice === "Workflow Trigger Cooldown") {
-        const count = Number((await ctx.ui.input("Minimum minutes between Workflow Suite proactive compaction attempts", String(compactionCooldownMinutes(loadWorkflowSettings(ctx.cwd)))) ?? ""));
-        if (Number.isInteger(count) && count >= 0 && count <= 240) { const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.compactionCooldownMinutes = count; }); ctx.ui.notify(`Compaction cooldown set to ${count} minute(s) in ${r.file}. This is the minimum wait between proactive compaction attempts, not a delay before compaction starts.`, "info"); }
-        else ctx.ui.notify("Cooldown must be an integer from 0 to 240 minutes.", "error");
+        const mode = await ctx.ui.select("Workflow Trigger Cooldown", ["Pi default", "Custom cooldown", "Back"]);
+        if (!mode || mode === "Back") continue;
+        if (mode === "Pi default") {
+          const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.compactionCooldownMinutes = 5; });
+          ctx.ui.notify(`Compaction cooldown reset to Pi default (5 minutes) in ${r.file}.`, "info");
+        } else {
+          const count = Number((await ctx.ui.input("Minimum minutes between Workflow Suite proactive compaction attempts", String(compactionCooldownMinutes(loadWorkflowSettings(ctx.cwd)))) ?? ""));
+          if (Number.isInteger(count) && count >= 0 && count <= 240) { const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.compactionCooldownMinutes = count; }); ctx.ui.notify(`Compaction cooldown set to ${count} minute(s) in ${r.file}. This is the minimum wait between proactive compaction attempts, not a delay before compaction starts.`, "info"); }
+          else ctx.ui.notify("Cooldown must be an integer from 0 to 240 minutes.", "error");
+        }
       } else if (choice === "Custom Reserve Tokens") {
-        const raw = String((await ctx.ui.input("Custom compaction reserve tokens (4096-65536, default, or reset)", String(customCompactionReserveTokens(loadWorkflowSettings(ctx.cwd)))) ?? "")).trim().toLowerCase();
-        const count = Number(raw);
-        if (raw === "default" || raw === "reset") { const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.customCompactionReserveTokens = DEFAULT_PI_COMPACTION_RESERVE_TOKENS; }); ctx.ui.notify(`Custom compaction reserve tokens reset to ${DEFAULT_PI_COMPACTION_RESERVE_TOKENS.toLocaleString()} in ${r.file}`, "info"); }
-        else if (Number.isInteger(count) && count >= 4096 && count <= 65536) { const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.customCompactionReserveTokens = count; }); ctx.ui.notify(`Custom compaction reserve tokens set to ${count.toLocaleString()} in ${r.file}`, "info"); }
-        else ctx.ui.notify("Reserve tokens must be an integer from 4096 to 65536, default, or reset.", "error");
+        const mode = await ctx.ui.select("Custom Reserve Tokens", ["Pi default", "Custom reserve tokens", "Back"]);
+        if (!mode || mode === "Back") continue;
+        if (mode === "Pi default") {
+          const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.customCompactionReserveTokens = DEFAULT_PI_COMPACTION_RESERVE_TOKENS; });
+          ctx.ui.notify(`Custom compaction reserve tokens reset to Pi default (${DEFAULT_PI_COMPACTION_RESERVE_TOKENS.toLocaleString()}) in ${r.file}`, "info");
+        } else {
+          const raw = String((await ctx.ui.input("Custom compaction reserve tokens (4096-65536)", String(customCompactionReserveTokens(loadWorkflowSettings(ctx.cwd)))) ?? "")).trim();
+          const count = Number(raw);
+          if (Number.isInteger(count) && count >= 4096 && count <= 65536) { const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.customCompactionReserveTokens = count; }); ctx.ui.notify(`Custom compaction reserve tokens set to ${count.toLocaleString()} in ${r.file}`, "info"); }
+          else ctx.ui.notify("Reserve tokens must be an integer from 4096 to 65536.", "error");
+        }
       } else if (choice === "Custom Keep Recent Tokens") {
-        const raw = String((await ctx.ui.input("Custom compaction keep-recent tokens (1000-200000, default, or reset)", String(customCompactionKeepRecentTokens(loadWorkflowSettings(ctx.cwd)))) ?? "")).trim().toLowerCase();
-        const count = Number(raw);
-        if (raw === "default" || raw === "reset") { const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.customCompactionKeepRecentTokens = DEFAULT_PI_COMPACTION_KEEP_RECENT_TOKENS; }); ctx.ui.notify(`Custom compaction keep-recent tokens reset to ${DEFAULT_PI_COMPACTION_KEEP_RECENT_TOKENS.toLocaleString()} in ${r.file}`, "info"); }
-        else if (Number.isInteger(count) && count >= 1000 && count <= 200000) { const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.customCompactionKeepRecentTokens = count; }); ctx.ui.notify(`Custom compaction keep-recent tokens set to ${count.toLocaleString()} in ${r.file}`, "info"); }
-        else ctx.ui.notify("Keep-recent tokens must be an integer from 1000 to 200000, default, or reset.", "error");
+        const mode = await ctx.ui.select("Custom Keep Recent Tokens", ["Pi default", "Custom keep-recent tokens", "Back"]);
+        if (!mode || mode === "Back") continue;
+        if (mode === "Pi default") {
+          const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.customCompactionKeepRecentTokens = DEFAULT_PI_COMPACTION_KEEP_RECENT_TOKENS; });
+          ctx.ui.notify(`Custom compaction keep-recent tokens reset to Pi default (${DEFAULT_PI_COMPACTION_KEEP_RECENT_TOKENS.toLocaleString()}) in ${r.file}`, "info");
+        } else {
+          const raw = String((await ctx.ui.input("Custom compaction keep-recent tokens (1000-200000)", String(customCompactionKeepRecentTokens(loadWorkflowSettings(ctx.cwd)))) ?? "")).trim();
+          const count = Number(raw);
+          if (Number.isInteger(count) && count >= 1000 && count <= 200000) { const r = updateSettings(ctx.cwd, undefined, (s) => { s.context.customCompactionKeepRecentTokens = count; }); ctx.ui.notify(`Custom compaction keep-recent tokens set to ${count.toLocaleString()} in ${r.file}`, "info"); }
+          else ctx.ui.notify("Keep-recent tokens must be an integer from 1000 to 200000.", "error");
+        }
       } else if (choice === "List Current Settings") {
         const s = loadWorkflowSettings(ctx.cwd);
-        show(pi, `# Shared Compaction\n\nCompaction Mode: ${s.context.compactionMode ?? "pi_default"}\nCustom Compaction: ${s.context.customCompactionEnabled ? "enabled" : "disabled"}\nProvider: ${s.context.compactionModelProvider ?? "none"}\nModel: ${s.context.compactionModel ?? "none"}\nWorkflow Auto Trigger: ${s.context.autoCompactionEnabled === true ? "enabled" : "disabled; Pi default applies"}\nWorkflow Trigger Percent Override: ${compactionTriggerOverrideLabel(s)}\nEffective Workflow Trigger Percent: ${compactionTriggerPercent(s)}%\nCooldown: ${s.context.compactionCooldownMinutes ?? 0} min\nReserve Tokens: ${s.context.customCompactionReserveTokens?.toLocaleString() ?? "default"}\nKeep Recent Tokens: ${s.context.customCompactionKeepRecentTokens?.toLocaleString() ?? "default"}`);
+        show(pi, `# Shared Compaction\n\nProvider: ${s.context.compactionModelProvider || "Pi default"}\nModel: ${s.context.compactionModel || "Pi default"}\nWorkflow Auto Trigger: ${workflowAutoTriggerLabel(s)}\nTrigger: ${formatSharedCompactionTrigger(s, ctx)}\nCooldown: ${compactionCooldownLabel(s)}\nReserve Tokens: ${compactionReserveTokensLabel(s)}\nKeep Recent Tokens: ${compactionKeepRecentTokensLabel(s)}`);
       }
     }
   }
@@ -15868,10 +16001,9 @@ Pi Version: v${VERSION}
 
   function workflowAutoCompactionDecision(ctx: ExtensionContext, options: { allowPendingMessages?: boolean } = {}): { ok: true; percent: number; trigger: number; cooldownMinutes: number } | { ok: false; reason: string } {
     const settings = loadWorkflowSettings(ctx.cwd);
-    const customModelTrigger = customModelCompactionConfigured(settings);
     if (!workflowProactiveCompactionEffective(settings)) return { ok: false, reason: "workflow proactive compaction disabled" };
     if (settings.context.compactionMode === "disabled") return { ok: false, reason: "workflow compaction mode disabled" };
-    if (!customModelTrigger && !workflowAutoCompactionModeEligible(state.mode)) return { ok: false, reason: `workflow mode ${state.mode} is active` };
+    if (!workflowAutoCompactionModeEligible(state.mode)) return { ok: false, reason: `workflow mode ${state.mode} is active` };
     if (!options.allowPendingMessages) {
       if (workflowScheduledAgentTurns > 0) return { ok: false, reason: "pending workflow handoff queued" };
       try { if (ctx.hasPendingMessages()) return { ok: false, reason: "pending messages queued" }; } catch { /* pending state unavailable */ }
@@ -15880,6 +16012,7 @@ Pi Version: v${VERSION}
     const percent = Number(usage?.percent);
     if (!Number.isFinite(percent)) return { ok: false, reason: "context usage unavailable" };
     const trigger = effectiveWorkflowCompactionTriggerPercent(settings, ctx, usage ?? {});
+    if (!Number.isFinite(trigger)) return { ok: false, reason: "compaction trigger unavailable" };
     if (percent < trigger) return { ok: false, reason: `context ${percent.toFixed(1)}% below trigger ${trigger}%` };
     const cooldownMinutes = compactionCooldownMinutes(settings);
     const cooldownMs = cooldownMinutes * 60 * 1000;
@@ -15992,19 +16125,11 @@ Pi Version: v${VERSION}
 
   pi.on("session_before_compact", async (event, ctx) => {
     const settings = loadWorkflowSettings(ctx.cwd);
-    if (!settings.context.customCompactionEnabled) return;
-    if (settings.context.compactionMode === "pi_default" || settings.context.compactionMode === "disabled") return;
-    if (settings.context.compactionMode !== "custom_model") {
-      rememberCustomCompactionStatus(`fallback to Pi default: ${compactionModeLabel(settings.context.compactionMode)} uses Pi fallback behavior in current releases`);
-      ctx.ui.notify("Agent-routed custom compaction uses Pi default fallback behavior in current releases.", "warning");
-      return;
-    }
+    if (settings.context.compactionMode === "disabled") return;
 
     const provider = settings.context.compactionModelProvider;
     const modelId = settings.context.compactionModel;
     if (!provider || !modelId) {
-      rememberCustomCompactionStatus("fallback to Pi default: custom compaction model is missing provider/model");
-      ctx.ui.notify("Custom compaction model is missing provider/model; using Pi default compaction.", "warning");
       return;
     }
 
@@ -16715,7 +16840,7 @@ Pi Version: v${VERSION}
     if (action === "scope" || action === "write-target") {
       const effective = loadEffectiveSettings(ctx.cwd);
       const target = getDefaultWriteTarget(ctx.cwd);
-      show(pi, `# Workflow Settings Scope\n\nCurrent Directory: ${ctx.cwd}\nProject Override: ${effective.projectOverridePath ?? "none"}\nWrite Target: ${target.scope}\nWrite Target File: ${target.file}\nGlobal Settings File: ${WORKFLOW_SETTINGS_FILE}\nSettings Priority: project workflow settings > global workflow-settings.json > example config defaults > built-in emergency fallback\nCompaction Effective Source: ${effective.projectOverridePath ? "project override may override global compaction settings" : "global workflow-settings.json"}\nEffective Compaction Model: ${effective.settings.context.compactionMode === "custom_model" ? `${effective.settings.context.compactionModelProvider || "(missing provider)"}/${effective.settings.context.compactionModel || "(missing model)"}` : effective.settings.context.compactionMode}`);
+      show(pi, `# Workflow Settings Scope\n\nCurrent Directory: ${ctx.cwd}\nProject Override: ${effective.projectOverridePath ?? "none"}\nWrite Target: ${target.scope}\nWrite Target File: ${target.file}\nGlobal Settings File: ${WORKFLOW_SETTINGS_FILE}\nSettings Priority: project workflow settings > global workflow-settings.json > example config defaults > built-in emergency fallback\nCompaction Effective Source: ${effective.projectOverridePath ? "project override may override global compaction settings" : "global workflow-settings.json"}\nCompaction Summary Model: ${effective.settings.context.compactionModelProvider && effective.settings.context.compactionModel ? `${effective.settings.context.compactionModelProvider}/${effective.settings.context.compactionModel}` : "Pi default"}`);
       return;
     }
     if (action === "create-project-override") {
@@ -17022,7 +17147,12 @@ Pi Version: v${VERSION}
         return show(pi, updatedMessage(result.scope, result.file, "context.customCompactionEnabled", String(bool)));
       }
       if (subject === "context" && key === "autoCompactionEnabled") {
-        if (bool === undefined) return show(pi, "# Error\n\nUsage: `/workflow-settings set context autoCompactionEnabled <true|false>`");
+        const normalizedValue = String(value ?? "").trim().toLowerCase();
+        if (normalizedValue === "default" || normalizedValue === "reset") {
+          const result = updateSettings(ctx.cwd, scope, (s) => { delete s.context.autoCompactionEnabled; });
+          return show(pi, updatedMessage(result.scope, result.file, "context.autoCompactionEnabled", "Pi default") + `\n\n${compactionTriggerStatus(result.settings)}`);
+        }
+        if (bool === undefined) return show(pi, "# Error\n\nUsage: `/workflow-settings set context autoCompactionEnabled <true|false|default>`");
         const result = updateSettings(ctx.cwd, scope, (s) => { s.context.autoCompactionEnabled = bool; });
         return show(pi, updatedMessage(result.scope, result.file, "context.autoCompactionEnabled", String(bool)) + `\n\n${compactionTriggerStatus(result.settings)}`);
       }
@@ -17036,18 +17166,18 @@ Pi Version: v${VERSION}
         const normalizedValue = String(value ?? "").trim().toLowerCase();
         if (key === "compactionTriggerPercent" && (normalizedValue === "default" || normalizedValue === "reset")) {
           const result = updateSettings(ctx.cwd, scope, (s) => { delete s.context.compactionTriggerPercent; });
-          return show(pi, updatedMessage(result.scope, result.file, "context.compactionTriggerPercent", "removed override; Pi default applies") + `\n\n${compactionTriggerStatus(result.settings)}`);
+          return show(pi, updatedMessage(result.scope, result.file, "context.compactionTriggerPercent", "removed override; Pi native formula applies") + `\n\n${compactionTriggerStatus(result.settings)}`);
         }
-        if ((key === "customCompactionReserveTokens" || key === "customCompactionKeepRecentTokens") && (normalizedValue === "default" || normalizedValue === "reset")) {
-          const fallback = key === "customCompactionReserveTokens" ? DEFAULT_PI_COMPACTION_RESERVE_TOKENS : DEFAULT_PI_COMPACTION_KEEP_RECENT_TOKENS;
+        if ((key === "compactionCooldownMinutes" || key === "customCompactionReserveTokens" || key === "customCompactionKeepRecentTokens") && (normalizedValue === "default" || normalizedValue === "reset")) {
+          const fallback = key === "compactionCooldownMinutes" ? 5 : key === "customCompactionReserveTokens" ? DEFAULT_PI_COMPACTION_RESERVE_TOKENS : DEFAULT_PI_COMPACTION_KEEP_RECENT_TOKENS;
           const result = updateSettings(ctx.cwd, scope, (s) => { (s.context as typeof s.context & Record<string, number>)[key] = fallback; });
-          return show(pi, updatedMessage(result.scope, result.file, `context.${key}`, `default ${fallback}`) + `\n\n${compactionTriggerStatus(result.settings)}`);
+          return show(pi, updatedMessage(result.scope, result.file, `context.${key}`, `Pi default ${fallback}`) + `\n\n${compactionTriggerStatus(result.settings)}`);
         }
         const rawCount = value === undefined ? NaN : Number(value);
         const count = Number.isInteger(rawCount) ? rawCount : undefined;
         const min = key === "compactionTriggerPercent" ? 50 : key === "compactionCooldownMinutes" ? 0 : key === "customCompactionReserveTokens" ? 4096 : 1000;
         const max = key === "compactionTriggerPercent" ? 95 : key === "compactionCooldownMinutes" ? 240 : key === "customCompactionReserveTokens" ? 65536 : 200000;
-        const usage = key === "compactionTriggerPercent" || key === "customCompactionReserveTokens" || key === "customCompactionKeepRecentTokens" ? `<${min}-${max}|default|reset>` : `<${min}-${max}>`;
+        const usage = `<${min}-${max}|default|reset>`;
         if (count === undefined || count < min || count > max) return show(pi, `# Error\n\nUsage: \`/workflow-settings set context ${key} ${usage}\``);
         const result = updateSettings(ctx.cwd, scope, (s) => { (s.context as typeof s.context & Record<string, number>)[key] = count; });
         return show(pi, updatedMessage(result.scope, result.file, `context.${key}`, String(count)) + `\n\n${compactionTriggerStatus(result.settings)}`);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mediadatafusion/pi-workflow-suite",
-  "version": "0.0.16",
-  "description": "Structured workflow orchestration suite for Pi with Standard, Plan, Mission, compaction, diagrams, web access, repo lock, and safety gates.",
+  "version": "0.0.18",
+  "description": "Multi-agent workflow suite for Pi with Idle, Standard, Plan, Mission, approval gates, reviewer/validator roles, sub-agents, model routing, web search/fetch, browser checks, diagrams, compaction, presets, settings, themes, widgets, and Repo Lock.",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -24,9 +24,20 @@
     "workflow-suite",
     "workflow-orchestration",
     "agent-workflow",
+    "idle-mode",
     "plan-mode",
     "mission-mode",
     "standard-mode",
+    "multi-agent",
+    "approval-gates",
+    "review-validation",
+    "sub-agent-orchestration",
+    "model-routing",
+    "web-search",
+    "browser-verification",
+    "repo-lock",
+    "workflow-settings",
+    "workflow-widgets",
     "subagents",
     "skills",
     "prompts",