@groeponline/pi-wishcraft 1.1.0 → 1.3.0

package/src/extension/session/session-lifecycle.ts

@@ -3,6 +3,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { BashTranscriptStore } from "../../../bash-mode/transcript.ts";
 import { BashCompletionEngine } from "../../../bash-mode/completion.ts";
 import { parsePowerlineConfig } from "../../config/powerline-config.ts";
+import { policyFromEnvironment } from "../../motion/accessibility.ts";
 import { registerCustomSegments } from "../../segments/index.ts";
 import { registerCustomPresets } from "../../config/presets.ts";
 import { invalidateGitStatus } from "../../git/status.ts";
@@ -15,26 +16,10 @@ import {
   onVibeToolCall,
 } from "../../working-vibes/index.ts";
 import {
-  getSessionTotalCost,
   getUsageTokenTotal,
   isSessionAssistantMessage,
 } from "../../usage/ledger.ts";
-import {
-  formatCostAlertMessage,
-  shouldTriggerCostAlert,
-} from "./cost-alert.ts";
-import {
-  formatTokenBudgetWarning,
-  parseTokenBudget,
-  tokenBudgetLevel,
-} from "../../usage/token-budget.ts";
-import {
-  recordUsageEvent,
-  loadUsageFileFromDisk,
-  tokenTotal,
-  totalsForRange,
-  dayKey,
-} from "../../usage/usage-store.ts";
+import { recordUsageEvent } from "../../usage/usage-store.ts";
 import {
   detectCustomCompactionEnabled,
   readSettings,
@@ -76,52 +61,14 @@ import {
   clearSkillsCountPublisher,
 } from "../skills/skill-status.ts";
 import { maybeAppendReadHint } from "./read-hints.ts";
-
-/**
- * Fire the configured `powerline.costAlert` warning at most once per session.
- * Reads the running cost from the (cached) token ledger so repeated calls are
- * cheap; a UI-less or already-notified session short-circuits immediately.
- */
-function maybeNotifyCostAlert(rt: RuntimeState, ctx: any): void {
-  if (!ctx?.hasUI || rt.costAlertNotified) return;
-  const threshold = config.costAlert;
-  const sessionEvents = rt.sessionBranchCache.get(ctx.sessionManager);
-  const totalCost = getSessionTotalCost(rt.tokenStatsCache.get(sessionEvents));
-  if (
-    !shouldTriggerCostAlert({
-      totalCost,
-      threshold,
-      alreadyNotified: rt.costAlertNotified,
-    })
-  ) {
-    return;
-  }
-  rt.costAlertNotified = true;
-  ctx.ui.notify(
-    formatCostAlertMessage(
-      totalCost,
-      threshold as number,
-      config.segmentOptions?.cost?.currency ?? "USD",
-    ),
-    "warning",
-  );
-}
-
-function maybeNotifyTokenBudget(rt: RuntimeState, ctx: any): void {
-  if (!ctx?.hasUI) return;
-  const daily = parseTokenBudget(readSettings(ctx.cwd ?? process.cwd()).wishcraft)
-    .daily;
-  if (!daily) return;
-  const now = Date.now();
-  const todayStart = Date.parse(`${dayKey(now)}T00:00:00`);
-  const used = tokenTotal(
-    totalsForRange(loadUsageFileFromDisk(), todayStart, now + 1),
-  );
-  const { level } = tokenBudgetLevel(used, daily);
-  if (level === 0 || level <= rt.tokenBudgetNotifiedLevel) return;
-  rt.tokenBudgetNotifiedLevel = level;
-  ctx.ui.notify(formatTokenBudgetWarning(used, daily, level), "warning");
-}
+import {
+  dispatchSignalEvent,
+  settleSignal,
+} from "../../signal/integration.ts";
+import {
+  maybeNotifyCostAlert,
+  maybeNotifyTokenBudget,
+} from "./session-notifications.ts";
 
 // Helper to extract recent agent response text (skipping thinking blocks)
 function getRecentAgentContext(ctx: any): string | undefined {
@@ -162,6 +109,7 @@ export function registerSessionLifecycle(
 ): void {
   // Track session start
   pi.on("session_start", async (event, ctx) => {
+    settleSignal(rt);
     clearSkillsCountPublisher();
     rt.shellSession?.dispose();
     rt.shellSession = null;
@@ -174,6 +122,7 @@ export function registerSessionLifecycle(
     rt.liveAssistantUsage = null;
     rt.costAlertNotified = false;
     rt.tokenBudgetNotifiedLevel = 0;
+    rt.tokenBudgetSnapshot = { day: "", dailyLimit: null, dailyUsed: 0 };
     rt.powerlineCompacting = false;
     rt.deliverAfterRetrySettles = false;
     rt.stashedEditorText = null;
@@ -183,6 +132,7 @@ export function registerSessionLifecycle(
     rt.bashModeSettings = parseBashModeSettings(settings, rt.resolvedShortcuts);
     rt.showLastPrompt = settings.showLastPrompt !== false;
     setConfig(parsePowerlineConfig(settings.powerline, PRESET_NAMES));
+    rt.motionPolicy = policyFromEnvironment(process.env, config.motionLevel);
     rt.queueStore.setSentRetentionMs(
       config.queue.retentionHours * 60 * 60 * 1000,
     );
@@ -225,7 +175,7 @@ export function registerSessionLifecycle(
       } else {
         dismissWelcome(rt, ctx);
       }
-      maybeNotifyTokenBudget(rt, ctx);
+      maybeNotifyTokenBudget(rt, ctx, settings);
     }
   });
 
@@ -238,6 +188,7 @@ export function registerSessionLifecycle(
     rt.welcomeOverlayShouldDismiss = false;
     rt.welcomeDismissScheduler.cancel();
     rt.statusRenderScheduler.cancel();
+    rt.motionScheduler.dispose();
     rt.restoreFooterStatusRepaintHook?.();
     rt.restoreFooterStatusRepaintHook = null;
     rt.stashShortcutInputUnsubscribe?.();
@@ -256,6 +207,7 @@ export function registerSessionLifecycle(
     rt.getThinkingLevelFn = null;
     rt.currentThinkingLevel = null;
     rt.liveAssistantUsage = null;
+    rt.tokenBudgetSnapshot = { day: "", dailyLimit: null, dailyUsed: 0 };
     rt.tuiRef = null;
     rt.currentEditor = null;
     resetLayoutCache(rt);
@@ -320,6 +272,7 @@ export function registerSessionLifecycle(
     onVibeAgentStart();
     dismissWelcome(rt, ctx);
     rt.currentCtx = ctx;
+    dispatchSignalEvent(rt, config.appearance, "thinking");
   });
 
   pi.on("message_update", async (event, ctx) => {
@@ -333,6 +286,9 @@ export function registerSessionLifecycle(
       rt.currentCtx = ctx;
       rt.layoutDirty = true;
       rt.statusRenderScheduler.schedule(CONTEXT_STATUS_RENDER_MS);
+      if (rt.signal.event !== "streaming") {
+        dispatchSignalEvent(rt, config.appearance, "streaming");
+      }
     }
   });
 
@@ -374,6 +330,7 @@ export function registerSessionLifecycle(
     rt.powerlineCompacting = true;
     rt.currentCtx = ctx;
     requestQueueRender(rt);
+    dispatchSignalEvent(rt, config.appearance, "compact");
   });
 
   pi.on("session_compact", async (event, ctx) => {
@@ -406,6 +363,12 @@ export function registerSessionLifecycle(
   // Also dismiss on tool calls (agent is working) + refresh vibe if rate limit allows
   pi.on("tool_call", async (event, ctx) => {
     dismissWelcome(rt, ctx);
+    dispatchSignalEvent(
+      rt,
+      config.appearance,
+      "tool.start",
+      `tool ${event.toolName}`,
+    );
     if (ctx.hasUI) {
       // Extract recent agent context from session for richer vibe generation
       const agentContext = getRecentAgentContext(ctx);
@@ -422,6 +385,7 @@ export function registerSessionLifecycle(
     rt.isStreaming = false;
     rt.liveAssistantUsage = null;
     rt.coreContextUsageCache.reset();
+    dispatchSignalEvent(rt, config.appearance, "success");
 
     let hasUI = false;
     try {
@@ -462,4 +426,4 @@ export function registerSessionLifecycle(
       schedulePostCompactionDelivery(pi, rt, ctx);
     }
   });
-}
+}

package/src/extension/session/session-notifications.ts

@@ -0,0 +1,91 @@
+import { getSessionTotalCost } from "../../usage/ledger.ts";
+import {
+  formatTokenBudgetWarning,
+  parseTokenBudget,
+  tokenBudgetLevel,
+} from "../../usage/token-budget.ts";
+import {
+  dayKey,
+  loadUsageFileFromDisk,
+  tokenTotal,
+  totalsForRange,
+} from "../../usage/usage-store.ts";
+import { config } from "../core/state.ts";
+import type { RuntimeState } from "../core/types.ts";
+import { readSettings } from "../settings/settings-io.ts";
+import {
+  formatCostAlertMessage,
+  shouldTriggerCostAlert,
+} from "./cost-alert.ts";
+
+/** Notify once when the configured per-session cost threshold is crossed. */
+export function maybeNotifyCostAlert(rt: RuntimeState, ctx: any): void {
+  if (!ctx?.hasUI || rt.costAlertNotified) return;
+  const threshold = config.costAlert;
+  const sessionEvents = rt.sessionBranchCache.get(ctx.sessionManager);
+  const totalCost = getSessionTotalCost(rt.tokenStatsCache.get(sessionEvents));
+  if (
+    !shouldTriggerCostAlert({
+      totalCost,
+      threshold,
+      alreadyNotified: rt.costAlertNotified,
+    })
+  ) {
+    return;
+  }
+
+  rt.costAlertNotified = true;
+  ctx.ui.notify(
+    formatCostAlertMessage(
+      totalCost,
+      threshold as number,
+      config.segmentOptions?.cost?.currency ?? "USD",
+    ),
+    "warning",
+  );
+}
+
+/**
+ * Refresh disk-backed budget data at lifecycle boundaries, never during paint.
+ * A local-day rollover also resets the per-day warning latch.
+ */
+export function refreshTokenBudgetSnapshot(
+  rt: RuntimeState,
+  ctx: any,
+  settings?: ReturnType<typeof readSettings>,
+): { daily: number | null; used: number; level: 0 | 80 | 100 } {
+  const now = Date.now();
+  const day = dayKey(now);
+  if (rt.tokenBudgetSnapshot.day !== day) {
+    rt.tokenBudgetNotifiedLevel = 0;
+  }
+
+  const resolvedSettings = settings ?? readSettings(ctx.cwd ?? process.cwd());
+  const daily = parseTokenBudget(resolvedSettings.wishcraft).daily;
+  if (!daily) {
+    rt.tokenBudgetSnapshot = { day, dailyLimit: null, dailyUsed: 0 };
+    return { daily: null, used: 0, level: 0 };
+  }
+
+  const todayStart = Date.parse(`${day}T00:00:00`);
+  const used = tokenTotal(
+    totalsForRange(loadUsageFileFromDisk(), todayStart, now + 1),
+  );
+  rt.tokenBudgetSnapshot = { day, dailyLimit: daily, dailyUsed: used };
+  const { level } = tokenBudgetLevel(used, daily);
+  return { daily, used, level };
+}
+
+/** Refresh the daily budget and emit its 80%/100% warning at most once per day. */
+export function maybeNotifyTokenBudget(
+  rt: RuntimeState,
+  ctx: any,
+  settings?: ReturnType<typeof readSettings>,
+): void {
+  if (!ctx?.hasUI) return;
+  const { daily, used, level } = refreshTokenBudgetSnapshot(rt, ctx, settings);
+  if (!daily || level === 0 || level <= rt.tokenBudgetNotifiedLevel) return;
+
+  rt.tokenBudgetNotifiedLevel = level;
+  ctx.ui.notify(formatTokenBudgetWarning(used, daily, level), "warning");
+}

package/src/extension/settings/appearance-write.ts

@@ -0,0 +1,135 @@
+/**
+ * appearance-write.ts
+ * ---------------------------------------------------------------------------
+ * Persist `powerline.appearance.base` and refresh the live Signal.
+ * ---------------------------------------------------------------------------
+ */
+
+import type { StructuralPresetName } from "../../config/types.ts";
+import type { MotionEvent } from "../../motion/types.ts";
+import { isStructuralPresetName } from "../../config/structural-presets.ts";
+import {
+  effectiveAppearanceMix,
+  resolveAppearanceMix,
+} from "../../config/appearance.ts";
+import {
+  isMotionLevel,
+  policyFromEnvironment,
+  type MotionLevel,
+} from "../../motion/accessibility.ts";
+import { parsePowerlineConfig } from "../../config/powerline-config.ts";
+import { isRecord, writePowerlineSetting } from "./settings-io.ts";
+import { config, PRESET_NAMES, setConfig } from "../core/state.ts";
+import {
+  requestImmediateStatusRender,
+  resetLayoutCache,
+} from "../core/segment-context.ts";
+import type { RuntimeState } from "../core/types.ts";
+
+export function writeAppearanceBase(
+  cwd: string,
+  name: StructuralPresetName,
+): boolean {
+  return writePowerlineSetting(cwd, (existing) => {
+    const node: Record<string, unknown> = isRecord(existing)
+      ? { ...existing }
+      : typeof existing === "string"
+        ? { preset: existing }
+        : {};
+    const appearance = isRecord(node.appearance) ? { ...node.appearance } : {};
+    appearance.base = name;
+    node.appearance = appearance;
+    return node;
+  });
+}
+
+/** Write the structural base, keep session config in sync, and repaint Signal. */
+export function applyAppearanceBase(
+  rt: RuntimeState,
+  cwd: string,
+  name: StructuralPresetName,
+): boolean {
+  config.appearance = { ...config.appearance, base: name };
+  const ok = writeAppearanceBase(cwd, name);
+  resetLayoutCache(rt);
+  requestImmediateStatusRender(rt);
+  return ok;
+}
+
+/** `/signal hexforge` also sets appearance.base so colors match the layout name. */
+export function syncAppearanceForLayoutPreset(
+  rt: RuntimeState,
+  cwd: string,
+  preset: string,
+): void {
+  if (!isStructuralPresetName(preset)) return;
+  applyAppearanceBase(rt, cwd, preset);
+}
+
+export function applyPersistedMotionPolicy(rt: RuntimeState): void {
+  rt.motionPolicy = policyFromEnvironment(process.env, config.motionLevel);
+}
+
+/** Re-parse `settings.powerline` into session config and repaint Signal. */
+export function reloadPowerlineFromSettings(
+  rt: RuntimeState,
+  settings: Record<string, unknown>,
+): void {
+  setConfig({
+    ...config,
+    ...parsePowerlineConfig(settings.powerline, PRESET_NAMES),
+  });
+  applyPersistedMotionPolicy(rt);
+  resetLayoutCache(rt);
+  requestImmediateStatusRender(rt);
+}
+
+export function applyMotionLevel(
+  rt: RuntimeState,
+  cwd: string,
+  level: MotionLevel,
+): boolean {
+  if (!isMotionLevel(level)) return false;
+  config.motionLevel = level;
+  applyPersistedMotionPolicy(rt);
+  const ok = writePowerlineSetting(cwd, (existing) => {
+    const node: Record<string, unknown> = isRecord(existing)
+      ? { ...existing }
+      : typeof existing === "string"
+        ? { preset: existing }
+        : {};
+    node.motionLevel = level;
+    return node;
+  });
+  resetLayoutCache(rt);
+  requestImmediateStatusRender(rt);
+  return ok;
+}
+
+export function applyMotionAssignment(
+  rt: RuntimeState,
+  cwd: string,
+  event: MotionEvent,
+  motionId: string,
+): boolean {
+  const current = {
+    ...resolveAppearanceMix(effectiveAppearanceMix(config.appearance, config.preset))
+      .motion,
+    [event]: motionId,
+  };
+  config.appearance = { ...config.appearance, motion: current };
+  const ok = writePowerlineSetting(cwd, (existing) => {
+    const node: Record<string, unknown> = isRecord(existing)
+      ? { ...existing }
+      : typeof existing === "string"
+        ? { preset: existing }
+        : {};
+    const appearance = isRecord(node.appearance) ? { ...node.appearance } : {};
+    appearance.motion = current;
+    node.appearance = appearance;
+    return node;
+  });
+  resetLayoutCache(rt);
+  requestImmediateStatusRender(rt);
+  return ok;
+}

package/src/extension/settings/wishcraft-config-items.ts

@@ -0,0 +1,119 @@
+/**
+ * Declarative groups for `/wishcraft settings`.
+ * Kept beside the overlay so the TUI file stays under the size budget.
+ */
+
+import { STRUCTURAL_PRESET_NAMES } from "../../config/types.ts";
+import { MOTION_LEVELS } from "../../motion/accessibility.ts";
+
+export type ConfigValue = boolean | string | number | null;
+
+export interface ConfigItem {
+  /** Label in the list. */
+  label: string;
+  /** Path inside settings ("powerline.placement", "wishcraft.hooksEnabled", ...). */
+  path: string;
+  /** Edit kind. */
+  kind: "toggle" | "select" | "text" | "number";
+  /** For select: the choices. */
+  choices?: string[];
+  /** Hint under the group. */
+  hint?: string;
+  /** Detail explanation (optional). */
+  description?: string;
+  /** Effective value when the setting is absent (toggles only; defaults to false). */
+  default?: boolean;
+}
+
+export interface ConfigGroup {
+  title: string;
+  items: ConfigItem[];
+}
+
+const SEPARATORS = [
+  "powerline",
+  "powerline-thin",
+  "slash",
+  "pipe",
+  "block",
+  "none",
+  "ascii",
+  "dot",
+  "chevron",
+  "star",
+];
+
+/** Build groups from current settings (values shown live). */
+export function buildConfigGroups(_settings: Record<string, unknown>): ConfigGroup[] {
+  return [
+    {
+      title: "Status bar",
+      items: [
+        { label: "Preset", path: "powerline.preset", kind: "select", choices: ["default", "minimal", "compact", "full", "nerd", "ascii", "chef"] },
+        {
+          label: "Structural base",
+          path: "powerline.appearance.base",
+          kind: "select",
+          choices: [...STRUCTURAL_PRESET_NAMES],
+          hint: "colors and motion for Signal; layout preset stays separate",
+        },
+        {
+          label: "Motion level",
+          path: "powerline.motionLevel",
+          kind: "select",
+          choices: [...MOTION_LEVELS],
+          hint: "full · reduced · functional · off",
+        },
+        { label: "Separator", path: "powerline.separator", kind: "select", choices: SEPARATORS },
+        { label: "Placement", path: "powerline.placement", kind: "select", choices: ["above", "below"] },
+        { label: "Path mode", path: "powerline.segmentOptions.path.mode", kind: "select", choices: ["basename", "abbreviated", "full"] },
+        { label: "Path max length", path: "powerline.segmentOptions.path.maxLength", kind: "number", hint: "0 = unlimited" },
+        { label: "Time format", path: "powerline.segmentOptions.time.format", kind: "select", choices: ["12h", "24h"] },
+        { label: "Time seconds", path: "powerline.segmentOptions.time.showSeconds", kind: "toggle" },
+        { label: "Git host icons", path: "powerline.segmentOptions.git.hostIcon", kind: "toggle" },
+        { label: "Git ahead/behind", path: "powerline.segmentOptions.git.showAheadBehind", kind: "toggle" },
+        { label: "Git latest commit", path: "powerline.segmentOptions.git.showCommit", kind: "toggle" },
+        { label: "Context format", path: "powerline.segmentOptions.context.format", kind: "select", choices: ["full", "percent"] },
+        { label: "Cache-read format", path: "powerline.segmentOptions.cache_read.format", kind: "select", choices: ["tokens", "percent", "both"] },
+        { label: "Cost display", path: "powerline.segmentOptions.cost.subscriptionDisplay", kind: "select", choices: ["subscription", "reported-cost", "both"] },
+        { label: "Currency", path: "powerline.segmentOptions.cost.currency", kind: "text" },
+        { label: "Ports include UDP", path: "powerline.segmentOptions.openPorts.includeUdp", kind: "toggle" },
+        { label: "TPS window (ms)", path: "powerline.segmentOptions.tps.windowMs", kind: "number", hint: "default 1000" },
+        { label: "TPS mode", path: "powerline.segmentOptions.tps.mode", kind: "select", choices: ["both", "out", "in"] },
+        { label: "TPS label", path: "powerline.segmentLabels.tps", kind: "text", hint: "empty = no label" },
+      ],
+    },
+    {
+      title: "Welcome & vibes",
+      items: [
+        { label: "Welcome overlay", path: "powerline.welcome", kind: "toggle", hint: "on = overlay at startup, off = no welcome" },
+        { label: "Animate wishcraft lantern", path: "wishcraft.welcome.animateLantern", kind: "toggle", hint: "flicker on the lantern" },
+      ],
+    },
+    {
+      title: "Skills",
+      items: [
+        { label: "Inline expand /command and $skill", path: "wishcraft.inlineSkills", kind: "toggle", hint: "needs a restart to take effect" },
+        { label: "Read hints", path: "wishcraft.readHints", kind: "toggle", default: true, hint: "off = no continuation hint after partial reads" },
+      ],
+    },
+    {
+      title: "Hooks & repairs (harness)",
+      items: [
+        { label: "Hooks enabled", path: "wishcraft.hooksEnabled", kind: "toggle", hint: "preToolUse / postToolUse / sessionStart command hooks" },
+        { label: "Tool-input repairs", path: "wishcraft.repairsEnabled", kind: "toggle", hint: "null-for-optional, auto-link, json-array, path aliases" },
+        { label: "Daily token budget", path: "wishcraft.tokenBudget.daily", kind: "number", hint: "colours the cost segment; never blocks. 0 = off" },
+      ],
+    },
+    {
+      title: "Shortcuts",
+      items: [
+        { label: "Menu", path: "powerlineShortcuts.menu", kind: "text", hint: "e.g. alt+p" },
+        { label: "Info", path: "powerlineShortcuts.info", kind: "text" },
+        { label: "Stash", path: "powerlineShortcuts.stashHistory", kind: "text" },
+        { label: "Idea", path: "powerlineShortcuts.ideaCapture", kind: "text" },
+        { label: "Queue", path: "powerlineShortcuts.queueOpen", kind: "text" },
+      ],
+    },
+  ];
+}