killeros 1.5.8 → 2.0.1

package/killeros/bounded-text.ts

@@ -0,0 +1,25 @@
+import { Text, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
+
+export class BoundedText implements Component {
+  private readonly text: string;
+  private readonly maxRows?: number;
+
+  constructor(text: string, maxRows?: number) {
+    this.text = text;
+    this.maxRows = maxRows;
+  }
+
+  render(width: number): string[] {
+    if (width <= 0) return [];
+    const lines = new Text(this.text, 0, 0).render(width);
+    if (this.maxRows === undefined || lines.length <= this.maxRows) return lines;
+    const rowLimit = Math.max(1, this.maxRows);
+    const visible = lines.slice(0, rowLimit);
+    const suffix = " …";
+    const last = visible.at(-1) ?? "";
+    visible[rowLimit - 1] = `${truncateToWidth(last, Math.max(0, width - visibleWidth(suffix)), "")}${suffix}`;
+    return visible.map((line) => truncateToWidth(line, width, ""));
+  }
+
+  invalidate(): void {}
+}

package/killeros/commands.ts

@@ -1,76 +1,5 @@
-import { type ExtensionAPI, type ExtensionCommandContext, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { type ExtensionAPI, type ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import type { AutocompleteItem } from "@earendil-works/pi-tui";
-import { formatThreadControls, type ThreadStatus } from "./subagent-ui.ts";
-
-export type SubagentControlAction = "list" | "inspect" | "wait" | "steer" | "interrupt" | "collect" | "resume" | "close";
-
-export interface SubagentControlRequest {
-  action: SubagentControlAction;
-  threadId?: string;
-  all?: true;
-  message?: string;
-  task?: string;
-  timeoutMs?: number;
-}
-
-interface SubagentControlThread {
-  id: string;
-  displayName?: string;
-  name?: string;
-  agent?: string;
-  role?: string;
-  task?: string;
-  prompt?: string;
-  status?: string;
-  state?: string;
-}
-
-export interface SubagentControlDetails {
-  results?: readonly SubagentControlThread[];
-  threads?: readonly SubagentControlThread[];
-}
-
-export interface SubagentControlResult {
-  text: string;
-  details?: SubagentControlDetails;
-  usage?: unknown;
-}
-
-export interface SubagentControlApi {
-  execute(request: SubagentControlRequest, ctx: ExtensionContext): Promise<SubagentControlResult>;
-}
-
-export interface SubagentToolLike {
-  name: string;
-  execute(
-    toolCallId: string,
-    params: unknown,
-    signal: AbortSignal | undefined,
-    onUpdate: undefined,
-    ctx: ExtensionContext,
-  ): Promise<{
-    content?: readonly { type: string; text?: string }[];
-    details?: unknown;
-    usage?: unknown;
-  }>;
-}
-
-export function createSubagentControlApi(tool: SubagentToolLike): SubagentControlApi {
-  return {
-    async execute(request, ctx) {
-      const toolRequest = request.action === "interrupt" && request.threadId === "all"
-        ? { action: "interrupt", all: true }
-        : request;
-      const result = await tool.execute("subagents-command", toolRequest, ctx.signal, undefined, ctx);
-      const text = result.content?.find((item) => item.type === "text")?.text ?? "";
-      return {
-        text,
-        details: result.details as SubagentControlDetails | undefined,
-        usage: result.usage,
-      };
-    },
-  };
-}
 
 async function confirmNewSession(ctx: ExtensionCommandContext): Promise<boolean> {
   if (!ctx.hasUI) return true;
@@ -125,10 +54,16 @@ const BUILTIN_COMMANDS: ReadonlyArray<{ name: string; description: string }> = [
   { name: "quit", description: "Quit Pi" },
 ];
 
+export function availableCommandNames(pi: ExtensionAPI): ReadonlySet<string> {
+  return new Set([
+    ...BUILTIN_COMMANDS.map((command) => command.name),
+    ...pi.getCommands().map((command) => command.name),
+  ]);
+}
+
 const COMMAND_SYNTAX_HINTS: Readonly<Record<string, string>> = {
   goal: "/goal [objective|clear|edit|pause|resume]",
   variants: "/variants [level]",
-  subagents: "/subagents [list|inspect|wait|steer|interrupt|collect|resume|close] [thread]",
   model: "/model [provider/model]",
   "scoped-models": "/scoped-models",
   login: "/login [provider]",
@@ -151,162 +86,6 @@ function scoreCommandMatch(name: string, prefix: string): number {
   return 0;
 }
 
-const SUBAGENT_COMMAND_USAGE = "/subagents [list|inspect|wait|steer|interrupt|collect|resume|close] [thread]";
-
-function subagentCommandError(message: string): Error {
-  return new Error(`${message} Usage: ${SUBAGENT_COMMAND_USAGE}`);
-}
-
-function parseThreadReference(action: SubagentControlAction, tail: string): string {
-  const reference = tail.match(/^(\S+)(?:\s+([\s\S]*))?$/u)?.[1];
-  if (!reference) throw subagentCommandError(`/subagents ${action} requires a thread reference.`);
-  return reference;
-}
-
-function parseExplicitSubagentCommand(args: string): SubagentControlRequest {
-  const trimmed = args.trim();
-  const match = trimmed.match(/^(\S+)(?:\s+([\s\S]*))?$/u);
-  if (!match) throw subagentCommandError("/subagents requires an explicit verb outside TUI.");
-  const action = match[1]!.toLocaleLowerCase() as SubagentControlAction;
-  const tail = match[2]?.trim() ?? "";
-
-  if (action === "list") {
-    if (tail) throw subagentCommandError("/subagents list does not accept arguments.");
-    return { action };
-  }
-  if (action === "wait") {
-    if (!tail) return { action };
-    const parts = tail.split(/\s+/u);
-    if (parts.length > 2) throw subagentCommandError("/subagents wait accepts one thread reference and one timeout-ms value.");
-    if (parts.length === 1 && /^\d+$/u.test(parts[0]!)) {
-      return { action, timeoutMs: parseTimeout(parts[0]!) };
-    }
-    const request: SubagentControlRequest = { action, threadId: parts[0] };
-    if (parts[1] !== undefined) request.timeoutMs = parseTimeout(parts[1]);
-    return request;
-  }
-  if (action === "steer") {
-    const referenceAndMessage = tail.match(/^(\S+)(?:\s+([\s\S]+))?$/u);
-    if (!referenceAndMessage?.[1]) throw subagentCommandError("/subagents steer requires a thread reference.");
-    if (!referenceAndMessage[2]?.trim()) throw subagentCommandError("/subagents steer requires a message.");
-    return { action, threadId: referenceAndMessage[1], message: referenceAndMessage[2] };
-  }
-  if (action === "resume") {
-    const referenceAndTask = tail.match(/^(\S+)(?:\s+([\s\S]+))?$/u);
-    if (!referenceAndTask?.[1]) throw subagentCommandError("/subagents resume requires a thread reference.");
-    return {
-      action,
-      threadId: referenceAndTask[1],
-      ...(referenceAndTask[2] ? { task: referenceAndTask[2] } : {}),
-    };
-  }
-  if (action === "inspect" || action === "interrupt" || action === "collect" || action === "close") {
-    const threadId = parseThreadReference(action, tail);
-    if (tail.slice(threadId.length).trim()) throw subagentCommandError(`/subagents ${action} accepts one thread reference.`);
-    return { action, threadId };
-  }
-  throw subagentCommandError(`Unknown /subagents action ${JSON.stringify(match[1])}.`);
-}
-
-function parseTimeout(value: string): number {
-  const timeoutMs = Number(value);
-  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 0) {
-    throw subagentCommandError("/subagents wait timeout-ms must be a non-negative integer.");
-  }
-  return timeoutMs;
-}
-
-function controlThreads(result: SubagentControlResult): SubagentControlThread[] {
-  const details = result.details;
-  if (!details) return [];
-  const results = [...(details.results ?? [])];
-  const threads = [...(details.threads ?? [])];
-  const candidates = results.length ? results : threads;
-  return candidates.filter((thread) => thread && typeof thread.id === "string" && thread.state !== "closed" && thread.status !== "closed");
-}
-
-function threadStatus(thread: SubagentControlThread): ThreadStatus {
-  const status = (thread.status ?? thread.state ?? "queued").toLocaleLowerCase();
-  if (status === "active" || status === "running") return "running";
-  if (status === "done" || status === "complete" || status === "closed") return "complete";
-  if (status === "stopped" || status === "cancelled") return "cancelled";
-  if (status === "limited") return "limited";
-  if (status === "orphaned") return "orphaned";
-  if (status === "failed") return "failed";
-  return "queued";
-}
-
-function threadLabel(thread: SubagentControlThread): string {
-  const name = thread.displayName ?? thread.name ?? thread.agent ?? thread.role ?? thread.id;
-  return `${name} · ${thread.id} · ${threadStatus(thread)}`;
-}
-
-function selectedThread(threads: readonly SubagentControlThread[], labels: readonly string[], choice: string): SubagentControlThread | undefined {
-  const index = labels.indexOf(choice);
-  if (index >= 0) return threads[index];
-  return threads.find((thread) => thread.id === choice || thread.displayName === choice || thread.name === choice);
-}
-
-async function executeSubagentControl(
-  control: SubagentControlApi | undefined,
-  request: SubagentControlRequest,
-  ctx: ExtensionCommandContext,
-): Promise<void> {
-  if (!control) throw new Error("Subagent control API is not available.");
-  const result = await control.execute(request, ctx);
-  if (result?.text) ctx.ui.notify(result.text, "info");
-}
-
-async function runTuiSubagentCommand(control: SubagentControlApi | undefined, ctx: ExtensionCommandContext): Promise<void> {
-  if (!control) throw new Error("Subagent control API is not available.");
-  const listed = await control.execute({ action: "list" }, ctx);
-  const threads = controlThreads(listed);
-  if (!threads.length) {
-    ctx.ui.notify("No child threads.", "info");
-    return;
-  }
-
-  const labels = threads.map(threadLabel);
-  const selected = await ctx.ui.select("Select a thread", labels);
-  if (selected === undefined) return;
-  const thread = selectedThread(threads, labels, selected);
-  if (!thread) return;
-
-  const controls = formatThreadControls(threadStatus(thread)).filter((item) => item.enabled);
-  const controlLabels = controls.map((item) => item.label);
-  const selectedControl = await ctx.ui.select("Select a control", controlLabels);
-  if (selectedControl === undefined) return;
-  const chosen = controls.find((item) => item.label === selectedControl || item.id === selectedControl);
-  if (!chosen) return;
-
-  const request: SubagentControlRequest = { action: chosen.id, threadId: thread.id };
-  if (chosen.id === "steer") {
-    const message = await ctx.ui.input("Steer child thread", "Message");
-    if (message === undefined || !message.trim()) return;
-    request.message = message;
-  } else if (chosen.id === "resume") {
-    const task = await ctx.ui.input("Resume child thread", "Optional task");
-    if (task === undefined) return;
-    if (task) request.task = task;
-  }
-  await executeSubagentControl(control, request, ctx);
-}
-
-export function registerSubagentCommand(pi: ExtensionAPI, control?: SubagentControlApi | void): void {
-  const api = control && typeof control.execute === "function" ? control : undefined;
-  pi.registerCommand("subagents", {
-    description: "Inspect and control child threads",
-    handler: async (args, ctx) => {
-      if (!args.trim()) {
-        if (ctx.mode !== "tui") throw subagentCommandError("/subagents requires an explicit verb outside TUI.");
-        await runTuiSubagentCommand(api, ctx);
-        return;
-      }
-      await executeSubagentControl(api, parseExplicitSubagentCommand(args), ctx);
-    },
-  });
-}
-
 export function registerSlashAutocomplete(pi: ExtensionAPI): void {
   const usage = new Map<string, number>();
   pi.on("session_start", (_event, ctx) => {
@@ -349,15 +128,6 @@ export function registerSlashAutocomplete(pi: ExtensionAPI): void {
           }
         }
 
-        if (!commands.has("subagents")) {
-          commands.set("subagents", {
-            name: "subagents",
-            description: "Inspect and control child threads",
-            category: "Extension",
-            syntaxHint: COMMAND_SYNTAX_HINTS.subagents,
-          });
-        }
-
         const ranked = [...commands.values()]
           .map((command) => ({
             command,

package/killeros/display.ts

@@ -6,9 +6,11 @@ export function formatCwd(cwd: string): string {
   if (!home) return cwd;
   const normalizedHome = home.replace(/[\\/]+$/, "");
   const normalizedCwd = cwd.replace(/[\\/]+$/, "");
-  if (normalizedCwd === normalizedHome) return "~";
+  const comparedHome = process.platform === "win32" ? normalizedHome.toLocaleLowerCase() : normalizedHome;
+  const comparedCwd = process.platform === "win32" ? normalizedCwd.toLocaleLowerCase() : normalizedCwd;
+  if (comparedCwd === comparedHome) return "~";
   const separator = normalizedCwd.slice(normalizedHome.length, normalizedHome.length + 1);
-  return normalizedCwd.startsWith(normalizedHome) && (separator === "/" || separator === "\\")
+  return comparedCwd.startsWith(comparedHome) && (separator === "/" || separator === "\\")
     ? `~${normalizedCwd.slice(normalizedHome.length)}`
     : cwd;
 }
@@ -20,6 +22,7 @@ export function padRight(text: string, width: number): string {
 }
 
 export function formatTime(milliseconds: number): string {
+  if (!Number.isFinite(milliseconds)) return "0s";
   const totalSeconds = Math.max(0, Math.floor(milliseconds / 1_000));
   if (totalSeconds < 60) return `${totalSeconds}s`;
   const minutes = Math.floor(totalSeconds / 60);
@@ -28,6 +31,7 @@ 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) {

package/killeros/footer.ts

@@ -13,8 +13,8 @@ export function formatCost(usd: number): string {
 }
 
 export function formatContextProgress(tokensUsed: number | null, contextWindow: number, theme: Theme): string {
-  if (tokensUsed === null) return theme.fg("dim", "—% left (—)");
-  const windowSize = contextWindow > 0 ? contextWindow : 128_000;
+  if (tokensUsed === null || !Number.isFinite(tokensUsed)) return theme.fg("dim", "—% left (—)");
+  const windowSize = Number.isFinite(contextWindow) && contextWindow > 0 ? contextWindow : 128_000;
   const remaining = Math.max(0, Math.min(windowSize, windowSize - Math.max(0, tokensUsed)));
   const percentLeft = Math.max(0, Math.min(100, Math.round((remaining / windowSize) * 100)));
   const color: ThemeColor = percentLeft < 20 ? "error" : percentLeft <= 50 ? "warning" : "success";
@@ -116,16 +116,34 @@ function formatGoalFooter(state: GoalState | undefined, theme: Theme): string {
   if (state.status === "active") return theme.fg("accent", `✻ goal · ${formatTime(goalElapsedMilliseconds(state))}`);
   if (state.status === "paused") return theme.fg("warning", "Ⅱ goal paused");
   if (state.status === "blocked") return theme.fg("error", "! goal blocked");
-  return theme.fg("success", "✓ goal complete");
+  return "";
 }
 
 export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void {
   let currentModel: ExtensionContext["model"];
   let thinkingLevel: ThinkingLevel = "off";
   let activeTui: TUI | undefined;
+  let cachedSessionCost = 0;
+  let sessionCostDirty = true;
+  const resetSessionCost = (): void => {
+    cachedSessionCost = 0;
+    sessionCostDirty = true;
+  };
+  const invalidateSessionCost = (): void => {
+    sessionCostDirty = true;
+    activeTui?.requestRender();
+  };
+  const getSessionCost = (ctx: ExtensionContext): number => {
+    if (sessionCostDirty) {
+      cachedSessionCost = sumSessionCost(ctx);
+      sessionCostDirty = false;
+    }
+    return cachedSessionCost;
+  };
   goalRuntime.requestRender = () => activeTui?.requestRender();
 
   pi.on("session_start", (_event, ctx) => {
+    resetSessionCost();
     if (ctx.mode !== "tui") return;
     const sessionStart = Date.now();
     currentModel = ctx.model;
@@ -150,7 +168,12 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
           const level = model?.reasoning === false
             ? theme.fg("thinkingOff", "no reasoning")
             : theme.fg(LEVEL_COLORS[thinkingLevel], thinkingLevel);
-          const usage = ctx.getContextUsage();
+          let usage: ReturnType<ExtensionContext["getContextUsage"]>;
+          try {
+            usage = ctx.getContextUsage();
+          } catch {
+            usage = undefined;
+          }
           const contextWindow = usage?.contextWindow ?? model?.contextWindow ?? 128_000;
           const context = formatContextProgress(usage?.tokens ?? null, contextWindow, theme);
           const branch = footerData.getGitBranch();
@@ -165,7 +188,7 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
             goal,
             branch ? theme.fg("dim", branch) : "",
             theme.fg("dim", formatTime(Date.now() - sessionStart)),
-            theme.fg("dim", formatCost(sumSessionCost(ctx))),
+            theme.fg("dim", formatCost(getSessionCost(ctx))),
           ], theme);
           const focused = joinFooterParts([signature, context, goal], theme);
 
@@ -202,7 +225,14 @@ export function registerFooter(pi: ExtensionAPI, goalRuntime: GoalRuntime): void
     thinkingLevel = event.level;
     activeTui?.requestRender();
   });
+  pi.on("turn_end", invalidateSessionCost);
+  pi.on("session_compact", invalidateSessionCost);
+  pi.on("session_tree", () => {
+    resetSessionCost();
+    activeTui?.requestRender();
+  });
   pi.on("session_shutdown", () => {
+    resetSessionCost();
     activeTui = undefined;
     goalRuntime.requestRender = undefined;
   });

package/killeros/goals.ts

@@ -1,7 +1,8 @@
-import { type ExtensionAPI, type ExtensionContext, type ThemeColor } from "@earendil-works/pi-coding-agent";
+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";
-import { MAX_NODE_TIMER_MS } from "./subagent-process.ts";
+import { MAX_NODE_TIMER_MS } from "./limits.ts";
+import { BoundedText } from "./bounded-text.ts";
 import { CONCISE_SYSTEM_PROMPT } from "./concise.ts";
 import { formatTime, formatTokens } from "./display.ts";
 import { reportError } from "./errors.ts";
@@ -175,6 +176,18 @@ function goalStatusLabel(status: GoalStatus): string {
   return `${status.charAt(0).toLocaleUpperCase()}${status.slice(1)}`;
 }
 
+function goalPanelActions(status: GoalStatus): Array<{ label: string; control: "pause" | "resume" | "edit" | "clear" }> {
+  const terminal = [
+    { 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];
+  if (status === "paused" || status === "blocked") {
+    return [{ label: "Resume automatic continuation", control: "resume" }, ...terminal];
+  }
+  return terminal;
+}
+
 function goalStatusSummary(state: GoalState, ctx: ExtensionContext): string {
   const usedTokens = Math.max(0, sumGoalTokens(ctx) - state.baselineTokens);
   const lines = [
@@ -293,7 +306,7 @@ export function registerGoal(
   runtime: GoalRuntime,
   initState: InitRuntime,
 ): void {
-  pi.registerEntryRenderer<GoalEntryData>(GOAL_ENTRY_TYPE, (entry, _options, theme) => {
+  pi.registerEntryRenderer<GoalEntryData>(GOAL_ENTRY_TYPE, (entry, options, theme) => {
     const data = entry.data;
     if (!data || data.version !== GOAL_VERSION || data.event === "turn" || data.event === "checkpoint") return undefined;
     if (data.event === "clear" || data.state === null) return new Text(theme.fg("dim", "Goal cleared"), 0, 0);
@@ -301,7 +314,11 @@ export function registerGoal(
     if (!state) return undefined;
     const icon = state.status === "active" ? "✻" : state.status === "paused" ? "Ⅱ" : state.status === "blocked" ? "!" : "✓";
     const color: ThemeColor = state.status === "active" ? "accent" : state.status === "paused" ? "warning" : state.status === "blocked" ? "error" : "success";
-    return new Text(`${theme.fg(color, `${icon} Goal ${state.status}`)}${theme.fg("dim", ` · ${state.objective}`)}`, 0, 0);
+    const status = theme.fg(color, `${icon} Goal ${state.status}`);
+    if (!options.expanded) return new BoundedText(`${status}${theme.fg("dim", ` · ${state.objective}`)}`, 3);
+    const lines = [status, theme.fg("dim", state.objective)];
+    if (state.result) lines.push(theme.fg("muted", state.result));
+    return new BoundedText(lines.join("\n"));
   });
 
   pi.registerTool<typeof GoalUpdateParams, GoalUpdateDetails>({
@@ -329,11 +346,11 @@ 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) {
       const details = result.details;
-      return new Text(details
-        ? `${theme.fg(details.status === "complete" ? "success" : "warning", details.status === "complete" ? "✓ Complete" : "! Blocked")}${theme.fg("dim", ` · ${details.evidence}`)}`
-        : theme.fg("dim", "Goal updated"), 0, 0);
+      if (!details) return new BoundedText(theme.fg("dim", "Goal updated"));
+      const text = `${theme.fg(details.status === "complete" ? "success" : "warning", details.status === "complete" ? "✓ Complete" : "! Blocked")}${theme.fg("dim", ` · ${details.evidence}`)}`;
+      return new BoundedText(text, options.expanded ? undefined : 3);
     },
   });
 
@@ -428,22 +445,7 @@ export function registerGoal(
     runtime.lastError = finalAssistant?.errorMessage;
   });
 
-  pi.registerCommand("goal", {
-    description: "Set or view the goal for a long-running task",
-    getArgumentCompletions: (prefix) => {
-      const normalized = prefix.trimStart().toLocaleLowerCase();
-      if (normalized.includes(" ")) return null;
-      const actions = [
-        { 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" },
-      ];
-      return actions
-        .filter((action) => action.value.startsWith(normalized))
-        .map((action) => ({ ...action, label: action.value }));
-    },
-    handler: async (args, ctx) => {
+  const handleGoalCommand = async (args: string, ctx: ExtensionCommandContext): Promise<void> => {
       if (ctx.mode === "print" || ctx.mode === "json") {
         ctx.ui.notify("/goal requires TUI or RPC mode", "error");
         return;
@@ -461,7 +463,16 @@ export function registerGoal(
           ctx.ui.notify("No goal is set. Use /goal <objective> to start a long-running task.", "info");
           return;
         }
-        ctx.ui.notify(goalStatusSummary(runtime.state, ctx), "info");
+        if (ctx.mode !== "tui") {
+          ctx.ui.notify(goalStatusSummary(runtime.state, ctx), "info");
+          return;
+        }
+        const actions = goalPanelActions(runtime.state.status);
+        const selected = await ctx.ui.select(goalStatusSummary(runtime.state, ctx), actions.map((action) => action.label));
+        const action = actions.find((candidate) => candidate.label === selected);
+        if (!action) return;
+        if (action.control === "clear" && !await ctx.ui.confirm("Clear goal?", runtime.state.objective)) return;
+        await handleGoalCommand(action.control, ctx);
         return;
       }
 
@@ -684,7 +695,24 @@ export function registerGoal(
         reportError(ctx, "Goal could not be started", error);
         scheduleGoalContinuation(pi, runtime, initState, ctx);
       }
+  };
+
+  pi.registerCommand("goal", {
+    description: "Set or view the goal for a long-running task",
+    getArgumentCompletions: (prefix) => {
+      const normalized = prefix.trimStart().toLocaleLowerCase();
+      if (normalized.includes(" ")) return null;
+      const actions = [
+        { 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" },
+      ];
+      return actions
+        .filter((action) => action.value.startsWith(normalized))
+        .map((action) => ({ ...action, label: action.value }));
     },
+    handler: handleGoalCommand,
   });
 }
 

package/killeros/hooks.ts

@@ -3,7 +3,7 @@ import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { CONFIG_DIR_NAME, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { reportError } from "./errors.ts";
-import { MAX_NODE_TIMER_MS } from "./subagent-process.ts";
+import { MAX_NODE_TIMER_MS } from "./limits.ts";
 
 type KillerosHookEvent = "tool_call" | "tool_result" | "agent_settled";
 

package/killeros/limits.ts

@@ -0,0 +1 @@
+export const MAX_NODE_TIMER_MS = 2_147_483_647;

package/killeros/personal-instructions.ts

@@ -1,6 +1,7 @@
 import { closeSync, existsSync, openSync, readFileSync, readSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { StringDecoder } from "node:string_decoder";
 import { fileURLToPath } from "node:url";
 import { CONFIG_DIR_NAME, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { InitRuntime } from "./runtime.ts";
@@ -14,7 +15,8 @@ function readBoundedText(filePath: string, limit = PERSONAL_INSTRUCTIONS_LIMIT):
     descriptor = openSync(filePath, "r");
     const buffer = Buffer.alloc(limit + 1);
     const bytesRead = readSync(descriptor, buffer, 0, buffer.length, 0);
-    const content = buffer.toString("utf8", 0, Math.min(bytesRead, limit));
+    const decoder = new StringDecoder("utf8");
+    const content = decoder.write(buffer.subarray(0, Math.min(bytesRead, limit)));
     if (!content.trim()) return undefined;
     return bytesRead > limit
       ? `${content}\n\n[Personal instructions truncated by KillerOS]`