@pellux/goodvibes-tui 0.25.0 → 0.27.0

package/src/daemon/handlers/triage/tagger/index.ts

@@ -0,0 +1,184 @@
+// ---------------------------------------------------------------------------
+// Daemon-internal triage TAGGER (composition).
+//
+// Applies user-defined triage labels back on the provider side:
+//   - IMAP : STORE a keyword flag on the message (IMAP4rev1 over TLS).
+//   - Slack: reactions.add emoji on the source message.
+//   - Discord: real forum thread tags (PATCH applied_tags, merge) when a
+//     forum-tag mapping is configured, else a unicode reaction analog.
+//
+// Hard rules honored here:
+//   - All provider credentials come ONLY from the daemon credential store.
+//     They are never returned in results and never logged.
+//   - The whole tagger is gated behind a config flag (surfaces.triage.autoTag);
+//     when disabled, applyTags() is a no-op that reports skipped:true.
+//   - Provider-side writes are EFFECTFUL; callers must pass an explicitly
+//     confirmed request (confirm === true && explicitUserRequest === true).
+//     Unconfirmed calls throw HandlerError(REQUIRE_CONFIRM).
+//
+// Contract-fidelity note: the triage surface (`inbox.triage.*`) is daemon-
+// internal and NOT a published operator method, so there is no external
+// request/response schema to certify these tag shapes against. What is
+// guaranteed is the provider-side behavior: no silent data loss (Discord thread
+// tags are merged, never blindly overwritten) and no command injection (IMAP
+// quoting rejects control characters).
+// ---------------------------------------------------------------------------
+
+import type { HandlerContext } from '../../context.ts';
+import type { DaemonCredentialStore } from '../../credentials.ts';
+import { HandlerError, REQUIRE_CONFIRM } from '../../errors.ts';
+import { labelToTag } from '../scorer.ts';
+import { applyImap, imapStoreFlagOverTls, makeRetryingImapStoreFlag } from './imap.ts';
+import type { ImapRetryOptions, ImapStoreFlag } from './imap.ts';
+import { applySlack } from './slack.ts';
+import { applyDiscord } from './discord.ts';
+import type { ApplyTagsRequest, ApplyTagsResult, TaggerProviderConfig } from './shared.ts';
+
+export type {
+  ApplyTagsRequest,
+  ApplyTagsResult,
+  TaggerProviderConfig,
+} from './shared.ts';
+export type { ImapRetryOptions, ImapStoreArgs, ImapStoreFlag } from './imap.ts';
+
+export const TRIAGE_AUTOTAG_FLAG = 'surfaces.triage.autoTag';
+
+export interface TriageTaggerOptions {
+  credentials?: DaemonCredentialStore;
+  /** Override the autotag flag lookup (used in tests). */
+  autoTagEnabled?: boolean;
+  /** Per-surface provider config; usually derived from configManager. */
+  providers?: TaggerProviderConfig;
+  /** Injectable fetch (Slack/Discord HTTP). Defaults to global fetch. */
+  fetchImpl?: typeof fetch;
+  /** Injectable IMAP flag-setter (used in tests to avoid a live socket). */
+  imapStoreFlag?: ImapStoreFlag;
+  /**
+   * Transient-failure retry policy for the default IMAP store implementation.
+   * Ignored when imapStoreFlag is injected and succeeds first-try.
+   */
+  imapRetry?: ImapRetryOptions;
+}
+
+export interface TriageTagger {
+  /** Whether provider-side tagging is currently enabled. */
+  enabled(): boolean;
+  applyTags(request: ApplyTagsRequest): Promise<ApplyTagsResult>;
+}
+
+function readBoolFlag(
+  configManager: HandlerContext['configManager'],
+  key: string,
+): boolean {
+  try {
+    const value = configManager.get(key as never) as unknown;
+    return value === true || value === 'true' || value === 1;
+  } catch {
+    return false;
+  }
+}
+
+function safeGet(configManager: HandlerContext['configManager'], key: string): unknown {
+  try {
+    return configManager.get(key as never) as unknown;
+  } catch {
+    return undefined;
+  }
+}
+
+function resolveProvidersFromConfig(
+  configManager: HandlerContext['configManager'],
+): TaggerProviderConfig {
+  const out: TaggerProviderConfig = {};
+  const slackToken = safeGet(configManager, 'surfaces.slack.botToken');
+  if (typeof slackToken === 'string' && slackToken.length > 0) {
+    out.slack = { tokenConfigKey: 'surfaces.slack.botToken' };
+  }
+  const discordToken = safeGet(configManager, 'surfaces.discord.botToken');
+  if (typeof discordToken === 'string' && discordToken.length > 0) {
+    out.discord = { tokenConfigKey: 'surfaces.discord.botToken' };
+  }
+  const imapHost = safeGet(configManager, 'surfaces.email.imap.host');
+  const imapUser = safeGet(configManager, 'surfaces.email.imap.user');
+  if (typeof imapHost === 'string' && imapHost.length > 0 && typeof imapUser === 'string') {
+    const portRaw = safeGet(configManager, 'surfaces.email.imap.port');
+    const mailbox = safeGet(configManager, 'surfaces.email.imap.mailbox');
+    out.imap = {
+      host: imapHost,
+      port: typeof portRaw === 'number' ? portRaw : 993,
+      user: imapUser,
+      passwordConfigKey: 'surfaces.email.imap.password',
+      mailbox: typeof mailbox === 'string' && mailbox.length > 0 ? mailbox : 'INBOX',
+    };
+  }
+  return out;
+}
+
+function resolveTags(request: ApplyTagsRequest): string[] {
+  if (request.tags && request.tags.length > 0) {
+    return [...new Set(request.tags.map((t) => t.trim()).filter((t) => t.length > 0))];
+  }
+  if (request.label) return [labelToTag(request.label)];
+  return [];
+}
+
+/**
+ * Create the triage tagger. Reads the autotag flag and provider config from the
+ * handler context; credentials are resolved lazily, per apply, from the daemon
+ * credential store.
+ */
+export function createTriageTagger(
+  ctx: HandlerContext,
+  options: TriageTaggerOptions = {},
+): TriageTagger {
+  const credentials = options.credentials ?? ctx.credentials;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const providers = options.providers ?? resolveProvidersFromConfig(ctx.configManager);
+  // Retry wraps whichever store impl is in use (default TLS client OR an
+  // injected one), so transient failures are retried uniformly.
+  const imapStoreFlag = makeRetryingImapStoreFlag(
+    options.imapStoreFlag ?? imapStoreFlagOverTls,
+    options.imapRetry,
+  );
+  const enabled = (): boolean =>
+    options.autoTagEnabled ?? readBoolFlag(ctx.configManager, TRIAGE_AUTOTAG_FLAG);
+
+  return {
+    enabled,
+    async applyTags(request: ApplyTagsRequest): Promise<ApplyTagsResult> {
+      const { item } = request;
+      const tags = resolveTags(request);
+      const base: ApplyTagsResult = {
+        surface: item.surface,
+        itemId: item.id,
+        appliedTags: [],
+        skipped: true,
+      };
+
+      if (!enabled()) {
+        return { ...base, reason: 'autotag-disabled' };
+      }
+
+      // Provider-side mutation is effectful — require explicit confirmation.
+      if (request.confirm !== true || request.explicitUserRequest !== true) {
+        throw new HandlerError(
+          'Provider-side triage tagging requires explicit user confirmation.',
+          REQUIRE_CONFIRM,
+          403,
+        );
+      }
+
+      switch (item.surface) {
+        case 'email':
+        case 'imap':
+          return applyImap(item, tags, providers, credentials, imapStoreFlag, base);
+        case 'slack':
+          return applySlack(item, tags, providers, credentials, fetchImpl, ctx, base);
+        case 'discord':
+          return applyDiscord(item, tags, providers, credentials, fetchImpl, ctx, base);
+        default:
+          return { ...base, reason: `unsupported-surface:${item.surface}` };
+      }
+    },
+  };
+}

package/src/daemon/handlers/triage/tagger/shared.ts

@@ -0,0 +1,70 @@
+// ---------------------------------------------------------------------------
+// Triage tagger — shared types and provider-agnostic helpers.
+//
+// Provider config shapes, the apply request/result contract, and the tag
+// normalization helpers used by the IMAP/Slack/Discord modules. No I/O here.
+// ---------------------------------------------------------------------------
+
+import type { InboundChannelItem, TriageLabel } from '../types.ts';
+
+export interface TaggerProviderConfig {
+  /** IMAP host:port (default port 993, TLS). Credentials resolved separately. */
+  imap?: { host: string; port?: number; user: string; passwordConfigKey: string; mailbox?: string };
+  /** Slack bot token config key (resolved from credential store). */
+  slack?: { tokenConfigKey: string };
+  /**
+   * Discord bot token config key (resolved from credential store), plus an
+   * optional forum-tag mapping. When `forumTagIds` maps a GoodVibes triage tag
+   * (e.g. 'GoodVibes/Spam') to a forum tag SNOWFLAKE id, items that target a
+   * forum/media-channel thread get that REAL thread tag applied (PATCH
+   * applied_tags) — exact fidelity to the contract's "Discord thread tags".
+   * Without a mapping (or for non-thread messages) tagging degrades to a
+   * unicode reaction analog.
+   */
+  discord?: { tokenConfigKey: string; forumTagIds?: Record<string, string> };
+}
+
+export interface ApplyTagsRequest {
+  item: InboundChannelItem;
+  /** Provider-side tags to apply. Defaults to [labelToTag(label)] when omitted. */
+  tags?: readonly string[];
+  label?: TriageLabel;
+  /** Must be true — provider-side mutation requires explicit confirmation. */
+  confirm?: boolean;
+  /** Mirror of the operator invocation context flag. */
+  explicitUserRequest?: boolean;
+}
+
+export interface ApplyTagsResult {
+  surface: string;
+  itemId: string;
+  appliedTags: string[];
+  /** True when the autotag flag is disabled or no provider matched. */
+  skipped: boolean;
+  reason?: string;
+}
+
+/** IMAP keywords cannot contain spaces or '/'; normalize the canonical tag. */
+export function imapKeywordForTag(tag: string): string {
+  return tag.replace(/[^A-Za-z0-9_]+/g, '_');
+}
+
+export function slackEmojiForTag(tag: string): string {
+  const lower = tag.toLowerCase();
+  if (lower.includes('spam')) return 'no_entry_sign';
+  if (lower.includes('priority')) return 'rotating_light';
+  return 'inbox_tray';
+}
+
+export function discordEmojiForTag(tag: string): string {
+  const lower = tag.toLowerCase();
+  if (lower.includes('spam')) return '\u{1F6AB}';
+  if (lower.includes('priority')) return '\u{1F6A8}';
+  return '\u{1F4E5}';
+}
+
+/** Read a non-empty string from the item's opaque metadata bag. */
+export function stringMeta(item: InboundChannelItem, key: string): string | undefined {
+  const value = item.metadata?.[key];
+  return typeof value === 'string' && value.length > 0 ? value : undefined;
+}

package/src/daemon/handlers/triage/tagger/slack.ts

@@ -0,0 +1,69 @@
+// ---------------------------------------------------------------------------
+// Triage tagger — Slack provider.
+//
+// Applies a triage label as a Slack message reaction (reactions.add). The bot
+// token is resolved per-apply from the daemon credential store and is never
+// logged or returned. `already_reacted` is treated as idempotent success.
+// ---------------------------------------------------------------------------
+
+import type { HandlerContext } from '../../context.ts';
+import type { DaemonCredentialStore } from '../../credentials.ts';
+import { HandlerError } from '../../errors.ts';
+import type { InboundChannelItem } from '../types.ts';
+import type { ApplyTagsResult, TaggerProviderConfig } from './shared.ts';
+import { slackEmojiForTag, stringMeta } from './shared.ts';
+
+export async function applySlack(
+  item: InboundChannelItem,
+  tags: string[],
+  providers: TaggerProviderConfig,
+  credentials: DaemonCredentialStore,
+  fetchImpl: typeof fetch,
+  ctx: HandlerContext,
+  base: ApplyTagsResult,
+): Promise<ApplyTagsResult> {
+  const cfg = providers.slack;
+  if (!cfg) return { ...base, reason: 'slack-not-configured' };
+  const channel = stringMeta(item, 'channelId') ?? item.conversationId;
+  const ts = stringMeta(item, 'ts') ?? stringMeta(item, 'messageTs');
+  if (!channel || !ts) return { ...base, reason: 'slack-missing-target' };
+  if (tags.length === 0) return { ...base, reason: 'no-tags' };
+
+  const token = await credentials.resolveConfigSecret(cfg.tokenConfigKey);
+  if (!token) return { ...base, reason: 'slack-no-credentials' };
+
+  const applied: string[] = [];
+  for (const tag of tags) {
+    const emoji = slackEmojiForTag(tag);
+    const response = await fetchImpl('https://slack.com/api/reactions.add', {
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json; charset=utf-8',
+      },
+      body: JSON.stringify({ channel, timestamp: ts, name: emoji }),
+    });
+    const payload = (await response.json().catch(() => ({}))) as {
+      ok?: boolean;
+      error?: string;
+    };
+    if (!response.ok) {
+      throw new HandlerError(
+        `Slack reactions.add HTTP ${response.status}`,
+        'TRIAGE_SLACK_TAG_FAILED',
+        502,
+      );
+    }
+    // 'already_reacted' is an idempotent success for our purposes.
+    if (payload.ok !== true && payload.error !== 'already_reacted') {
+      ctx.logger.warn('triage: slack reaction rejected', { error: payload.error });
+      throw new HandlerError(
+        `Slack reactions.add rejected: ${payload.error ?? 'unknown'}`,
+        'TRIAGE_SLACK_TAG_FAILED',
+        502,
+      );
+    }
+    applied.push(tag);
+  }
+  return { surface: item.surface, itemId: item.id, appliedTags: applied, skipped: false };
+}

package/src/daemon/handlers/triage/types.ts

@@ -0,0 +1,50 @@
+// ---------------------------------------------------------------------------
+// Daemon-internal triage domain types.
+//
+// `InboundChannelItem` is the daemon-internal shape the inbox poller produces
+// and the triage pipeline scores. It is NOT an SDK catalog contract: the
+// published `channels.inbox.list` output schema (CHANNEL_INBOX_ITEM_SCHEMA) is
+// owned by the SDK and never re-declared here. This is the internal poller
+// item per the handoff doc — it carries `fromDigest` (never a raw sender id),
+// `subjectPreview`/`bodyPreview` (PII-stripped, length-bounded) and an opaque
+// `metadata` bag the tagger reads provider targeting from (imapUid, channelId,
+// Slack ts, Discord messageId/threadId).
+// ---------------------------------------------------------------------------
+
+/** Triage label assigned by the scorer. */
+export type TriageLabel = 'spam' | 'priority' | 'normal';
+
+/** 1:1 vs group/channel/thread conversation hint (priority signal). */
+export type ConversationKind = 'direct' | 'group' | 'channel' | 'thread' | 'service';
+
+/**
+ * Internal inbound feed item. Mirrors the handoff `InboundChannelItem` shape
+ * plus the optional fields the scorer/tagger consult. `surface` is the provider
+ * family ('email' | 'imap' | 'slack' | 'discord' | ...) the tagger dispatches
+ * on; `provider` is the handoff-facing provider id. They are usually equal.
+ */
+export interface InboundChannelItem {
+  /** Stable, provider-scoped dedup key. */
+  readonly id: string;
+  /** Provider family the tagger dispatches on (email/imap/slack/discord/...). */
+  readonly surface: string;
+  /** Handoff-facing provider id ("slack" | "discord" | "email" | ...). */
+  readonly provider?: string;
+  readonly kind?: 'dm' | 'thread' | 'mention' | 'reaction';
+  /** SHA-256 first-N of sender external id — NEVER a raw identifier. */
+  readonly fromDigest?: string;
+  /** Conversation id (Slack/Discord channel, IMAP mailbox-scoped). */
+  readonly conversationId?: string;
+  readonly conversationKind?: ConversationKind;
+  /** Display subject (<= 200 chars). */
+  readonly subject?: string;
+  /** Display body preview (<= 500 chars, PII-stripped). Alias: bodyPreview. */
+  readonly snippet?: string;
+  /** Optional daemon route binding id. */
+  readonly routeId?: string;
+  /** Unix ms. */
+  readonly receivedAt?: number;
+  readonly unread?: boolean;
+  /** Opaque provider targeting bag (imapUid/uid, channelId, ts, messageId, threadId). */
+  readonly metadata?: Record<string, unknown>;
+}

package/src/export/gist-uploader.ts

@@ -16,6 +16,8 @@
 // the URL can view it).
 // ---------------------------------------------------------------------------
 
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
 export type UploadResult =
   | { ok: true; url: string }
   | { ok: false; error: string };
@@ -96,7 +98,7 @@ export class GistUploadTarget implements UploadTarget {
         body,
       });
     } catch (fetchErr: unknown) {
-      const msg = fetchErr instanceof Error ? fetchErr.message : String(fetchErr);
+      const msg = summarizeError(fetchErr);
       return { ok: false, error: `Network error: ${msg}` };
     }
 

package/src/input/command-registry.ts

@@ -139,6 +139,7 @@ export interface CommandSessionServices {
   readonly sessionManager?: import('@pellux/goodvibes-sdk/platform/sessions').SessionManager;
   readonly sessionMemoryStore?: import('@pellux/goodvibes-sdk/platform/core').SessionMemoryStore;
   readonly sessionLineageTracker?: import('@pellux/goodvibes-sdk/platform/core').SessionLineageTracker;
+  readonly wrfcController?: import('@pellux/goodvibes-sdk/platform/agents').WrfcController;
   readonly changeTracker?: import('@pellux/goodvibes-sdk/platform/sessions').SessionChangeTracker;
 }
 

package/src/input/commands/cloudflare-runtime.ts

@@ -11,6 +11,7 @@ import {
 } from '../../runtime/cloudflare-control-plane.ts';
 import type { CommandContext, CommandRegistry } from '../command-registry.ts';
 import { requireShellPaths } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 interface ParsedCloudflareArgs {
   readonly positional: readonly string[];
@@ -366,5 +367,5 @@ function formatCloudflareError(error: unknown): string {
   if (error instanceof CloudflareDaemonRouteError) {
     return `${error.message} (HTTP ${error.status}, ${error.code})`;
   }
-  return error instanceof Error ? error.message : String(error);
+  return summarizeError(error);
 }

package/src/input/commands/guidance-runtime.ts

@@ -2,7 +2,7 @@ import { estimateConversationTokens } from '@pellux/goodvibes-sdk/platform/core'
 import { evaluateSessionMaintenance, formatSessionMaintenanceLines, getGuidanceMode } from '@/runtime/index.ts';
 import { dismissGuidance, evaluateContextualGuidance, formatGuidanceItems, resetGuidance } from '@/runtime/index.ts';
 import type { CommandRegistry } from '../command-registry.ts';
-import { requireProviderApi, requireReadModels, requireSessionMemoryStore, requireShellPaths } from './runtime-services.ts';
+import { requireReadModels, requireSessionMemoryStore, requireShellPaths } from './runtime-services.ts';
 
 export function registerGuidanceRuntimeCommands(registry: CommandRegistry): void {
   registry.register({
@@ -68,8 +68,6 @@ export function registerGuidanceRuntimeCommands(registry: CommandRegistry): void
         return;
       }
 
-      const providerApi = requireProviderApi(ctx);
-      const currentModel = await providerApi.getCurrentModel().catch(() => null); // best-effort: null handled as unknown context window
       const llmMessages = ctx.session.conversationManager.getMessagesForLLM();
       const readModels = requireReadModels(ctx);
       const session = readModels.session.getSnapshot();
@@ -80,7 +78,7 @@ export function registerGuidanceRuntimeCommands(registry: CommandRegistry): void
       const maintenance = evaluateSessionMaintenance({
         configManager: ctx.platform.configManager,
         currentTokens: estimateConversationTokens(llmMessages),
-        contextWindow: currentModel?.contextWindow ?? 0,
+        contextWindow: ctx.provider.providerRegistry.getContextWindowForModel(ctx.provider.providerRegistry.getCurrentModel()),
         messageCount: llmMessages.length,
         sessionMemoryCount: requireSessionMemoryStore(ctx).list().length,
         session: session.session,

package/src/input/commands/health-runtime.ts

@@ -13,7 +13,6 @@ import {
   openCommandPanel,
   requireLocalUserAuthManager,
   requireOperatorClient,
-  requireProviderApi,
   requireReadModels,
   requireSecretsManager,
   requireServiceRegistry,
@@ -240,15 +239,19 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
 
       if (sub === 'maintenance') {
         const session = readModels.session.getSnapshot();
-        const providerApi = requireProviderApi(ctx);
-        const currentModel = await providerApi.getCurrentModel().catch(() => null); // best-effort: null handled as unknown context window
+        const providerRegistry = ctx.provider.providerRegistry;
+        // Resolve the context window the same way the Tokens panel does so the
+        // maintenance usage %/remaining agree across every diagnostics surface.
+        const contextWindow = providerRegistry.getContextWindowForModel(
+          providerRegistry.getCurrentModel(),
+        );
         const llmMessages = typeof ctx.session.conversationManager.getMessagesForLLM === 'function'
           ? ctx.session.conversationManager.getMessagesForLLM()
           : [];
         const maintenance = evaluateSessionMaintenance({
           configManager: ctx.platform.configManager,
           currentTokens: estimateConversationTokens(llmMessages),
-          contextWindow: currentModel?.contextWindow ?? 0,
+          contextWindow,
           messageCount: llmMessages.length,
           sessionMemoryCount: requireSessionMemoryStore(ctx).list().length,
           session: session.session,
@@ -386,12 +389,15 @@ export function registerHealthRuntimeCommands(registry: CommandRegistry): void {
       }
 
       const session = readModels.session.getSnapshot();
-      const providerApi = requireProviderApi(ctx);
-      const currentModel = await providerApi.getCurrentModel().catch(() => null); // best-effort: null handled as unknown context window
+      const providerRegistry = ctx.provider.providerRegistry;
       const llmMessages = typeof ctx.session.conversationManager.getMessagesForLLM === 'function'
         ? ctx.session.conversationManager.getMessagesForLLM()
         : [];
-      const contextWindow = currentModel?.contextWindow ?? 0;
+      // Resolve the context window the same way the Tokens panel does so the
+      // maintenance usage %/remaining agree across every diagnostics surface.
+      const contextWindow = providerRegistry.getContextWindowForModel(
+        providerRegistry.getCurrentModel(),
+      );
       const maintenance = evaluateSessionMaintenance({
         configManager: ctx.platform.configManager,
         currentTokens: estimateConversationTokens(llmMessages),

package/src/input/commands/knowledge.ts

@@ -1,5 +1,6 @@
 import type { KnowledgeService } from '@pellux/goodvibes-sdk/platform/knowledge';
 import type { CommandContext, SlashCommand } from '../command-registry.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 const KNOWLEDGE_REVIEW_ACTIONS = ['accept', 'reject', 'resolve', 'reopen', 'edit', 'forget'] as const;
 
@@ -397,7 +398,7 @@ export const knowledgeCommand: SlashCommand = {
             ...(result.appliedFacts ? [`  applied facts: ${Object.keys(result.appliedFacts).join(', ') || 'none'}`] : []),
           ].join('\n'));
         } catch (error) {
-          context.print(`[knowledge] ${error instanceof Error ? error.message : String(error)}`);
+          context.print(`[knowledge] ${summarizeError(error)}`);
         }
         break;
       }

package/src/input/commands/runtime-services.ts

@@ -7,7 +7,7 @@ import type {
   CommandSessionServices,
   CommandWorkspaceServices,
 } from '../command-registry.ts';
-import { getLastCompactionEvent } from '@pellux/goodvibes-sdk/platform/core';
+import { compactSmallWindow, getLastCompactionEvent, SMALL_WINDOW_THRESHOLD } from '@pellux/goodvibes-sdk/platform/core';
 import type { CompactionContext, CompactionEvent } from '@pellux/goodvibes-sdk/platform/core';
 import type { UiReadModels } from '../../runtime/ui-read-models.ts';
 import type { ShellPathService } from '@/runtime/index.ts';
@@ -244,23 +244,53 @@ export function requireProviderApi(context: CommandContext): ProviderApi {
  * change).
  */
 export async function compactConversation(context: CommandContext): Promise<CompactionEvent | null> {
+  const conversationManager = context.session.conversationManager;
+  const providerRegistry = context.provider.providerRegistry;
+  // Resolve the live context window for the current model so manual /compact
+  // matches the auto-compaction path (which scales behaviour by window size)
+  // instead of passing a meaningless 0.
+  const contextWindow = providerRegistry.getContextWindowForModel(
+    providerRegistry.getCurrentModel(),
+  );
+
+  // Small-window models lack room for the structured (multi-LLM) extraction
+  // pipeline, so mirror the SDK auto-compaction path and degrade to the
+  // simplified "keep the most recent messages" compaction.
+  if (contextWindow > 0 && contextWindow < SMALL_WINDOW_THRESHOLD) {
+    const compacted = compactSmallWindow(conversationManager.getMessagesForLLM(), 10);
+    conversationManager.replaceMessagesForLLM(compacted);
+    return null;
+  }
+
   const eventBefore = getLastCompactionEvent();
   const sessionMemories = context.session.sessionMemoryStore?.list() ?? [];
+  const lineageTracker = context.session.sessionLineageTracker;
+  const agentManager = context.ops.agentManager;
+  const planManager = context.ops.planManager;
   const compactionCtx: CompactionContext = {
-    messages: context.session.conversationManager.getMessagesForLLM(),
+    messages: conversationManager.getMessagesForLLM(),
     sessionMemories,
-    agents: [],
-    wrfcChains: [],
-    activePlan: null,
-    lineageEntries: [],
-    compactionCount: 0,
-    contextWindow: 0,
+    // Mirror buildAutoCompactionContext: pass the running/pending agents, the
+    // active execution plan, and the session-lineage log so the handoff summary
+    // and lineage section are populated correctly (not "compaction #0").
+    agents:
+      agentManager
+        ?.exportState()
+        .filter((agent) => agent.status === 'running' || agent.status === 'pending') ?? [],
+    // Mirror buildAutoCompactionContext: include the live WRFC chains (wired
+    // through context.session.wrfcController) so the handoff summary's
+    // orchestration section matches the SDK auto-compaction path.
+    wrfcChains: context.session.wrfcController?.listChains() ?? [],
+    activePlan: planManager?.getActive(context.session.runtime.sessionId) ?? null,
+    lineageEntries: lineageTracker?.getEntries() ?? [],
+    compactionCount: lineageTracker?.getCompactionCount() ?? 0,
+    contextWindow,
     trigger: 'manual',
     extractionModelId: context.session.runtime.model,
     extractionProvider: context.session.runtime.provider,
   };
-  await context.session.conversationManager.compact(
-    context.provider.providerRegistry,
+  await conversationManager.compact(
+    providerRegistry,
     context.session.runtime.model,
     'manual',
     context.session.runtime.provider,

package/src/input/handler-command-route.ts

@@ -117,7 +117,7 @@ export function handleCommandModeToken(state: CommandModeRouteState, token: Inpu
     return true;
   }
 
-  return token.logicalName !== 'left' && token.logicalName !== 'right';
+  return token.logicalName !== 'left' && token.logicalName !== 'right' && token.logicalName !== 'home' && token.logicalName !== 'end';
 }
 
 function withPanelFocusSync(context: CommandContext, state: CommandModeRouteState): CommandContext {

package/src/input/handler-interactions.ts

@@ -5,6 +5,7 @@ import { cleanupMarkerRegistry, expandPrompt, findMarkerAtPos, handleBlockCopy,
 import { clearModalStack, handleEscape, modalOpened } from './handler-modal-stack.ts';
 import { openOnboardingWizardState, type OpenOnboardingWizardOptions } from './handler-ui-state.ts';
 import type { InputHandlerLike as InputHandler } from './handler-types.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 export function openOnboardingWizardForHandler(
   handler: InputHandler,
@@ -49,7 +50,7 @@ export async function hydrateOnboardingWizardFromRuntimeForHandler(handler: Inpu
       handler.requestRender();
     } catch (error) {
       if (!handler.onboardingWizard.active || hydrationSerial !== handler.onboardingHydrationSerial) return;
-      const message = error instanceof Error ? error.message : String(error);
+      const message = summarizeError(error);
       handler.onboardingWizard.failRuntimeHydration(message);
       handler.commandContext?.print?.(`Onboarding runtime snapshot failed: ${message}`);
       handler.requestRender();

package/src/input/handler-modal-routes.ts

@@ -3,6 +3,7 @@ import type { SelectionResult, SelectionAction } from './selection-modal.ts';
 import type { CommandContext } from './command-registry.ts';
 import { openTtsProviderPicker, openTtsVoicePicker } from './tts-settings-actions.ts';
 import { isTextBackspace } from './delete-key-policy.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 type SelectionRouteState = {
   selectionModal: {
@@ -285,7 +286,7 @@ function consumeSettingsPickerRequest(state: SettingsRouteState): void {
       return;
     }
     void openTtsVoicePicker(state.commandContext).catch((error: unknown) => {
-      state.commandContext?.print(`Unable to list TTS voices: ${error instanceof Error ? error.message : String(error)}`);
+      state.commandContext?.print(`Unable to list TTS voices: ${summarizeError(error)}`);
       state.requestRender();
     });
     return;

package/src/input/handler-onboarding-cloudflare.ts

@@ -22,6 +22,7 @@ import {
   getCloudflareSetupSource,
   shouldShowCloudflareStep,
 } from './onboarding/onboarding-wizard-cloudflare.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 type CloudflareOnboardingAction = Extract<OnboardingWizardAction,
   | 'cloudflare-token-requirements'
@@ -44,7 +45,7 @@ function normalizeCloudflareActionError(error: unknown): string {
   if (error instanceof CloudflareDaemonRouteError) {
     return `${error.message} (HTTP ${error.status}, ${error.code})`;
   }
-  return error instanceof Error ? error.message : String(error);
+  return summarizeError(error);
 }
 
 function setCloudflareWizardStatusForHandler(