killeros 2.0.7 → 2.0.8

package/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.0.8] - 2026-08-15
+
+### Added
+
+- Added a reusable, opt-in pre-turn gate for explicitly activated decision-gated workflows. It opens the shared structured question UI before skill expansion, keeps the selected policy active, blocks unknown and disallowed tools, and clears safely across lifecycle boundaries.
+- Added a disposable decision-gated workflow fixture and focused coverage for activation ordering, pending safety, policy allowlists, lifecycle cleanup, adapter reuse, and Pi 0.84.2 compatibility.
+
+### Removed
+
+- Removed KillerOS's always-on concise response policy and provider-specific concise defaults; Pi now owns response-style guidance.
+
+### Changed
+
+- Raised the locked direct Pi development packages to 0.84.2 while keeping the peer dependency floor at 0.84.1.
+
 ## [2.0.7] - 2026-08-13
 
 ### Changed

package/Killeros.ts

@@ -1,7 +1,6 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { registerRequestActivity } from "./killeros/activity.ts";
 import { registerAliases, registerSlashAutocomplete } from "./killeros/commands.ts";
-import { registerConcisePrompt } from "./killeros/concise.ts";
 import { registerFooter } from "./killeros/footer.ts";
 import { registerGoal, registerGoalSettlement } from "./killeros/goals.ts";
 import { registerLifecycleHooks } from "./killeros/hooks.ts";
@@ -11,31 +10,47 @@ import {
   type CompletionNotificationDependencies,
 } from "./killeros/notifications.ts";
 import { registerPersonalInstructions } from "./killeros/personal-instructions.ts";
-import { registerQuestionTool } from "./killeros/question.ts";
+import { registerQuestionTool, type QuestionRunner } from "./killeros/question.ts";
+import { createDecisionGatedWorkflowAdapter } from "./killeros/decision-gated-workflow.ts";
 import { createGoalRuntime, createInitRuntime } from "./killeros/runtime.ts";
 import { registerShellUi } from "./killeros/shell-ui.ts";
 import { registerVariants } from "./killeros/variants.ts";
 import { registerWorkedFor } from "./killeros/worked-for.ts";
+import { registerWorkflowGate, type WorkflowAdapter } from "./killeros/workflow-gate.ts";
 
-export { CONCISE_SYSTEM_PROMPT, isConciseEnabled, isConcisedEnabled } from "./killeros/concise.ts";
 export { contextPercentRemaining, formatCost, formatContextProgress } from "./killeros/footer.ts";
 export { executeHook } from "./killeros/hooks.ts";
 export { INIT_WORKFLOW_PROMPT } from "./killeros/init.ts";
 export { buildInitEvidence, listInitEvidence, readInitEvidence } from "./killeros/init-evidence.ts";
 export { captureInitTargetBaseline, installInitAgentsFile, validateGeneratedGuidance, writeInitAgentsFile } from "./killeros/init-target.ts";
+export { createDecisionGatedWorkflowAdapter } from "./killeros/decision-gated-workflow.ts";
+export { explicitSkillActivation, registerWorkflowGate } from "./killeros/workflow-gate.ts";
+export type {
+  WorkflowAdapter,
+  WorkflowGateController,
+  WorkflowGateState,
+  WorkflowPolicy,
+  WorkflowTerminalReason,
+  WorkflowToolAuthorization,
+} from "./killeros/workflow-gate.ts";
 
 export interface KillerosOptions {
   completionNotifications?: CompletionNotificationDependencies;
+  decisionGatedWorkflows?: readonly WorkflowAdapter[];
 }
 
 export default function Killeros(pi: ExtensionAPI, options: KillerosOptions = {}): void {
   const initRuntime = createInitRuntime();
   const goalRuntime = createGoalRuntime();
   registerShellUi(pi);
-  registerConcisePrompt(pi);
   registerGoal(pi, goalRuntime, initRuntime);
   registerPersonalInstructions(pi, initRuntime);
-  registerQuestionTool(pi);
+  const questionRunner: QuestionRunner = registerQuestionTool(pi);
+  registerWorkflowGate(
+    pi,
+    questionRunner,
+    options.decisionGatedWorkflows ?? [createDecisionGatedWorkflowAdapter()],
+  );
   registerAliases(pi);
   registerSlashAutocomplete(pi);
   registerFooter(pi, goalRuntime);

package/README.md

@@ -1,11 +1,11 @@
 # KillerOS
 
-A production-hardened Pi extension that combines a custom TUI, repository initialization, long-running goals, reasoning controls, interactive questions, command aliases, and concise-response guidance.
+A production-hardened Pi extension that combines a custom TUI, repository initialization, long-running goals, reasoning controls, interactive questions, and command aliases.
 
 ## Requirements
 
 - Node.js `22.19.0` or later
-- Pi `0.84.1` or later
+- Pi `0.84.2` or later
 - Interactive TUI mode for the custom header, editor, footer, `question` tool, and `/init`
 
 The extension is strict TypeScript. Pi provides the runtime modules.
@@ -31,7 +31,7 @@ pi install git:github.com/KyrosHendrix/pi-KillerOS
 Pin an install to a release:
 
 ```bash
-pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.7
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.8
 ```
 
 Add `-l` to either command for a project-only install. Restart Pi after installing.
@@ -48,11 +48,11 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 - Optional completion sounds after successful or failed settled requests, excluding manual aborts
 - `/variants` selector and direct reasoning-level arguments
 - Codex-style `/goal` with an interactive status/action panel, durable objectives, immediate pause and clear cancellation, automatic continuation, explicit completion, and durable blocker audits
-- Automatic `/init` guideline synthesis with a frozen safe evidence map, protected existing policy, and the four packaged behavioral sections adapted from `writing-great-guidelines`
+- Automatic `/init` guideline synthesis with a frozen safe evidence map, protected existing policy, and the four packaged behavioral sections adapted from `writing-great-guidelines`
+- Opt-in decision-gated workflows that ask a structured policy question before explicit skill expansion, preserve the selected allowlist, and fail closed across tool and session boundaries
 - `question` tool with single-select and opt-in bounded multi-select, height-bounded option windows, configured Pi keybindings, live option/input progress, proposal previews, custom answers, history, cancellation, and compact expandable transcript rendering
-- Mid-prompt slash completion with current Pi `0.84.1` commands, extensions, prompts, and skills; paths, URLs, and invalid commands remain plain text
+- Mid-prompt slash completion with current Pi `0.84.2` commands, extensions, prompts, and skills; paths, URLs, and invalid commands remain plain text
 - Goal-aware `/clear` that confirms, aborts active work, waits for settlement, and starts a new session, plus `/exit` for graceful shutdown
-- Concise system-prompt guidance and supported native concise defaults that preserve explicit provider settings
 
 ## Commands
 
@@ -77,9 +77,13 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 
 `/init` freezes a safe project-file map and exposes only dedicated read and list operations while it generates root `AGENTS.md`. Git-ignored files, known secret paths, private-key formats, other guidance, dependencies, links, non-regular files, and files outside that map are unavailable. Existing root `AGENTS.md` is separate protected policy: compatible rules are preserved, a real policy conflict leaves it unchanged with a reason, and any concurrent target change aborts installation without replacing the newer file.
 
-The generated file uses the four behavioral sections adapted from `writing-great-guidelines`; no external skill installation is required. `/init` asks no setup questions, starts no second model process, writes no other file, and reloads Pi resources only after a successful write.
-
-### Interactive questions
+The generated file uses the four behavioral sections adapted from `writing-great-guidelines`; no external skill installation is required. `/init` asks no setup questions, starts no second model process, writes no other file, and reloads Pi resources only after a successful write.
+
+### Decision-gated workflows
+
+Explicit `/skill:decision-gated-workflow` activation opens the shared question UI before Pi expands the skill. `Normal` allows only interview and read-only tools; `With docs` additionally permits agreed glossary, context-map, and ADR paths. The selected policy remains active until the workflow is explicitly finished or cancelled, and lifecycle changes clear it safely. Extensions can supply additional adapters through `KillerosOptions.decisionGatedWorkflows`.
+
+### Interactive questions
 
 Single-select remains the default. Explicit `minSelections: 1` and `maxSelections: 1` are equivalent to omitting both bounds; other single-select bounds are rejected. An agent opts into multi-select with `mode: "multiple"` and may set `minSelections` and `maxSelections`; the custom answer counts as one selection.
 
@@ -108,8 +112,8 @@ Lifecycle hooks are loaded from `.pi/killeros-hooks.json` at session start. Supp
 | Mode | Behavior |
 |---|---|
 | TUI | All features are available, including the completion sound and tab-title indicator |
-| RPC | Goal set/view/pause/resume/clear and concise prompt guidance work; TUI components, `/goal edit`, `/init`, completion sounds, and the title indicator are disabled |
-| Print/JSON | Concise prompt guidance works; interactive questions, `/goal`, and `/init` fail explicitly; completion sounds and the title indicator are disabled |
+| RPC | Goal set/view/pause/resume/clear work; TUI components, `/goal edit`, `/init`, completion sounds, and the title indicator are disabled |
+| Print/JSON | Interactive questions, `/goal`, and `/init` fail explicitly; completion sounds and the title indicator are disabled |
 
 ## Validation
 

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/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.8",
   "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"

package/killeros/concise.ts

@@ -1,69 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-export const CONCISE_SYSTEM_PROMPT = `
-# Action-oriented response guidance
-
-Make each response easy to start and easy to follow. Keep the state the user needs on screen instead of expecting them to remember missing context. Concise means low friction, not minimal detail: preserve everything required for safety, correctness, and action.
-
-## Serve the immediate need
-
-The first line serves the user's immediate need: give the answer for an informational request, the next action for executable work, or the failure and recovery when blocked. Omit conversational preambles. If the agent can continue the work, continue instead of asking permission; if the task is complete, do not manufacture a next step.
-
-Finish the primary task before raising a separate concern. Mention an unrelated issue only when it materially affects safety, correctness, or the user's next decision. Ask one concrete question only when a material ambiguity remains after checking available code and context.
-
-## Reduce action and memory friction
-
-Use structure by meaning: numbered steps for sequence, bullets for parallel facts or options, and short headings when they make a longer answer easier to scan or re-enter. Keep each step bounded. When a list grows beyond about five items, rank or group it instead of omitting required detail.
-
-Use a compact state anchor only when multi-step work spans turns or resumes after interruption. During tool-driven work, report meaningful phase changes, long-running verification, failures, and required decisions rather than narrating routine actions.
-
-## Make outcomes and failures concrete
-
-When work completes, make the verified outcome prominent: state what now works and the evidence that proves it. Do not append a redundant recap. State failures matter-of-factly with the cause, impact, and recovery action. After three consecutive turns leave the same issue broken, stop speculative edits, name the likely invalid assumption from the observed evidence, and ask one diagnostic question.
-
-Never invent facts, completion claims, or timing. Give a concrete human execution estimate only when requested or supported by evidence, state its assumptions, and never predict the agent's own completion time. Preserve exact code, commands, paths, quoted text, warnings, and user-requested formats.
-
-## Resolve conflicts deliberately
-
-Safety and harness constraints come first, followed by the user's explicit depth or format request, then correctness and completeness, then these concise defaults. Explain fully when asked, confirm before destructive actions, and retain necessary uncertainty rather than manufacturing confidence.
-
-Before sending, check that the first line serves the immediate need, filler and tangents are gone, exact artifacts and necessary uncertainty remain, and the ending is either the verified outcome or one action the user must take. Use a pragmatic tone: direct, plain, and focused on the task. Omit generic praise, recap sections, and closing pleasantries.
-`.trim();
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function applyConciseModelSettings(payload: unknown, api: unknown, modelId: unknown): unknown {
-  if (!isRecord(payload) || !Array.isArray(payload.input)) return payload;
-
-  const supportsSummary = api === "openai-codex-responses" || api === "openai-responses" || api === "azure-openai-responses";
-  const supportsVerbosity = api === "openai-codex-responses"
-    || api === "openai-responses" && typeof modelId === "string" && /^gpt-5(?:[.-]|$)/u.test(modelId);
-  let updated = payload;
-  const text = isRecord(payload.text) ? payload.text : undefined;
-  if (supportsVerbosity && !Object.hasOwn(text ?? {}, "verbosity")) {
-    updated = { ...updated, text: { ...(text ?? {}), verbosity: "low" } };
-  }
-  const reasoning = isRecord(payload.reasoning) ? payload.reasoning : undefined;
-  if (supportsSummary && reasoning && !Object.hasOwn(reasoning, "summary")) {
-    updated = { ...updated, reasoning: { ...reasoning, summary: "concise" } };
-  }
-  return updated;
-}
-
-export function isConciseEnabled(): boolean {
-  return true;
-}
-
-/** @deprecated Use isConciseEnabled instead. */
-export function isConcisedEnabled(): boolean {
-  return isConciseEnabled();
-}
-
-export function registerConcisePrompt(pi: ExtensionAPI): void {
-  pi.on("before_agent_start", (event) => ({
-    systemPrompt: `${event.systemPrompt}\n\n${CONCISE_SYSTEM_PROMPT}`,
-  }));
-  pi.on("before_provider_request", (event, ctx) => applyConciseModelSettings(event.payload, ctx.model?.api, ctx.model?.id));
-}