killeros 2.0.6 → 2.0.8

package/killeros/variants.ts

@@ -1,9 +1,9 @@
-import { DynamicBorder, keyHint, type ExtensionAPI, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
-import { Container, SelectList, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { DynamicBorder, type ExtensionAPI, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
+import { SelectList, truncateToWidth } from "@earendil-works/pi-tui";
 
-export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+export type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
 
-const ALL_LEVELS: readonly ThinkingLevel[] = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+const ALL_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"] as const satisfies readonly ThinkingLevel[];
 const LEVEL_LABELS: Readonly<Record<ThinkingLevel, string>> = {
   off: "Off",
   minimal: "Minimal",
@@ -42,7 +42,7 @@ const LEVEL_ALIASES: Readonly<Record<string, ThinkingLevel>> = {
 };
 
 function isThinkingLevel(value: string): value is ThinkingLevel {
-  return (ALL_LEVELS as readonly string[]).includes(value);
+  return ALL_LEVELS.some((level) => level === value);
 }
 
 function resolveThinkingLevel(input: string): ThinkingLevel | undefined {
@@ -96,40 +96,82 @@ export function registerVariants(pi: ExtensionAPI): void {
         ctx.ui.notify(`${modelLabel(ctx.model)} does not support extended reasoning`, "info");
         return;
       }
-      const current = pi.getThinkingLevel() as ThinkingLevel;
+      const current = pi.getThinkingLevel();
       const items = supported.map((level) => ({
         value: level,
         label: level === current ? `${LEVEL_LABELS[level]} ← current` : LEVEL_LABELS[level],
         description: LEVEL_DESCRIPTIONS[level],
       }));
-      const selected = await ctx.ui.custom<ThinkingLevel | null>((tui, theme, _keybindings, done) => {
-        const container = new Container();
-        container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
-        container.addChild(new Text(theme.fg("accent", theme.bold("Thinking variants")), 1, 0));
-        container.addChild(new Text(theme.fg("dim", `Model: ${modelLabel(ctx.model)}`), 1, 0));
-        container.addChild(new Text("", 0, 0));
-        const selectList = new SelectList(items, Math.min(items.length, 10), {
-          selectedPrefix: (text) => theme.fg("accent", text),
-          selectedText: (text) => theme.fg("accent", text),
-          description: (text) => theme.fg("muted", text),
-          scrollInfo: (text) => theme.fg("dim", text),
-          noMatch: (text) => theme.fg("warning", text),
-        });
-        selectList.onSelect = (item) => done(isThinkingLevel(item.value) ? item.value : null);
-        selectList.onCancel = () => done(null);
-        container.addChild(selectList);
-        container.addChild(new Text("", 0, 0));
-        container.addChild(new Text(
-          theme.fg("dim", `${keyHint("tui.select.up", "up")} • ${keyHint("tui.select.down", "down")} • ${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", "cancel")}`),
-          1,
-          0,
-        ));
-        container.addChild(new DynamicBorder((text: string) => theme.fg("accent", text)));
+      const selected = await ctx.ui.custom<ThinkingLevel | null>((tui, theme, keybindings, done) => {
+        const listTheme = {
+          selectedPrefix: (text: string) => theme.fg("accent", text),
+          selectedText: (text: string) => theme.fg("accent", text),
+          description: (text: string) => theme.fg("muted", text),
+          scrollInfo: (text: string) => theme.fg("dim", text),
+          noMatch: (text: string) => theme.fg("warning", text),
+        };
+        let selectList: SelectList | undefined;
+        let visibleOptionRows = 0;
+
+        const chromeFor = (rowBudget: number): "full" | "compact" | "none" => (
+          rowBudget >= 8 ? "full" : rowBudget >= 4 ? "compact" : "none"
+        );
+        const visibleRowsFor = (rowBudget: number): number => {
+          const chrome = chromeFor(rowBudget);
+          const chromeRows = chrome === "full" ? 5 : chrome === "compact" ? 2 : 0;
+          const availableListRows = Math.max(1, rowBudget - chromeRows);
+          return availableListRows >= items.length
+            ? items.length
+            : Math.max(1, availableListRows - 1);
+        };
+        const ensureSelectList = (nextVisibleOptionRows: number): SelectList => {
+          if (selectList && visibleOptionRows === nextVisibleOptionRows) return selectList;
+          const selectedValue = selectList?.getSelectedItem()?.value ?? current;
+          const nextSelectList = new SelectList(items, nextVisibleOptionRows, listTheme);
+          const selectedIndex = items.findIndex((item) => item.value === selectedValue);
+          nextSelectList.setSelectedIndex(Math.max(0, selectedIndex));
+          nextSelectList.onSelect = (item) => done(isThinkingLevel(item.value) ? item.value : null);
+          nextSelectList.onCancel = () => done(null);
+          selectList = nextSelectList;
+          visibleOptionRows = nextVisibleOptionRows;
+          return nextSelectList;
+        };
+
+        const border = new DynamicBorder((text: string) => theme.fg("accent", text));
+        const title = ` ${theme.fg("accent", theme.bold("Thinking variants"))}`;
+        const model = ` ${theme.fg("dim", `Model: ${modelLabel(ctx.model)}`)}`;
+        const keyHint = (keybinding: Parameters<typeof keybindings.getKeys>[0], description: string): string => {
+          const keyText = keybindings.getKeys(keybinding)
+            .join("/")
+            .split("/")
+            .map((key) => key.split("+").map((part) => process.platform === "darwin" && part.toLocaleLowerCase() === "alt" ? "option" : part).join("+"))
+            .join("/");
+          return theme.fg("dim", keyText) + theme.fg("muted", ` ${description}`);
+        };
+        const controls = ` ${theme.fg("dim", `${keyHint("tui.select.up", "up")} • ${keyHint("tui.select.down", "down")} • ${keyHint("tui.select.confirm", "select")} • ${keyHint("tui.select.cancel", "cancel")}`)}`;
+
+        const render = (width: number): string[] => {
+          const rowBudget = Math.max(0, tui.terminal.rows);
+          if (width <= 0 || rowBudget === 0) return [];
+          const chrome = chromeFor(rowBudget);
+          const list = ensureSelectList(visibleRowsFor(rowBudget));
+          const lines: string[] = [];
+
+          if (chrome === "full") lines.push(...border.render(width));
+          if (chrome !== "none") lines.push(title);
+          if (chrome === "full") lines.push(model);
+          lines.push(...list.render(width));
+          if (chrome !== "none") lines.push(controls);
+          if (chrome === "full") lines.push(...border.render(width));
+
+          return lines.slice(0, rowBudget).map((line) => truncateToWidth(line, width, ""));
+        };
+
         return {
-          render: (width) => container.render(width).map((line) => truncateToWidth(line, width, "")),
-          invalidate: () => container.invalidate(),
+          render,
+          invalidate: () => selectList?.invalidate(),
           handleInput: (data) => {
-            selectList.handleInput(data);
+            ensureSelectList(visibleRowsFor(Math.max(1, tui.terminal.rows))).handleInput(data);
             tui.requestRender();
           },
         };

package/killeros/worked-for.ts

@@ -1,14 +1,34 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { StopReason } from "@earendil-works/pi-ai";
 import { Text } from "@earendil-works/pi-tui";
 
 const WORKED_FOR_ENTRY_TYPE = "killeros-worked-for";
-const WORKED_FOR_ENTRY_VERSION = 1;
 
-interface WorkedForEntryData {
-  version: typeof WORKED_FOR_ENTRY_VERSION;
+interface WorkedForEntryDataV1 {
+  version: 1;
   milliseconds: number;
 }
 
+export type WorkedForOutcome = "done" | "stopped" | "failed";
+
+interface WorkedForEntryDataV2 {
+  version: 2;
+  milliseconds: number;
+  outcome: WorkedForOutcome;
+}
+
+type WorkedForEntryData = WorkedForEntryDataV1 | WorkedForEntryDataV2;
+
+const OUTCOMES = {
+  done: { marker: "✓", label: "Done", color: "success" },
+  stopped: { marker: "■", label: "Stopped", color: "warning" },
+  failed: { marker: "×", label: "Failed", color: "error" },
+} as const satisfies Record<WorkedForOutcome, { marker: string; label: string; color: string }>;
+
+function isWorkedForOutcome(value: unknown): value is WorkedForOutcome {
+  return value === "done" || value === "stopped" || value === "failed";
+}
+
 export function formatWorkedForDuration(milliseconds: number): string {
   const boundedMilliseconds = Number.isFinite(milliseconds) ? Math.max(0, milliseconds) : 0;
   const totalSeconds = Math.max(1, Math.floor(boundedMilliseconds / 1_000));
@@ -22,13 +42,23 @@ export function formatWorkedForDuration(milliseconds: number): string {
   return `${Math.floor(totalMinutes / 60)}h ${(totalMinutes % 60).toString().padStart(2, "0")}m`;
 }
 
-function isWorkedForEntryData(data: unknown): data is WorkedForEntryData {
-  if (!data || typeof data !== "object") return false;
-  const candidate = data as Partial<WorkedForEntryData>;
-  return candidate.version === WORKED_FOR_ENTRY_VERSION
-    && typeof candidate.milliseconds === "number"
-    && Number.isFinite(candidate.milliseconds)
-    && candidate.milliseconds >= 0;
+function parseWorkedForEntryData(data: unknown): WorkedForEntryData | undefined {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return undefined;
+  if (!("version" in data) || !("milliseconds" in data)) return undefined;
+  if (typeof data.milliseconds !== "number" || !Number.isFinite(data.milliseconds) || data.milliseconds < 0) {
+    return undefined;
+  }
+  if (data.version === 1) return { version: 1, milliseconds: data.milliseconds };
+  if (data.version !== 2 || !("outcome" in data) || !isWorkedForOutcome(data.outcome)) {
+    return undefined;
+  }
+  return { version: 2, milliseconds: data.milliseconds, outcome: data.outcome };
+}
+
+export function workedForOutcome(stopReason: StopReason | undefined): WorkedForOutcome {
+  if (stopReason === "stop") return "done";
+  if (stopReason === "aborted") return "stopped";
+  return "failed";
 }
 
 function errorMessage(error: unknown): string {
@@ -40,11 +70,21 @@ export function registerWorkedFor(
   now: () => number = Date.now,
 ): void {
   let startedAt: number | undefined;
+  let stopReason: StopReason | undefined;
 
   pi.registerEntryRenderer<WorkedForEntryData>(WORKED_FOR_ENTRY_TYPE, (entry, _options, theme) => {
-    if (!isWorkedForEntryData(entry.data)) return undefined;
+    const data = parseWorkedForEntryData(entry.data);
+    if (!data) return undefined;
+    if (data.version === 1) {
+      return new Text(
+        theme.fg("dim", `✻ Worked for ${formatWorkedForDuration(data.milliseconds)}`),
+        0,
+        0,
+      );
+    }
+    const outcome = OUTCOMES[data.outcome];
     return new Text(
-      theme.fg("dim", `✻ Worked for ${formatWorkedForDuration(entry.data.milliseconds)}`),
+      `${theme.fg(outcome.color, `${outcome.marker} ${outcome.label}`)}${theme.fg("dim", ` · ${formatWorkedForDuration(data.milliseconds)}`)}`,
       0,
       0,
     );
@@ -52,6 +92,7 @@ export function registerWorkedFor(
 
   pi.on("session_start", () => {
     startedAt = undefined;
+    stopReason = undefined;
   });
 
   pi.on("agent_start", (_event, ctx) => {
@@ -59,15 +100,28 @@ export function registerWorkedFor(
     startedAt = now();
   });
 
+  pi.on("agent_end", (event, ctx) => {
+    if (ctx.mode !== "tui" || startedAt === undefined) return;
+    for (let index = event.messages.length - 1; index >= 0; index -= 1) {
+      const message = event.messages[index];
+      if (message?.role !== "assistant") continue;
+      stopReason = message.stopReason;
+      break;
+    }
+  });
+
   pi.on("agent_settled", (_event, ctx) => {
     if (ctx.mode !== "tui" || startedAt === undefined) return;
     if (!ctx.isIdle() || ctx.hasPendingMessages()) return;
     const milliseconds = Math.max(0, now() - startedAt);
+    const outcome = workedForOutcome(stopReason);
     startedAt = undefined;
+    stopReason = undefined;
     try {
-      pi.appendEntry<WorkedForEntryData>(WORKED_FOR_ENTRY_TYPE, {
-        version: WORKED_FOR_ENTRY_VERSION,
+      pi.appendEntry<WorkedForEntryDataV2>(WORKED_FOR_ENTRY_TYPE, {
+        version: 2,
         milliseconds,
+        outcome,
       });
     } catch (error) {
       ctx.ui.notify(`Worked-for timing could not be saved: ${errorMessage(error)}`, "error");
@@ -76,5 +130,6 @@ export function registerWorkedFor(
 
   pi.on("session_shutdown", () => {
     startedAt = undefined;
+    stopReason = undefined;
   });
 }

package/killeros/workflow-gate.ts

@@ -0,0 +1,347 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  ToolCallEvent,
+} from "@earendil-works/pi-coding-agent";
+import type { QuestionDetails, QuestionParamsValue, QuestionRunner } from "./question.ts";
+
+export type WorkflowToolAuthorization = true | false | string;
+
+export interface WorkflowPolicy {
+  id: string;
+  allowedTools: readonly string[];
+  authorizeTool?: (
+    toolName: string,
+    input: Readonly<Record<string, unknown>>,
+    ctx: ExtensionContext,
+  ) => WorkflowToolAuthorization;
+}
+
+export interface WorkflowAdapter {
+  id: string;
+  activation: string;
+  question: QuestionParamsValue;
+  policies: readonly WorkflowPolicy[];
+  selectPolicy: (details: QuestionDetails) => WorkflowPolicy | undefined;
+  onActivated?: (policy: WorkflowPolicy, details: QuestionDetails) => void | Promise<void>;
+  onFinish?: () => void | Promise<void>;
+  onCancel?: (reason: string) => void | Promise<void>;
+  onFailure?: (error: unknown) => void | Promise<void>;
+}
+
+export type WorkflowGateState =
+  | { kind: "inactive" }
+  | { kind: "pending_decision"; adapterId: string; activation: string }
+  | { kind: "active"; adapterId: string; activation: string; policyId: string }
+  | { kind: "terminal_cleanup"; adapterId: string; activation: string; reason: WorkflowTerminalReason };
+
+export interface WorkflowGateController {
+  getState(): WorkflowGateState;
+  finish(): Promise<boolean>;
+  cancel(reason?: string): Promise<boolean>;
+}
+
+export type WorkflowTerminalReason = "finish" | "cancel" | "fail" | "session-reset";
+
+type InternalState =
+  | { kind: "inactive" }
+  | {
+    kind: "pending_decision";
+    adapter: WorkflowAdapter;
+    abortController: AbortController;
+    token: symbol;
+  }
+  | { kind: "active"; adapter: WorkflowAdapter; policy: WorkflowPolicy; token: symbol }
+  | { kind: "terminal_cleanup"; adapter: WorkflowAdapter; reason: WorkflowTerminalReason; token: symbol };
+
+function explicitSkillActivation(text: string): string | undefined {
+  if (!text.startsWith("/skill:")) return;
+  const spaceIndex = text.indexOf(" ");
+  const activation = spaceIndex === -1 ? text.slice(7) : text.slice(7, spaceIndex);
+  return /^[A-Za-z0-9][A-Za-z0-9._-]*$/u.test(activation) ? activation : undefined;
+}
+
+function isCancelled(details: QuestionDetails): boolean {
+  if (details.cancelled) return true;
+  return "answer" in details && details.answer === null;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+function publicState(state: InternalState): WorkflowGateState {
+  if (state.kind === "inactive") return state;
+  if (state.kind === "pending_decision") {
+    return {
+      kind: state.kind,
+      adapterId: state.adapter.id,
+      activation: state.adapter.activation,
+    };
+  }
+  if (state.kind === "terminal_cleanup") {
+    return {
+      kind: state.kind,
+      adapterId: state.adapter.id,
+      activation: state.adapter.activation,
+      reason: state.reason,
+    };
+  }
+  return {
+    kind: state.kind,
+    adapterId: state.adapter.id,
+    activation: state.adapter.activation,
+    policyId: state.policy.id,
+  };
+}
+
+function notify(ctx: ExtensionContext, message: string, type: "info" | "warning" | "error" = "error"): void {
+  ctx.ui.notify(message, type);
+}
+
+function isKnownPolicy(adapter: WorkflowAdapter, policy: WorkflowPolicy): boolean {
+  return adapter.policies.includes(policy);
+}
+
+async function invokeCleanup(callback: (() => void | Promise<void>) | undefined): Promise<void> {
+  try {
+    await callback?.();
+  } catch {
+    // Cleanup callbacks are best effort; the gate must still reach a terminal state.
+  }
+}
+
+async function invokeCancel(
+  callback: ((reason: string) => void | Promise<void>) | undefined,
+  reason: string,
+): Promise<void> {
+  try {
+    await callback?.(reason);
+  } catch {
+    // Cleanup callbacks are best effort; the gate must still reach a terminal state.
+  }
+}
+
+async function invokeFailure(
+  callback: ((error: unknown) => void | Promise<void>) | undefined,
+  error: unknown,
+): Promise<void> {
+  try {
+    await callback?.(error);
+  } catch {
+    // Cleanup callbacks are best effort; the gate must still reach a terminal state.
+  }
+}
+
+export function registerWorkflowGate(
+  pi: ExtensionAPI,
+  questionRunner: QuestionRunner,
+  adapters: readonly WorkflowAdapter[],
+): WorkflowGateController {
+  const adaptersByActivation = new Map<string, WorkflowAdapter>();
+  for (const adapter of adapters) {
+    if (!adapter.id.trim()) throw new Error("Decision-gated workflow adapters require an id");
+    if (!/^[-A-Za-z0-9._]+$/u.test(adapter.activation)) {
+      throw new Error(`Invalid decision-gated workflow activation: ${adapter.activation}`);
+    }
+    if (adaptersByActivation.has(adapter.activation)) {
+      throw new Error(`Duplicate decision-gated workflow activation: ${adapter.activation}`);
+    }
+    if (adapter.policies.length === 0) throw new Error(`Workflow adapter ${adapter.id} has no policies`);
+    adaptersByActivation.set(adapter.activation, adapter);
+  }
+
+  let state: InternalState = { kind: "inactive" };
+
+  const transitionToCleanup = (
+    current: Exclude<InternalState, { kind: "inactive" } | { kind: "terminal_cleanup" }>,
+    reason: WorkflowTerminalReason,
+  ): symbol => {
+    state = {
+      kind: "terminal_cleanup",
+      adapter: current.adapter,
+      reason,
+      token: current.token,
+    };
+    if (current.kind === "pending_decision") current.abortController.abort();
+    return current.token;
+  };
+
+  const finishCleanup = (token: symbol): void => {
+    if (state.kind === "terminal_cleanup" && state.token === token) state = { kind: "inactive" };
+  };
+
+  const finish = async (): Promise<boolean> => {
+    if (state.kind !== "active") return false;
+    const active = state;
+    const token = transitionToCleanup(active, "finish");
+    await invokeCleanup(active.adapter.onFinish);
+    finishCleanup(token);
+    return true;
+  };
+
+  const cancel = async (reason = "Workflow cancelled"): Promise<boolean> => {
+    if (state.kind === "inactive" || state.kind === "terminal_cleanup") return false;
+    const current = state;
+    const token = transitionToCleanup(current, "cancel");
+    await invokeCancel(current.adapter.onCancel, reason);
+    finishCleanup(token);
+    return true;
+  };
+
+  const fail = async (
+    adapter: WorkflowAdapter,
+    token: symbol,
+    error: unknown,
+    ctx: ExtensionContext,
+  ): Promise<void> => {
+    if (state.kind === "inactive" || state.kind === "terminal_cleanup") return;
+    if (state.adapter !== adapter || state.token !== token) return;
+    const cleanupToken = transitionToCleanup(state, "fail");
+    await invokeFailure(adapter.onFailure, error);
+    finishCleanup(cleanupToken);
+    notify(ctx, `Decision-gated workflow was not activated: ${errorMessage(error)}`);
+  };
+
+  pi.on("input", async (event, ctx) => {
+    const activation = explicitSkillActivation(event.text);
+    if (!activation) return;
+
+    if (state.kind === "pending_decision" || state.kind === "terminal_cleanup") {
+      notify(ctx, "A decision-gated workflow is waiting for its structured question; skill routing is blocked", "warning");
+      return { action: "handled" };
+    }
+
+    const adapter = adaptersByActivation.get(activation);
+    if (!adapter) return;
+
+    if (state.kind === "active") {
+      notify(ctx, `Cannot start /skill:${activation} while a decision-gated workflow is active`, "warning");
+      return { action: "handled" };
+    }
+    if (ctx.mode !== "tui" || !ctx.hasUI) {
+      notify(ctx, `The /skill:${activation} workflow requires interactive TUI mode`);
+      return { action: "handled" };
+    }
+    if (!ctx.isIdle() || ctx.hasPendingMessages()) {
+      notify(ctx, `The /skill:${activation} workflow can start only when Pi is idle`, "warning");
+      return { action: "handled" };
+    }
+
+    const abortController = new AbortController();
+    const token = Symbol();
+    state = { kind: "pending_decision", adapter, abortController, token };
+    let details: QuestionDetails;
+    try {
+      details = await questionRunner.ask(adapter.question, abortController.signal, ctx);
+    } catch (error) {
+      if (state.kind !== "pending_decision" || state.adapter !== adapter || state.token !== token) {
+        return { action: "handled" };
+      }
+      await fail(adapter, token, error, ctx);
+      return { action: "handled" };
+    }
+
+    if (state.kind !== "pending_decision" || state.adapter !== adapter || state.token !== token) {
+      return { action: "handled" };
+    }
+    if (isCancelled(details)) {
+      await cancel("Decision question cancelled");
+      notify(ctx, `The /skill:${activation} workflow was cancelled`, "warning");
+      return { action: "handled" };
+    }
+
+    let policy: WorkflowPolicy | undefined;
+    try {
+      policy = adapter.selectPolicy(details);
+    } catch (error) {
+      await fail(adapter, token, error, ctx);
+      return { action: "handled" };
+    }
+    if (!policy || !isKnownPolicy(adapter, policy)) {
+      await fail(adapter, token, new Error("The structured answer did not select a registered policy"), ctx);
+      return { action: "handled" };
+    }
+
+    try {
+      await adapter.onActivated?.(policy, details);
+    } catch (error) {
+      if (state.kind !== "pending_decision" || state.adapter !== adapter || state.token !== token) {
+        return { action: "handled" };
+      }
+      await fail(adapter, token, error, ctx);
+      return { action: "handled" };
+    }
+    if (state.kind !== "pending_decision" || state.adapter !== adapter || state.token !== token) {
+      return { action: "handled" };
+    }
+    state = { kind: "active", adapter, policy, token };
+    return { action: "continue" };
+  });
+
+  pi.on("tool_call", (event: ToolCallEvent, ctx) => {
+    if (state.kind === "inactive") return;
+    if (state.kind === "pending_decision" || state.kind === "terminal_cleanup") {
+      return {
+        block: true,
+        reason: "A decision-gated workflow is waiting for its structured question; no model tool calls are allowed yet",
+      };
+    }
+
+    const { policy } = state;
+    if (!policy.allowedTools.includes(event.toolName)) {
+      return {
+        block: true,
+        reason: `Tool ${event.toolName} is not allowed by decision-gated policy ${policy.id}`,
+      };
+    }
+    const authorization = policy.authorizeTool?.(event.toolName, event.input, ctx) ?? true;
+    if (authorization === true) return;
+    return {
+      block: true,
+      reason: typeof authorization === "string"
+        ? authorization
+        : `Tool ${event.toolName} is denied by decision-gated policy ${policy.id}`,
+    };
+  });
+
+  const resetForLifecycle = async (reason: string): Promise<void> => {
+    if (state.kind === "inactive" || state.kind === "terminal_cleanup") return;
+    const current = state;
+    const token = transitionToCleanup(current, "session-reset");
+    await invokeCancel(current.adapter.onCancel, reason);
+    finishCleanup(token);
+  };
+
+  pi.on("session_start", () => resetForLifecycle("Session lifecycle reset"));
+  pi.on("session_shutdown", () => resetForLifecycle("Session lifecycle reset"));
+  pi.on("session_tree", () => resetForLifecycle("Session tree reset"));
+  pi.on("session_before_switch", () => resetForLifecycle("Session switch reset"));
+  pi.on("session_before_fork", () => resetForLifecycle("Session fork reset"));
+  pi.on("session_before_tree", () => resetForLifecycle("Session tree reset"));
+
+  pi.on("agent_end", async (event, ctx) => {
+    if (state.kind !== "active") return;
+
+    let failureMessage: string | undefined;
+    for (let index = event.messages.length - 1; index >= 0; index -= 1) {
+      const message = event.messages[index];
+      if (message?.role === "assistant" && message.errorMessage) {
+        failureMessage = message.errorMessage;
+        break;
+      }
+    }
+    if (failureMessage === undefined) return;
+
+    const active = state;
+    await fail(active.adapter, active.token, new Error(failureMessage), ctx);
+  });
+
+  return {
+    getState: () => publicState(state),
+    finish,
+    cancel,
+  };
+}
+
+export { explicitSkillActivation };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killeros",
-  "version": "2.0.6",
+  "version": "2.0.8",
   "description": "TUI, goals, and workflow automation for the Pi coding agent",
   "type": "module",
   "keywords": [
@@ -42,14 +42,15 @@
     ]
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.82.1",
-    "@earendil-works/pi-coding-agent": ">=0.82.1",
-    "@earendil-works/pi-tui": ">=0.82.1",
+    "@earendil-works/pi-ai": ">=0.84.1",
+    "@earendil-works/pi-coding-agent": ">=0.84.1",
+    "@earendil-works/pi-tui": ">=0.84.1",
     "typebox": ">=1.1.38 <2"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "0.82.1",
-    "@earendil-works/pi-tui": "0.82.1",
+    "@earendil-works/pi-ai": "0.84.2",
+    "@earendil-works/pi-coding-agent": "0.84.2",
+    "@earendil-works/pi-tui": "0.84.2",
     "@types/node": "24.12.4",
     "typebox": "1.1.38",
     "typescript": "5.9.3"