killeros 2.1.22 → 2.1.23

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to KillerOS are documented here.
 
 ## [Unreleased]
 
+## [2.1.23] - 2026-09-04
+
+### Changed
+
+- Simplified `/goal` to five forms with proof-by-prose and silent file proof, removing configured completion checks.
+
+### Fixed
+
+- Kept the automatic 20-turn goal pause silent as documented.
+- Stripped sentence punctuation from unquoted inferred goal paths and picked token units after rounding so 999.6 shows as 1k and 999999 as 1M.
+- Increased change-receipt Git timeouts to five seconds and stopped timeout failures from showing warning notifications.
+
 ## [2.1.22] - 2026-09-03
 
 ### Added

package/README.md

@@ -5,7 +5,7 @@ A TypeScript extension for the [Pi coding agent](https://github.com/earendil-wor
 ## What you get
 
 - A custom TUI: startup card with version, model, provider, working directory, and Git branch; a dark theme with coral accents; a multiline editor with slash-command completion; a footer that tracks model, context, and goal state; settled task receipts with duration and token usage.
-- `/goal`: set an objective and Pi keeps working toward it across turns, compaction, reloads, and branch navigation. New goals default to 20 turns. Named checks and turn limits control completion and unattended work.
+- `/goal`: set an objective and Pi keeps working toward it across turns, compaction, reloads, and branch navigation. New goals pause after 20 turns; `/goal resume` grants another 20.
 - `/init`: generates a root `AGENTS.md` from repository evidence, preserving compatible existing rules.
 - `/variants`: pick a reasoning level supported by the active model.
 - `/codex-fast`: toggles the `priority` service tier on Codex requests.
@@ -34,19 +34,17 @@ Or from GitHub:
 pi install git:github.com/KyrosHendrix/pi-KillerOS
 ```
 
-Pin a release by appending its tag, for example `@v2.1.22`. Add `-l` to install only for the current project. Restart Pi after installing.
+Pin a release by appending its tag, for example `@v2.1.23`. Add `-l` to install only for the current project. Restart Pi after installing.
 
 ## Commands
 
 ```text
 /init                     Generate root AGENTS.md from repository evidence
-/goal                     Open status, or set with /goal <objective>
-/goal start [--check name] [--turns count] -- <objective>
-/goal check <name|clear>  Set or clear a named completion check
-/goal checks              List configured completion-check names
-/goal limit <count|clear> Set a limit or clear it for unlimited turns
-/goal history [count]     Show transitions and blocker evidence on this branch
-/goal edit|pause|resume|clear
+/goal                     View the current goal
+/goal <objective>        Set an objective
+/goal pause               Stop automatic continuation
+/goal resume              Resume automatic continuation
+/goal clear               Remove the current goal
 /variants                 Reasoning-level selector (/variants high sets directly)
 /codex-fast               Toggle Codex fast mode
 /notification             Configure the completion sound
@@ -60,7 +58,7 @@ Pin a release by appending its tag, for example `@v2.1.22`. Add `-l` to install
 | Mode | What works |
 | --- | --- |
 | TUI | Everything |
-| RPC | Goals, proactive compaction; no TUI components, `/goal edit`, `/init`, sounds, title indicator |
+| RPC | Goals, proactive compaction; no TUI components, `/init`, sounds, title indicator |
 | Print/JSON | No interactive questions, `/goal`, `/init`, or proactive compaction |
 
 ## Configuration
@@ -79,22 +77,19 @@ The packaged `killeros` theme activates on TUI start. Compaction triggers by def
 
 `handoffMaxTokens` caps the `/handoff` summary output at 8192 tokens by default; raise it when long sessions truncate the summary.
 
-Trusted projects can define up to 32 named goal checks in `.pi/killeros-hooks.json`:
+State proof in the objective so the agent can verify it with its normal tools:
 
-```json
-{
-  "goalChecks": {
-    "quality": {
-      "command": "npm run check && npm test",
-      "timeoutMs": 300000
-    }
-  }
-}
+```text
+/goal Reduce p95 checkout latency below 120 ms, verified by the checkout benchmark, while keeping the correctness suite green
 ```
 
-Use `/goal checks` to list configured names. Use `/goal start -- <objective>` when an objective begins with `start`, `check`, `checks`, `limit`, `history`, `clear`, `edit`, `pause`, or `resume`. Bind a check with `/goal start --check quality -- <objective>` or `/goal check quality`. KillerOS stores the check name and definition hash, not the command. If the project changes the command or timeout, bind the check again before completing the goal.
+A direct quoted file target binds silent file proof:
+
+```text
+/goal Fix `killeros/footer.ts`, verified by npm test
+```
 
-New goals use a 20-turn limit unless `/goal start --turns <count> -- <objective>` supplies another value. Use `/goal limit <count>` to change the current goal or `/goal limit clear` to allow unlimited turns. Restored goals keep their persisted limit.
+KillerOS captures the file baseline at goal start and only completes when the file is created or changed. New goals pause after 20 turns without warning. An explicit `/goal resume` on an exhausted goal grants another 20 turns; compaction recovery never grants turns. Restored goals keep their persisted limit.
 
 Completion sounds are off by default; change with `/notification` in TUI mode. The tab-title indicator requires a Nerd Font.
 

package/killeros/change-receipt.ts

@@ -5,7 +5,7 @@ import path from "node:path";
 import { promisify } from "node:util";
 import { inflate } from "node:zlib";
 
-const GIT_TIMEOUT_MS = 1_000;
+const GIT_TIMEOUT_MS = 5_000;
 const GIT_OUTPUT_LIMIT = 16 * 1024 * 1024;
 const SNAPSHOT_CONTENT_LIMIT = 128 * 1024 * 1024;
 const MAX_DIFF_OPERATIONS = 500_000;

package/killeros/commands.ts

@@ -70,7 +70,7 @@ const BUILTIN_COMMANDS: ReadonlyArray<{ name: string; description: string }> = [
 ];
 
 const COMMAND_SYNTAX_HINTS: Readonly<Record<string, string>> = {
-  goal: "/goal [objective|start|check|checks|limit|history|clear|edit|pause|resume]",
+  goal: "/goal [objective|pause|resume|clear]",
   handoff: "/handoff [next-session focus]",
   variants: "/variants [level]",
   model: "/model [provider/model]",

package/killeros/display.ts

@@ -40,12 +40,14 @@ export function formatTime(milliseconds: number): string {
 
 export function formatTokens(value: number): string {
   if (!Number.isFinite(value)) return "0";
-  const amount = Math.max(0, value);
-  if (amount < 1_000) return `${Math.round(amount)}`;
-  if (amount >= 1_000_000) {
-    const precision = amount >= 10_000_000 ? 0 : 1;
-    return `${Number((amount / 1_000_000).toFixed(precision))}M`;
+  const rounded = Math.round(Math.max(0, value));
+  if (rounded < 1_000) return `${rounded}`;
+  if (rounded >= 1_000_000) {
+    const precision = rounded >= 10_000_000 ? 0 : 1;
+    return `${Number((rounded / 1_000_000).toFixed(precision))}M`;
   }
-  const precision = amount >= 100_000 ? 0 : 1;
-  return `${Number((amount / 1_000).toFixed(precision))}k`;
+  const precision = rounded >= 100_000 ? 0 : 1;
+  const inK = Number((rounded / 1_000).toFixed(precision));
+  if (inK >= 1_000) return `${Number((rounded / 1_000_000).toFixed(1))}M`;
+  return `${inK}k`;
 }

package/killeros/goal-command.ts

@@ -1,120 +1,23 @@
-import { parseArgs } from "node:util";
-import { GOAL_CHECK_NAME_PATTERN, GOAL_MAX_TURNS, validateGoalObjective } from "./goal-state.ts";
-
-const GOAL_START_USAGE = "Usage: /goal start [--check <name>] [--turns <count>] -- <objective>";
-const GOAL_CHECK_USAGE = "Usage: /goal check <name|clear>";
-const GOAL_CHECKS_USAGE = "Usage: /goal checks";
-const GOAL_LIMIT_USAGE = "Usage: /goal limit <count|clear>";
-const GOAL_HISTORY_USAGE = "Usage: /goal history [count]";
-const RESERVED_OBJECTIVE_USAGE = "Objective begins with a reserved goal command. Use /goal start -- <objective>.";
-
-interface ControlledGoalStart {
-  objective: string;
-  completionCheckName?: string;
-  maxTurns?: number;
-}
+import { validateGoalObjective } from "./goal-state.ts";
 
 export type GoalCommand =
   | { kind: "status" }
   | { kind: "objective"; objective: string }
-  | { kind: "start"; objective: string; completionCheckName?: string; maxTurns?: number }
-  | { kind: "check"; value: { kind: "clear" } | { kind: "named"; name: string } }
-  | { kind: "checks" }
-  | { kind: "limit"; value: { kind: "clear" } | { kind: "count"; count: number } }
-  | { kind: "history"; count: number }
-  | { kind: "clear" }
-  | { kind: "edit" }
   | { kind: "pause" }
   | { kind: "resume" }
+  | { kind: "clear" }
   | { kind: "invalid"; message: string };
 
-const RESERVED_GOAL_WORDS = ["start", "check", "checks", "limit", "history", "clear", "edit", "pause", "resume"] as const;
-
-function parseBoundedInteger(value: string, maximum: number): number | undefined {
-  if (!/^[1-9][0-9]*$/u.test(value)) return undefined;
-  const parsed = Number(value);
-  return Number.isSafeInteger(parsed) && parsed <= maximum ? parsed : undefined;
-}
-
-function parseControlledGoalStart(input: string): ControlledGoalStart | undefined {
-  const separator = input.startsWith("-- ") ? 0 : input.indexOf(" -- ");
-  if (separator < 0) return undefined;
-  const optionText = input.slice(0, separator).trim();
-  const objective = validateGoalObjective(input.slice(separator + (separator === 0 ? 3 : 4)));
-  if (!objective) return undefined;
-  const tokens = optionText ? optionText.split(/\s+/u) : [];
-  if (tokens.filter((token) => token === "--check" || token.startsWith("--check=")).length > 1
-    || tokens.filter((token) => token === "--turns" || token.startsWith("--turns=")).length > 1) return undefined;
-  try {
-    const parsed = parseArgs({
-      args: tokens,
-      options: { check: { type: "string" }, turns: { type: "string" } },
-      strict: true,
-      allowPositionals: false,
-    });
-    const check = parsed.values.check;
-    const turns = parsed.values.turns;
-    if (check !== undefined && !GOAL_CHECK_NAME_PATTERN.test(check)) return undefined;
-    const maxTurns = turns === undefined ? undefined : parseBoundedInteger(turns, GOAL_MAX_TURNS);
-    if (turns !== undefined && maxTurns === undefined) return undefined;
-    return {
-      objective,
-      ...(check === undefined ? {} : { completionCheckName: check }),
-      ...(maxTurns === undefined ? {} : { maxTurns }),
-    };
-  } catch {
-    return undefined;
-  }
-}
-
 /** Parses one raw /goal argument string into a closed command variant. */
 export function parseGoalCommand(args: string): GoalCommand {
   const input = args.trim();
   if (!input) return { kind: "status" };
-  const parts = input.split(/\s+/u);
-  const rawFirstWord = parts[0] ?? "";
-  const firstWord = RESERVED_GOAL_WORDS.find((word) => word === rawFirstWord.toLowerCase());
-  if (!firstWord) {
-    const objective = validateGoalObjective(input);
-    return objective
-      ? { kind: "objective", objective }
-      : { kind: "invalid", message: "A goal objective may not exceed 4,000 characters" };
-  }
-
-  if (firstWord === "start") {
-    const start = parseControlledGoalStart(input.slice(rawFirstWord.length).trimStart());
-    if (start) return { kind: "start", ...start };
-    return { kind: "invalid", message: rawFirstWord === firstWord ? GOAL_START_USAGE : RESERVED_OBJECTIVE_USAGE };
-  }
-  if (firstWord === "check") {
-    const value = parts[1];
-    if (parts.length === 2 && value?.toLowerCase() === "clear") return { kind: "check", value: { kind: "clear" } };
-    if (parts.length === 2 && value && GOAL_CHECK_NAME_PATTERN.test(value)) return { kind: "check", value: { kind: "named", name: value } };
-    return { kind: "invalid", message: rawFirstWord !== firstWord && parts.length > 2 ? RESERVED_OBJECTIVE_USAGE : GOAL_CHECK_USAGE };
-  }
-  if (firstWord === "checks") {
-    return parts.length === 1
-      ? { kind: "checks" }
-      : { kind: "invalid", message: rawFirstWord === firstWord ? GOAL_CHECKS_USAGE : RESERVED_OBJECTIVE_USAGE };
-  }
-  if (firstWord === "limit") {
-    const value = parts[1];
-    if (parts.length === 2 && value?.toLowerCase() === "clear") return { kind: "limit", value: { kind: "clear" } };
-    const count = parts.length === 2 && value ? parseBoundedInteger(value, GOAL_MAX_TURNS) : undefined;
-    if (count !== undefined) return { kind: "limit", value: { kind: "count", count } };
-    return { kind: "invalid", message: rawFirstWord !== firstWord && parts.length > 2 ? RESERVED_OBJECTIVE_USAGE : GOAL_LIMIT_USAGE };
-  }
-  if (firstWord === "history") {
-    if (parts.length === 1) return { kind: "history", count: 20 };
-    const count = parts.length === 2 && parts[1] ? parseBoundedInteger(parts[1], 50) : undefined;
-    if (count !== undefined) return { kind: "history", count };
-    return { kind: "invalid", message: rawFirstWord !== firstWord && parts.length > 2 ? RESERVED_OBJECTIVE_USAGE : GOAL_HISTORY_USAGE };
-  }
-  if (parts.length === 1) return { kind: firstWord };
-  return {
-    kind: "invalid",
-    message: rawFirstWord === firstWord
-      ? `Usage: /goal ${firstWord}`
-      : RESERVED_OBJECTIVE_USAGE,
-  };
+  const lowered = input.toLowerCase();
+  if (lowered === "pause") return { kind: "pause" };
+  if (lowered === "resume") return { kind: "resume" };
+  if (lowered === "clear") return { kind: "clear" };
+  const objective = validateGoalObjective(input);
+  return objective
+    ? { kind: "objective", objective }
+    : { kind: "invalid", message: "A goal objective may not exceed 4,000 characters" };
 }

package/killeros/goal-interface.ts

@@ -6,11 +6,9 @@ import { BoundedText } from "./bounded-text.ts";
 import { formatTime, formatTokens } from "./display.ts";
 import { reportError } from "./errors.ts";
 import { parseGoalCommand } from "./goal-command.ts";
-import { formatGoalHistory } from "./goal-history.ts";
-import { GOAL_ENTRY_TYPE, GOAL_UPDATE_TOOL, goalBranchEntries, isGoalModeSupported, isSavedSession, pauseGoalAfterFailure, persistGoalState, scheduleGoalContinuation, stopGoalRun, sumGoalTokens, syncGoalUpdateTool, transitionGoal, type GoalEntryData } from "./goal-runtime.ts";
-import { checkpointPausedGoalState, createNewGoalState, DEFAULT_GOAL_MAX_TURNS, editGoalState, goalElapsedMilliseconds, GOAL_VERSION, inferGoalVerification, parseGoalState, pauseGoalState, recordGoalBlockerAudit, updateGoalControlsState, validateGoalObjective, verifyGoalDeliverable } from "./goal-state.ts";
-import { listGoalCompletionChecks, resolveGoalCompletionCheck, runGoalCompletionCheck } from "./hooks.ts";
-import type { GoalCompletionCheck, GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
+import { GOAL_ENTRY_TYPE, GOAL_UPDATE_TOOL, isGoalModeSupported, isSavedSession, pauseGoalAfterFailure, persistGoalState, scheduleGoalContinuation, stopGoalRun, sumGoalTokens, syncGoalUpdateTool, transitionGoal, type GoalEntryData } from "./goal-runtime.ts";
+import { checkpointPausedGoalState, createNewGoalState, DEFAULT_GOAL_MAX_TURNS, GOAL_MAX_TURNS, goalElapsedMilliseconds, GOAL_VERSION, inferGoalVerification, parseGoalState, recordGoalBlockerAudit, transitionGoalState, verifyGoalDeliverable } from "./goal-state.ts";
+import type { GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
 import { safeTerminalText } from "./safe-terminal-text.ts";
 
 const GoalUpdateParams = Type.Object({
@@ -33,7 +31,7 @@ const GoalUpdateParams = Type.Object({
 interface GoalUpdateDetails {
   status: "complete" | "blocked" | "blocker-audit";
   evidence: string;
-  verification?: "file" | "check" | "file-and-check" | "model-reported";
+  verification?: "file" | "model-reported";
   blockerKey?: string;
   streak?: number;
 }
@@ -42,17 +40,12 @@ function goalStatusLabel(status: GoalStatus): string {
   return `${status.charAt(0).toUpperCase()}${status.slice(1)}`;
 }
 
-function goalPanelActions(status: GoalStatus): Array<{ label: string; control: "checks" | "pause" | "resume" | "edit" | "clear" }> {
-  const terminal = [
-    { label: "List completion checks", control: "checks" as const },
-    { label: "Edit objective", control: "edit" as const },
-    { label: "Clear goal", control: "clear" as const },
-  ];
-  if (status === "active") return [{ label: "Pause automatic continuation", control: "pause" }, ...terminal];
+function goalPanelActions(status: GoalStatus): Array<{ label: string; control: "pause" | "resume" | "clear" }> {
+  if (status === "active") return [{ label: "Pause automatic continuation", control: "pause" }, { label: "Clear goal", control: "clear" }];
   if (status === "paused" || status === "blocked") {
-    return [{ label: "Resume automatic continuation", control: "resume" }, ...terminal];
+    return [{ label: "Resume automatic continuation", control: "resume" }, { label: "Clear goal", control: "clear" }];
   }
-  return terminal;
+  return [{ label: "Clear goal", control: "clear" }];
 }
 
 function goalStatusSummary(state: GoalState, ctx: ExtensionContext): string {
@@ -62,7 +55,7 @@ function goalStatusSummary(state: GoalState, ctx: ExtensionContext): string {
     : `${state.turns}/${state.maxTurns} turns`;
   const lines = [
     `Goal ${goalStatusLabel(state.status).toLowerCase()} · ${turns} · ${formatTime(goalElapsedMilliseconds(state, Date.now()))} · ${formatTokens(usedTokens)} tokens`,
-    ...(state.completionCheck === undefined ? [] : [`Check: ${state.completionCheck.name}`]),
+    ...(state.verification === undefined ? [] : [`Deliverable: ${state.verification.path}`]),
     state.objective,
   ];
   if (state.result) lines.push(state.result);
@@ -105,21 +98,13 @@ export function registerGoalInterface(
       if (!evidence) throw new Error("Goal evidence must not be empty");
       if (params.status === "complete") {
         if (state.verification) await verifyGoalDeliverable(state.verification);
-        if (state.completionCheck) await runGoalCompletionCheck(ctx, state.completionCheck, signal);
-        if (state.verification && state.completionCheck) await verifyGoalDeliverable(state.verification);
         if (runtime.state !== state) throw new Error("Goal changed while completion was being verified");
-        const verification = state.verification && state.completionCheck
-          ? "file-and-check"
-          : state.verification ? "file" : state.completionCheck ? "check" : "model-reported";
+        const verification = state.verification ? "file" : "model-reported";
         transitionGoal(pi, runtime, "complete", "complete", evidence, { resetBlockedAudit: true });
         const safeEvidence = safeTerminalText(evidence);
-        const text = state.verification && state.completionCheck
-          ? `Goal verified complete by file and ${state.completionCheck.name}: ${safeEvidence}`
-          : state.completionCheck
-            ? `Goal verified complete by ${state.completionCheck.name}: ${safeEvidence}`
-            : state.verification
-              ? `Goal verified complete at ${safeTerminalText(state.verification.path)}: ${safeEvidence}`
-              : `Goal marked complete (model-reported): ${safeEvidence}`;
+        const text = state.verification
+          ? `Goal verified complete at ${safeTerminalText(state.verification.path)}: ${safeEvidence}`
+          : `Goal marked complete (model-reported): ${safeEvidence}`;
         return {
           content: [{ type: "text", text }],
           details: { status: "complete", evidence, verification },
@@ -198,99 +183,6 @@ export function registerGoalInterface(
         return;
       }
 
-      if (command.kind === "history") {
-        const history = formatGoalHistory(goalBranchEntries(ctx), command.count);
-        ctx.ui.notify(history ?? "No goal history on the current branch.", "info");
-        return;
-      }
-
-      if (command.kind === "checks") {
-        try {
-          const checks = listGoalCompletionChecks(ctx);
-          ctx.ui.notify(checks.length
-            ? `Goal completion checks: ${checks.join(", ")}`
-            : "No goal completion checks are configured.", "info");
-        } catch (error) {
-          reportError(ctx, "Goal completion checks could not be listed", error);
-        }
-        return;
-      }
-
-      if (command.kind === "check" || command.kind === "limit") {
-        if (initState.active) {
-          ctx.ui.notify(`Wait for /init to finish before changing goal ${command.kind}`, "error");
-          return;
-        }
-        const maxTurns = command.kind === "limit" && command.value.kind === "count" ? command.value.count : undefined;
-        const current = runtime.state;
-        if (!current) {
-          ctx.ui.notify("No goal is set", "info");
-          return;
-        }
-        if (current.status === "complete") {
-          ctx.ui.notify("The goal is complete. Set a new objective or use /goal edit.", "info");
-          return;
-        }
-        let completionCheck: GoalCompletionCheck | undefined = current.completionCheck;
-        if (command.kind === "check") {
-          try {
-            completionCheck = command.value.kind === "clear" ? undefined : resolveGoalCompletionCheck(ctx, command.value.name);
-          } catch (error) {
-            reportError(ctx, "Goal completion check could not be set", error);
-            return;
-          }
-        }
-        runtime.continuationHeld = true;
-        try {
-          await ctx.waitForIdle();
-        } catch (error) {
-          runtime.continuationHeld = false;
-          reportError(ctx, "Goal could not wait for the active turn", error);
-          scheduleGoalContinuation(pi, runtime, initState, ctx);
-          return;
-        }
-        runtime.continuationHeld = false;
-        const latest = runtime.state;
-        if (!latest || latest.status === "complete") {
-          ctx.ui.notify(latest?.status === "complete" ? "The goal completed before its controls changed." : "No goal is set", "info");
-          return;
-        }
-        if (command.kind === "check" && command.value.kind === "named") {
-          try {
-            completionCheck = resolveGoalCompletionCheck(ctx, command.value.name);
-          } catch (error) {
-            reportError(ctx, "Goal completion check could not be set", error);
-            scheduleGoalContinuation(pi, runtime, initState, ctx);
-            return;
-          }
-        } else if (command.kind === "check") {
-          completionCheck = undefined;
-        } else {
-          completionCheck = latest.completionCheck;
-        }
-        const nextLimit = command.kind === "limit" ? maxTurns : latest.maxTurns;
-        let next = updateGoalControlsState(latest, { completionCheck, ...(nextLimit === undefined ? {} : { maxTurns: nextLimit }) }, Date.now());
-        const exhausted = next.status === "active" && next.maxTurns !== undefined && next.turns >= next.maxTurns;
-        if (exhausted) next = pauseGoalState(next, `Turn limit reached (${next.turns}/${next.maxTurns}).`, Date.now());
-        try {
-          persistGoalState(pi, runtime, command.kind, next);
-          runtime.continuationScheduled = false;
-          if (exhausted) {
-            ctx.ui.notify(`Goal paused: turn limit reached (${next.turns}/${next.maxTurns})`, "warning");
-          } else {
-            const message = command.kind === "check"
-              ? completionCheck ? `Goal completion check set to ${completionCheck.name}` : "Goal completion check cleared"
-              : next.maxTurns === undefined ? "Goal turn limit cleared" : `Goal turn limit set to ${next.maxTurns}`;
-            ctx.ui.notify(message, "info");
-            scheduleGoalContinuation(pi, runtime, initState, ctx);
-          }
-        } catch (error) {
-          reportError(ctx, `Goal ${command.kind} could not be changed`, error);
-          scheduleGoalContinuation(pi, runtime, initState, ctx);
-        }
-        return;
-      }
-
       if (command.kind === "clear") {
         if (!runtime.state) {
           ctx.ui.notify("No goal is set", "info");
@@ -401,17 +293,30 @@ export function registerGoalInterface(
           return;
         }
         if (runtime.state.status === "complete") {
-          ctx.ui.notify("The goal is complete. Set a new objective or use /goal edit.", "info");
-          return;
-        }
-        if (runtime.state.maxTurns !== undefined && runtime.state.turns >= runtime.state.maxTurns) {
-          ctx.ui.notify(`Goal turn limit reached (${runtime.state.turns}/${runtime.state.maxTurns}). Raise or clear it before resuming.`, "warning");
+          ctx.ui.notify("The goal is complete. Set a new objective.", "info");
           return;
         }
         if (runtime.state.status === "active") {
           ctx.ui.notify("Goal is already active", "info");
           return;
         }
+        const currentMax = runtime.state.maxTurns;
+        if (currentMax !== undefined && runtime.state.turns >= currentMax) {
+          if (runtime.state.turns >= GOAL_MAX_TURNS) {
+            ctx.ui.notify(`Goal reached the lifetime limit (${runtime.state.turns}/${GOAL_MAX_TURNS}). Set a new objective.`, "warning");
+            return;
+          }
+          const renewed = Math.min(Math.max(currentMax, runtime.state.turns) + DEFAULT_GOAL_MAX_TURNS, GOAL_MAX_TURNS);
+          try {
+            const base = transitionGoalState(runtime.state, "active", undefined, { resetBlockedAudit: true }, Date.now());
+            persistGoalState(pi, runtime, "resume", { ...base, maxTurns: renewed });
+            runtime.continuationScheduled = false;
+            if (scheduleGoalContinuation(pi, runtime, initState, ctx)) ctx.ui.notify("Goal resumed", "info");
+          } catch (error) {
+            reportError(ctx, "Goal could not be resumed", error);
+          }
+          return;
+        }
         try {
           transitionGoal(pi, runtime, "resume", "active", undefined, { resetBlockedAudit: true });
           runtime.continuationScheduled = false;
@@ -422,80 +327,12 @@ export function registerGoalInterface(
         return;
       }
 
-      if (command.kind === "edit") {
-        if (initState.active) {
-          ctx.ui.notify("Wait for /init to finish before editing a goal", "error");
-          return;
-        }
-        if (!runtime.state) {
-          ctx.ui.notify("No goal is set", "info");
-          return;
-        }
-        if (ctx.mode !== "tui") {
-          ctx.ui.notify("/goal edit requires interactive TUI mode", "error");
-          return;
-        }
-        runtime.continuationHeld = true;
-        let waitError: unknown;
-        try {
-          await ctx.waitForIdle();
-        } catch (error) {
-          waitError = error;
-        } finally {
-          runtime.continuationHeld = false;
-        }
-        if (waitError) {
-          reportError(ctx, "Goal could not wait for the active turn", waitError);
-          scheduleGoalContinuation(pi, runtime, initState, ctx);
-          return;
-        }
-        const edited = await ctx.ui.editor("Edit long-running goal", runtime.state.objective);
-        if (edited === undefined) {
-          scheduleGoalContinuation(pi, runtime, initState, ctx);
-          return;
-        }
-        const objective = validateGoalObjective(edited);
-        if (!objective) {
-          ctx.ui.notify(edited.trim() ? "A goal objective may not exceed 4,000 characters" : "A goal objective may not be empty", "error");
-          scheduleGoalContinuation(pi, runtime, initState, ctx);
-          return;
-        }
-        let verification: Awaited<ReturnType<typeof inferGoalVerification>>;
-        try {
-          verification = await inferGoalVerification(objective);
-        } catch (error) {
-          reportError(ctx, "Goal verification could not be inferred", error);
-          scheduleGoalContinuation(pi, runtime, initState, ctx);
-          return;
-        }
-        const next = editGoalState(runtime.state, objective, verification, Date.now());
-        try {
-          persistGoalState(pi, runtime, "edit", next);
-          runtime.continuationScheduled = false;
-          if (scheduleGoalContinuation(pi, runtime, initState, ctx)) ctx.ui.notify("Goal updated and active", "info");
-        } catch (error) {
-          if (runtime.state?.status === "active") {
-            pauseGoalAfterFailure(
-              pi,
-              runtime,
-              ctx,
-              `Goal could not be edited: ${error instanceof Error ? error.message : String(error)}`,
-              "Automatic continuation is stopped. Retry /goal edit after session storage recovers.",
-            );
-          } else {
-            reportError(ctx, "Goal could not be edited", error);
-          }
-        }
-        return;
-      }
-
       if (initState.active) {
         ctx.ui.notify("Wait for /init to finish before starting a goal", "error");
         return;
       }
       switch (command.kind) {
         case "objective":
-        case "start":
           break;
         default: {
           const unhandled: never = command;
@@ -503,17 +340,6 @@ export function registerGoalInterface(
         }
       }
       const objective = command.objective;
-      const controlledStart = command.kind === "start" ? command : undefined;
-
-      let completionCheck: GoalCompletionCheck | undefined;
-      if (controlledStart?.completionCheckName) {
-        try {
-          completionCheck = resolveGoalCompletionCheck(ctx, controlledStart.completionCheckName);
-        } catch (error) {
-          reportError(ctx, "Goal completion check could not be resolved", error);
-          return;
-        }
-      }
 
       const unfinished = runtime.state && runtime.state.status !== "complete";
       if (unfinished) {
@@ -539,14 +365,21 @@ export function registerGoalInterface(
         scheduleGoalContinuation(pi, runtime, initState, ctx);
         return;
       }
+      let verification: Awaited<ReturnType<typeof inferGoalVerification>>;
       try {
-        if (controlledStart?.completionCheckName) {
-          completionCheck = resolveGoalCompletionCheck(ctx, controlledStart.completionCheckName);
+        verification = await inferGoalVerification(objective, ctx.cwd);
+      } catch (error) {
+        if (!unfinished) {
+          reportError(ctx, "Goal could not be started", error);
+        } else {
+          reportError(ctx, "Goal could not be replaced", error);
+          scheduleGoalContinuation(pi, runtime, initState, ctx);
         }
-        const verification = await inferGoalVerification(objective);
+        return;
+      }
+      try {
         const state = createNewGoalState(objective, sumGoalTokens(ctx), verification, Date.now(), {
-          ...(completionCheck === undefined ? {} : { completionCheck }),
-          maxTurns: controlledStart?.maxTurns ?? DEFAULT_GOAL_MAX_TURNS,
+          maxTurns: DEFAULT_GOAL_MAX_TURNS,
         });
         persistGoalState(pi, runtime, unfinished ? "replace" : "set", state);
         if (scheduleGoalContinuation(pi, runtime, initState, ctx)) {
@@ -573,23 +406,11 @@ export function registerGoalInterface(
     description: "Set a non-command objective or view the current goal",
     getArgumentCompletions: (prefix) => {
       const normalized = prefix.trimStart().toLowerCase();
-      const actions = normalized.startsWith("start ")
-        ? [
-            { value: "start --check ", description: "Bind a named completion check" },
-            { value: "start --turns ", description: "Set a goal turn limit" },
-            { value: "start -- ", description: "Start a goal with strict syntax" },
-          ]
-        : [
-            { value: "clear", description: "Remove the current goal" },
-            { value: "edit", description: "Edit and reactivate the current goal" },
-            { value: "pause", description: "Stop automatic continuation" },
-            { value: "resume", description: "Resume automatic continuation" },
-            { value: "start", description: "Start with optional controls" },
-            { value: "check", description: "Set or clear a completion check" },
-            { value: "checks", description: "List completion checks" },
-            { value: "limit", description: "Set or clear a turn limit" },
-            { value: "history", description: "Show goal history" },
-          ];
+      const actions = [
+        { value: "clear", description: "Remove the current goal" },
+        { value: "pause", description: "Stop automatic continuation" },
+        { value: "resume", description: "Resume automatic continuation" },
+      ];
       return actions
         .filter((action) => action.value.startsWith(normalized))
         .map((action) => ({ ...action, label: action.value.trimEnd() }));

package/killeros/goal-runtime.ts

@@ -9,7 +9,7 @@ export const GOAL_ENTRY_TYPE = "killeros-goal";
 const GOAL_CONTINUATION_TYPE = "killeros-goal-continuation";
 export const GOAL_UPDATE_TOOL = "killeros_goal_update";
 
-export type GoalEntryEvent = "set" | "replace" | "edit" | "check" | "limit" | "turn" | "pause" | "resume" | "blocked" | "complete" | "error" | "clear" | "checkpoint" | "blocker-audit";
+export type GoalEntryEvent = "set" | "replace" | "limit" | "turn" | "pause" | "resume" | "blocked" | "complete" | "error" | "clear" | "checkpoint" | "blocker-audit";
 export interface GoalEntryData {
   version: 1;
   event: GoalEntryEvent;
@@ -125,14 +125,12 @@ export function pauseGoalAtTurnLimit(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
   ctx: ExtensionContext,
-  notify = true,
 ): boolean {
   const state = runtime.state;
   if (state?.status !== "active" || state.maxTurns === undefined || state.turns < state.maxTurns) return false;
   const result = `Turn limit reached (${state.turns}/${state.maxTurns}).`;
   try {
     transitionGoal(pi, runtime, "limit", "paused", result);
-    if (notify) ctx.ui.notify(`Goal paused: turn limit reached (${state.turns}/${state.maxTurns})`, "warning");
   } catch (error) {
     pauseGoalAfterFailure(pi, runtime, ctx, `turn limit pause could not be saved: ${error instanceof Error ? error.message : String(error)}`);
   }

package/killeros/goal-state.ts

@@ -2,12 +2,11 @@ import { createHash } from "node:crypto";
 import type { Stats } from "node:fs";
 import { lstat, open, type FileHandle } from "node:fs/promises";
 import path from "node:path";
-import type { GoalBlockerAudit, GoalCompletionCheck, GoalFileBaseline, GoalFileVerification, GoalState, GoalStateCommon, GoalStatus } from "./runtime.ts";
+import type { GoalBlockerAudit, GoalFileBaseline, GoalFileVerification, GoalState, GoalStateCommon, GoalStatus } from "./runtime.ts";
 
 export const DEFAULT_GOAL_MAX_TURNS = 20;
 export const GOAL_OBJECTIVE_LIMIT = 4_000;
 export const GOAL_MAX_TURNS = 10_000;
-export const GOAL_CHECK_NAME_PATTERN = /^[a-z0-9][a-z0-9._-]{0,63}$/u;
 export const GOAL_VERSION = 1;
 const FILE_HASH_CHUNK_SIZE = 64 * 1024;
 export const FILE_HASH_LIMIT = 64 * 1024 * 1024;
@@ -64,6 +63,14 @@ function isAbsoluteFilePath(value: string): boolean {
   return path.isAbsolute(value) || path.win32.isAbsolute(value);
 }
 
+function stripUnquotedPathPunctuation(value: string): string {
+  const pathWithoutMarks = value.replace(/[.!?]+$/u, "");
+  const trailingClosers = pathWithoutMarks.match(/\)+$/u)?.[0].length ?? 0;
+  const unmatchedClosers = Math.max(0, pathWithoutMarks.split(")").length - pathWithoutMarks.split("(").length);
+  const punctuationLength = Math.min(trailingClosers, unmatchedClosers);
+  return pathWithoutMarks.slice(0, punctuationLength ? -punctuationLength : undefined);
+}
+
 function isGoalFileVerification(value: unknown): value is GoalFileVerification {
   return isUnknownRecord(value)
     && value.kind === "file"
@@ -73,15 +80,6 @@ function isGoalFileVerification(value: unknown): value is GoalFileVerification {
     && isGoalFileBaseline(value.baseline);
 }
 
-function isGoalCompletionCheck(value: unknown): value is GoalCompletionCheck {
-  return isUnknownRecord(value)
-    && value.kind === "named-command"
-    && typeof value.name === "string"
-    && GOAL_CHECK_NAME_PATTERN.test(value.name)
-    && typeof value.configHash === "string"
-    && /^[a-f0-9]{64}$/u.test(value.configHash);
-}
-
 function isMaxTurns(value: unknown): value is number {
   return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= GOAL_MAX_TURNS;
 }
@@ -118,7 +116,6 @@ export function parseGoalState(value: unknown): GoalState | undefined {
     resumeAfterManualCompaction,
     blockerAudit,
     verification,
-    completionCheck,
     maxTurns,
   } = value;
   if (version !== GOAL_VERSION
@@ -134,7 +131,6 @@ export function parseGoalState(value: unknown): GoalState | undefined {
     || !safeNonNegativeInteger(baselineTokens)
     || result !== undefined && typeof result !== "string"
     || verification !== undefined && !isGoalFileVerification(verification)
-    || completionCheck !== undefined && !isGoalCompletionCheck(completionCheck)
     || maxTurns !== undefined && !isMaxTurns(maxTurns)
     || resumeAfterManualCompaction !== undefined && resumeAfterManualCompaction !== true
     || blockerAudit !== undefined && !isGoalBlockerAudit(blockerAudit, turns, status)) {
@@ -152,7 +148,6 @@ export function parseGoalState(value: unknown): GoalState | undefined {
     blockedAuditStartTurn: blockedAuditStartTurn ?? 0,
     baselineTokens,
     ...(verification === undefined ? {} : { verification }),
-    ...(completionCheck === undefined ? {} : { completionCheck }),
     ...(maxTurns === undefined ? {} : { maxTurns }),
   };
   switch (status) {
@@ -238,13 +233,26 @@ export async function captureGoalFileBaseline(
   }
 }
 
-/** Captures one explicit absolute output path so goal completion can verify its creation or modification. */
-export async function inferGoalVerification(objective: string): Promise<GoalFileVerification | undefined> {
+/** Captures one explicit output path so goal completion can verify its creation or modification. */
+export async function inferGoalVerification(objective: string, cwd: string): Promise<GoalFileVerification | undefined> {
+  const candidates: string[] = [];
   const destination = /\b(?:create|write|save|generate)\b[^\r\n]{0,160}?\b(?:file|document|markdown|report|spreadsheet|presentation|image)\b\s+(?:to|at|as|destination(?:\s+is)?|output(?:\s+(?:to|at))?)\b\s*(?:`([^`\r\n]+)`|"([^"\r\n]+)"|'([^'\r\n]+)'|([A-Za-z]:\\[^\s,;]+|\/[^\s,;]+))/giu;
-  const paths = [...objective.matchAll(destination)]
-    .map((match) => (match[1] ?? match[2] ?? match[3] ?? match[4] ?? "").trim())
-    .filter(isAbsoluteFilePath);
-  const unique = [...new Set(paths)];
+  for (const match of objective.matchAll(destination)) {
+    const quoted = match[1] ?? match[2] ?? match[3];
+    candidates.push(quoted !== undefined ? quoted.trim() : stripUnquotedPathPunctuation((match[4] ?? "").trim()));
+  }
+  const direct = /\b(?:update|edit|fix|refactor|migrate)\s+(`([^`\r\n]+)`|"([^"\r\n]+)"|'([^'\r\n]+)')/giu;
+  for (const match of objective.matchAll(direct)) {
+    const quoted = match[2] ?? match[3] ?? match[4];
+    if (quoted !== undefined) candidates.push(quoted.trim());
+  }
+  const resolved: string[] = [];
+  for (const raw of candidates) {
+    if (!raw || /^(?:https?|file):\/\//iu.test(raw) || /[\\\/]$/u.test(raw)) continue;
+    const absolute = path.isAbsolute(raw) || path.win32.isAbsolute(raw) ? raw : path.resolve(cwd, raw);
+    if (isAbsoluteFilePath(absolute)) resolved.push(absolute);
+  }
+  const unique = [...new Set(resolved)];
   const filePath = unique.length === 1 ? unique[0] : undefined;
   return filePath ? { kind: "file", path: filePath, baseline: await captureGoalFileBaseline(filePath) } : undefined;
 }
@@ -302,7 +310,6 @@ export function commonGoalState(state: GoalState): GoalStateCommon {
     blockedAuditStartTurn: state.blockedAuditStartTurn,
     baselineTokens: state.baselineTokens,
     ...(state.verification === undefined ? {} : { verification: state.verification }),
-    ...(state.completionCheck === undefined ? {} : { completionCheck: state.completionCheck }),
     ...(state.maxTurns === undefined ? {} : { maxTurns: state.maxTurns }),
   };
 }
@@ -319,7 +326,7 @@ export function createNewGoalState(
   baselineTokens: number,
   verification: GoalFileVerification | undefined,
   now: number,
-  controls: { completionCheck?: GoalCompletionCheck; maxTurns?: number } = {},
+  controls: { maxTurns?: number } = {},
 ): GoalState {
   return {
     version: GOAL_VERSION,
@@ -334,71 +341,10 @@ export function createNewGoalState(
     blockedAuditStartTurn: 0,
     baselineTokens,
     ...(verification === undefined ? {} : { verification }),
-    ...(controls.completionCheck === undefined ? {} : { completionCheck: controls.completionCheck }),
     ...(controls.maxTurns === undefined ? {} : { maxTurns: controls.maxTurns }),
   };
 }
 
-export function editGoalState(
-  state: GoalState,
-  objective: string,
-  verification: GoalFileVerification | undefined,
-  now: number,
-): GoalState {
-  const current = stopGoalClock(state, now);
-  const { verification: _previousVerification, ...common } = current;
-  return {
-    ...common,
-    revision: current.revision + 1,
-    objective,
-    status: "active",
-    updatedAt: now,
-    activeStartedAt: now,
-    blockedAuditStartTurn: current.turns,
-    ...(verification === undefined ? {} : { verification }),
-  };
-}
-
-export function updateGoalControlsState(
-  state: Exclude<GoalState, { status: "complete" }>,
-  controls: { completionCheck?: GoalCompletionCheck; maxTurns?: number },
-  now: number,
-): GoalState {
-  const stopped = stopGoalClock(state, now);
-  const { completionCheck: _completionCheck, maxTurns: _maxTurns, ...common } = stopped;
-  const nextCommon: GoalStateCommon = {
-    ...common,
-    revision: common.revision + 1,
-    updatedAt: now,
-    ...(controls.completionCheck === undefined ? {} : { completionCheck: controls.completionCheck }),
-    ...(controls.maxTurns === undefined ? {} : { maxTurns: controls.maxTurns }),
-  };
-  if (state.status === "active") {
-    return {
-      ...nextCommon,
-      status: "active",
-      activeStartedAt: now,
-      ...(state.result === undefined ? {} : { result: state.result }),
-      ...(state.blockerAudit === undefined ? {} : { blockerAudit: state.blockerAudit }),
-    };
-  }
-  if (state.status === "paused") {
-    return {
-      ...nextCommon,
-      status: "paused",
-      ...(state.result === undefined ? {} : { result: state.result }),
-      ...(state.blockerAudit === undefined ? {} : { blockerAudit: state.blockerAudit }),
-      ...(state.resumeAfterManualCompaction === undefined ? {} : { resumeAfterManualCompaction: true }),
-    };
-  }
-  return {
-    ...nextCommon,
-    status: "blocked",
-    result: state.result,
-    ...(state.blockerAudit === undefined ? {} : { blockerAudit: state.blockerAudit }),
-  };
-}
-
 export function beginGoalTurnState(
   current: Extract<GoalState, { status: "active" }>,
   now: number,

package/killeros/hooks.ts

@@ -1,4 +1,3 @@
-import { createHash } from "node:crypto";
 import {
   spawn,
   type SpawnOptionsWithStdioTuple,
@@ -9,8 +8,6 @@ import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { CONFIG_DIR_NAME, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { errorMessage, reportError } from "./errors.ts";
-import { GOAL_CHECK_NAME_PATTERN } from "./goal-state.ts";
-import type { GoalCompletionCheck } from "./runtime.ts";
 import { safeTerminalText } from "./safe-terminal-text.ts";
 
 type KillerosHookEvent = "tool_call" | "tool_result" | "agent_settled";
@@ -21,14 +18,8 @@ interface KillerosHook {
   timeoutMs?: number;
 }
 
-interface KillerosGoalCheck {
-  command: string;
-  timeoutMs?: number;
-}
-
 interface KillerosHookConfig {
   hooks?: Partial<Record<KillerosHookEvent, KillerosHook[]>>;
-  goalChecks?: Record<string, KillerosGoalCheck>;
 }
 
 interface HookExecutionResult {
@@ -70,8 +61,6 @@ const HOOK_OUTPUT_LIMIT = 16 * 1024;
 const HOOK_PAYLOAD_LIMIT = 8_000;
 const HOOK_TIMEOUT_DEFAULT_MS = 30_000;
 const HOOK_TIMEOUT_MAX_MS = 300_000;
-const GOAL_CHECK_LIMIT = 32;
-const GOAL_CHECK_COMMAND_LIMIT = 8_000;
 
 // Reads executable project configuration through a bounded, project-local file descriptor.
 function readHookConfig(configPath: string, projectRoot: string): string {
@@ -122,12 +111,11 @@ function isUnknownRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function loadKillerosConfig(ctx: ExtensionContext, strictGoalChecks = false): KillerosHookConfig {
+function loadKillerosConfig(ctx: ExtensionContext): KillerosHookConfig {
   const configPath = path.join(ctx.cwd, CONFIG_DIR_NAME, "killeros-hooks.json");
   if (!existsSync(configPath)) return {};
   const displayPath = safeTerminalText(configPath).replaceAll("\n", "");
   if (!ctx.isProjectTrusted()) {
-    if (strictGoalChecks) throw new Error("Goal completion checks require a trusted project");
     ctx.ui.notify(`Ignored untrusted project hooks in ${displayPath}`, "warning");
     return {};
   }
@@ -181,34 +169,8 @@ function loadKillerosConfig(ctx: ExtensionContext, strictGoalChecks = false): Ki
       hooks[event] = accepted;
     }
 
-    let goalChecks: Record<string, KillerosGoalCheck> | undefined;
-    try {
-      const candidates = parsed.goalChecks;
-      if (candidates !== undefined) {
-        if (!isUnknownRecord(candidates)) throw new Error("goalChecks must contain a JSON object");
-        const entries = Object.entries(candidates);
-        if (entries.length > GOAL_CHECK_LIMIT) throw new Error(`goalChecks may contain at most ${GOAL_CHECK_LIMIT} checks`);
-        goalChecks = {};
-        for (const [name, candidate] of entries) {
-          if (!GOAL_CHECK_NAME_PATTERN.test(name)) throw new Error(`Invalid goal check name: ${JSON.stringify(name)}`);
-          if (!isUnknownRecord(candidate)) throw new Error(`Goal check ${name} must contain a JSON object`);
-          const { command, timeoutMs } = candidate;
-          if (typeof command !== "string" || command.trim().length < 1 || command.trim().length > GOAL_CHECK_COMMAND_LIMIT) {
-            throw new Error(`Goal check ${name} command must contain 1 to ${GOAL_CHECK_COMMAND_LIMIT} characters`);
-          }
-          if (timeoutMs !== undefined && (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > HOOK_TIMEOUT_MAX_MS)) {
-            throw new Error(`Goal check ${name} timeoutMs must be an integer from 1 to ${HOOK_TIMEOUT_MAX_MS}`);
-          }
-          goalChecks[name] = { command: command.trim(), ...(timeoutMs === undefined ? {} : { timeoutMs }) };
-        }
-      }
-    } catch (error) {
-      if (strictGoalChecks) throw error;
-      reportError(ctx, `Invalid ${CONFIG_DIR_NAME}/killeros-hooks.json goalChecks`, error);
-    }
-    return { hooks, ...(goalChecks === undefined ? {} : { goalChecks }) };
+    return { hooks };
   } catch (error) {
-    if (strictGoalChecks) throw error;
     reportError(ctx, `Invalid ${CONFIG_DIR_NAME}/killeros-hooks.json`, error);
     return {};
   }
@@ -427,48 +389,6 @@ function hookFailureMessage(result: HookExecutionResult): string {
   return safeTerminalText(`Hook failed${result.timedOut ? " (timed out)" : ""}${result.exitUnconfirmed ? " (process exit unconfirmed)" : ""}\n${detail}`);
 }
 
-function goalCheckHash(check: KillerosGoalCheck): string {
-  return createHash("sha256")
-    .update(JSON.stringify({ command: check.command, timeoutMs: check.timeoutMs ?? HOOK_TIMEOUT_DEFAULT_MS }))
-    .digest("hex");
-}
-
-/** Lists validated completion-check names without exposing their definitions. */
-export function listGoalCompletionChecks(ctx: ExtensionContext): readonly string[] {
-  if (!ctx.isProjectTrusted()) throw new Error("Goal completion checks require a trusted project");
-  return Object.keys(loadKillerosConfig(ctx, true).goalChecks ?? {}).sort();
-}
-
-export function resolveGoalCompletionCheck(ctx: ExtensionContext, name: string): GoalCompletionCheck {
-  if (!GOAL_CHECK_NAME_PATTERN.test(name)) throw new Error("Invalid goal completion check name");
-  if (!ctx.isProjectTrusted()) throw new Error("Goal completion checks require a trusted project");
-  const check = loadKillerosConfig(ctx, true).goalChecks?.[name];
-  if (!check) throw new Error(`Unknown goal completion check: ${safeTerminalText(name)}`);
-  return { kind: "named-command", name, configHash: goalCheckHash(check) };
-}
-
-export async function runGoalCompletionCheck(
-  ctx: ExtensionContext,
-  bound: GoalCompletionCheck,
-  signal?: AbortSignal,
-): Promise<void> {
-  if (!ctx.isProjectTrusted()) throw new Error("Goal completion checks require a trusted project");
-  const check = loadKillerosConfig(ctx, true).goalChecks?.[bound.name];
-  if (!check) throw new Error(`Unknown goal completion check: ${safeTerminalText(bound.name)}`);
-  if (goalCheckHash(check) !== bound.configHash) {
-    throw new Error(`Goal completion check ${safeTerminalText(bound.name)} changed; run /goal check ${safeTerminalText(bound.name)} to approve it`);
-  }
-  const result = await executeHook({
-    command: check.command,
-    cwd: ctx.cwd,
-    environment: { KILLEROS_EVENT: "goal_check", KILLEROS_GOAL_CHECK: bound.name },
-    timeoutMs: check.timeoutMs,
-    signal,
-  });
-  if (result.cancelled) throw new Error(`Goal completion check ${safeTerminalText(bound.name)} was cancelled`);
-  if (result.code !== 0) throw new Error(hookFailureMessage(result).replace(/^Hook failed/u, `Goal completion check ${safeTerminalText(bound.name)} failed`));
-}
-
 export function registerLifecycleHooks(pi: ExtensionAPI): void {
   let config: KillerosHookConfig = {};
   pi.on("session_start", (_event, ctx) => { config = loadKillerosConfig(ctx); });

package/killeros/runtime.ts

@@ -39,12 +39,6 @@ export interface GoalFileVerification {
   baseline: GoalFileBaseline;
 }
 
-export interface GoalCompletionCheck {
-  kind: "named-command";
-  name: string;
-  configHash: string;
-}
-
 export interface GoalStateCommon {
   version: 1;
   revision: number;
@@ -56,7 +50,6 @@ export interface GoalStateCommon {
   blockedAuditStartTurn: number;
   baselineTokens: number;
   verification?: GoalFileVerification;
-  completionCheck?: GoalCompletionCheck;
   maxTurns?: number;
 }
 

package/killeros/worked-for.ts

@@ -348,7 +348,7 @@ export function registerWorkedFor(
     const settled = active;
     active = undefined;
     const changes = await (await settled.collection).finish();
-    if (changes.state === "unavailable" && changes.reason !== "not-git" && !collectionNoticeShown) {
+    if (changes.state === "unavailable" && changes.reason !== "not-git" && changes.reason !== "timeout" && !collectionNoticeShown) {
       collectionNoticeShown = true;
       ctx.ui.notify(`Change receipt unavailable: ${changes.reason}`, "warning");
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "killeros",
-  "version": "2.1.22",
+  "version": "2.1.23",
   "description": "TUI, goals, and workflow automation for the Pi coding agent",
   "type": "module",
   "keywords": [

package/killeros/goal-history.ts

@@ -1,71 +0,0 @@
-import { formatTime, formatTokens } from "./display.ts";
-import { parseGoalState } from "./goal-state.ts";
-import type { GoalState } from "./runtime.ts";
-import { safeTerminalText } from "./safe-terminal-text.ts";
-
-const GOAL_ENTRY_TYPE = "killeros-goal";
-const VALID_GOAL_EVENTS: ReadonlySet<string> = new Set([
-  "set", "replace", "edit", "check", "limit", "turn", "pause", "resume",
-  "blocker-audit", "blocked", "complete", "error", "clear", "checkpoint",
-]);
-function isUnknownRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function tokenUsage(entry: Record<string, unknown>): number | undefined {
-  if (entry.type === "message" && isUnknownRecord(entry.message)
-    && (entry.message.role === "assistant" || entry.message.role === "toolResult")
-    && isUnknownRecord(entry.message.usage)
-    && typeof entry.message.usage.totalTokens === "number"
-    && Number.isFinite(entry.message.usage.totalTokens)
-    && entry.message.usage.totalTokens >= 0) {
-    return entry.message.usage.totalTokens;
-  }
-  if ((entry.type === "compaction" || entry.type === "branch_summary")
-    && isUnknownRecord(entry.usage)
-    && typeof entry.usage.totalTokens === "number"
-    && Number.isFinite(entry.usage.totalTokens)
-    && entry.usage.totalTokens >= 0) {
-    return entry.usage.totalTokens;
-  }
-  return undefined;
-}
-
-function preview(value: string): string {
-  const safe = safeTerminalText(value).replaceAll("\n", " ").trim();
-  const characters = [...safe];
-  return characters.length <= 160 ? safe : `${characters.slice(0, 159).join("")}…`;
-}
-
-function eventDetail(event: string, state: GoalState): string {
-  if (event === "check") return state.completionCheck ? `check ${state.completionCheck.name}` : "check cleared";
-  if (event === "limit") return state.maxTurns === undefined ? "limit cleared" : `limit ${state.maxTurns}`;
-  if (event === "blocker-audit" && state.blockerAudit) {
-    return `Blocker ${state.blockerAudit.streak}/3: ${state.blockerAudit.evidence ?? state.blockerAudit.key}`;
-  }
-  return state.result || state.objective;
-}
-
-/** Projects branch entries into the latest bounded goal-history rows. */
-export function formatGoalHistory(entries: readonly unknown[], count: number): string | undefined {
-  const lines: string[] = [];
-  let tokens = 0;
-  let previousState: GoalState | undefined;
-  for (const value of entries) {
-    if (!isUnknownRecord(value)) continue;
-    const usage = tokenUsage(value);
-    if (usage !== undefined) {
-      tokens += usage;
-      continue;
-    }
-    if (value.type !== "custom" || value.customType !== GOAL_ENTRY_TYPE || !isUnknownRecord(value.data)) continue;
-    const event = value.data.event;
-    if (typeof event !== "string" || !VALID_GOAL_EVENTS.has(event)) continue;
-    const state = value.data.state === null ? previousState : parseGoalState(value.data.state);
-    if (!state) continue;
-    if (value.data.state !== null) previousState = state;
-    if (event === "turn" || event === "checkpoint") continue;
-    lines.push(`+${formatTime(Math.max(0, state.updatedAt - state.createdAt))}  ${event}  turn ${state.turns}  ${formatTokens(Math.max(0, tokens - state.baselineTokens))} tokens  ${preview(eventDetail(event, state))}`);
-  }
-  return lines.length ? lines.slice(-count).join("\n") : undefined;
-}