killeros 2.0.7 → 2.0.9

package/killeros/decision-gated-workflow.ts

@@ -0,0 +1,76 @@
+import path from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { QuestionDetails } from "./question.ts";
+import type { WorkflowAdapter, WorkflowPolicy, WorkflowToolAuthorization } from "./workflow-gate.ts";
+
+const READ_ONLY_TOOLS = ["read", "grep", "find", "ls", "question"] as const;
+
+const DOCUMENTATION_PATHS: readonly RegExp[] = [
+  /^(?:docs\/)?(?:glossary|context-map)(?:\.md|\/|$)/u,
+  /^docs\/adr\/[^/]+\.md$/u,
+];
+
+function relativePath(input: Readonly<Record<string, unknown>>, ctx: ExtensionContext): string | undefined {
+  if (typeof input.path !== "string" || input.path.trim().length === 0) return;
+  const absolute = path.resolve(ctx.cwd, input.path);
+  const relative = path.relative(ctx.cwd, absolute);
+  if (!relative || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return;
+  return relative.replaceAll(path.sep, "/").toLocaleLowerCase();
+}
+
+function authorizeDocumentationTool(
+  toolName: string,
+  input: Readonly<Record<string, unknown>>,
+  ctx: ExtensionContext,
+): WorkflowToolAuthorization {
+  if (toolName !== "edit" && toolName !== "write") return true;
+  const target = relativePath(input, ctx);
+  if (target && DOCUMENTATION_PATHS.some((pattern) => pattern.test(target))) return true;
+  return "With docs policy permits writes only to the agreed glossary, context-map, and ADR paths";
+}
+
+const NORMAL_POLICY: WorkflowPolicy = {
+  id: "normal",
+  allowedTools: READ_ONLY_TOOLS,
+};
+
+const WITH_DOCS_POLICY: WorkflowPolicy = {
+  id: "with-docs",
+  allowedTools: [...READ_ONLY_TOOLS, "edit", "write"],
+  authorizeTool: authorizeDocumentationTool,
+};
+
+const POLICIES = [NORMAL_POLICY, WITH_DOCS_POLICY] as const;
+
+function selectedAnswer(details: QuestionDetails): string | undefined {
+  if (!("answer" in details) || details.answer === null) return;
+  return details.answer;
+}
+
+export function createDecisionGatedWorkflowAdapter(): WorkflowAdapter {
+  return {
+    id: "decision-gated-workflow",
+    activation: "decision-gated-workflow",
+    question: {
+      question: "Choose the policy for this workflow before the model starts",
+      options: [
+        {
+          label: "Normal",
+          description: "Interview and read-only work; implementation files stay protected.",
+        },
+        {
+          label: "With docs",
+          description: "Allow only agreed glossary, context-map, or ADR documentation writes.",
+        },
+      ],
+    },
+    policies: POLICIES,
+    selectPolicy(details) {
+      switch (selectedAnswer(details)) {
+        case "Normal": return NORMAL_POLICY;
+        case "With docs": return WITH_DOCS_POLICY;
+        default: return undefined;
+      }
+    },
+  };
+}

package/killeros/question.ts

@@ -1,5 +1,10 @@
 import { StringEnum } from "@earendil-works/pi-ai";
-import { type ExtensionAPI, type ThemeColor } from "@earendil-works/pi-coding-agent";
+import {
+  type ExtensionAPI,
+  type ExtensionContext,
+  type ThemeColor,
+  type ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
 import {
   decodeKittyPrintable,
   Editor,
@@ -40,7 +45,7 @@ const QuestionParams = Type.Object({
   })),
 });
 
-type QuestionParamsValue = Static<typeof QuestionParams>;
+export type QuestionParamsValue = Static<typeof QuestionParams>;
 
 type NormalizedQuestionSelection =
   | { mode: "single"; minSelections: 1; maxSelections: 1 }
@@ -95,7 +100,11 @@ interface MultipleQuestionDetails {
   cancelled?: boolean;
 }
 
-type QuestionDetails = SingleQuestionDetails | MultipleQuestionDetails;
+export type QuestionDetails = SingleQuestionDetails | MultipleQuestionDetails;
+
+export interface QuestionRunner {
+  ask(params: QuestionParamsValue, signal: AbortSignal | undefined, ctx: ExtensionContext): Promise<QuestionDetails>;
+}
 
 type QuestionSelection =
   | { kind: "selected"; answer: string; originalIndex: number }
@@ -210,7 +219,7 @@ class MultipleResultText {
   invalidate(): void {}
 }
 
-export function registerQuestionTool(pi: ExtensionAPI): void {
+export function registerQuestionTool(pi: ExtensionAPI): QuestionRunner {
   const customInputHistory: string[] = [];
   let customInputHistoryBytes = 0;
   const clearCustomInputHistory = (): void => {
@@ -242,7 +251,7 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
   pi.on("session_tree", clearCustomInputHistory);
   pi.on("session_shutdown", clearCustomInputHistory);
 
-  pi.registerTool<typeof QuestionParams, QuestionDetails>({
+  const questionTool: ToolDefinition<typeof QuestionParams, QuestionDetails> = {
     name: "question",
     label: "Question",
     description: `Ask one interactive multiple-choice question. Provide 1-9 concise options. Single-select is the default; opt into bounded multi-select with mode "multiple". The user can filter options or type a custom answer. Filter queries are limited to ${FILTER_QUERY_MAX_CHARACTERS.toLocaleString()} characters and ${FILTER_QUERY_MAX_BYTES.toLocaleString()} bytes.`,
@@ -752,5 +761,14 @@ export function registerQuestionTool(pi: ExtensionAPI): void {
       }
       return new BoundedText(`${theme.fg("success", "✓ ")}${theme.fg("accent", answer)}`);
     },
-  });
+  };
+  pi.registerTool(questionTool);
+
+  return {
+    async ask(params, signal, ctx): Promise<QuestionDetails> {
+      const result = await questionTool.execute("killeros-workflow-gate", params, signal, undefined, ctx);
+      if (!result.details) throw new Error("Question did not return a structured result");
+      return result.details;
+    },
+  };
 }

package/killeros/shell-ui.ts

@@ -10,6 +10,7 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import {
   CURSOR_MARKER,
+  stripTerminalSequences,
   truncateToWidth,
   visibleWidth,
   wrapTextWithAnsi,
@@ -17,6 +18,11 @@ import {
   type TUI,
 } from "@earendil-works/pi-tui";
 import { formatCwd, padRight } from "./display.ts";
+import {
+  createSlashCommandResolver,
+  findSlashCommandTokens,
+  type SlashCommandResolver,
+} from "./commands.ts";
 import { reportError } from "./errors.ts";
 import { formatModel } from "./footer.ts";
 import { LEVEL_COLORS, type ThinkingLevel } from "./variants.ts";
@@ -166,10 +172,8 @@ class PiStartupHeader {
   }
 }
 
-const ANSI_REGEX = /\x1b(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
-
 function stripAnsi(text: string): string {
-  return text.replace(ANSI_REGEX, "").trim();
+  return stripTerminalSequences(text).trim();
 }
 
 function isBorderLine(line: string): boolean {
@@ -182,10 +186,98 @@ function isScrolledTopBorder(line: string): boolean {
   return unstyled.includes("↑");
 }
 
+interface RenderChunk {
+  text: string;
+  plainStart: number;
+  isAnsi: boolean;
+}
+
+function extractTerminalSequence(text: string, position: number): { code: string; length: number } | undefined {
+  if (text[position] !== "\x1B") return undefined;
+  const next = text[position + 1];
+  if (next === "[") {
+    let end = position + 2;
+    while (end < text.length && !/[\x40-\x7E]/u.test(text[end] ?? "")) end += 1;
+    if (end < text.length) return { code: text.slice(position, end + 1), length: end + 1 - position };
+    return undefined;
+  }
+  if (next === "]" || next === "_") {
+    let end = position + 2;
+    while (end < text.length) {
+      if (text[end] === "\x07") return { code: text.slice(position, end + 1), length: end + 1 - position };
+      if (text[end] === "\x1B" && text[end + 1] === "\\") {
+        return { code: text.slice(position, end + 2), length: end + 2 - position };
+      }
+      end += 1;
+    }
+    return undefined;
+  }
+  if (next !== undefined) return { code: text.slice(position, position + 2), length: 2 };
+  return undefined;
+}
+
+export function highlightSlashCommands(
+  line: string,
+  isValidCommand: (name: string) => boolean,
+  styleCommand: (token: string) => string,
+): string {
+  const chunks: RenderChunk[] = [];
+  let plain = "";
+  let index = 0;
+  while (index < line.length) {
+    const ansi = extractTerminalSequence(line, index);
+    if (ansi) {
+      chunks.push({ text: ansi.code, plainStart: plain.length, isAnsi: true });
+      index += ansi.length;
+      continue;
+    }
+
+    const start = index;
+    const plainStart = plain.length;
+    while (index < line.length && !extractTerminalSequence(line, index)) {
+      plain += line[index] ?? "";
+      index += 1;
+    }
+    chunks.push({
+      text: line.slice(start, index),
+      plainStart,
+      isAnsi: false,
+    });
+  }
+
+  const tokens = findSlashCommandTokens(plain).filter((token) => isValidCommand(token.name));
+  if (tokens.length === 0) return line;
+
+  return chunks.map((chunk) => {
+    if (chunk.isAnsi) return chunk.text;
+    let output = "";
+    let offset = 0;
+    while (offset < chunk.text.length) {
+      const plainIndex = chunk.plainStart + offset;
+      const token = tokens.find(({ start, end }) => plainIndex >= start && plainIndex < end);
+      if (!token) {
+        const nextTokenStart = tokens.find(({ start }) => start > plainIndex)?.start;
+        const end = nextTokenStart === undefined
+          ? chunk.text.length
+          : Math.min(chunk.text.length, nextTokenStart - chunk.plainStart);
+        output += chunk.text.slice(offset, end);
+        offset = end;
+        continue;
+      }
+
+      const tokenEnd = Math.min(chunk.text.length, token.end - chunk.plainStart);
+      output += styleCommand(chunk.text.slice(offset, tokenEnd));
+      offset = tokenEnd;
+    }
+    return output;
+  }).join("");
+}
+
 class PiCodeEditor extends CustomEditor {
   private readonly appKeybindings: KeybindingsManager;
   private readonly runtimeTheme: Theme;
   private readonly suggestion: string;
+  private readonly commandResolver: SlashCommandResolver;
 
   constructor(
     tui: TUI,
@@ -193,11 +285,13 @@ class PiCodeEditor extends CustomEditor {
     appKeybindings: KeybindingsManager,
     runtimeTheme: Theme,
     suggestion: string,
+    commandResolver: SlashCommandResolver,
   ) {
     super(tui, theme, appKeybindings);
     this.appKeybindings = appKeybindings;
     this.runtimeTheme = runtimeTheme;
     this.suggestion = suggestion;
+    this.commandResolver = commandResolver;
   }
 
   override handleInput(data: string): void {
@@ -248,6 +342,13 @@ class PiCodeEditor extends CustomEditor {
         const cursorMarker = this.focused ? CURSOR_MARKER : "";
         content = `${cursorMarker}\x1B[7m${dim(first)}\x1B[27m${dim(rest)}`;
       }
+      if (this.getText() !== "") {
+        content = highlightSlashCommands(
+          content,
+          (name) => this.commandResolver.isValidCommand(name),
+          (token) => this.runtimeTheme.fg("mdLink", token),
+        );
+      }
       rendered.push(`${prefix}${padRight(content, innerWidth)}`);
     }
 
@@ -272,7 +373,10 @@ const ACTIVITY_FRAME_INTERVAL_MS = 120;
 
 let killerosEditorFactory: ReturnType<ExtensionContext["ui"]["getEditorComponent"]>;
 
-export function registerShellUi(pi: ExtensionAPI): void {
+export function registerShellUi(
+  pi: ExtensionAPI,
+  commandResolver: SlashCommandResolver = createSlashCommandResolver(pi),
+): void {
   let activeHeader: PiStartupHeader | undefined;
 
   pi.on("session_start", (_event, ctx) => {
@@ -294,7 +398,7 @@ export function registerShellUi(pi: ExtensionAPI): void {
       if (!existingEditorFactory || existingEditorFactory === killerosEditorFactory) {
         const editorSuggestion = nextEditorSuggestion();
         killerosEditorFactory = (tui, editorTheme, keybindings) =>
-          new PiCodeEditor(tui, editorTheme, keybindings, ctx.ui.theme, editorSuggestion);
+          new PiCodeEditor(tui, editorTheme, keybindings, ctx.ui.theme, editorSuggestion, commandResolver);
         ctx.ui.setEditorComponent(killerosEditorFactory);
       }
     } catch (error) {

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.7",
+  "version": "2.0.9",
   "description": "TUI, goals, and workflow automation for the Pi coding agent",
   "type": "module",
   "keywords": [
@@ -48,9 +48,9 @@
     "typebox": ">=1.1.38 <2"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.84.1",
-    "@earendil-works/pi-coding-agent": "0.84.1",
-    "@earendil-works/pi-tui": "0.84.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"