killeros 2.0.10 → 2.0.12

package/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.0.12] - 2026-08-18
+
+### Fixed
+
+- Resumed active goals exactly once after Pi reports automatic compaction complete.
+
+## [2.0.11] - 2026-08-17
+
+### Fixed
+
+- Made automated npm publication and GitHub release recovery idempotent, aligned the documented and tested Pi floor, and made machine-identifier casing locale-independent.
+- Extended strict type checking to release scripts and typed test suites, while correctly identifying JavaScript-only suites as `.js`.
+
+### Removed
+
+- Removed the decision-gated workflow subsystem, its skill-specific policy, public extension interface, and YAML dependency. Skills now remain instruction-only.
+
 ## [2.0.10] - 2026-08-16
 
 ### Added

package/Killeros.ts

@@ -15,33 +15,19 @@ import {
   type CompletionNotificationDependencies,
 } from "./killeros/notifications.ts";
 import { registerPersonalInstructions } from "./killeros/personal-instructions.ts";
-import { registerQuestionTool, type QuestionRunner } from "./killeros/question.ts";
-import { createDecisionGatedWorkflowAdapter } from "./killeros/decision-gated-workflow.ts";
+import { registerQuestionTool } from "./killeros/question.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 { 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 {
@@ -51,12 +37,7 @@ export default function Killeros(pi: ExtensionAPI, options: KillerosOptions = {}
   registerShellUi(pi, commandResolver);
   registerGoal(pi, goalRuntime, initRuntime);
   registerPersonalInstructions(pi, initRuntime);
-  const questionRunner: QuestionRunner = registerQuestionTool(pi);
-  registerWorkflowGate(
-    pi,
-    questionRunner,
-    options.decisionGatedWorkflows ?? [createDecisionGatedWorkflowAdapter()],
-  );
+  registerQuestionTool(pi);
   registerAliases(pi);
   registerSlashAutocomplete(pi, commandResolver);
   registerFooter(pi, goalRuntime);

package/README.md

@@ -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.10
+pi install git:github.com/KyrosHendrix/pi-KillerOS@v2.0.12
 ```
 
 Add `-l` to either command for a project-only install. Restart Pi after installing.
@@ -49,7 +49,6 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 - `/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`
-- 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.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
@@ -79,10 +78,6 @@ Add `-l` to either command for a project-only install. Restart Pi after installi
 
 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:<name>` activation opens the shared question UI before Pi expands a registered skill. `WorkflowAdapter.activation` keeps the existing exact-match API, while `WorkflowAdapter.activations` lets one policy register multiple explicit skill names without duplicating the gate. `Normal` allows only interview and read-only tools; `With docs` additionally permits agreed glossary, context-map, and ADR paths. Unregistered names pass through unchanged, duplicate or ambiguous registrations fail at startup, and the selected policy remains active until the workflow is explicitly finished or cancelled. 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.
@@ -144,16 +139,9 @@ The package manifest lists Pi’s built-in modules as peer dependencies, so npm
 
 ## Publish
 
-To create a GitHub release, update the version in `package.json` and `package-lock.json`, add the matching `CHANGELOG.md` section, and push the release commit to `main`. After the full CI workflow passes, the release workflow creates the matching tag and GitHub release from that verified commit.
-
-Do not manually tag a normal release. If automation must recover a missing GitHub release, push the matching version tag; the same workflow validates the tag against the package and changelog before creating the release.
+To release KillerOS, update the version in `package.json` and `package-lock.json`, add the matching `CHANGELOG.md` section, and push the release commit to `main`. After the full CI workflow passes, the release workflow publishes the package to npm through trusted publishing, then creates the matching tag and GitHub release from that verified commit. The [`pi-package`](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/packages.md) keyword makes the npm release visible in Pi’s package catalog.
 
-The [`pi-package`](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/packages.md) keyword makes a published npm release visible in Pi’s package catalog. GitHub release automation does not publish to npm. Publish there separately after validation:
-
-```bash
-npm login
-npm publish
-```
+Do not manually tag a normal release. If automation must recover a missing GitHub release, push the matching version tag. The workflow validates the tag against the package and changelog, skips npm publication when that version already exists, and creates only the missing release.
 
 ## Security
 

package/killeros/activity.ts

@@ -30,7 +30,7 @@ export function formatActivityMessage(message: ActivityMessage, theme: Theme): s
       detail = "assembling the answer";
       break;
     case "tool":
-      switch (message.toolName.trim().toLocaleLowerCase()) {
+      switch (message.toolName.trim().toLowerCase()) {
         case "read":
         case "grep":
         case "find":

package/killeros/commands.ts

@@ -166,8 +166,8 @@ export function createSlashCommandResolver(
 
 function scoreCommandMatch(name: string, prefix: string): number {
   if (!prefix) return 1;
-  const normalizedName = name.toLocaleLowerCase();
-  const normalizedPrefix = prefix.toLocaleLowerCase();
+  const normalizedName = name.toLowerCase();
+  const normalizedPrefix = prefix.toLowerCase();
   if (normalizedName.startsWith(normalizedPrefix)) return 100;
   if (normalizedName.split(/[:\-_]/).some((token) => token.startsWith(normalizedPrefix))) return 80;
   if (normalizedName.includes(normalizedPrefix)) return 50;
@@ -190,7 +190,7 @@ export function registerSlashAutocomplete(
         const prefixMatch = getSlashCommandPrefix(beforeCursor);
         if (!prefixMatch) return current.getSuggestions(lines, cursorLine, cursorCol, options);
 
-        const prefix = prefixMatch.prefix.toLocaleLowerCase();
+        const prefix = prefixMatch.prefix.toLowerCase();
         const baseSuggestions = await current.getSuggestions(lines, cursorLine, cursorCol, options);
         resolver.updateFallbackCommands(baseSuggestions?.items ?? []);
         const commands = resolver.getCommandCatalog(baseSuggestions?.items ?? []);

package/killeros/display.ts

@@ -6,8 +6,8 @@ export function formatCwd(cwd: string): string {
   if (!home) return cwd;
   const normalizedHome = home.replace(/[\\/]+$/, "");
   const normalizedCwd = cwd.replace(/[\\/]+$/, "");
-  const comparedHome = process.platform === "win32" ? normalizedHome.toLocaleLowerCase() : normalizedHome;
-  const comparedCwd = process.platform === "win32" ? normalizedCwd.toLocaleLowerCase() : normalizedCwd;
+  const comparedHome = process.platform === "win32" ? normalizedHome.toLowerCase() : normalizedHome;
+  const comparedCwd = process.platform === "win32" ? normalizedCwd.toLowerCase() : normalizedCwd;
   if (comparedCwd === comparedHome) return "~";
   const separator = normalizedCwd.slice(normalizedHome.length, normalizedHome.length + 1);
   return comparedCwd.startsWith(comparedHome) && (separator === "/" || separator === "\\")

package/killeros/footer.ts

@@ -75,12 +75,12 @@ const PROVIDER_WORDS: Readonly<Record<string, string>> = {
 
 function formatProviderName(provider: string): string {
   const normalized = provider.trim();
-  const known = PROVIDER_LABELS[normalized.toLocaleLowerCase()];
+  const known = PROVIDER_LABELS[normalized.toLowerCase()];
   if (known) return known;
   return normalized
     .split(/[-_]+/u)
     .filter(Boolean)
-    .map((word) => PROVIDER_WORDS[word.toLocaleLowerCase()] ?? `${word.charAt(0).toLocaleUpperCase()}${word.slice(1)}`)
+    .map((word) => PROVIDER_WORDS[word.toLowerCase()] ?? `${word.charAt(0).toUpperCase()}${word.slice(1)}`)
     .join(" ") || "Unknown provider";
 }
 

package/killeros/goals.ts

@@ -291,7 +291,7 @@ async function stopGoalRun(runtime: GoalRuntime, ctx: ExtensionCommandContext, s
 }
 
 function goalStatusLabel(status: GoalStatus): string {
-  return `${status.charAt(0).toLocaleUpperCase()}${status.slice(1)}`;
+  return `${status.charAt(0).toUpperCase()}${status.slice(1)}`;
 }
 
 function goalPanelActions(status: GoalStatus): Array<{ label: string; control: "pause" | "resume" | "edit" | "clear" }> {
@@ -309,7 +309,7 @@ function goalPanelActions(status: GoalStatus): Array<{ label: string; control: "
 function goalStatusSummary(state: GoalState, ctx: ExtensionContext): string {
   const usedTokens = Math.max(0, sumGoalTokens(ctx) - state.baselineTokens);
   const lines = [
-    `Goal ${goalStatusLabel(state.status).toLocaleLowerCase()} · ${state.turns} turn${state.turns === 1 ? "" : "s"} · ${formatTime(goalElapsedMilliseconds(state))} · ${formatTokens(usedTokens)} tokens`,
+    `Goal ${goalStatusLabel(state.status).toLowerCase()} · ${state.turns} turn${state.turns === 1 ? "" : "s"} · ${formatTime(goalElapsedMilliseconds(state))} · ${formatTokens(usedTokens)} tokens`,
     state.objective,
   ];
   if (state.result) lines.push(state.result);
@@ -468,8 +468,6 @@ function completeAutomaticCompaction(
     runtime.automaticCompaction = undefined;
     return;
   }
-  runtime.automaticCompaction = "completed";
-  if (runtime.goalTurnInFlight || !ctx.isIdle()) return;
   runtime.automaticCompaction = undefined;
   setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
 }
@@ -708,7 +706,7 @@ export function registerGoal(
         return;
       }
       const input = args.trim();
-      const control = input.toLocaleLowerCase();
+      const control = input.toLowerCase();
       const isControl = control === "clear" || control === "edit" || control === "pause" || control === "resume";
 
       if (!input) {
@@ -1008,7 +1006,7 @@ export function registerGoal(
   pi.registerCommand("goal", {
     description: "Set or view the goal for a long-running task",
     getArgumentCompletions: (prefix) => {
-      const normalized = prefix.trimStart().toLocaleLowerCase();
+      const normalized = prefix.trimStart().toLowerCase();
       if (normalized.includes(" ")) return null;
       const actions = [
         { value: "clear", description: "Remove the current goal" },
@@ -1058,12 +1056,7 @@ export function registerGoalSettlement(
       const reason = runtime.lastError || "the agent turn was aborted";
       runtime.lastStopReason = undefined;
       runtime.lastError = undefined;
-      if (runtime.automaticCompaction !== undefined) {
-        if (runtime.automaticCompaction === "completed") {
-          completeAutomaticCompaction(pi, runtime, initState, ctx);
-        }
-        return;
-      }
+      if (runtime.automaticCompaction !== undefined) return;
       pauseGoalForPossibleManualCompaction(pi, runtime, ctx, reason);
       return;
     }
@@ -1080,10 +1073,7 @@ export function registerGoalSettlement(
   });
 
   pi.on("session_compact", (event, ctx) => {
-    if (runtime.automaticCompaction !== undefined) {
-      completeAutomaticCompaction(pi, runtime, initState, ctx);
-      return;
-    }
+    if (runtime.automaticCompaction !== undefined) return;
     if (event.reason !== "manual") return;
     recoverGoalAfterManualCompaction(pi, runtime, initState, ctx);
   });

package/killeros/init-evidence.ts

@@ -35,11 +35,11 @@ export interface InitEvidenceBuildResult {
 
 function evidenceKey(relativePath: string): string {
   const normalized = relativePath.replaceAll("\\", "/");
-  return process.platform === "win32" ? normalized.toLocaleLowerCase() : normalized;
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 
 function sensitiveEvidencePath(relativePath: string): boolean {
-  const normalized = relativePath.replaceAll("\\", "/").toLocaleLowerCase();
+  const normalized = relativePath.replaceAll("\\", "/").toLowerCase();
   const name = path.posix.basename(normalized);
   return /^\.env(?:\.|$)/u.test(name)
     || [".npmrc", ".pypirc", ".netrc", "id_rsa", "id_ed25519", "credentials.json"].includes(name)
@@ -50,8 +50,8 @@ function sensitiveEvidencePath(relativePath: string): boolean {
 function excludedPath(relativePath: string): boolean {
   const segments = relativePath.replaceAll("\\", "/").split("/");
   return segments.some((segment, index) =>
-    (index < segments.length - 1 && EXCLUDED_DIRS.has(segment.toLocaleLowerCase()))
-    || EXCLUDED_GUIDANCE.has(segment.toLocaleLowerCase()))
+    (index < segments.length - 1 && EXCLUDED_DIRS.has(segment.toLowerCase()))
+    || EXCLUDED_GUIDANCE.has(segment.toLowerCase()))
     || sensitiveEvidencePath(relativePath);
 }
 
@@ -74,7 +74,7 @@ async function collectCandidates(projectRoot: string): Promise<string[]> {
       if (files.length >= PATH_LIMIT) break;
       const relativePath = path.posix.join(current.relativePath.replaceAll("\\", "/"), entry.name);
       if (entry.isDirectory()) {
-        if (current.depth < DEPTH_LIMIT && !EXCLUDED_DIRS.has(entry.name.toLocaleLowerCase())) {
+        if (current.depth < DEPTH_LIMIT && !EXCLUDED_DIRS.has(entry.name.toLowerCase())) {
           queue.push({ relativePath, depth: current.depth + 1 });
         }
       } else if (entry.isFile() && !excludedPath(relativePath)) {

package/killeros/init.ts

@@ -76,7 +76,7 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
       if (!initState.active || !initState.evidence || !initState.targetPath || !initState.projectRoot) {
         throw new Error("killeros_init_read is available only during /init");
       }
-      const generatedTarget = initState.outcome.kind === "written" && requestedPath.replaceAll("\\", "/").toLocaleLowerCase() === "agents.md";
+      const generatedTarget = initState.outcome.kind === "written" && requestedPath.replaceAll("\\", "/").toLowerCase() === "agents.md";
       const text = generatedTarget
         ? await readGeneratedInitTarget(initState.projectRoot, initState.targetPath)
         : await readInitEvidence(initState.evidence, requestedPath);

package/killeros/question.ts

@@ -45,7 +45,7 @@ const QuestionParams = Type.Object({
   })),
 });
 
-export type QuestionParamsValue = Static<typeof QuestionParams>;
+type QuestionParamsValue = Static<typeof QuestionParams>;
 
 type NormalizedQuestionSelection =
   | { mode: "single"; minSelections: 1; maxSelections: 1 }
@@ -100,11 +100,7 @@ interface MultipleQuestionDetails {
   cancelled?: boolean;
 }
 
-export type QuestionDetails = SingleQuestionDetails | MultipleQuestionDetails;
-
-export interface QuestionRunner {
-  ask(params: QuestionParamsValue, signal: AbortSignal | undefined, ctx: ExtensionContext): Promise<QuestionDetails>;
-}
+type QuestionDetails = SingleQuestionDetails | MultipleQuestionDetails;
 
 type QuestionSelection =
   | { kind: "selected"; answer: string; originalIndex: number }
@@ -219,7 +215,7 @@ class MultipleResultText {
   invalidate(): void {}
 }
 
-export function registerQuestionTool(pi: ExtensionAPI): QuestionRunner {
+export function registerQuestionTool(pi: ExtensionAPI): void {
   const customInputHistory: string[] = [];
   let customInputHistoryBytes = 0;
   const clearCustomInputHistory = (): void => {
@@ -303,7 +299,7 @@ export function registerQuestionTool(pi: ExtensionAPI): QuestionRunner {
           const keyText = keybindings.getKeys(keybinding)
             .join("/")
             .split("/")
-            .map((key) => key.split("+").map((part) => process.platform === "darwin" && part.toLocaleLowerCase() === "alt" ? "option" : part).join("+"))
+            .map((key) => key.split("+").map((part) => process.platform === "darwin" && part.toLowerCase() === "alt" ? "option" : part).join("+"))
             .join("/");
           return theme.fg("dim", keyText) + theme.fg("muted", ` ${description}`);
         };
@@ -322,11 +318,11 @@ export function registerQuestionTool(pi: ExtensionAPI): QuestionRunner {
         customInputHistory.forEach((value) => editor.addToHistory(value));
 
         const filteredOptions = (): DisplayOption[] => {
-          const query = filterQuery.trim().toLocaleLowerCase();
+          const query = filterQuery.trim().toLowerCase();
           return options.filter((option) => option.isOther
             || query.length === 0
-            || option.label.toLocaleLowerCase().includes(query)
-            || option.description?.toLocaleLowerCase().includes(query));
+            || option.label.toLowerCase().includes(query)
+            || option.description?.toLowerCase().includes(query));
         };
         const selectedCount = (): number => selectedOriginalIndices.size + (customAnswer === undefined ? 0 : 1);
         const orderedMultipleSelection = () => {
@@ -763,12 +759,4 @@ export function registerQuestionTool(pi: ExtensionAPI): QuestionRunner {
     },
   };
   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/runtime.ts

@@ -57,7 +57,7 @@ export interface GoalRuntime {
   continuationHeld: boolean;
   goalTurnInFlight: boolean;
   agentEndObserved: boolean;
-  automaticCompaction?: "pending" | "completed";
+  automaticCompaction?: "pending";
   persistenceRetryNeeded: boolean;
   lastStopReason?: string;
   lastError?: string;

package/killeros/variants.ts

@@ -46,7 +46,7 @@ function isThinkingLevel(value: string): value is ThinkingLevel {
 }
 
 function resolveThinkingLevel(input: string): ThinkingLevel | undefined {
-  const normalized = input.trim().toLocaleLowerCase();
+  const normalized = input.trim().toLowerCase();
   return isThinkingLevel(normalized) ? normalized : LEVEL_ALIASES[normalized];
 }
 
@@ -144,7 +144,7 @@ export function registerVariants(pi: ExtensionAPI): void {
           const keyText = keybindings.getKeys(keybinding)
             .join("/")
             .split("/")
-            .map((key) => key.split("+").map((part) => process.platform === "darwin" && part.toLocaleLowerCase() === "alt" ? "option" : part).join("+"))
+            .map((key) => key.split("+").map((part) => process.platform === "darwin" && part.toLowerCase() === "alt" ? "option" : part).join("+"))
             .join("/");
           return theme.fg("dim", keyText) + theme.fg("muted", ` ${description}`);
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killeros",
-  "version": "2.0.10",
+  "version": "2.0.12",
   "description": "TUI, goals, and workflow automation for the Pi coding agent",
   "type": "module",
   "keywords": [
@@ -31,7 +31,7 @@
   },
   "scripts": {
     "check": "tsc --noEmit",
-    "test": "node --test --experimental-strip-types test/*.test.ts"
+    "test": "node --test --experimental-strip-types test/*.test.*"
   },
   "pi": {
     "extensions": [
@@ -42,9 +42,9 @@
     ]
   },
   "peerDependencies": {
-    "@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",
     "typebox": ">=1.1.38 <2"
   },
   "devDependencies": {

package/killeros/decision-gated-workflow.ts

@@ -1,76 +0,0 @@
-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/workflow-gate.ts

@@ -1,365 +0,0 @@
-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;
-  /** The existing single explicit skill activation API. */
-  activation?: string;
-  /** Additional explicit skill activations that share this adapter policy. */
-  activations?: readonly 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;
-    activation: string;
-    abortController: AbortController;
-    token: symbol;
-  }
-  | { kind: "active"; adapter: WorkflowAdapter; activation: string; policy: WorkflowPolicy; token: symbol }
-  | { kind: "terminal_cleanup"; adapter: WorkflowAdapter; activation: string; reason: WorkflowTerminalReason; token: symbol };
-
-const ACTIVATION_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/u;
-
-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.activation,
-    };
-  }
-  if (state.kind === "terminal_cleanup") {
-    return {
-      kind: state.kind,
-      adapterId: state.adapter.id,
-      activation: state.activation,
-      reason: state.reason,
-    };
-  }
-  return {
-    kind: state.kind,
-    adapterId: state.adapter.id,
-    activation: state.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 (adapter.activations !== undefined && !Array.isArray(adapter.activations)) {
-      throw new Error(`Workflow adapter ${adapter.id} activations must be an array`);
-    }
-    const activations = [
-      ...(adapter.activation === undefined ? [] : [adapter.activation]),
-      ...(adapter.activations ?? []),
-    ];
-    if (activations.length === 0) {
-      throw new Error(`Workflow adapter ${adapter.id} must register at least one explicit skill activation`);
-    }
-    for (const activation of activations) {
-      if (typeof activation !== "string" || !ACTIVATION_PATTERN.test(activation)) {
-        throw new Error(`Invalid decision-gated workflow activation: ${activation}`);
-      }
-      if (adaptersByActivation.has(activation)) {
-        throw new Error(`Duplicate decision-gated workflow activation: ${activation}`);
-      }
-      adaptersByActivation.set(activation, adapter);
-    }
-    if (adapter.policies.length === 0) throw new Error(`Workflow adapter ${adapter.id} has no policies`);
-  }
-
-  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,
-      activation: current.activation,
-      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) => {
-    if ((state.kind === "pending_decision" || state.kind === "terminal_cleanup") && event.text.startsWith("/skill:")) {
-      notify(ctx, "A decision-gated workflow is waiting for its structured question; skill routing is blocked", "warning");
-      return { action: "handled" };
-    }
-    const activation = explicitSkillActivation(event.text);
-    if (!activation) return;
-
-    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, activation, 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, activation, 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 };