@pi-unipi/unipi 3.0.0-alpha.2 → 3.0.0-alpha.21

package/packages/core/src/hints/store.ts

@@ -0,0 +1,120 @@
+/**
+ * Hint store — ~/.unipi/global/hints/hints.json, write-through JSON.
+ *
+ * Persists show counts, learned hints, and last seen unipi version:
+ *   {
+ *     "counts": { "<hintId>": { "count": 2, "last": 1730000000000 } },
+ *     "learned": ["utility.settings-hub"],
+ *     "lastSeenVersion": "3.0.0-alpha.20"
+ *   }
+ */
+
+import { readFileSync, writeFileSync, unlinkSync } from "node:fs";
+import { statePath } from "../workspace/paths.js";
+
+export interface HintRecord {
+  count: number;
+  last: number;
+}
+
+export interface HintStoreData {
+  counts: Record<string, HintRecord>;
+  learned: string[];
+  lastSeenVersion?: string;
+}
+
+let cache: HintStoreData | null = null;
+
+function emptyStore(): HintStoreData {
+  return {
+    counts: {},
+    learned: [],
+    lastSeenVersion: undefined,
+  };
+}
+
+export function loadHintStore(): HintStoreData {
+  if (cache) return cache;
+  try {
+    const raw = readFileSync(statePath("hints", "hints.json", "global"), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null) {
+      cache = {
+        counts: (typeof parsed.counts === "object" && parsed.counts !== null ? parsed.counts : {}) as Record<string, HintRecord>,
+        learned: Array.isArray(parsed.learned) ? parsed.learned : [],
+        lastSeenVersion: typeof parsed.lastSeenVersion === "string" ? parsed.lastSeenVersion : undefined,
+      };
+    } else {
+      cache = emptyStore();
+    }
+  } catch {
+    cache = emptyStore();
+  }
+  return cache;
+}
+
+function saveStore(): void {
+  if (!cache) return;
+  try {
+    writeFileSync(statePath("hints", "hints.json", "global"), JSON.stringify(cache, null, 2));
+  } catch {
+    // best-effort
+  }
+}
+
+export function recordHintShow(id: string): void {
+  const store = loadHintStore();
+  const prev = store.counts[id];
+  store.counts[id] = { count: (prev?.count ?? 0) + 1, last: Date.now() };
+  saveStore();
+}
+
+export function recordHintLearned(id: string): void {
+  const store = loadHintStore();
+  if (!store.learned.includes(id)) {
+    store.learned.push(id);
+    saveStore();
+  }
+}
+
+export function isHintLearned(id: string): boolean {
+  const store = loadHintStore();
+  return store.learned.includes(id);
+}
+
+export function setLastSeenVersion(version: string): void {
+  const store = loadHintStore();
+  store.lastSeenVersion = version;
+  saveStore();
+}
+
+export function getLastSeenVersion(): string | undefined {
+  const store = loadHintStore();
+  return store.lastSeenVersion;
+}
+
+export function resetHintHistory(): void {
+  const store = loadHintStore();
+  store.counts = {};
+  store.learned = [];
+  try {
+    writeFileSync(statePath("hints", "hints.json", "global"), JSON.stringify(store, null, 2));
+  } catch {
+    // best effort
+  }
+}
+
+/** Clear disk file and cached store completely (e.g. for testing clean slate). */
+export function clearHintStoreFile(): void {
+  cache = null;
+  try {
+    unlinkSync(statePath("hints", "hints.json", "global"));
+  } catch {
+    // absent file is already clear
+  }
+}
+
+/** Test hook: drop memoized store so next call re-reads disk. */
+export function resetHintStoreCache(): void {
+  cache = null;
+}

package/packages/core/src/jev/chatter.ts

@@ -0,0 +1,24 @@
+/**
+ * Chatter detection shared by jev consumers (auto-rename, skill judging):
+ * greetings, thanks, acknowledgements and bare "continue"-style nudges carry
+ * no subject, so no decision should be made from them.
+ */
+
+const CHATTER = new RegExp(
+  "^(?:" + [
+    "h(?:i|ello|ey|owdy)(?: there)?", "yo", "sup", "good (?:morning|afternoon|evening)",
+    "thanks?(?: you)?(?: so much)?", "thx", "ty", "cheers", "nice", "great", "cool", "perfect", "awesome",
+    "ok(?:ay)?", "k", "yes", "yep", "yeah", "no", "nope", "sure", "lgtm", "sounds good", "go(?: on| ahead)?",
+    "continue", "proceed", "retry", "again", "do it", "next", "done",
+  ].join("|") + ")[\\s.!?,]*$",
+  "i",
+);
+
+/** True for messages with no subject of their own (no jev call needed). */
+export function isChatter(text: string): boolean {
+  const t = text.trim();
+  if (t.length < 3) return true;
+  if (t.startsWith("/")) return true;
+  return CHATTER.test(t);
+}
+

package/packages/core/src/jev/settings.ts

@@ -1,23 +1,186 @@
 /**
- * Jev settings source — reads the long-horizon Decision-model settings from
- * the engine so every jev consumer (mode router, skill exposure, watchdog)
- * shares one provider/model/key/baseUrl configuration.
+ * Decision Model — one shared setting for the fast calibrated classifier
+ * (TypeSafe jev today) that several modules consult: long-horizon mode
+ * routing, permission auto-judging, skill exposure, the watchdog, kanboard
+ * strategy choice and compactor pruning.
+ *
+ * The model lives in its own settings namespace ("decision-model"), not in
+ * any consumer, so a different decision model can be adopted in one place.
+ * Each consumer carries a `decisionModel` block: `source: "inherit"` (the
+ * default) uses the shared model; `source: "custom"` overrides provider,
+ * model, base URL, key or timeout for that consumer only (empty fields fall
+ * back to the shared value).
  */
 
-import { getSettings } from "../settings/engine.js";
+import { getSettings, getSettingsScoped, registerSettings, setSettings } from "../settings/engine.js";
+import type { SettingsField, SettingsSection } from "../settings/schema.js";
+import { globalSettingsPath } from "../settings/paths.js";
 import type { JevSettings } from "./client.js";
 
-/** Read the Decision-model settings (long-horizon judge) as JevSettings. */
-export function readJudgeJevSettings(cwd: string): JevSettings {
-  const raw = getSettings("long-horizon", cwd) as {
-    judge?: Record<string, unknown>;
+export const DECISION_MODEL_NAMESPACE = "decision-model";
+
+export type DecisionProvider = JevSettings["provider"];
+
+export interface DecisionModelSettings {
+  provider: DecisionProvider;
+  model: string;
+  baseUrl: string;
+  apiKey: string;
+  timeoutMs: number;
+}
+
+export interface DecisionModelOverride extends DecisionModelSettings {
+  source: "inherit" | "custom";
+}
+
+export const DEFAULT_DECISION_MODEL: DecisionModelSettings = {
+  provider: "openrouter",
+  model: "typesafe/jev-1.13",
+  baseUrl: "",
+  apiKey: "",
+  timeoutMs: 0,
+};
+
+/** The per-consumer block's defaults: inherit, custom fields empty. */
+export const DEFAULT_DECISION_OVERRIDE: DecisionModelOverride = {
+  source: "inherit",
+  provider: "openrouter",
+  model: "",
+  baseUrl: "",
+  apiKey: "",
+  timeoutMs: 0,
+};
+
+const PROVIDER_OPTIONS = [
+  { value: "openrouter", label: "openrouter (decisions endpoint)" },
+  { value: "typesafe", label: "typesafe (native systemone)" },
+  { value: "custom", label: "custom (Base URL + API key)" },
+] as const;
+
+const MODEL_PRESETS = {
+  typesafe: ["jev-latest"],
+  openrouter: ["typesafe/jev-1.13"],
+  custom: ["typesafe/jev-1.13"],
+} as const;
+
+/** Provider / model / base URL / key / timeout fields under a key prefix. */
+function modelFields(prefix: string, emptyModel?: string): SettingsField[] {
+  const k = (name: string) => (prefix ? `${prefix}.${name}` : name);
+  return [
+    { key: k("provider"), type: "enum", label: "Provider", options: PROVIDER_OPTIONS, description: "openrouter = decisions endpoint · typesafe = native systemone · custom = your own gateway" },
+    {
+      key: k("model"),
+      type: "model",
+      label: "Model",
+      description: "A decision (classifier) model — jev; custom… for others",
+      providerKey: k("provider"),
+      presetsByProvider: MODEL_PRESETS,
+      ...(emptyModel ? { emptyLabel: emptyModel, emptyOption: emptyModel } : {}),
+    },
+    { key: k("baseUrl"), type: "string", label: "Base URL", description: "Required when provider = custom", emptyLabel: "provider default" },
+    { key: k("apiKey"), type: "secret", label: "API key", description: "A stored key wins over the environment (OPENROUTER_API_KEY / TYPESAFE_API_KEY)", emptyLabel: "environment" },
+    { key: k("timeoutMs"), type: "number", label: "Timeout ms", min: 0, zeroLabel: "auto (1s native / 6s decisions)" },
+  ];
+}
+
+registerSettings({
+  namespace: DECISION_MODEL_NAMESPACE,
+  label: "Decision Model",
+  defaults: DEFAULT_DECISION_MODEL as unknown as Record<string, unknown>,
+  schema: [
+    {
+      title: "Decision model",
+      description:
+        "A fast calibrated classifier used for mode routing, permission judging, skill exposure, the watchdog, kanboard strategy and compaction pruning. Each of those can inherit this or use its own.",
+      fields: modelFields(""),
+    },
+  ],
+});
+
+/**
+ * The hub section a consumer adds to its own settings: inherit the shared
+ * Decision Model, or use a custom one (fields empty = shared value).
+ */
+export function decisionModelSection(opts: { title?: string; advanced?: boolean } = {}): SettingsSection {
+  return {
+    title: opts.title ?? "Decision model",
+    description: "inherit = the shared Decision Model settings · custom = override below for this module only (empty = shared value)",
+    advanced: opts.advanced ?? true,
+    fields: [
+      {
+        key: "decisionModel.source",
+        type: "enum",
+        label: "Decision model",
+        options: [
+          { value: "inherit", label: "inherit (Decision Model settings)" },
+          { value: "custom", label: "custom" },
+        ],
+      },
+      ...modelFields("decisionModel", "shared model"),
+    ],
   };
-  const j = raw?.judge ?? {};
+}
+
+const isRecord = (v: unknown): v is Record<string, unknown> => typeof v === "object" && v !== null && !Array.isArray(v);
+
+function normalize(raw: Record<string, unknown>, fallback: DecisionModelSettings): DecisionModelSettings {
+  const provider: DecisionProvider =
+    raw.provider === "typesafe" || raw.provider === "custom" || raw.provider === "openrouter" ? raw.provider : fallback.provider;
+  const str = (v: unknown, dflt: string) => (typeof v === "string" && v.trim() ? v.trim() : dflt);
+  const model = str(raw.model, provider === fallback.provider ? fallback.model : provider === "typesafe" ? "jev-latest" : "typesafe/jev-1.13");
   return {
-    provider: j.provider === "typesafe" ? "typesafe" : "openrouter",
-    model: typeof j.model === "string" ? j.model : "",
-    baseUrl: typeof j.baseUrl === "string" ? j.baseUrl : "",
-    apiKey: typeof j.apiKey === "string" ? j.apiKey : "",
-    timeoutMs: typeof j.timeoutMs === "number" ? j.timeoutMs : 0,
+    provider,
+    model,
+    baseUrl: str(raw.baseUrl, fallback.baseUrl),
+    apiKey: str(raw.apiKey, fallback.apiKey),
+    timeoutMs: typeof raw.timeoutMs === "number" && raw.timeoutMs > 0 ? raw.timeoutMs : fallback.timeoutMs,
   };
 }
+
+/** Latched per global settings file (one per HOME), not per process. */
+const migrated = new Set<string>();
+
+/**
+ * One-time move of the pre-namespace settings (long-horizon `judge.*`
+ * transport fields) into "decision-model". Additive: long-horizon keeps its
+ * copy; runs only while the decision-model global file does not exist.
+ */
+export function migrateLegacyDecisionModel(cwd: string): void {
+  const target = globalSettingsPath(DECISION_MODEL_NAMESPACE);
+  if (migrated.has(target)) return;
+  migrated.add(target);
+  try {
+    if (getSettingsScoped(DECISION_MODEL_NAMESPACE, "global", cwd)) return;
+    const judge = getSettingsScoped("long-horizon", "global", cwd)?.judge;
+    if (!isRecord(judge)) return;
+    const patch: Record<string, unknown> = {};
+    for (const key of ["provider", "model", "baseUrl", "apiKey", "timeoutMs"]) {
+      if (judge[key] !== undefined && judge[key] !== "") patch[key] = judge[key];
+    }
+    if (patch.provider === "auto") patch.provider = "openrouter";
+    if (Object.keys(patch).length > 0) setSettings(DECISION_MODEL_NAMESPACE, patch, "global", cwd);
+  } catch {
+    // Unreadable legacy settings: defaults apply.
+  }
+}
+
+/** The shared Decision Model. */
+export function readDecisionModel(cwd: string): DecisionModelSettings {
+  migrateLegacyDecisionModel(cwd);
+  return normalize(getSettings(DECISION_MODEL_NAMESPACE, cwd), DEFAULT_DECISION_MODEL);
+}
+
+/**
+ * The Decision Model a consumer should use: its own `decisionModel` block
+ * when `source: "custom"`, otherwise the shared one.
+ */
+export function resolveDecisionModel(cwd: string, namespace?: string): DecisionModelSettings {
+  const shared = readDecisionModel(cwd);
+  if (!namespace) return shared;
+  const block = getSettings(namespace, cwd)?.decisionModel;
+  if (!isRecord(block) || block.source !== "custom") return shared;
+  return normalize(block, shared);
+}
+
+/** @deprecated Use resolveDecisionModel(cwd, namespace). */
+export const readJudgeJevSettings = (cwd: string): DecisionModelSettings => readDecisionModel(cwd);

package/packages/core/src/package-colors.ts

@@ -41,6 +41,7 @@ export const PACKAGE_COLORS: Record<string, string> = {
   "background-tasks": `${ESC}[91m`, // Bright Red
   fusion:    `${ESC}[96m`, // Bright Cyan
   watchdog:  `${ESC}[90m`, // Bright Black (gray)
+  "skill-registry": `${ESC}[92m`, // Bright Green
 };
 
 /** Hub namespace → PACKAGE_COLORS key (others use the namespace identity). */
@@ -48,6 +49,7 @@ const NAMESPACE_COLOR_KEYS: Record<string, string> = {
   "command-enchantment": "autocomplete",
   "info-screen": "info",
   compactor: "compact",
+  skills: "skill-registry",
 };
 
 /** ANSI color for a settings namespace ("" when unknown — no color). */

package/packages/core/src/settings/catalog.ts

@@ -1,10 +1,12 @@
 /**
  * Model catalog for `model`-type settings fields — the searchable picker's data.
  *
- * Source: pi's own model registry (~/.pi/agent/models.json), the same catalog
- * `pi --list-models` renders. The omniroute bridge keeps it current. Shape:
- *   { providers: { <provider>: { models: [{ id, ... }] } } }
- * → flattened ["provider/model-id", …] ids.
+ * Primary source: the unipi model cache (~/.unipi/config/models-cache.json),
+ * written by utility from pi's live registry every session — it covers
+ * built-in providers with credentials and the image-generation collection,
+ * with input/output modalities. Pi's models.json (custom providers, shape
+ *   { providers: { <provider>: { models: [{ id, ... }] } } })
+ * fills in anything the cache has not seen yet (first run, no session yet).
  *
  * The loader is sync + cached + never throws (empty catalog on any error), and
  * the path is injectable so tests feed a fixture instead of the real registry.
@@ -13,6 +15,7 @@
 import { readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { readModelCache, modelInputs, modelOutputs, modelRef } from "../../model-cache.js";
 
 export function defaultModelCatalogPath(): string {
   return join(homedir(), ".pi", "agent", "models.json");
@@ -23,21 +26,44 @@ export interface ModelCatalogEntry {
   readonly id: string;
   /** Declared input modalities, e.g. ["text"] or ["text", "image"]. */
   readonly input: string[];
+  /** Declared output modalities; absent → ["text"]. */
+  readonly output?: string[];
 }
 
-let entryCache: ModelCatalogEntry[] | undefined;
+export type ModelCapability = "text" | "image-input" | "image-output" | "image-edit";
 
-/** Load and cache the full "provider/model" id list. Empty on any failure. */
+/** Capability filter shared by every model picker. */
+export function matchesCapability(entry: ModelCatalogEntry, capability: ModelCapability): boolean {
+  // No declared input = unknown → hidden from capability pickers (custom… still
+  // accepts any id). Output defaults to text: chat catalogs rarely declare it.
+  const input = entry.input;
+  const output = entry.output?.length ? entry.output : ["text"];
+  switch (capability) {
+    case "text": return input.includes("text") && output.includes("text");
+    case "image-input": return input.includes("image") && output.includes("text");
+    case "image-output": return output.includes("image");
+    case "image-edit": return input.includes("image") && output.includes("image");
+  }
+}
+
+/** Load the full "provider/model" id list. Empty on any failure. */
 export function loadModelCatalog(path: string = defaultModelCatalogPath()): string[] {
   return loadModelCatalogEntries(path).map((e) => e.id);
 }
 
-/** Load and cache catalog entries (ids + metadata). Empty on any failure. */
+/** Load catalog entries (ids + modalities). Read per call (picker open), so a
+ *  cache rewritten mid-session is seen. Empty on any failure. */
 export function loadModelCatalogEntries(path: string = defaultModelCatalogPath()): ModelCatalogEntry[] {
-  if (entryCache && path === defaultModelCatalogPath()) return entryCache;
-  const entries = parseModelCatalogEntries(() => readFileSync(path, "utf8"));
-  if (path === defaultModelCatalogPath()) entryCache = entries;
-  return entries;
+  const isDefault = path === defaultModelCatalogPath();
+  const fromFile = parseModelCatalogEntries(() => readFileSync(path, "utf8"));
+  if (!isDefault) return fromFile;
+  const cached: ModelCatalogEntry[] = readModelCache().map((m) => ({
+    id: modelRef(m),
+    input: modelInputs(m),
+    output: modelOutputs(m),
+  }));
+  const seen = new Set(cached.map((e) => e.id));
+  return [...cached, ...fromFile.filter((e) => !seen.has(e.id))];
 }
 
 /** Pure parser — testable without the filesystem. */
@@ -78,10 +104,8 @@ export function parseModelCatalogEntries(read: () => string): ModelCatalogEntry[
   }
 }
 
-/** Test hook. */
-export function resetModelCatalogCache(): void {
-  entryCache = undefined;
-}
+/** Test hook (the catalog is no longer cached in memory; kept for callers). */
+export function resetModelCatalogCache(): void {}
 
 /** Pure id-only parser (back-compat shim over parseModelCatalogEntries). */
 export function parseModelCatalog(read: () => string): string[] {

package/packages/core/src/settings/engine.ts

@@ -27,6 +27,20 @@ export interface SettingsDefinition {
   readonly projectOverrides?: boolean;
   /** Field schema — sections/fields the hub renders automatically. */
   readonly schema?: readonly SettingsSection[];
+  /**
+   * Called after every write to one layer (set or unset) with that layer's
+   * new content — for settings that mirror into another program's config
+   * (e.g. fusion's startup model → pi's settings.json). Errors are swallowed.
+   */
+  readonly onSet?: (layer: Record<string, unknown>, scope: SettingsScope, cwd: string) => void;
+}
+
+function notifySet(definition: SettingsDefinition, layer: Record<string, unknown>, scope: SettingsScope, cwd: string): void {
+  try {
+    definition.onSet?.(layer, scope, cwd);
+  } catch {
+    /* a mirror failure must not fail the settings write */
+  }
 }
 
 const registry = new Map<string, SettingsDefinition>();
@@ -139,8 +153,40 @@ export function setSettings(
   }
   const target =
     scope === "global" ? globalSettingsPath(namespace) : projectSettingsPath(cwd, namespace);
-  const current = readJson(target) ?? {};
-  writeJson(target, deepMerge(current, patch));
+  const next = deepMerge(readJson(target) ?? {}, patch);
+  writeJson(target, next);
+  notifySet(definition, next, scope, cwd);
+}
+
+/** Delete a dot-path key from ONE scope — the "use default" / clear write. */
+export function unsetSettings(namespace: string, key: string, scope: SettingsScope, cwd: string): void {
+  runGates(cwd);
+  const definition = registry.get(namespace);
+  if (!definition) throw new Error(`unknown settings namespace: ${namespace}`);
+  const target = scope === "global" ? globalSettingsPath(namespace) : projectSettingsPath(cwd, namespace);
+  const current = readJson(target);
+  if (!current) return;
+  const segments = key.split(".");
+  let cursor: Record<string, unknown> = current;
+  for (let i = 0; i < segments.length - 1; i++) {
+    const next = cursor[segments[i]!];
+    if (typeof next !== "object" || next === null) return;
+    cursor = next as Record<string, unknown>;
+  }
+  delete cursor[segments[segments.length - 1]!];
+  writeJson(target, current);
+  notifySet(definition, current, scope, cwd);
+}
+
+/** One layer only (no defaults, no merge) — for layered fallback chains. */
+export function getSettingsScoped(
+  namespace: string,
+  scope: SettingsScope,
+  cwd: string,
+): Record<string, unknown> | undefined {
+  runGates(cwd);
+  const path = scope === "global" ? globalSettingsPath(namespace) : projectSettingsPath(cwd, namespace);
+  return readJson(path) ?? undefined;
 }
 
 /** Which layers currently exist for a namespace (hub status display). */