pi-blackhole 0.3.3 → 0.3.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-blackhole",
-  "version": "0.3.3",
+  "version": "0.3.4",
   "packageManager": "pnpm@11.2.2",
   "description": "Unified compaction + observational memory extension for Pi — compresses conversation context while preserving durable observations and reflections",
   "license": "MIT",

package/src/core/unified-config.ts

@@ -187,6 +187,11 @@ function positiveInt(v: unknown): number | undefined {
 	return Number.isInteger(v) && typeof v === "number" && v > 0 ? v : undefined;
 }
 
+/** Like positiveInt but allows 0. Used for cooldownHours where 0 means "disabled". */
+function nonNegativeInt(v: unknown): number | undefined {
+	return Number.isInteger(v) && typeof v === "number" && v >= 0 ? v : undefined;
+}
+
 function parseModel(v: unknown): OmModelConfig | undefined {
 	if (!isRecord(v)) return undefined;
 	const provider = nonEmptyString(v.provider);
@@ -194,7 +199,7 @@ function parseModel(v: unknown): OmModelConfig | undefined {
 	if (!provider || !id) return undefined;
 	const model: OmModelConfig = { provider, id };
 	if (isThinkingLevel(v.thinking)) model.thinking = v.thinking;
-	const cooldown = positiveInt(v.cooldownHours);
+	const cooldown = nonNegativeInt(v.cooldownHours);
 	if (cooldown !== undefined) model.cooldownHours = cooldown;
 	const ctxWindow = positiveInt(v.contextWindow);
 	if (ctxWindow !== undefined) model.contextWindow = ctxWindow;

package/src/om/configure-overlay.ts

@@ -6,7 +6,8 @@
  * Navigation: ↑↓  Edit: Enter  Save: Ctrl+S  Cancel: Esc
  */
 
-import { matchKey, visibleWidth } from "./key-matcher.js";
+import { visibleWidth } from "./key-matcher.js";
+import { matchesKey, decodeKittyPrintable } from "@earendil-works/pi-tui";
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 
@@ -191,18 +192,18 @@ export function createConfigureOverlay(
 
 		// While editing a number field
 		if (cur.editing) {
-			if (matchKey(data, "escape")) {
+			if (matchesKey(data, "escape")) {
 				cur.value = formatValue(cur.def, raw[cur.def.key]);
 				cur.editing = false;
 				invalidate();
 				return;
 			}
-			if (matchKey(data, "enter") || matchKey(data, "tab")) {
+			if (matchesKey(data, "enter") || matchesKey(data, "tab")) {
 				cur.editing = false;
 				invalidate();
 				return;
 			}
-			if (matchKey(data, "backspace")) {
+			if (matchesKey(data, "backspace")) {
 				if (cur.cursor > 0) {
 					cur.value = cur.value.slice(0, cur.cursor - 1) + cur.value.slice(cur.cursor);
 					cur.cursor--;
@@ -210,18 +211,19 @@ export function createConfigureOverlay(
 				}
 				return;
 			}
-			if (matchKey(data, "left")) {
+			if (matchesKey(data, "left")) {
 				cur.cursor = Math.max(0, cur.cursor - 1);
 				invalidate();
 				return;
 			}
-			if (matchKey(data, "right")) {
+			if (matchesKey(data, "right")) {
 				cur.cursor = Math.min(cur.value.length, cur.cursor + 1);
 				invalidate();
 				return;
 			}
-			if (data.length === 1 && data >= "0" && data <= "9") {
-				cur.value = cur.value.slice(0, cur.cursor) + data + cur.value.slice(cur.cursor);
+			const digit = decodeKittyPrintable(data) ?? data;
+			if (digit.length === 1 && digit >= "0" && digit <= "9") {
+				cur.value = cur.value.slice(0, cur.cursor) + digit + cur.value.slice(cur.cursor);
 				cur.cursor++;
 				invalidate();
 			}
@@ -231,20 +233,20 @@ export function createConfigureOverlay(
 		// Not editing — global navigation
 
 		// Ctrl+S → save and close
-		if (matchKey(data, "ctrl+s")) {
+		if (matchesKey(data, "ctrl+s")) {
 			const saved = save();
 			done({ saved, path: configPath });
 			return;
 		}
 
 		// Esc → close without saving
-		if (matchKey(data, "escape")) {
+		if (matchesKey(data, "escape")) {
 			done(undefined);
 			return;
 		}
 
 		// Enter/space → edit/toggle
-		if (matchKey(data, "enter") || matchKey(data, "space")) {
+		if (matchesKey(data, "enter") || matchesKey(data, "space")) {
 			switch (cur.def.type) {
 				case "boolean":
 					cur.value = cur.value === "on" ? "off" : "on";
@@ -268,12 +270,12 @@ export function createConfigureOverlay(
 		}
 
 		// ↑↓ navigation
-		if (matchKey(data, "up")) {
+		if (matchesKey(data, "up")) {
 			selectedIndex = Math.max(0, selectedIndex - 1);
 			invalidate();
 			return;
 		}
-		if (matchKey(data, "down")) {
+		if (matchesKey(data, "down")) {
 			selectedIndex = Math.min(fields.length - 1, selectedIndex + 1);
 			invalidate();
 			return;

package/src/om/consolidation.ts

@@ -59,9 +59,9 @@ import {
 	type Reflection,
 } from "./ledger/index.js";
 
-type ResolvedModel = Extract<ResolveResult, { ok: true }>;
+export type ResolvedModel = Extract<ResolveResult, { ok: true }>;
 
-type ConsolidationCtx = {
+export type ConsolidationCtx = {
 	cwd: string;
 	hasUI: boolean;
 	ui?: { notify: (message: string, type?: "warning" | "info" | "error") => void };
@@ -182,15 +182,16 @@ function stageThinkingLevel(runtime: Runtime, stage: "observer" | "reflector" |
 	return stageModel?.thinking ?? runtime.config.model?.thinking ?? "low";
 }
 
-function makeModelResolver(runtime: Runtime, ctx: ConsolidationCtx): (stage: "observer" | "reflector" | "dropper") => Promise<ResolvedModel | undefined> {
+export function makeModelResolver(runtime: Runtime, ctx: ConsolidationCtx): (stage: "observer" | "reflector" | "dropper") => Promise<ResolvedModel | undefined> {
 	return async (stage) => {
+		const stageFallbacks = stageFallbackModels(runtime, stage);
 		const resolved = await runtime.resolveModel({
 			model: ctx.model,
 			modelRegistry: ctx.modelRegistry,
 			hasUI: ctx.hasUI,
 			ui: ctx.ui,
 			stageModel: stageModelConfig(runtime, stage),
-			stageFallbacks: stageFallbackModels(runtime, stage),
+			stageFallbacks,
 		});
 		if (resolved.ok) {
 			runtime.resolveFailureNotified = false;
@@ -198,7 +199,17 @@ function makeModelResolver(runtime: Runtime, ctx: ConsolidationCtx): (stage: "ob
 		}
 		debugLog(`${stage}.model_unavailable`, { reason: resolved.reason });
 		if (!runtime.resolveFailureNotified && ctx.hasUI && ctx.ui) {
-			ctx.ui.notify(`Observational memory: ${stage} skipped — ${resolved.reason}`, "warning");
+			if (runtime.failedInCycle.size > 0 && resolved.reason.includes("all candidates exhausted")) {
+				const fallbackMsg = stageFallbacks.length === 0
+					? "no fallbacks configured"
+					: "no available fallbacks";
+				ctx.ui.notify(
+					`Observational memory: ${stage} skipped — model unavailable (cooldown set to 0, ${fallbackMsg}, will retry next run)`,
+					"info",
+				);
+			} else {
+				ctx.ui.notify(`Observational memory: ${stage} skipped — ${resolved.reason}`, "warning");
+			}
 			runtime.resolveFailureNotified = true;
 		}
 		return undefined;
@@ -254,6 +265,8 @@ export async function runConsolidationPipeline(
 	const resolveModel = makeModelResolver(runtime, ctx);
 
 	runtime.consolidationPhase = "observer";
+	runtime.failedInCycle.clear();
+	runtime.resolveFailureNotified = false;
 	try {
 		const observerOutcome = await runObserverStage(pi, runtime, ctx, resolveModel);
 		if (observerOutcome === "abort") return;
@@ -263,6 +276,8 @@ export async function runConsolidationPipeline(
 	}
 
 	runtime.consolidationPhase = "reflector";
+	runtime.failedInCycle.clear();
+	runtime.resolveFailureNotified = false;
 	let reflectorResult: ReflectorStageResult;
 	try {
 		reflectorResult = await runReflectorStage(pi, runtime, ctx, resolveModel);
@@ -273,6 +288,8 @@ export async function runConsolidationPipeline(
 	}
 
 	runtime.consolidationPhase = "dropper";
+	runtime.failedInCycle.clear();
+	runtime.resolveFailureNotified = false;
 	try {
 		await runDropperStage(pi, runtime, ctx, resolveModel, reflectorResult.sameRunReflections, reflectorResult.effectiveReflectionCoverageId);
 	} catch (error) {

package/src/om/cooldown.ts

@@ -75,8 +75,13 @@ function writeCooldownMap(map: CooldownMap): void {
 /**
  * Check whether a model is currently cooled down.
  * Expired entries are cleaned up lazily.
+ *
+ * When cooldownHours is explicitly 0, cooldown is disabled — always returns false.
  */
 export function isCooldownActive(model: OmModelConfig, now: Date = new Date()): boolean {
+	// cooldownHours === 0 means cooldown disabled
+	if (model.cooldownHours === 0) return false;
+
 	const map = readCooldownMap();
 	const key = modelKey(model);
 	const entry = map[key];
@@ -97,11 +102,16 @@ export function isCooldownActive(model: OmModelConfig, now: Date = new Date()):
 /**
  * Record a cooldown for a model after a retryable error.
  *
+ * When cooldownHours is explicitly 0, cooldown is disabled — no-op.
+ *
  * @param model   The model that failed.
  * @param reason  Human-readable error reason (e.g. "429 Too Many Requests").
  * @param stage   Which pipeline stage failed ("observer" | "reflector" | "dropper").
  */
 export function recordCooldown(model: OmModelConfig, reason: string, stage: string): void {
+	// cooldownHours === 0 means cooldown disabled
+	if (model.cooldownHours === 0) return;
+
 	const hours = model.cooldownHours ?? 1;
 	const until = new Date(Date.now() + hours * 3_600_000).toISOString();
 	const map = readCooldownMap();

package/src/om/key-matcher.ts

@@ -1,46 +1,12 @@
 /**
  * Terminal utilities shared by blackhole overlay components.
  *
- * Key matcher — standalone replacement for pi-tui's `matchesKey`
- * to keep overlay components free of that dependency.
- *
  * visibleWidth — CJK-aware visible width for terminal columns,
  * extracted from pi-tui to avoid import resolution issues.
  *
  * Ported from voice-type extension's key-matcher.ts.
  */
 
-// ---------------------------------------------------------------------------
-// Key matching
-// ---------------------------------------------------------------------------
-
-export function matchKey(data: string, key: string): boolean {
-	// Escape
-	if (key === "escape") return data === "\x1b";
-	// Enter
-	if (key === "enter") return data === "\r" || data === "\n";
-	// Tab
-	if (key === "tab") return data === "\t";
-	// Space
-	if (key === "space") return data === " ";
-	// Backspace
-	if (key === "backspace") return data === "\x7f" || data === "\b";
-	// Arrows
-	if (key === "up") return data === "\x1b[A" || data === "\x1bOA";
-	if (key === "down") return data === "\x1b[B" || data === "\x1bOB";
-	if (key === "left") return data === "\x1b[D" || data === "\x1bOD";
-	if (key === "right") return data === "\x1b[C" || data === "\x1bOC";
-	// Ctrl+letter (must be exactly 6 chars: "ctrl+" + one lowercase letter)
-	if (key.startsWith("ctrl+") && key.length === 6) {
-		const letter = key[5];
-		if (letter && letter >= "a" && letter <= "z") {
-			const code = letter.charCodeAt(0) - 96; // ctrl+a = 1, ctrl+z = 26
-			return data.length === 1 && data.charCodeAt(0) === code;
-		}
-	}
-	return false;
-}
-
 // ---------------------------------------------------------------------------
 // Visible width (CJK-aware)
 // ---------------------------------------------------------------------------

package/src/om/runtime.ts

@@ -45,6 +45,13 @@ export class Runtime {
 	consolidationInFlight = false;
 	consolidationPromise: Promise<void> | null = null;
 	consolidationPhase: ConsolidationPhase | undefined;
+	/**
+	 * Models that failed in the current consolidation stage (in-memory only).
+	 * Used when cooldownHours is 0 — avoids disk writes while still letting
+	 * the retry loop advance past the failed model within this stage.
+	 * Cleared between stages at the pipeline level.
+	 */
+	failedInCycle: Set<string> = new Set();
 	compactInFlight = false;
 	compactHookInFlight = false;
 	resolveFailureNotified = false;
@@ -101,10 +108,23 @@ export class Runtime {
 
 		// Try configured candidates
 		for (const candidate of candidates) {
+			const key = modelKey(candidate);
+
+			// In-memory skip: model failed earlier in this stage with cooldownHours 0
+			if (this.failedInCycle.has(key)) {
+				if (ctx.hasUI && ctx.ui) {
+					ctx.ui.notify(
+						`Observational memory: ${stageName} skipping ${key} (failed this cycle, cooldown disabled)`,
+						"info",
+					);
+				}
+				continue;
+			}
+
 			if (isCooldownActive(candidate)) {
 				if (ctx.hasUI && ctx.ui) {
 					ctx.ui.notify(
-						`Observational memory: ${stageName} skipping ${modelKey(candidate)} (cooldown active)`,
+						`Observational memory: ${stageName} skipping ${key} (cooldown active)`,
 						"info",
 					);
 				}
@@ -179,9 +199,19 @@ export class Runtime {
 	/**
 	 * Record a retryable error for a model.  The model must be one of the candidates
 	 * (not the session model).  If it's the session model we don't cool it down.
+	 *
+	 * When cooldownHours is explicitly 0, the model is tracked in-memory for the
+	 * current consolidation stage (no disk writes). Otherwise a persisted cooldown
+	 * is recorded.
 	 */
 	recordRetryableError(modelConfig: ConfiguredModel | undefined, error: unknown, stage: ConsolidationPhase): void {
 		if (!modelConfig) return;
+		if (modelConfig.cooldownHours === 0) {
+			// In-memory only: skip this model for the rest of this stage.
+			// No disk writes, no persistent cooldown.
+			this.failedInCycle.add(modelKey(modelConfig));
+			return;
+		}
 		const reason = error instanceof Error ? error.message : String(error || "unknown error");
 		recordCooldown(modelConfig, reason, stage);
 	}

package/src/om/status-overlay.ts

@@ -7,7 +7,8 @@
  * Esc to close.
  */
 
-import { matchKey, visibleWidth } from "./key-matcher.js";
+import { visibleWidth } from "./key-matcher.js";
+import { matchesKey } from "@earendil-works/pi-tui";
 
 // ---------------------------------------------------------------------------
 // Theme shape (duck-typed from what pi provides)
@@ -117,12 +118,12 @@ export function createStatusOverlay(
 	}
 
 	function handleInput(data: string): void {
-		if (matchKey(data, "escape")) {
+		if (matchesKey(data, "escape")) {
 			done({ action: "close" });
 			return;
 		}
 
-		if (matchKey(data, "enter") || matchKey(data, "space")) {
+		if (matchesKey(data, "enter") || matchesKey(data, "space")) {
 			if (navIsAction(selectedIndex)) {
 				const actionIdx = selectedIndex - selectableConfigCount - selectablePipelineCount - selectableErrorCount;
 				const action = actionItems[actionIdx]!;
@@ -132,12 +133,12 @@ export function createStatusOverlay(
 			return;
 		}
 
-		if (matchKey(data, "up")) {
+		if (matchesKey(data, "up")) {
 			selectedIndex = Math.max(0, selectedIndex - 1);
 			invalidate();
 			return;
 		}
-		if (matchKey(data, "down")) {
+		if (matchesKey(data, "down")) {
 			selectedIndex = Math.min(totalSelectable - 1, selectedIndex + 1);
 			invalidate();
 			return;