killeros 2.0.5 → 2.0.7

package/killeros/goals.ts

@@ -1,4 +1,6 @@
 import { StringEnum } from "@earendil-works/pi-ai";
+import { lstatSync } from "node:fs";
+import path from "node:path";
 import { type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
@@ -7,10 +9,11 @@ import { BoundedText } from "./bounded-text.ts";
 import { formatTime, formatTokens } from "./display.ts";
 import { reportError } from "./errors.ts";
 import { resolvePersonalInstructions } from "./personal-instructions.ts";
-import type { GoalBlockerAudit, GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
+import type { GoalBlockerAudit, GoalFileVerification, GoalRuntime, GoalState, GoalStatus, InitRuntime } from "./runtime.ts";
 
 const GOAL_ENTRY_TYPE = "killeros-goal";
 const GOAL_CONTINUATION_TYPE = "killeros-goal-continuation";
+const GOAL_UPDATE_TOOL = "killeros_goal_update";
 const GOAL_OBJECTIVE_LIMIT = 4_000;
 const GOAL_VERSION = 1;
 
@@ -29,7 +32,6 @@ interface GoalTransitionOptions {
 
 interface RestoredGoalState {
   state?: GoalState;
-  recoveryProven: boolean;
 }
 
 const GoalUpdateParams = Type.Object({
@@ -52,6 +54,7 @@ const GoalUpdateParams = Type.Object({
 interface GoalUpdateDetails {
   status: "complete" | "blocked" | "blocker-audit";
   evidence: string;
+  verification?: "file" | "model-reported";
   blockerKey?: string;
   streak?: number;
 }
@@ -64,6 +67,41 @@ function finiteNonNegative(value: unknown): value is number {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
 
+function isGoalFileVerification(value: unknown): value is GoalFileVerification {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<GoalFileVerification>;
+  return candidate.kind === "file"
+    && typeof candidate.path === "string"
+    && candidate.path === candidate.path.trim()
+    && isAbsoluteFilePath(candidate.path);
+}
+
+function isAbsoluteFilePath(value: string): boolean {
+  if (!value || /^(?:https?|file):\/\//iu.test(value) || /[\\\/]$/u.test(value)) return false;
+  return path.isAbsolute(value) || path.win32.isAbsolute(value);
+}
+
+function inferGoalVerification(objective: string): GoalFileVerification | undefined {
+  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)];
+  return unique.length === 1 ? { kind: "file", path: unique[0]! } : undefined;
+}
+
+function verifyGoalDeliverable(verification: GoalFileVerification): void {
+  let artifact: ReturnType<typeof lstatSync>;
+  try {
+    artifact = lstatSync(verification.path);
+  } catch {
+    throw new Error(`Goal deliverable is not a regular file at the required path: ${verification.path}`);
+  }
+  if (!artifact.isFile()) {
+    throw new Error(`Goal deliverable is not a regular file at the required path: ${verification.path}`);
+  }
+}
+
 function isGoalBlockerAudit(value: unknown, turns: number, status: GoalStatus): value is GoalBlockerAudit {
   if (!value || typeof value !== "object") return false;
   const candidate = value as Partial<GoalBlockerAudit>;
@@ -92,6 +130,7 @@ function parseGoalState(value: unknown): GoalState | undefined {
     || !finiteNonNegative(candidate.baselineTokens)
     || candidate.activeStartedAt !== undefined && !finiteNonNegative(candidate.activeStartedAt)
     || candidate.result !== undefined && typeof candidate.result !== "string"
+    || candidate.verification !== undefined && !isGoalFileVerification(candidate.verification)
     || candidate.blockerAudit !== undefined && !isGoalBlockerAudit(candidate.blockerAudit, candidate.turns!, candidate.status)
     || candidate.resumeAfterManualCompaction !== undefined && candidate.resumeAfterManualCompaction !== true
     || candidate.resumeAfterManualCompaction === true && candidate.status !== "paused") {
@@ -112,6 +151,7 @@ function parseGoalState(value: unknown): GoalState | undefined {
     result: candidate.result,
     resumeAfterManualCompaction: candidate.resumeAfterManualCompaction,
     blockerAudit: candidate.blockerAudit,
+    verification: candidate.verification,
   };
 }
 
@@ -130,19 +170,17 @@ function restoreGoalState(ctx: ExtensionContext): RestoredGoalState {
     if (entry?.type !== "custom" || entry.customType !== GOAL_ENTRY_TYPE) continue;
     const data = entry.data as Partial<GoalEntryData> | undefined;
     if (!data || data.version !== GOAL_VERSION || data.state === null) {
-      return { state: undefined, recoveryProven: false };
+      return { state: undefined };
     }
     const restored = parseGoalState(data.state);
-    if (!restored) return { state: undefined, recoveryProven: false };
+    if (!restored) return { state: undefined };
     const state = restored.status === "active"
       ? { ...restored, activeStartedAt: Date.now() }
       : { ...restored, activeStartedAt: undefined };
-    const recoveryProven = state.status === "paused"
-      && state.resumeAfterManualCompaction === true
-      && entries.slice(index + 1).some((candidate) => candidate.type === "compaction");
-    return { state, recoveryProven };
+    if (state.status === "paused") state.resumeAfterManualCompaction = undefined;
+    return { state };
   }
-  return { state: undefined, recoveryProven: false };
+  return { state: undefined };
 }
 
 export function goalElapsedMilliseconds(state: GoalState, now = Date.now()): number {
@@ -173,6 +211,21 @@ function sumGoalTokens(ctx: ExtensionContext): number {
   return total;
 }
 
+function setGoalUpdateToolActive(pi: ExtensionAPI, active: boolean): void {
+  const api = pi as ExtensionAPI & { getActiveTools?: () => string[]; setActiveTools?: (names: string[]) => void };
+  if (!api.getActiveTools || !api.setActiveTools) return;
+  const activeTools = api.getActiveTools();
+  const isActive = activeTools.includes(GOAL_UPDATE_TOOL);
+  if (active === isActive) return;
+  api.setActiveTools(active
+    ? [...activeTools, GOAL_UPDATE_TOOL]
+    : activeTools.filter((name) => name !== GOAL_UPDATE_TOOL));
+}
+
+function syncGoalUpdateTool(pi: ExtensionAPI, runtime: GoalRuntime): void {
+  setGoalUpdateToolActive(pi, runtime.state?.status === "active");
+}
+
 function persistGoalState(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
@@ -182,6 +235,7 @@ function persistGoalState(
   const data: GoalEntryData = { version: GOAL_VERSION, event, state: state ?? null };
   pi.appendEntry(GOAL_ENTRY_TYPE, data);
   runtime.state = state;
+  syncGoalUpdateTool(pi, runtime);
   runtime.persistenceRetryNeeded = false;
   runtime.requestRender?.();
 }
@@ -276,6 +330,7 @@ export function pauseGoalAfterFailure(
       result: reason,
       resumeAfterManualCompaction: undefined,
     } : undefined;
+    syncGoalUpdateTool(pi, runtime);
     runtime.persistenceRetryNeeded = true;
     runtime.continuationScheduled = false;
     runtime.requestRender?.();
@@ -301,6 +356,7 @@ function pauseGoalForPossibleManualCompaction(
       result: reason,
       resumeAfterManualCompaction: true,
     } : undefined;
+    syncGoalUpdateTool(pi, runtime);
     runtime.persistenceRetryNeeded = true;
     runtime.continuationScheduled = false;
     runtime.requestRender?.();
@@ -333,6 +389,34 @@ function recoverGoalAfterManualCompaction(
   return true;
 }
 
+function beginGoalTurn(
+  pi: ExtensionAPI,
+  runtime: GoalRuntime,
+  ctx: ExtensionContext,
+  current: GoalState,
+): GoalState | undefined {
+  const now = Date.now();
+  const next: GoalState = {
+    ...current,
+    revision: current.revision + 1,
+    turns: current.turns + 1,
+    updatedAt: now,
+    activeStartedAt: current.activeStartedAt ?? now,
+    resumeAfterManualCompaction: undefined,
+  };
+  try {
+    persistGoalState(pi, runtime, "turn", next);
+  } catch (error) {
+    pauseGoalAfterFailure(pi, runtime, ctx, `turn state could not be saved: ${error instanceof Error ? error.message : String(error)}`);
+    return undefined;
+  }
+  runtime.goalTurnInFlight = true;
+  runtime.agentEndObserved = false;
+  runtime.lastStopReason = undefined;
+  runtime.lastError = undefined;
+  return next;
+}
+
 function scheduleGoalContinuation(
   pi: ExtensionAPI,
   runtime: GoalRuntime,
@@ -348,16 +432,13 @@ function scheduleGoalContinuation(
     || initState.active
     || !ctx.isIdle()
     || ctx.hasPendingMessages()) return false;
-  const current = runtime.state;
   runtime.continuationScheduled = true;
-  runtime.goalTurnInFlight = false;
-  runtime.agentEndObserved = false;
-  runtime.lastStopReason = undefined;
-  runtime.lastError = undefined;
+  const next = beginGoalTurn(pi, runtime, ctx, runtime.state);
+  if (!next) return false;
   try {
     pi.sendMessage({
       customType: GOAL_CONTINUATION_TYPE,
-      content: goalContinuationMessage(current, ctx),
+      content: goalContinuationMessage(next, ctx),
       display: false,
     }, { triggerTurn: true, deliverAs: "followUp" });
     return true;
@@ -440,7 +521,7 @@ export function registerGoal(
   });
 
   pi.registerTool<typeof GoalUpdateParams, GoalUpdateDetails>({
-    name: "killeros_goal_update",
+    name: GOAL_UPDATE_TOOL,
     label: "Goal update",
     description: "Mark the active KillerOS long-running goal complete after verification, or record the same blocker key on three consecutive goal turns before blocking it.",
     parameters: GoalUpdateParams,
@@ -453,10 +534,14 @@ export function registerGoal(
       const evidence = params.evidence.trim();
       if (!evidence) throw new Error("Goal evidence must not be empty");
       if (params.status === "complete") {
+        if (state.verification) verifyGoalDeliverable(state.verification);
+        const verification = state.verification ? "file" : "model-reported";
         transitionGoal(pi, runtime, "complete", "complete", evidence, { resetBlockedAudit: true });
         return {
-          content: [{ type: "text", text: `Goal marked complete: ${evidence}` }],
-          details: { status: "complete", evidence },
+          content: [{ type: "text", text: state.verification
+            ? `Goal verified complete at ${state.verification.path}: ${evidence}`
+            : `Goal marked complete (model-reported): ${evidence}` }],
+          details: { status: "complete", evidence, verification },
         };
       }
       if (!runtime.goalTurnInFlight) throw new Error("A blocker audit can only be recorded during an active KillerOS goal turn");
@@ -491,7 +576,12 @@ export function registerGoal(
     renderCall(args, theme) {
       return new Text(`${theme.fg("toolTitle", theme.bold("goal "))}${theme.fg("muted", args.status)}`, 0, 0);
     },
-    renderResult(result, options, theme) {
+    renderResult(result, options, theme, context) {
+      if (context?.isError) {
+        const first = result.content[0];
+        const message = first?.type === "text" ? first.text : "Goal update failed";
+        return new BoundedText(theme.fg("error", message), options.expanded ? undefined : 3);
+      }
       const details = result.details;
       if (!details) return new BoundedText(theme.fg("dim", "Goal updated"));
       const label = details.status === "complete" ? "✓ Complete" : details.status === "blocked" ? "! Blocked" : `! Blocker audit ${details.streak}/3`;
@@ -502,7 +592,8 @@ export function registerGoal(
 
   const restoreGoal = (ctx: ExtensionContext): void => {
     const restored = restoreGoalState(ctx);
-    runtime.state = restored.state;
+    runtime.state = isGoalModeSupported(ctx) ? restored.state : undefined;
+    syncGoalUpdateTool(pi, runtime);
     runtime.continuationScheduled = false;
     runtime.continuationHeld = false;
     runtime.goalTurnInFlight = false;
@@ -511,9 +602,7 @@ export function registerGoal(
     runtime.lastStopReason = undefined;
     runtime.lastError = undefined;
     runtime.requestRender?.();
-    if (restored.recoveryProven) {
-      recoverGoalAfterManualCompaction(pi, runtime, initState, ctx);
-    } else if (runtime.state?.status === "active") {
+    if (runtime.state?.status === "active") {
       setImmediate(() => scheduleGoalContinuation(pi, runtime, initState, ctx));
     }
   };
@@ -536,6 +625,7 @@ export function registerGoal(
       }
     }
     runtime.state = undefined;
+    syncGoalUpdateTool(pi, runtime);
     runtime.continuationScheduled = false;
     runtime.continuationHeld = false;
     runtime.goalTurnInFlight = false;
@@ -550,25 +640,8 @@ export function registerGoal(
     const current = runtime.state;
     if (!isGoalModeSupported(ctx) || !isSavedSession(ctx) || !current || current.status !== "active" || initState.active) return;
     if (runtime.goalTurnInFlight) return { systemPrompt: `${event.systemPrompt}\n\n${goalSystemPrompt(current)}` };
-    const now = Date.now();
-    const next: GoalState = {
-      ...current,
-      revision: current.revision + 1,
-      turns: current.turns + 1,
-      updatedAt: now,
-      activeStartedAt: current.activeStartedAt ?? now,
-      resumeAfterManualCompaction: undefined,
-    };
-    try {
-      persistGoalState(pi, runtime, "turn", next);
-    } catch (error) {
-      pauseGoalAfterFailure(pi, runtime, ctx, `turn state could not be saved: ${error instanceof Error ? error.message : String(error)}`);
-      return;
-    }
-    runtime.goalTurnInFlight = true;
-    runtime.agentEndObserved = false;
-    runtime.lastStopReason = undefined;
-    runtime.lastError = undefined;
+    const next = beginGoalTurn(pi, runtime, ctx, current);
+    if (!next) return;
     return { systemPrompt: `${event.systemPrompt}\n\n${goalSystemPrompt(next)}` };
   });
 
@@ -672,6 +745,7 @@ export function registerGoal(
             ctx.ui.notify("Goal pause saved. Goal remains paused. Automatic compaction recovery is off.", "info");
           } catch (error) {
             runtime.state = checkpoint;
+            syncGoalUpdateTool(pi, runtime);
             runtime.persistenceRetryNeeded = true;
             runtime.continuationScheduled = false;
             runtime.requestRender?.();
@@ -790,6 +864,7 @@ export function registerGoal(
           activeStartedAt: now,
           blockedAuditStartTurn: current.turns,
           blockerAudit: undefined,
+          verification: inferGoalVerification(objective),
           result: undefined,
           resumeAfterManualCompaction: undefined,
         };
@@ -861,6 +936,7 @@ export function registerGoal(
         turns: 0,
         blockedAuditStartTurn: 0,
         baselineTokens: sumGoalTokens(ctx),
+        verification: inferGoalVerification(objective),
       };
       try {
         persistGoalState(pi, runtime, unfinished ? "replace" : "set", state);

package/killeros/init.ts

@@ -133,8 +133,10 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
 
   pi.on("session_start", () => setInitTools(pi, initState, false));
   pi.on("session_shutdown", () => {
+    const settle = initState.settle;
     setInitTools(pi, initState, false);
     resetInitRuntime(initState);
+    settle?.({ kind: "cancelled" });
   });
   pi.on("before_agent_start", () => {
     if (initState.active) setInitTools(pi, initState, true);
@@ -160,7 +162,7 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
         ctx.ui.notify("/init requires interactive TUI mode", "error");
         return;
       }
-      if (initState.active) {
+      if (initState.active || initState.starting) {
         ctx.ui.notify("/init is already running", "warning");
         return;
       }
@@ -172,28 +174,45 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
         ctx.ui.notify("Trust this project before running /init", "error");
         return;
       }
-      await ctx.waitForIdle();
+      const starting = Symbol();
+      initState.starting = starting;
+      try {
+        await ctx.waitForIdle();
+      } catch (error) {
+        if (initState.starting !== starting) return;
+        initState.starting = undefined;
+        reportError(ctx, "/init could not wait for active work", error);
+        return;
+      }
+      if (initState.starting !== starting) return;
 
       let projectRoot: string;
       try {
         projectRoot = await fs.realpath(ctx.cwd);
       } catch (error) {
+        if (initState.starting !== starting) return;
+        initState.starting = undefined;
         reportError(ctx, "/init could not resolve the project root", error);
         return;
       }
+      if (initState.starting !== starting) return;
       const targetPath = path.join(projectRoot, "AGENTS.md");
       try {
         const [{ index: evidence }, baseline] = await Promise.all([
           buildInitEvidence(projectRoot),
           captureInitTargetBaseline(targetPath),
         ]);
+        if (initState.starting !== starting) return;
         initState.active = true;
         initState.projectRoot = projectRoot;
         initState.targetPath = targetPath;
         initState.evidence = evidence;
         initState.baseline = baseline;
         initState.outcome = { kind: "pending" };
+        initState.starting = undefined;
       } catch (error) {
+        if (initState.starting !== starting) return;
+        initState.starting = undefined;
         reportError(ctx, "/init could not capture safe repository evidence", error);
         return;
       }
@@ -234,6 +253,8 @@ export function registerInitCommand(pi: ExtensionAPI, initState: InitRuntime, go
         case "policy-conflict":
           ctx.ui.notify(`/init left AGENTS.md unchanged: ${outcome.reason}`, "warning");
           break;
+        case "cancelled":
+          break;
         default:
           reportError(ctx, "/init did not generate AGENTS.md", "the model completed without a write or policy-conflict outcome");
       }