killeros 2.0.22 → 2.1.23

package/killeros/goal-state.ts

@@ -4,7 +4,9 @@ import { lstat, open, type FileHandle } from "node:fs/promises";
 import path from "node:path";
 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_VERSION = 1;
 const FILE_HASH_CHUNK_SIZE = 64 * 1024;
 export const FILE_HASH_LIMIT = 64 * 1024 * 1024;
@@ -25,6 +27,20 @@ function finiteNonNegative(value: unknown): value is number {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
 
+function safeNonNegativeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+
+function incrementableNonNegativeInteger(value: unknown): value is number {
+  return safeNonNegativeInteger(value) && value < Number.MAX_SAFE_INTEGER;
+}
+
+function addGoalMilliseconds(accumulated: number, interval: number): number {
+  const total = accumulated + interval;
+  if (!safeNonNegativeInteger(total)) throw new Error("Goal active duration exceeds the safe integer range");
+  return total;
+}
+
 function isUnknownRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -47,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"
@@ -56,12 +80,18 @@ function isGoalFileVerification(value: unknown): value is GoalFileVerification {
     && isGoalFileBaseline(value.baseline);
 }
 
+function isMaxTurns(value: unknown): value is number {
+  return typeof value === "number" && Number.isInteger(value) && value >= 1 && value <= GOAL_MAX_TURNS;
+}
+
 function isGoalBlockerAudit(value: unknown, turns: number, status: GoalStatus): value is GoalBlockerAudit {
   if (!isUnknownRecord(value)
     || typeof value.key !== "string"
     || !/^[a-z0-9][a-z0-9._-]{0,119}$/u.test(value.key)
     || typeof value.streak !== "number" || !Number.isInteger(value.streak) || value.streak < 1 || value.streak > 3
-    || typeof value.lastTurn !== "number" || !Number.isInteger(value.lastTurn) || value.lastTurn < 1 || value.lastTurn > turns) {
+    || typeof value.lastTurn !== "number" || !Number.isInteger(value.lastTurn) || value.lastTurn < 1 || value.lastTurn > turns
+    || value.evidence !== undefined && (typeof value.evidence !== "string"
+      || value.evidence !== value.evidence.trim() || !value.evidence || value.evidence.length > 2_000)) {
     return false;
   }
   if (status === "complete") return false;
@@ -86,21 +116,22 @@ export function parseGoalState(value: unknown): GoalState | undefined {
     resumeAfterManualCompaction,
     blockerAudit,
     verification,
+    maxTurns,
   } = value;
   if (version !== GOAL_VERSION
-    || typeof revision !== "number" || !Number.isInteger(revision) || revision < 1
+    || !incrementableNonNegativeInteger(revision) || revision < 1
     || typeof objective !== "string" || !objective.trim() || [...objective].length > GOAL_OBJECTIVE_LIMIT
     || !isGoalStatus(status)
-    || !finiteNonNegative(createdAt)
-    || !finiteNonNegative(updatedAt)
-    || !finiteNonNegative(activeMilliseconds)
-    || typeof turns !== "number" || !Number.isInteger(turns) || turns < 0
+    || !safeNonNegativeInteger(createdAt)
+    || !safeNonNegativeInteger(updatedAt)
+    || !incrementableNonNegativeInteger(activeMilliseconds)
+    || !incrementableNonNegativeInteger(turns)
     || blockedAuditStartTurn !== undefined
-      && (typeof blockedAuditStartTurn !== "number" || !Number.isInteger(blockedAuditStartTurn)
-        || blockedAuditStartTurn < 0 || blockedAuditStartTurn > turns)
-    || !finiteNonNegative(baselineTokens)
+      && (!safeNonNegativeInteger(blockedAuditStartTurn) || blockedAuditStartTurn > turns)
+    || !safeNonNegativeInteger(baselineTokens)
     || result !== undefined && typeof result !== "string"
     || verification !== undefined && !isGoalFileVerification(verification)
+    || maxTurns !== undefined && !isMaxTurns(maxTurns)
     || resumeAfterManualCompaction !== undefined && resumeAfterManualCompaction !== true
     || blockerAudit !== undefined && !isGoalBlockerAudit(blockerAudit, turns, status)) {
     return undefined;
@@ -117,10 +148,11 @@ export function parseGoalState(value: unknown): GoalState | undefined {
     blockedAuditStartTurn: blockedAuditStartTurn ?? 0,
     baselineTokens,
     ...(verification === undefined ? {} : { verification }),
+    ...(maxTurns === undefined ? {} : { maxTurns }),
   };
   switch (status) {
     case "active":
-      if (!finiteNonNegative(activeStartedAt) || resumeAfterManualCompaction !== undefined) return undefined;
+      if (!safeNonNegativeInteger(activeStartedAt) || resumeAfterManualCompaction !== undefined) return undefined;
       return {
         ...common,
         status,
@@ -201,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;
 }
@@ -250,7 +295,7 @@ export function validateGoalObjective(input: string): string | undefined {
 
 export function goalElapsedMilliseconds(state: GoalState, now: number): number {
   const activeInterval = state.status === "active" ? Math.max(0, now - state.activeStartedAt) : 0;
-  return state.activeMilliseconds + activeInterval;
+  return addGoalMilliseconds(state.activeMilliseconds, activeInterval);
 }
 
 export function commonGoalState(state: GoalState): GoalStateCommon {
@@ -265,13 +310,14 @@ export function commonGoalState(state: GoalState): GoalStateCommon {
     blockedAuditStartTurn: state.blockedAuditStartTurn,
     baselineTokens: state.baselineTokens,
     ...(state.verification === undefined ? {} : { verification: state.verification }),
+    ...(state.maxTurns === undefined ? {} : { maxTurns: state.maxTurns }),
   };
 }
 
 export function stopGoalClock(state: GoalState, now: number): GoalStateCommon {
   const common = commonGoalState(state);
   return state.status === "active"
-    ? { ...common, activeMilliseconds: common.activeMilliseconds + Math.max(0, now - state.activeStartedAt) }
+    ? { ...common, activeMilliseconds: addGoalMilliseconds(common.activeMilliseconds, Math.max(0, now - state.activeStartedAt)) }
     : common;
 }
 
@@ -280,6 +326,7 @@ export function createNewGoalState(
   baselineTokens: number,
   verification: GoalFileVerification | undefined,
   now: number,
+  controls: { maxTurns?: number } = {},
 ): GoalState {
   return {
     version: GOAL_VERSION,
@@ -294,26 +341,7 @@ export function createNewGoalState(
     blockedAuditStartTurn: 0,
     baselineTokens,
     ...(verification === undefined ? {} : { verification }),
-  };
-}
-
-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 }),
+    ...(controls.maxTurns === undefined ? {} : { maxTurns: controls.maxTurns }),
   };
 }
 

package/killeros/hooks.ts

@@ -2,6 +2,7 @@ import {
   spawn,
   type SpawnOptionsWithStdioTuple,
 } from "node:child_process";
+import { EventEmitter } from "node:events";
 import { closeSync, existsSync, fstatSync, lstatSync, openSync, readSync, realpathSync } from "node:fs";
 import path from "node:path";
 import { StringDecoder } from "node:string_decoder";
@@ -58,6 +59,7 @@ const HOOK_EVENTS: readonly KillerosHookEvent[] = ["tool_call", "tool_result", "
 const HOOK_CONFIG_LIMIT = 64 * 1024;
 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;
 
 // Reads executable project configuration through a bounded, project-local file descriptor.
@@ -109,7 +111,7 @@ function isUnknownRecord(value: unknown): value is Record<string, unknown> {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function loadKillerosHooks(ctx: ExtensionContext): 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", "");
@@ -166,6 +168,7 @@ function loadKillerosHooks(ctx: ExtensionContext): KillerosHookConfig {
       }
       hooks[event] = accepted;
     }
+
     return { hooks };
   } catch (error) {
     reportError(ctx, `Invalid ${CONFIG_DIR_NAME}/killeros-hooks.json`, error);
@@ -265,7 +268,7 @@ export function executeHook(
     command,
     cwd,
     environment,
-    timeoutMs = 30_000,
+    timeoutMs = HOOK_TIMEOUT_DEFAULT_MS,
     spawnProcess = spawn,
     signal,
   } = options;
@@ -331,18 +334,19 @@ export function executeHook(
         }, 2_000);
         return;
       }
-      terminateHookProcess(child, false);
       forceTimer = setTimeout(() => {
         if (completed) return;
         terminateHookProcess(child, true);
         settleTimer = setTimeout(() => finish(terminationCode(), true), 1_000);
       }, 1_000);
+      terminateHookProcess(child, false);
     };
     const abort = (): void => beginTermination("cancelled");
-    signal?.addEventListener("abort", abort, { once: true });
-    if (signal?.aborted) beginTermination("cancelled");
     child.stdout.on("data", (chunk) => appendBounded(stdout, chunk));
     child.stderr.on("data", (chunk) => appendBounded(stderr, chunk));
+    const captureStreamError = (error: Error): void => appendBounded(stderr, error.message);
+    if (child.stdout instanceof EventEmitter) child.stdout.on("error", captureStreamError);
+    if (child.stderr instanceof EventEmitter) child.stderr.on("error", captureStreamError);
     child.on("error", (error) => {
       appendBounded(stderr, error.message);
       if (!windowsCleanupPending) finish(termination ? terminationCode() : 1);
@@ -350,12 +354,23 @@ export function executeHook(
     child.once("close", (code) => {
       if (!windowsCleanupPending) finish(termination ? terminationCode() : code ?? 1);
     });
-    timer = setTimeout(() => beginTermination("timeout"), Math.max(1, Math.min(timeoutMs, HOOK_TIMEOUT_MAX_MS)));
+    if (completed) return;
+    const boundedTimeoutMs = Number.isNaN(timeoutMs)
+      ? HOOK_TIMEOUT_DEFAULT_MS
+      : Math.max(1, Math.min(timeoutMs, HOOK_TIMEOUT_MAX_MS));
+    timer = setTimeout(() => beginTermination("timeout"), boundedTimeoutMs);
+    signal?.addEventListener("abort", abort, { once: true });
+    if (signal?.aborted) beginTermination("cancelled");
   });
 }
 
 function serializeHookPayload(payload: unknown): string {
-  const serialized = JSON.stringify(payload) ?? "null";
+  let serialized: string;
+  try {
+    serialized = JSON.stringify(payload) ?? "null";
+  } catch {
+    return JSON.stringify({ serializationError: true });
+  }
   if (serialized.length <= HOOK_PAYLOAD_LIMIT) return serialized;
   const previewLength = Math.floor((HOOK_PAYLOAD_LIMIT - 64) / 2);
   return JSON.stringify({ truncated: true, preview: serialized.slice(0, previewLength) });
@@ -376,7 +391,7 @@ function hookFailureMessage(result: HookExecutionResult): string {
 
 export function registerLifecycleHooks(pi: ExtensionAPI): void {
   let config: KillerosHookConfig = {};
-  pi.on("session_start", (_event, ctx) => { config = loadKillerosHooks(ctx); });
+  pi.on("session_start", (_event, ctx) => { config = loadKillerosConfig(ctx); });
 
   pi.on("tool_call", async (event, ctx) => {
     for (const hook of config.hooks?.tool_call ?? []) {

package/killeros/runtime.ts

@@ -26,6 +26,7 @@ export interface GoalBlockerAudit {
   key: string;
   streak: number;
   lastTurn: number;
+  evidence?: string;
 }
 
 export type GoalFileBaseline =
@@ -49,6 +50,7 @@ export interface GoalStateCommon {
   blockedAuditStartTurn: number;
   baselineTokens: number;
   verification?: GoalFileVerification;
+  maxTurns?: number;
 }
 
 export type GoalState = GoalStateCommon & (