killeros 2.0.4 → 2.0.6

package/killeros/runtime.ts

@@ -20,6 +20,12 @@ export interface InitRuntime {
 
 export type GoalStatus = "active" | "paused" | "blocked" | "complete";
 
+export interface GoalBlockerAudit {
+  key: string;
+  streak: number;
+  lastTurn: number;
+}
+
 export interface GoalState {
   version: 1;
   revision: number;
@@ -34,6 +40,7 @@ export interface GoalState {
   baselineTokens: number;
   result?: string;
   resumeAfterManualCompaction?: true;
+  blockerAudit?: GoalBlockerAudit;
 }
 
 export interface GoalRuntime {

package/killeros/shell-ui.ts

@@ -11,6 +11,7 @@ import {
 } from "@earendil-works/pi-coding-agent";
 import {
   Container,
+  CURSOR_MARKER,
   Text,
   truncateToWidth,
   visibleWidth,
@@ -43,6 +44,13 @@ const STARTUP_TIPS = [
   "Run /notification to enable a terminal bell when work settles.",
 ] as const;
 
+const EDITOR_SUGGESTIONS = [
+  'Try "how does <filepath> work?"',
+  'Try "find edge cases in <filepath>"',
+  'Try "simplify <filepath> without changing behavior"',
+  'Try "write tests for <filepath>"',
+] as const;
+
 export function resolveGitBranch(cwd: string): Promise<string | undefined> {
   return new Promise((resolve) => {
     execFile(
@@ -66,13 +74,26 @@ export function resolveGitBranch(cwd: string): Promise<string | undefined> {
   });
 }
 
-function shuffledTips(): string[] {
-  const tips = [...STARTUP_TIPS];
-  for (let index = tips.length - 1; index > 0; index -= 1) {
+function shuffledDeck(values: readonly string[]): string[] {
+  const deck = [...values];
+  for (let index = deck.length - 1; index > 0; index -= 1) {
     const swapIndex = Math.floor(Math.random() * (index + 1));
-    [tips[index], tips[swapIndex]] = [tips[swapIndex]!, tips[index]!];
+    [deck[index], deck[swapIndex]] = [deck[swapIndex]!, deck[index]!];
   }
-  return tips;
+  return deck;
+}
+
+let tipDeck: string[] = [];
+let editorSuggestionDeck: string[] = [];
+
+function nextStartupTip(): string {
+  if (tipDeck.length === 0) tipDeck = shuffledDeck(STARTUP_TIPS);
+  return tipDeck.pop() ?? STARTUP_TIPS[0];
+}
+
+function nextEditorSuggestion(): string {
+  if (editorSuggestionDeck.length === 0) editorSuggestionDeck = shuffledDeck(EDITOR_SUGGESTIONS);
+  return editorSuggestionDeck.pop() ?? EDITOR_SUGGESTIONS[0];
 }
 
 function compactBoxLine(content: string, width: number, theme: Theme): string {
@@ -167,16 +188,19 @@ function isScrolledTopBorder(line: string): boolean {
 class PiCodeEditor extends CustomEditor {
   private readonly appKeybindings: KeybindingsManager;
   private readonly runtimeTheme: Theme;
+  private readonly suggestion: string;
 
   constructor(
     tui: TUI,
     theme: EditorTheme,
     appKeybindings: KeybindingsManager,
     runtimeTheme: Theme,
+    suggestion: string,
   ) {
     super(tui, theme, appKeybindings);
     this.appKeybindings = appKeybindings;
     this.runtimeTheme = runtimeTheme;
+    this.suggestion = suggestion;
   }
 
   override handleInput(data: string): void {
@@ -220,8 +244,16 @@ class PiCodeEditor extends CustomEditor {
     }
 
     for (let index = 1; index < bottomBorderIndex; index += 1) {
-      const prefix = index === 1 && !isScrolledHeader ? gray("❯ ") : "  ";
-      framed.push(`${prefix}${padRight(lines[index] ?? "", innerWidth)}`);
+      const isPromptLine = index === 1 && !isScrolledHeader;
+      const prefix = isPromptLine ? gray("❯\u00A0") : "  ";
+      let content = lines[index] ?? "";
+      if (isPromptLine && this.getText() === "") {
+        const first = this.suggestion.slice(0, 1);
+        const rest = this.suggestion.slice(1);
+        const cursorMarker = this.focused ? CURSOR_MARKER : "";
+        content = `${cursorMarker}\x1B[7m${gray(first)}\x1B[27m${gray(rest)}`;
+      }
+      framed.push(`${prefix}${padRight(content, innerWidth)}`);
     }
 
     const bottom = stripAnsi(lines[bottomBorderIndex] ?? "");
@@ -258,11 +290,6 @@ export function registerShellUi(pi: ExtensionAPI): void {
   let activityDeck: string[] = [];
   let lastActivityWord: string | undefined;
   let activityTimer: ReturnType<typeof setInterval> | undefined;
-  let tipDeck: string[] = [];
-  const nextStartupTip = (): string => {
-    if (tipDeck.length === 0) tipDeck = shuffledTips();
-    return tipDeck.pop() ?? STARTUP_TIPS[0];
-  };
   const refillActivityDeck = (): void => {
     activityDeck = [...ACTIVITY_WORDS];
     for (let index = activityDeck.length - 1; index > 0; index -= 1) {
@@ -302,8 +329,9 @@ export function registerShellUi(pi: ExtensionAPI): void {
       ctx.ui.setHiddenThinkingLabel("└ Thinking…");
       const existingEditorFactory = ctx.ui.getEditorComponent?.();
       if (!existingEditorFactory || existingEditorFactory === killerosEditorFactory) {
+        const editorSuggestion = nextEditorSuggestion();
         killerosEditorFactory = (tui, editorTheme, keybindings) =>
-          new PiCodeEditor(tui, editorTheme, keybindings, ctx.ui.theme);
+          new PiCodeEditor(tui, editorTheme, keybindings, ctx.ui.theme, editorSuggestion);
         ctx.ui.setEditorComponent(killerosEditorFactory);
       }
     } catch (error) {

package/killeros/worked-for.ts

@@ -0,0 +1,80 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+
+const WORKED_FOR_ENTRY_TYPE = "killeros-worked-for";
+const WORKED_FOR_ENTRY_VERSION = 1;
+
+interface WorkedForEntryData {
+  version: typeof WORKED_FOR_ENTRY_VERSION;
+  milliseconds: number;
+}
+
+export function formatWorkedForDuration(milliseconds: number): string {
+  const boundedMilliseconds = Number.isFinite(milliseconds) ? Math.max(0, milliseconds) : 0;
+  const totalSeconds = Math.max(1, Math.floor(boundedMilliseconds / 1_000));
+  if (totalSeconds < 60) return `${totalSeconds}s`;
+
+  const totalMinutes = Math.floor(totalSeconds / 60);
+  if (totalMinutes < 60) {
+    return `${totalMinutes}m ${(totalSeconds % 60).toString().padStart(2, "0")}s`;
+  }
+
+  return `${Math.floor(totalMinutes / 60)}h ${(totalMinutes % 60).toString().padStart(2, "0")}m`;
+}
+
+function isWorkedForEntryData(data: unknown): data is WorkedForEntryData {
+  if (!data || typeof data !== "object") return false;
+  const candidate = data as Partial<WorkedForEntryData>;
+  return candidate.version === WORKED_FOR_ENTRY_VERSION
+    && typeof candidate.milliseconds === "number"
+    && Number.isFinite(candidate.milliseconds)
+    && candidate.milliseconds >= 0;
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function registerWorkedFor(
+  pi: ExtensionAPI,
+  now: () => number = Date.now,
+): void {
+  let startedAt: number | undefined;
+
+  pi.registerEntryRenderer<WorkedForEntryData>(WORKED_FOR_ENTRY_TYPE, (entry, _options, theme) => {
+    if (!isWorkedForEntryData(entry.data)) return undefined;
+    return new Text(
+      theme.fg("dim", `✻ Worked for ${formatWorkedForDuration(entry.data.milliseconds)}`),
+      0,
+      0,
+    );
+  });
+
+  pi.on("session_start", () => {
+    startedAt = undefined;
+  });
+
+  pi.on("agent_start", (_event, ctx) => {
+    if (ctx.mode !== "tui" || startedAt !== undefined) return;
+    startedAt = now();
+  });
+
+  pi.on("agent_settled", (_event, ctx) => {
+    if (ctx.mode !== "tui" || startedAt === undefined) return;
+    if (!ctx.isIdle() || ctx.hasPendingMessages()) return;
+    const milliseconds = Math.max(0, now() - startedAt);
+    startedAt = undefined;
+    try {
+      pi.appendEntry<WorkedForEntryData>(WORKED_FOR_ENTRY_TYPE, {
+        version: WORKED_FOR_ENTRY_VERSION,
+        milliseconds,
+      });
+    } catch (error) {
+      ctx.ui.notify(`Worked-for timing could not be saved: ${errorMessage(error)}`, "error");
+    }
+  });
+
+  pi.on("session_shutdown", () => {
+    startedAt = undefined;
+  });
+}

package/package.json

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